summaryrefslogtreecommitdiff
path: root/_selfcheck.lua
blob: 1662ae368bef82c2f12e34bd229435c94cefaced (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
-- panto lua _selfcheck.lua; no network/provider tokens. Child modes reuse this file.
local uv=require('luv')
local json=require('panto').ext.json
local here=debug.getinfo(1,'S').source:match('^@(.*)/[^/]+$') or '.'
here=uv.fs_realpath(here)
package.path=here .. '/?.lua;' .. here .. '/?/init.lua;' .. package.path
local async=require('panto_mcp.async')
local function close(h) async.close(h) end
local function write(path,text)
    local f=assert(io.open(path,'wb')); assert(f:write(text)); f:close()
end
local function read(path)
    local f=io.open(path,'rb'); if not f then return nil end
    local s=f:read('a'); f:close(); return s
end
-- A stand-in parent dies without running extension teardown. Its inherited
-- stderr reports the actual server/group pid to the outer test.
if arg[1]=='--parent' then
    local transport=assert(require('panto_mcp.stdio').new({command=uv.exepath(),args={'lua',here .. '/_selfcheck.lua','--fake','grandchild'},env={}}))
    local reported=false
    local watchdog=uv.new_timer(); watchdog:start(0,10,function()
        if transport.server_pid and transport.stderr_tail:find('GRANDCHILD=%d+') and not reported then
            io.stdout:write('SERVER=',transport.server_pid,'\n'); io.stdout:flush(); reported=true
        end
    end)
    uv.run(); return
end
if arg[1]=='--fake' then
    local mode=arg[2]
    if mode=='banner' then io.stdout:write('starting fake server\n'); io.stdout:flush(); mode='modern' end
    if mode=='exit-on-eof' then
        local pipe=uv.new_pipe(false); assert(pipe:open(0))
        pipe:read_start(function(_,data) if not data then close(pipe) end end)
        uv.run(); return
    end
    if mode=='noisy-exit' then
        io.stderr:write('diagnostic-tail-from-child'); io.stderr:flush()
        io.stdout:write('diagnostic-tail-from-child\n'); io.stdout:flush(); return
    end
    if mode=='env-check' then
        assert(os.getenv('PANTO_MCP_TEST_CHILD_ENV')=='child','server env not applied')
        mode='modern'
    end
    if mode=='ignore' or mode=='grandchild' then
        local keep=uv.new_timer(); keep:start(100000,100000,function() end)
        local signal=uv.new_signal(); signal:start('sigterm',function() end)
        if mode=='grandchild' then
            local child,pid=assert(uv.spawn('sh',{args={'-c','trap "" TERM; sleep 1000 & wait'},stdio={nil,nil,2}},function() end))
            io.stderr:write('GRANDCHILD=',pid,'\n'); io.stderr:flush(); child:unref()
        end
        local pipe=uv.new_pipe(false); assert(pipe:open(0)); pipe:read_start(function() end)
        uv.run(); return
    end
    local initialized=false; local changed=false; local removed=false
    local function send(msg) io.stdout:write(json.encode(msg),'\r\n'); io.stdout:flush() end
    local pipe=uv.new_pipe(false); assert(pipe:open(0))
    local feed=require('panto_mcp.stdio').framer(function(req)
        if not req.method then return end
        if req.id==nil then return end
        local function result(r) send({jsonrpc='2.0',id=req.id,result=r}) end
        local function err(code,msg,data) send({jsonrpc='2.0',id=req.id,error={code=code,message=msg,data=data}}) end
        local caps={tools={listChanged=true},prompts={},resources={}}
        if mode=='tools-only' then caps={tools={}} end
        if req.method=='server/discover' then
            if mode=='legacy-close' then close(pipe); return end
            if mode~='modern' then err(-32600,'initialize first'); return end
            assert(req.params._meta['io.modelcontextprotocol/protocolVersion']=='2026-07-28')
            result({resultType='complete',supportedVersions={'2026-07-28'},capabilities=caps,instructions='Fake server instructions',_meta={['io.modelcontextprotocol/serverInfo']={name='fake'}}}); return
        end
        if req.method=='initialize' then
            assert(mode~='modern','modern must never initialize'); initialized=true
            result({protocolVersion='2025-06-18',capabilities=caps,serverInfo={name='fake'},instructions='Fake server instructions'}); return
        end
        if mode=='modern' then assert(req.params._meta and req.params._meta['io.modelcontextprotocol/clientCapabilities'])
        else assert(initialized,'legacy request before initialize') end
        if req.method=='tools/list' then
            if removed then result({tools={}})
            elseif req.params.cursor then result({tools={{name='other',description='Other tool',inputSchema={type='object'}}}})
            else
                local tools={{name='echo',description='Echo a message',inputSchema={type='object',properties={message={type='string'}},required={'message'},additionalProperties=false}}}
                if changed then tools[#tools+1]={name='new_tool',inputSchema={type='object'}} end
                result({tools=tools,nextCursor='page2'})
            end
        elseif req.method=='prompts/list' then
            assert(mode~='tools-only')
            result({prompts=removed and {} or {{name=changed and 'wave' or 'greet',arguments={{name='name',required=true}}}}})
        elseif req.method=='resources/list' then assert(mode~='tools-only'); result({resources={{name='guide',uri='docs://guide',description='Guide document'}}})
        elseif req.method=='resources/templates/list' then
            if mode=='missing-templates' then err(-32601,'not implemented') else result({resourceTemplates={{name='entry',uriTemplate='docs://{name}'}}}) end
        elseif req.method=='resources/read' then result({contents={{uri=req.params.uri,text='resource body'}}})
        elseif req.method=='prompts/get' then result({messages={{role='user',content={type='text',text='Hello'}}}})
        elseif req.method=='tools/call' then
            result({content={{type='text',text=(req.params.arguments or {}).message or 'ok'}}})
            if req.params.arguments and req.params.arguments.message=='change' then
                changed=true; send({jsonrpc='2.0',method='notifications/tools/list_changed'})
            elseif req.params.arguments and req.params.arguments.message=='remove' then
                removed=true; send({jsonrpc='2.0',method='notifications/tools/list_changed'}); send({jsonrpc='2.0',method='notifications/prompts/list_changed'})
            end
        else err(-32601,'not implemented') end
    end)
    pipe:read_start(function(e,data) assert(not e,e); if data then assert(feed(data)) else close(pipe) end end)
    uv.run(); return
end

local checks=0
local function check(v,label) assert(v,label); checks=checks+1 end
local function eq(a,b,label) check(a==b,(label or '') .. ': ' .. tostring(a) .. ' ~= ' .. tostring(b)) end
local config=require('panto_mcp.config')
local cache=require('panto_mcp.cache')
local validate=require('panto_mcp.validate')
local results=require('panto_mcp.results')
local stdio=require('panto_mcp.stdio')
local Rpc=require('panto_mcp.jsonrpc')
local Manager=require('panto_mcp.manager')
local search=require('panto_mcp.search')
local prompts=require('panto_mcp.prompts')
local namespace=require('panto_mcp.namespace')
check(require('panto_mcp.docs').discovery:find('Search is the default',1,true),'docs describe search as default')
local manifest_environment={}
assert(loadfile(here .. '/panto-mcp-0.1.0-1.rockspec','t',manifest_environment))()
local module_scan=assert(uv.fs_scandir(here .. '/panto_mcp'))
while true do
    local file=uv.fs_scandir_next(module_scan); if not file then break end
    local stem=file:match('^(.*)%.lua$')
    if stem then check(manifest_environment.build.modules['panto_mcp.' .. stem]=='panto_mcp/' .. file,'rock manifest: ' .. file) end
end
local temp=assert(uv.fs_mkdtemp('/tmp/panto-mcp-check-XXXXXX'))
local function timers()
    local ts={}
    local function factory(ms,fn)
        local t={ms=ms,fn=fn,closed=false}
        function t:is_closing() return self.closed end
        function t:close() self.closed=true end
        function t:fire() if not self.closed then self:close(); self.fn() end end
        ts[#ts+1]=t; return t
    end
    return ts,factory
end
local function fake_transport()
    local t={sent={},cancels={}}
    function t:set_callbacks(message,err) self.message=message; self.error=err end
    function t:send(msg,opts) self.sent[#self.sent+1]={msg=msg,opts=opts}; return {} end
    function t:cancel(id) self.cancels[#self.cancels+1]=id end
    function t:close() self.closed=true end
    return t
end
-- Config trust boundary, canonical identity and stable future eager names.
local settings,servers,warnings=config.parse({servers={fs={command='echo',args={'${env:ABSENT}','${project_root}'},env={X='${env:TOKEN}'},cwd='sub'},bad={command='x',url='https://x'},['bad.name']={command='x'},['bad__name']={command='x'},['tail_']={command='x'},off={enabled=false}}},{project_root='/project'},function(k) if k=='TOKEN' then return 'secret' end end)
eq(servers.fs.args[1],'','missing env'); eq(servers.fs.args[2],'/project'); eq(servers.fs.cwd,'/project/sub'); eq(#warnings,4)
check(not servers.off and not servers.bad and not servers.bad__name and not servers.tail_,'invalid/disabled skipped')
check(not config.valid_name('a__b') and not config.valid_name('ends_'),'wire-ambiguous server names rejected')
do
    local _,remote_servers=config.parse({servers={cloud={url='https://api.example/mcp',auth='mcp.cloud',headers={['X-Tenant']='${env:TENANT}'}}}},{project_root='/project'},function(k) if k=='TENANT' then return 'tenant-a' end end)
    eq(remote_servers.cloud.transport,'http'); eq(remote_servers.cloud.url,'https://api.example/mcp')
    eq(remote_servers.cloud.auth,'mcp.cloud'); eq(remote_servers.cloud.headers['X-Tenant'],'tenant-a')
    local _,safe_server,header_warnings=config.parse({servers={remote={url='https://api.example',auth='mcp',headers={
        Host='h',Connection='c',['Content-Length']='1',['Transfer-Encoding']='chunked',Expect='100-continue',Upgrade='websocket',
        TE='trailers',['Keep-Alive']='x',['Proxy-Connection']='x',Authorization='Bearer SECRET',
        ['Bad Header']='x',['X-Empty']='${env:EMPTY}',['X-Good']='fine'}}}},{project_root='/project'},function() end)
    eq(#header_warnings,12,'unsafe HTTP headers warn at parse time'); eq(safe_server.remote.headers['X-Good'],'fine')
    for _,header in ipairs({'Host','Connection','Content-Length','Transfer-Encoding','Expect','Upgrade','TE','Keep-Alive','Proxy-Connection','Authorization','Bad Header','X-Empty'}) do
        eq(safe_server.remote.headers[header],nil,'forbidden header omitted: '..header)
    end
    check(not table.concat(header_warnings,' '):find('SECRET',1,true),'header warnings do not reveal values')
    local _,http_servers,http_warnings=config.parse({servers={
        insecure={url='http://example.test/mcp',headers={Cookie='SECRET',['X-API-Key']='APISECRET'}},
        secret={url='http://api.example/mcp',auth='mcp.secret'},
        loopback={url='http://127.0.0.1:9000/mcp',auth='mcp.local',headers={Cookie='local'}}
    }},{project_root='/project'})
    eq(#http_warnings,3,'plain non-loopback credentials warn early'); check(not http_servers.secret,'unsafe named auth server skipped')
    eq(next(http_servers.insecure.headers),nil,'sensitive non-loopback headers omitted')
    eq(http_servers.loopback.headers.Cookie,'local','loopback sensitive header allowed')
    check(not table.concat(http_warnings,' '):find('APISECRET',1,true),'credential warnings redact values')
    local long_idle,_,warnings_idle=config.parse({idle_timeout_ms=120001,servers={}},{project_root='/project'})
    eq(long_idle.idle_timeout_ms,120001); eq(#warnings_idle,0,'Lua-owned idle timeout has no core cap')
end
eq(config.hash('hello'),'4f9f2cab','FNV-1a vector')
eq(config.canonical({b=2,a=1}),config.canonical({a=1,b=2}),'canonical order')
check(config.fingerprint(servers.fs)~=config.fingerprint({command='changed'}),'identity changes')
eq(cache.directory(function(k) if k=='XDG_DATA_HOME' then return '' elseif k=='HOME' then return '/h' end end),'/h/.local/share/panto-mcp')
local _,eager_servers,eager_warnings=config.parse({servers={fast={command='echo',expose='eager'}}},{project_root='/project'})
eq(eager_servers.fast.expose,'eager','eager setting preserved until core capability check'); eq(#eager_warnings,0,'eager does not warn before activation')
check(config.tool_name('fs','a.b')~=config.tool_name('fs','a_b'),'sanitizer collisions')
local sanitized_candidate=config.tool_name('fs','a.b')
local crafted_collision=sanitized_candidate:sub(#'mcp.fs.'+1)
check(config.tool_name('fs',crafted_collision)~=sanitized_candidate,'own-name suffix avoids crafted sanitizer collision')
local stable_name=config.tool_name('fs','stable.tool')
config.tool_name('fs','a new tool')
eq(config.tool_name('fs','stable.tool'),stable_name,'adding a catalog name cannot rename an eager tool')
for _,c in ipairs({
    {'a.b','mcp.fs.a_b-'}, {'a__b','mcp.fs.a_b-'},
}) do check(config.tool_name('fs',c[1]):find(c[2],1,true),'sanitized wire name '..c[1]) end
local long_a=config.tool_name('fs',string.rep('x',300)); local long_b=config.tool_name('fs',string.rep('y',300))
eq(#(long_a:gsub('%.','__'))<=64,true,'wire length')
check(long_a~=long_b,'hash-suffixed truncation distinguishes long names')
local long_server_a=config.tool_name(string.rep('s',40)..'a','tool'); local long_server_b=config.tool_name(string.rep('s',40)..'b','tool')
check(long_server_a~=long_server_b,'long server names are disambiguated')
eq(config.tool_name('github','create_issue'),'mcp.github.create_issue','unchanged eager name has no suffix')
eq(config.tool_name(string.rep('s',32),'create_issue'),'mcp.'..string.rep('s',32)..'.create_issue','32-byte server leaves normal tool name intact')
do
    local names={'list','_x','x_','__','a.b','é','',string.rep('z',200),'a b','a/b','a__b','_','-','---___'}
    local seed=1
    local function random(n) seed=(seed*1664525+1013904223)&0xffffffff; return (seed%n)+1 end
    for _=1,3000 do local out={}; for _=1,random(90) do out[#out+1]=string.char(31+random(95)) end; names[#names+1]=table.concat(out) end
    local seen={}; local valid=true
    for _,server in ipairs({'a','gh','a-b','x_y',string.rep('s',32),string.rep('t',33),string.rep('u_',40)..'u','s-_-'} ) do
        for _,name in ipairs(names) do
            local wire=config.tool_name(server,name):gsub('%.','__'); local parts={}; local cursor=1
            while true do local at=wire:find('__',cursor,true); if not at then parts[#parts+1]=wire:sub(cursor); break end
                parts[#parts+1]=wire:sub(cursor,at-1); cursor=at+2 end
            local identity=server..'\0'..name
            if #wire>64 or #parts~=3 or parts[1]~='mcp' or not wire:match('^[A-Za-z0-9_-]+$') or (seen[wire] and seen[wire]~=identity) then valid=false end
            seen[wire]=identity
        end
    end
    check(valid,'names_probe regression: 3000 random names x 8 servers decode without collisions within wire limits')
end
check(config.tool_enabled({enabled_tools={'read*'},disabled_tools={'*secret*'}},'read_file'),'enabled glob')
check(not config.tool_enabled({enabled_tools={},disabled_tools={'delete_*'}},'delete_a'),'disabled glob')
-- Validator table: false/null, deep equality, combinators, refs, prefix items,
-- JSON-pointer paths, Unicode lengths and multiple independent diagnostics.
for i,c in ipairs({
    {false,{type='boolean'},true}, {json.null,{type='null'},true}, {json.null,{type='object'},false},
    {{},{type='object'},true}, {json.array({}),{type='array'},true}, {json.array({}),{type='object'},false}, {{1,2},{type='object'},false},
    {{a=1},{enum={{a=1}}},true}, {{a=1},{const={a=2}},false},
    {2,{anyOf={{type='string'},{type='integer'}}},true}, {2,{oneOf={{type='number'},{type='integer'}}},true},
    {2,{allOf={{minimum=1},{maximum=1}}},false}, {2,{['not']={const=2}},true},
    {{x=1},{patternProperties={['^x']={type='number'}},additionalProperties=false},true},
    {{x=3},{type='object',properties={x={['$ref']='#/$defs/n'}},['$defs']={n={minimum=4}}},false},
    {'x',{['$ref']='#/$defs/tuple/0',['$defs']={tuple={{type='integer'}}}},false},
    {2,{['$ref']='#/$defs/',['$defs']={['']={const=1}}},false},
    {{'x',3},{prefixItems={{type='string'}},items={minimum=2}},true},
    {{'x',1},{prefixItems={{type='string'}},items=false},false},
    {1,{exclusiveMinimum=1},false}, {0.3,{multipleOf=0.1},true},
    {'é',{maxLength=1},true}, {'x',{pattern='never',format='unknown'},true},
    {{a=1},{additionalProperties=false},false}, {{1,1},{uniqueItems=true},false},
    {{},{minItems=1},false}, {{},{required={'x'}},false},
}) do local ok=validate.check(c[1],c[2]); eq(ok,c[3],'validator case ' .. i) end
local valid,errors=validate.check({['a/b']=1,z=false},{properties={['a/b']={type='string'},z={type='integer'}}})
check(not valid and #errors==2 and table.concat(errors,' '):find('/a~1b',1,true),'multiple pointer errors')
-- Prompt arguments are parsed synchronously; quoted values and a single
-- positional remainder are covered table-first rather than via the TUI.
local one_arg={arguments={{name='text',required=true}}}
local named_prompt={arguments={{name='person',required=true},{name='tone'}}}
for _,case in ipairs({
    {one_arg,'two words "quoted phrase"',{text='two words "quoted phrase"'}},
    {one_arg,'hello   world',{text='hello   world'}},
    {one_arg,"Don't",{text="Don't"}},
    {one_arg,'text="Ada Lovelace"',{text='Ada Lovelace'}},
    {one_arg,'other=literal',{text='other=literal'}},
    {one_arg,'back\\slash',{text='back\\slash'}},
    {named_prompt,'person="Ada Lovelace" tone=\'calm voice\'',{person='Ada Lovelace',tone='calm voice'}},
    {named_prompt,'person=Ada\\ Lovelace',{person='Ada Lovelace'}},
}) do
    local value,why=prompts.parse_arguments(case[1],case[2]); check(value,tostring(why)..' input='..case[2])
    for key,expected in pairs(case[3]) do eq(value[key],expected,'prompt argument '..key) end
end
for _,case in ipairs({
    {named_prompt,'','missing required arguments: person'},
    {named_prompt,'person="open','unclosed quote'},
    {named_prompt,'other=x','unknown prompt argument: other'},
    {named_prompt,'person=x person=y','duplicate prompt argument: person'},
}) do local value,why=prompts.parse_arguments(case[1],case[2]); check(not value and why:find(case[3],1,true),'prompt parse error '..case[3]) end
local prompt_messages={
    {role='user',content={type='text',text='before'}},
    {role='assistant',content={{type='text',text='answer'},{type='image',data='aGk=',mimeType='image/png'}}},
    {role='user',content={type='text',text='last'}}
}
local mapped_prompt=assert(prompts.map_messages(prompt_messages))
eq(mapped_prompt[1].role,'user'); eq(mapped_prompt[2].role,'assistant')
check(mapped_prompt[2].blocks[2].text:find('Assistant media omitted',1,true),'assistant media becomes placeholder')
local conv_log={}; local conversation={}
function conversation:add_user_blocks(blocks) conv_log[#conv_log+1]={role='user',blocks=blocks} end
function conversation:add_assistant_message(message) conv_log[#conv_log+1]={role='assistant',blocks=message.blocks} end
local media_prompt=assert(prompts.map_messages({{role='user',content={{type='resource',resource={uri='file://x',blob='JVBERi0=',mimeType='application/pdf'}},{type='image',data='aGk=',mimeType='image/png'}}}}))
eq(media_prompt[1].blocks[1].type,'text','non-image resource blob becomes a placeholder')
eq(media_prompt[1].blocks[2].type,'media','image/* content remains media')
local unsupported=assert(prompts.map_messages({{role='user',content={type='image',data='aGk=',mimeType='image/svg+xml'}}}))
eq(unsupported[1].blocks[1].type,'text','unsupported image subtype becomes a placeholder')
local submitted; local agent={}
function agent:conversation() return conversation end
function agent:submit(blocks) submitted=blocks end
local invalid_prompt={{role='user',content={type='text',text='valid'}},{role='system',content={type='text',text='invalid role'}}}
local no_append,append_error=prompts.append_to(agent,invalid_prompt)
check(not no_append and append_error and #conv_log==0,'all prompt messages map before conversation mutation')
if type(require('panto').conversation)=='function' then
    local ok,why=prompts.append_to(agent,{{role='user',content={type='image',data='aGk=',mimeType='image/png'}}})
    check(ok==nil and why=='MCP prompt image could not be decoded' and #conv_log==0,'preflight failure is clean and does not mutate conversation')
end
check(prompts.append_to(agent,prompt_messages),'trailing user prompt submits')
eq(#conv_log,2,'trailing user is not duplicated')
eq(conv_log[1].role,'user'); eq(conv_log[2].role,'assistant'); eq(submitted[1].text,'last')
submitted=nil; conv_log={}
check(not prompts.append_to(agent,{prompt_messages[1],prompt_messages[2]}),'assistant-tail does not submit')
eq(#conv_log,2,'assistant-tail appends all roles'); eq(submitted,nil)
-- Slash callbacks return synchronously; a late async result is discarded if a turn starts meanwhile.
do
    local waits={async.future(),async.future(),async.future()}; local request_count=0; local command_spec
    local turn_state={busy=false}; local conversation_log={}; local sent_blocks; local emitted={}
    local prompt_agent={}
    function prompt_agent:conversation()
        return {
            add_user_blocks=function(_,blocks) conversation_log[#conversation_log+1]={role='user',blocks=blocks} end,
            add_assistant_message=function(_,message) conversation_log[#conversation_log+1]={role='assistant',blocks=message.blocks} end,
        }
    end
    function prompt_agent:submit(blocks) sent_blocks=blocks end
    local saved_module=package.loaded.panto
    package.loaded.panto={ext={agent=prompt_agent}}
    local prompt_manager={}
    function prompt_manager:prompt() request_count=request_count+1; return waits[request_count]:await() end
    local command_set=prompts.commands({register_command=function(spec) command_spec=spec; return true end,
        unregister_command=function() return true end,emit=function(name) emitted[#emitted+1]=name end},prompt_manager,turn_state,true)
    command_set.reconcile('server',{catalog={prompts={{name='ask',arguments={{name='who',required=true}}}}}},true)
    check(command_spec,'async prompt command registered')
    turn_state.busy=true
    check(command_spec.handler('who=busy'):find('turn is in progress',1,true),'prompt refuses an active turn')
    eq(request_count,0,'busy prompt does not start network request')
    turn_state.busy=false
    check(command_spec.handler('who=first'):find('Fetching',1,true),'prompt callback returns immediately')
    eq(request_count,1)
    waits[1]:resolve({{role='assistant',content={type='text',text='prior'}},{role='user',content={type='text',text='question'}}})
    eq(conversation_log[1].role,'assistant','async prompt preserves assistant role')
    eq(sent_blocks[1].text,'question','async prompt submits trailing user blocks')
    local before=#conversation_log; turn_state.busy=false
    command_spec.handler('who=late'); eq(request_count,2)
    turn_state.busy=true
    waits[2]:resolve({{role='user',content={type='text',text='discard'}}})
    eq(#conversation_log,before,'result arriving during a new turn is discarded')
    eq(sent_blocks[1].text,'question','discarded prompt does not submit')
    turn_state.busy=false
    command_spec.handler('who=tail')
    waits[3]:resolve({{role='assistant',content={type='text',text='assistant tail'}}})
    eq(emitted[1],'agent_submission','assistant-tail prompt wakes TUI conversation sync')
    eq(sent_blocks[1].text,'question','assistant-tail prompt does not submit a turn')
    package.loaded.panto=saved_module
end
do
    local callbacks={}; local busy_state={busy=false}
    prompts.track_busy({on=function(name,fn) callbacks[name]=fn end},busy_state,{registered={['mcp:server:ask']=true}})
    callbacks.command_start({command_name='mcp:server:ask'}); eq(busy_state.busy,false,'prompt command itself does not block its callback')
    callbacks.command_end({command_name='mcp:server:ask'})
    callbacks.command_start({command_name='compact'}); check(busy_state.busy,'command_start marks /compact busy')
    callbacks.turn_start({}); callbacks.command_end({command_name='compact'})
    check(busy_state.busy,'command_end cannot clear active turn state')
    callbacks.turn_end({}); eq(busy_state.busy,false,'turn_end clears busy after compact')
end
do
    local registrations,removed,warnings,event_hooks={}, {}, {}, {}
    local mount_component,mount_handle
    local ext={
        register_command=function(spec) registrations[spec.name]=spec; return true end,
        unregister_command=function(name) removed[#removed+1]=name; registrations[name]=nil; return true end,
        on=function(name,fn) event_hooks[name]=fn end,
        mount=function(component,placement)
            eq(placement,'above_input','prompt errors mount above input')
            mount_component=component; mount_handle={live=true}
            function mount_handle:alive() return self.live end
            function mount_handle:invalidate() self.invalidated=true end
            function mount_handle:unmount() self.live=false end
            return mount_handle
        end,
    }
    local failure=async.future(); local prompt_manager={}
    function prompt_manager:prompt() return failure:await() end
    local commands=prompts.commands(ext,prompt_manager,{busy=false},true,warnings)
    commands.reconcile('a',{catalog={prompts={{name='pa'}}}},true)
    commands.reconcile('b',{catalog={prompts={{name='pb'},{name='bad/name'},{name='bad name'}}}},true)
    commands.reconcile('a',{catalog={prompts={{name='pa'}}}},false)
    check(registrations['mcp:a:pa'] and registrations['mcp:b:pb'],'reconciling one server preserves other-server prompt commands')
    check(not registrations['mcp:b:bad/name'] and not registrations['mcp:b:bad name'],'core-invalid prompt command names skipped')
    local warning_status=require('panto_mcp.tools').status({servers=function() return {} end},warnings)
    check(warning_status:find('prompt command skipped',1,true),'invalid prompt names appear in /mcp warnings')
    check(registrations['mcp:b:pb'].handler(''):find('Fetching',1,true),'prompt failure command returns immediately')
    failure:resolve(nil,'server unavailable')
    check(mount_handle and mount_handle:alive() and mount_component.render():find('server unavailable',1,true),'async prompt failure is visible above input')
    event_hooks.command_start({command_name='next'})
    check(not mount_handle:alive(),'prompt error mount clears at next command_start')
    registrations['mcp:b:pb'].handler(''); event_hooks.turn_start({})
    check(not mount_handle:alive(),'prompt error mount clears on a normal turn')
end
-- NDJSON chunks/CRLF and malformed/oversized lines.
local bad_lines={}; local frames={}; local feed=stdio.framer(function(m) frames[#frames+1]=m end,nil,function(line) bad_lines[#bad_lines+1]=line end)
check(feed('{"jsonrpc":"2.0",'),'partial frame'); check(feed('"id":1,"result":{}}\r\n\n{"id":2}\n'),'CRLF frame')
eq(#frames,2); eq(frames[1].id,1)
check(not stdio.framer(function() end,4)('12345'),'frame cap')
check(feed('not json\n{"id":3}\n'),'bad stdout line does not stop transport'); eq(#bad_lines,1); eq(#frames,3)
do
-- OAuth policy checks use injected auth, HTTP and timers; no credentials or wall-clock sleeps.
do
    local OAuth=require('panto_mcp.oauth')
    local sha256=require('panto_mcp.hash').sha256
    for _,case in ipairs({
        {'','e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'},
        {'abc','ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad'},
        {'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq','248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1'},
    }) do eq(sha256(case[1]),case[2],'SHA-256 known vector') end
    for _,case in ipairs({
        {'Bearer scope="read write", resource_metadata="https://r.example/meta"','read write','https://r.example/meta'},
        {'Basic realm="a,b", Bearer scope="read", error="insufficient_scope"','read',nil,'insufficient_scope'},
        {'Digest realm="x", nonce="a\\\"b,c", Bearer resource_metadata="https://r.example/a,b", scope="r\\ead"','read','https://r.example/a,b'},
        {'Bearer scope="first", Basic realm="x", Bearer resource_metadata="https://r.example/m", scope="second"','second','https://r.example/m'},
        {'Bearer scope="unterminated',nil},
        {'Bearer scope="one", scope="two"',nil},
        {'Basic realm="private"',nil},
    }) do
        local c=OAuth.challenge(case[1]); eq(c.scope,case[2],'challenge scope'); eq(c.resource_metadata,case[3],'challenge PRM'); eq(c.error,case[4],'challenge error')
    end
    for _,case in ipairs({
        {'https://API.example/mcp','https://api.example/.well-known/oauth-protected-resource/mcp,https://api.example/.well-known/oauth-protected-resource'},
        {'https://api.example/','https://api.example/.well-known/oauth-protected-resource'},
        {'https://api.example/a/b?tenant=x','https://api.example/.well-known/oauth-protected-resource/a/b,https://api.example/.well-known/oauth-protected-resource'},
    }) do eq(table.concat(OAuth.prm_urls(case[1]),','),case[2],'PRM URL order') end
    for _,case in ipairs({
        {'https://as.example','https://as.example/.well-known/oauth-authorization-server,https://as.example/.well-known/openid-configuration'},
        {'https://as.example/tenant','https://as.example/.well-known/oauth-authorization-server/tenant,https://as.example/.well-known/openid-configuration/tenant,https://as.example/tenant/.well-known/openid-configuration'},
    }) do eq(table.concat(OAuth.metadata_urls(case[1]),','),case[2],'AS URL order') end
    for _,url in ipairs({'http://evil.example','https://u:p@as.example','https://as.example/#x','https://as.example\\@evil.test','https://127.0.0.1:99999'}) do eq(OAuth.url(url),nil,'unsafe OAuth URL rejected') end
    eq(OAuth.url('HTTPS://API.example:443/mcp'),'https://api.example/mcp','canonical resource')
    eq(table.concat(OAuth.union({'read','read'},{'write','read'}),' '),'read write','scope union')
    eq(#OAuth.scopes({'bad scope','quote"','back\\slash','read'}),1,'invalid scope tokens omitted')
    local metadata={issuer='https://as.example/tenant',authorization_endpoint='https://as.example/authorize',token_endpoint='https://as.example/token',code_challenge_methods_supported={'plain','S256'}}
    for _,case in ipairs({{metadata.issuer,true},{'https://as.example/tenant/',false},{'https://evil.example',false}}) do
        eq(not not OAuth.validate_metadata(metadata,case[1]),case[2],'exact issuer')
    end
    metadata.code_challenge_methods_supported={'plain'}; check(not OAuth.validate_metadata(metadata,metadata.issuer),'reject missing S256')
    metadata.code_challenge_methods_supported=nil; check(not OAuth.validate_metadata(metadata,metadata.issuer),'reject absent PKCE declaration')
    local _,configured,config_warnings=config.parse({servers={oauth={url='https://api.example/mcp',oauth={client_id='id',issuer='https://as.example/tenant',client_secret='${env:SECRET}',scopes={'configured'}}}}},{project_root='/project'},function() return 'DO_NOT_LOG' end)
    eq(configured.oauth.oauth.client_secret,'DO_NOT_LOG','OAuth secret expansion'); eq(#config_warnings,0)
    local _,missing_issuer,missing_warnings=config.parse({servers={remote={url='https://api.example/mcp',oauth={client_id='id',client_secret='secret'}}}},{project_root='/project'})
    check(not missing_issuer.remote and missing_warnings[1]:find('oauth.issuer',1,true),'H1 configured client requires an issuer binding')
    local session=OAuth.session_name(string.rep('s',200),'https://resource.example/mcp','https://issuer.example','id')
    check(#session<=128,'H2 bounded core session name')
    for _,identity in ipairs({{'https://other.example/mcp','https://issuer.example','id'},{'https://resource.example/mcp','https://other.example','id'},{'https://resource.example/mcp','https://issuer.example','other'}}) do
        check(OAuth.session_name(string.rep('s',200),table.unpack(identity))~=session,'H2 resource/issuer/client identity changes token namespace')
    end
    eq(session,OAuth.session_name(string.rep('s',200),'https://resource.example/mcp','https://issuer.example','id'),'H2 session name is deterministic')
    for _,url in ipairs({'http://0127.0.0.1/x','https://127.00.0.1/x','http://127.0.0.01/x','https://127.1/x','https://2130706433/x','https://0x7f000001/x'}) do eq(OAuth.url(url),nil,'ambiguous IPv4 octets rejected') end
    local status={state='logged_out'}; local specs={}; local logins,refreshes=0,0; local definitions=0
    local clock=0; local status_reads=0; local refresh_failure=false; local login_failure=false
    local dcr_count=0; local logouts={}; local prm_servers
    local issuer='https://as.example/tenant'; local scope_challenge='read write'
    local fake_auth={
        define=function(name,spec) definitions=definitions+1; specs[name]=spec; return true end,
        status=function() status_reads=status_reads+1; return status end,
        login=function() logins=logins+1; if login_failure then login_failure=false; return nil,'AuthFlowFailed' end; status={state='pending'}; return {url='https://as.example/authorize?state=opaque'} end,
        logout=function(name) logouts[#logouts+1]=name; return true end,
        complete=function(_,url) if url=='bad' then return nil,'SECRET' end; status={state='pending'}; return true end,
        refresh=function() refreshes=refreshes+1; if refresh_failure then status={state='logged_out'}; return nil,type(refresh_failure)=='string' and refresh_failure or 'AuthLoginRequired' end; status={state='pending'}; return true end,
    }
    local stored={}; local fake_state={get=function(k) return stored[k] end,set=function(k,v) stored[k]=v; return true end}
    local sent={}; local protected='normal'; local refresh_once=false
    local registration_result={client_id='dynamic-public',registration_access_token='DO_NOT_STORE'}
    local function request_fn(opts,cb)
        sent[#sent+1]=opts
        local response={status=200,headers={},body=''}
        if opts.url=='https://api.example/mcp' then
            if not opts.auth or protected=='always401' or ((protected=='refresh' or protected=='refresh_scope') and not refresh_once) then
                if opts.auth then refresh_once=true end
                response.status=401; response.headers['www-authenticate']='Basic realm="x", Bearer resource_metadata="https://api.example/meta", scope="read"'
                response.body='DO_NOT_LOG_ACCESS_TOKEN'
            elseif protected=='bad_body' then
                response.status=500; response.body='DO_NOT_LOG_ACCESS_TOKEN'
            elseif protected=='bad_rpc' then
                response.status=500; local req=json.decode(opts.body)
                response.body=json.encode({jsonrpc='2.0',id=req.id,error={code=-32000,message='DO_NOT_LOG_ACCESS_TOKEN'}})
            elseif (protected=='scope' or protected=='refresh_scope') and json.decode(opts.body).params.arguments and json.decode(opts.body).params.arguments.restricted then
                response.status=403; response.headers['www-authenticate']='Bearer error="insufficient_scope", scope="'..scope_challenge..'"'
            else
                local req=json.decode(opts.body)
                local result=req.method=='server/discover' and {capabilities={tools={}},resultType='complete'} or
                    req.method=='tools/list' and {tools={{name='echo',inputSchema={type='object'}}}} or {content={{type='text',text='oauth success'}}}
                response.body=json.encode({jsonrpc='2.0',id=req.id,result=result})
            end
        elseif opts.url=='https://api.example/meta' then
            check(not opts.auth and not opts.headers.Authorization,'discovery never carries credentials')
            response.body=json.encode({resource='https://api.example/mcp',authorization_servers=prm_servers or {issuer},scopes_supported={'fallback'}})
        elseif opts.url==OAuth.metadata_urls(issuer)[1] then
            local origin=issuer:match('^(https://[^/]+)')
            response.body=json.encode({issuer=issuer,authorization_endpoint=origin..'/authorize',token_endpoint=origin..'/token',
                registration_endpoint=origin..'/register',code_challenge_methods_supported={'S256'},authorization_response_iss_parameter_supported=true})
        elseif opts.url==issuer:match('^(https://[^/]+)')..'/register' then
            dcr_count=dcr_count+1; registration_result.client_id='dynamic-public-'..dcr_count
            local body=json.decode(opts.body)
            eq(body.application_type,'native'); eq(body.redirect_uris[1],'http://127.0.0.1/callback'); eq(body.token_endpoint_auth_method,'none')
            eq(table.concat(body.grant_types,','),'authorization_code,refresh_token')
            response.body=json.encode(registration_result)
        else error('unexpected fake OAuth request') end
        cb(response); return {cancel=function() end}
    end
    local ts,tf=timers()
    local _,cfgs=config.parse({servers={remote={url='https://api.example/mcp'}}},{project_root='/project'})
    local manager=Manager.new(settings,cfgs,{cache_dir=temp..'/oauth-cache',request_fn=request_fn,auth=fake_auth,state=fake_state,timer_factory=tf,clock=function() return clock end})
    local s=manager.states.remote; local oauth=s.oauth
    manager:start(s)
    eq(s.state,'failed','401 discovers then stops for user login'); check(s.error:find('/mcp-login remote',1,true),'login-required error: '..tostring(s.error))
    eq(logins,0,'never starts login automatically'); eq(#sent,4,'401 PRM AS DCR sequence'); eq(definitions,1)
    check(oauth:blocked(),'logged-out scoped session requires login')
    local not_authorized=OAuth.new(cfgs.remote,{auth=fake_auth,state=fake_state,request_fn=request_fn,timer_factory=tf})
    check(not_authorized:blocked() and not not_authorized:request_auth(),'warm definition still checks core status'); not_authorized:close()
    eq(specs[oauth.name].resource,'https://api.example/mcp'); eq(specs[oauth.name].scopes[1],'read','challenge overrides PRM')
    check(specs[oauth.name].require_iss,'require issuer in callback when advertised')
    check(not json.encode(stored):find('DO_NOT_STORE',1,true),'DCR registration tokens never persisted')
    local initial_name=oauth.name
    local command=manager:login('remote'); eq(dcr_count,1,'first login does not repeat initial DCR'); eq(oauth.name,initial_name,'first login retains token namespace')
    check(command:find('https://as.example/authorize',1,true),'login prints URL'); check(command:find('<callback-url>',1,true),'headless instructions')
    local function tick() local t=ts[#ts]; check(t and not t.closed,'poll timer armed'); clock=clock+t.ms; t:fire() end
    status={state='logged_in'}; tick()
    eq(s.state,'ready','login completion reconnects'); eq(logins,1)
    local output; async.run(function() output=manager:call('remote','echo',{}) end,error)
    check(output and not output.is_error and output.text:find('oauth success',1,true),'authenticated tool success')
    for _,mode in ipairs({'bad_body','bad_rpc'}) do
        protected=mode; async.run(function() output=manager:call('remote','echo',{}) end,error)
        check(output.is_error and not output.text:find('DO_NOT_LOG',1,true),'authenticated HTTP errors discard reflected credentials')
    end
    protected='normal'
    local before=#sent
    local warm=OAuth.new(cfgs.remote,{auth=fake_auth,state=fake_state,request_fn=request_fn,timer_factory=tf})
    eq(#sent,before,'warm activation does not rediscover'); check(warm.definition,'warm definition restored')
    protected='refresh'; output=nil
    async.run(function() output=manager:call('remote','echo',{}) end,error)
    eq(refreshes,1,'401 forces one refresh'); check(not output,'refresh waits asynchronously')
    local parallel; local before_parallel=#sent
    async.run(function() parallel=manager:call('remote','echo',{}) end,error)
    check(not parallel,'M4 parallel calls wait for forced refresh'); eq(#sent,before_parallel,'no unauthenticated call while refresh pending')
    eq(oauth:request_auth(),oauth.name,'M4 refresh-pending retains auth name')
    status={state='logged_in'}; tick(); check(output and not output.is_error,'refresh retries successfully')
    check(parallel and not parallel.is_error,'M4 parallel call succeeds after refresh')
    protected='always401'; output=nil
    async.run(function() output=manager:call('remote','echo',{}) end,error)
    status={state='logged_in'}; tick()
    check(output.is_error and output.text:find('/mcp-login remote',1,true),'second 401 requires login'); eq(refreshes,2,'never refreshes twice per request')
    check(not output.text:find('DO_NOT_LOG',1,true),'401 body never reaches tool errors')
    eq(manager:login('remote','bad'),'OAuth callback rejected; check the URL/state/issuer and retry','callback rejection hides core detail')
    protected='normal'; manager:login('remote','callback'); status={state='logged_in'}; tick()
    protected='refresh_scope'; refresh_once=false; output=nil; async.run(function() output=manager:call('remote','echo',{restricted=true}) end,error)
    status={state='logged_in'}; tick()
    check(output.is_error and output.text:find('/mcp-login remote',1,true),'scope step-up after refresh asks for consent')
    eq(table.concat(oauth.spec.scopes,' '),'read write','scope step-up unions scopes')
    check(not oauth.login_required,'M3 scope step-up does not lock out the server')
    local stepped=OAuth.new(cfgs.remote,{auth=fake_auth,state=fake_state,request_fn=request_fn,timer_factory=tf})
    check(not stepped:blocked() and stepped:request_auth(),'M3 warm scope upgrade preserves usable token'); stepped:close()
    local requests_before=#sent; async.run(function() output=manager:call('remote','echo',{}) end,error)
    check(#sent>requests_before and not output.is_error,'M3 unrelated tool still works after a scope challenge')
    scope_challenge='read'; status={state='logged_in',scopes={'read'}}; clock=clock+1000
    async.run(function() output=manager:call('remote','echo',{restricted=true}) end,error)
    check(output.is_error and not oauth.login_required,'M3 already-held scope is a per-tool permission failure, not a server lockout')
    async.run(function() output=manager:call('remote','echo',{}) end,error)
    check(not output.is_error,'M3 unrelated tool works after already-held scope challenge')
    local logins_before=logins
    for i=1,5 do
        local ok,err=oauth:recover({http_status=403,challenge={error='insufficient_scope',scope='extra'..i}})
        check(not ok and err:find('/mcp-login',1,true),'scope upgrades require user action, not an artificial counter')
    end
    eq(logins,logins_before,'scope challenges never start login automatically')
    protected='refresh'; refresh_once=false; refresh_failure='AuthFlowFailed'; status={state='logged_in'}
    local discovery_before=#sent
    async.run(function() output=manager:call('remote','echo',{}) end,error)
    check(output.is_error and #sent>discovery_before+1 and oauth.definition,'M6 refresh failure rediscovered metadata and registration')
    eq(dcr_count,1,'transient refresh failure keeps DCR registration'); eq(oauth.name,initial_name,'transient failure retains token namespace')
    check(output.text:find('--reregister',1,true),'failed refresh explains registration escape hatch')
    refresh_failure=false; protected='normal'; issuer='https://as2.example/tenant'; local old_name=oauth.name; login_failure=true
    local refreshed_login=manager:login('remote')
    check(refreshed_login:find('https://as.example/authorize',1,true),'M6 manual login starts after rediscovery')
    eq(oauth.spec.issuer,issuer,'M6 manual login observes changed issuer'); check(oauth.name~=old_name,'H2 changed issuer selects a different token file')
    eq(logouts[#logouts],old_name,'issuer/name change logs out previous session')
    status={state='logged_in'}; tick(); eq(s.state,'ready','rediscovered login reconnects')
    local count=dcr_count; local stable=oauth.name; local requests=#sent
    manager:login('remote')
    eq(dcr_count,count,'repeat consent login keeps DCR registration'); eq(oauth.name,stable,'repeat consent retains session name'); eq(#sent,requests,'usable definition avoids rediscovery')
    check(not oauth:blocked() and not oauth.login_required,'consent login does not block an existing usable token')
    async.run(function() output=manager:call('remote','echo',{}) end,error)
    check(not output.is_error,'working tools remain usable during consent')
    for _=1,670 do
        local t; for i=#ts,1,-1 do if not ts[i].closed then t=ts[i]; break end end
        assert(t,'login poll must remain active until give-up'); clock=clock+t.ms; t:fire()
    end
    check(not oauth.login_required and not oauth:blocked(),'abandoned consent poll clears lockout and retains usable token')
    check(s.error:find('--reregister',1,true),'failed login poll explains escape hatch')
    status={state='logged_in'}; clock=clock+1000
    async.run(function() output=manager:call('remote','echo',{}) end,error); check(not output.is_error,'working tools survive abandoned consent')
    manager:login('remote',nil,true)
    eq(dcr_count,count+1,'explicit --reregister performs exactly one DCR'); check(oauth.name~=stable,'explicit reregistration selects new client namespace')
    eq(logouts[#logouts],stable,'explicit reregistration logs out old namespace')
    status={state='logged_in'}; tick()
    manager:close(); warm:close()
    for _,case in ipairs({{method='none',secret='IGNORE_PUBLIC_SECRET'},{method='client_secret_basic',secret='CONFIDENTIAL_DCR_SECRET'}}) do
        local key='mcp.oauth.registration_'..config.hash(issuer); stored[key]=nil
        registration_result={client_id='registered-'..case.method,client_secret=case.secret,token_endpoint_auth_method=case.method}
        local instance=OAuth.new({name='client_'..case.method,url=cfgs.remote.url,fingerprint=case.method},
            {auth=fake_auth,state=fake_state,request_fn=request_fn,timer_factory=tf})
        local ok,why=instance:discover({resource_metadata='https://api.example/meta'})
        check(not ok and why:find('Confidential DCR',1,true),'M5 refuse any DCR secret, including public-method responses')
        check(not instance.spec and not stored[key],'M5 confidential DCR is never defined or persisted')
        check(not why:find(case.secret,1,true) and not json.encode(stored):find(case.secret,1,true),'M5 secret absent from state/errors')
        instance:close()
    end
    local old=OAuth.new(cfgs.remote,{auth={},state=fake_state,request_fn=request_fn,timer_factory=tf})
    local _,old_error=old:recover({http_status=401}); check(old_error:find('newer panto',1,true),'old core OAuth clear error')
    local override=OAuth.new({name='remote',url='https://api.example/mcp',auth='custom'},{auth=fake_auth,state=fake_state})
    eq(override:request_auth(),'custom','explicit auth takes precedence'); check(not override.definition,'explicit auth disables automatic definition')
    for _,auth in ipairs({{}, {define=function() return true end,status=function() return {state='logged_in'} end,login=function() return nil,'UnsupportedAuthType' end,complete=function() end,refresh=function() return nil,'UnsupportedAuthType' end}}) do
        local explicit=OAuth.new({name='explicit',auth='api-key',url=cfgs.remote.url},{auth=auth,state=fake_state})
        local _,err=explicit:recover({http_status=401,auth_used=true})
        check(err:find('Configured auth session',1,true) and not err:find('newer panto',1,true) and not err:find('/mcp-login',1,true),'explicit/non-PKCE auth rejection has actionable, accurate error')
    end
    local _,permission_error=override:recover({http_status=403,challenge={}})
    check(permission_error:find('permissions',1,true) and not permission_error:find('/mcp-login',1,true),'unrelated 403 is not a login instruction')
    local cached=OAuth.new(cfgs.remote,{auth=fake_auth,state=fake_state,clock=function() return clock end})
    local reads_before=status_reads
    for _=1,100 do cached:status(); cached:blocked(); cached:request_auth() end
    eq(status_reads,reads_before+1,'status reads cached across request/status paths')
    clock=clock+999; cached:status(); eq(status_reads,reads_before+1,'status cache holds for one second')
    clock=clock+1; cached:status(); eq(status_reads,reads_before+2,'status cache refreshes after one second'); cached:close()
    local unsafe_requests=0
    local remote_policy=OAuth.new({name='remote',url='https://resource.example/mcp'},{auth=fake_auth,state=fake_state,request_fn=function() unsafe_requests=unsafe_requests+1 end})
    for _,url in ipairs({'http://127.0.0.1:6379/','http://[::1]/','https://127.0.0.1/','https://localhost/','https://localhost./','https://[0:0:0:0:0:0:0:1]/','https://[::ffff:7f00:1]/'}) do
        local value=remote_policy:fetch(url); check(not value,'remote OAuth cannot reach loopback discovery/DCR')
    end
    eq(unsafe_requests,0,'unsafe loopback URLs rejected before HTTP')
    local local_policy=OAuth.new({name='local',url='http://127.0.0.1:9000/mcp'},{auth=fake_auth,state=fake_state})
    check(local_policy:url_allowed('http://127.0.0.1:9001/meta'),'loopback resource permits loopback OAuth')
    registration_result={client_id='public'}; prm_servers={'https://unrelated.example',issuer}
    local pinned=OAuth.new({name='pinned',url=cfgs.remote.url,fingerprint='pin',oauth={issuer=issuer}},
        {auth=fake_auth,state=fake_state,request_fn=request_fn,timer_factory=tf})
    check(pinned:discover({resource_metadata='https://api.example/meta'}),'issuer-only pin selects the advertised second issuer')
    eq(pinned.spec.issuer,issuer,'DCR uses the configured issuer without a client ID')
    local definitions_before=definitions
    pinned.cfg.oauth.issuer='https://other.example'
    check(not pinned:define(pinned.definition) and definitions==definitions_before,'warm definition enforces issuer-only pin'); pinned:close()
    prm_servers=nil
    -- Discovery fallbacks fail closed on a mismatched resource/issuer, not on unavailable URLs.
    for _,case in ipairs({
        {name='fallback',scope='prm',requests=5},
        {name='configured',scope='configured',requests=5,no_prm_scopes=true},
        {name='bad_resource',error='resource mismatch',requests=2},
        {name='bad_issuer',error='issuer mismatch',requests=5},
        {name='bad_pkce',error='S256',requests=5},
        {name='foreign_issuer',error='oauth.issuer',requests=2},
    }) do
        local calls={}; local saved={}; local spec
        local auth={define=function(_,value) spec=value; return true end,status=function() return {state='logged_out'} end,
            login=fake_auth.login,complete=fake_auth.complete,refresh=fake_auth.refresh}
        local state={get=function(key) return saved[key] end,set=function(key,value) saved[key]=value; return true end}
        local cfg={name=case.name,url='https://resource.example/mcp',fingerprint=case.name,oauth={client_id='configured-id',issuer='https://issuer.example/tenant',client_secret='CONFIG_SECRET',scopes={'configured'}}}
        local function request(options,callback)
            calls[#calls+1]=options.url
            local value
            if options.url=='https://resource.example/.well-known/oauth-protected-resource' then
                value={resource=case.name=='bad_resource' and 'https://other.example' or 'https://resource.example',authorization_servers={case.name=='foreign_issuer' and 'https://evil-as.example' or 'https://issuer.example/tenant'},
                    scopes_supported=not case.no_prm_scopes and {'prm'} or nil}
            elseif options.url=='https://issuer.example/tenant/.well-known/openid-configuration' then
                value={issuer=case.name=='bad_issuer' and 'https://other.example' or 'https://issuer.example/tenant',
                    authorization_endpoint='https://issuer.example/authorize',token_endpoint='https://issuer.example/token',
                    code_challenge_methods_supported=case.name=='bad_pkce' and {'plain'} or {'S256'}}
            end
            callback({status=value and 200 or 404,body=value and json.encode(value) or ''})
            return {cancel=function() end}
        end
        local failed_clock=0
        local o=OAuth.new(cfg,{auth=auth,state=state,request_fn=request,timer_factory=tf,clock=function() return failed_clock end})
        local ok,err=o:recover({http_status=401,challenge={}})
        check(not ok,'discovery never starts user login'); eq(#calls,case.requests,'fallback request count')
        if case.error then
            check(err:find(case.error,1,true),'discovery validation fails closed'); check(not spec,'invalid discovery never defines auth')
            o:recover({http_status=401,challenge={}}); eq(#calls,case.requests,'failed discovery is negatively cached')
            failed_clock=5000; o:recover({http_status=401,challenge={}})
            eq(#calls,case.requests*2,'negative discovery cache expires via injected clock')
            eq(o.retry_at,15000,'failed discovery backoff increases without waiting')
        else
            check(err:find('/mcp-login',1,true),'configured discovery requests login')
            eq(spec.client_id,'configured-id','configured id skips DCR'); eq(spec.client_secret,'CONFIG_SECRET')
            eq(spec.scopes[1],case.scope,'scope selection fallback')
            check(not json.encode(saved):find('CONFIG_SECRET',1,true),'configured secrets absent from discovery state')
            eq(calls[3],'https://issuer.example/.well-known/oauth-authorization-server/tenant','RFC8414 before OIDC')
            eq(calls[4],'https://issuer.example/.well-known/openid-configuration/tenant','OIDC inserted before appended')
        end
        o:close()
    end
    -- Poll timeout and teardown settle parked refreshes with injected timers only.
    local timeout_auth={define=fake_auth.define,status=function() return {state='pending'} end,login=fake_auth.login,complete=fake_auth.complete,
        refresh=function() return true end}
    local timeout=OAuth.new(cfgs.remote,{auth=timeout_auth,timer_factory=tf,state=fake_state})
    local settled,refresh_error
    async.run(function() settled,refresh_error=timeout:refresh() end,error)
    for _=1,70 do ts[#ts]:fire() end
    check(not settled and refresh_error:find('/mcp-login',1,true),'injected refresh deadline settles caller')
    refresh_error=nil
    async.run(function() settled,refresh_error=timeout:refresh() end,error)
    timeout:close()
    eq(refresh_error,'session ended','teardown settles refresh without blocking')
end
-- HTTP transport/parser checks use an injected request API. `panto lua` has
-- an http_request function, but no usable HTTP service outside an active entry.
local http=require('panto_mcp.http')
for i,c in ipairs({
    {{'data: one\n\n'},{'one'}},
    {{'data: hel','lo\r','\n\r\n'},{'hello'}},
    {{': ping\r\nevent: message\r\ndata: first\r\ndata: second\r\n\r\n'},{'first\nsecond'}},
    {{'event: empty\n\n'},{}},
    {{'event: ping\ndata: ignored\n\n'},{}},
    {{'event: message\ndata:\n\n'},{}},
    {{'\239','\187\191data: bom\n\n'},{'bom'}}
}) do
    local got={}; local parser=http.sse_parser(function(v) got[#got+1]=v end)
    for _,chunk in ipairs(c[1]) do check(parser:feed(chunk),'SSE feed') end
    check(parser:finish(),'SSE finish'); eq(#got,#c[2],'SSE event count '..i)
    for j,value in ipairs(c[2]) do eq(got[j],value,'SSE value '..i) end
end
local eof_events={}; local eof_parser=http.sse_parser(function(v) eof_events[#eof_events+1]=v end)
check(eof_parser:feed('data: final'),'SSE partial'); check(eof_parser:finish(),'SSE EOF'); eq(eof_events[1],'final')
check(eof_parser:feed('data: carriage\r'),'SSE trailing CR'); check(eof_parser:finish(),'SSE CR EOF'); eq(eof_events[2],'carriage')
local header_cfg={headers={accept='wrong',['MCP-METHOD']='wrong',Authorization='Bearer PRIVATE'}}
local mh=http.headers(header_cfg,{era='modern',protocol_version='2026-07-28',method='tools/call',name='lookup'})
eq(mh.Accept,'application/json, text/event-stream'); eq(mh['Content-Type'],'application/json'); eq(mh['MCP-Protocol-Version'],'2026-07-28')
eq(mh['Mcp-Method'],'tools/call'); eq(mh['Mcp-Name'],'lookup'); eq(mh.Authorization,'Bearer PRIVATE'); eq(mh.accept,nil)
for _,method in ipairs({'tools/call','resources/read','prompts/get'}) do
    eq(http.headers({}, {era='modern',method=method,name='item'})['Mcp-Name'],'item','required MCP name header')
end
eq(http.headers({}, {era='modern',method='tools/list'})['Mcp-Name'],nil,'name omitted for other methods')
local ih=http.headers(header_cfg,{era='legacy',initial=true,method='initialize'},'old')
eq(ih['MCP-Protocol-Version'],nil); eq(ih['Mcp-Session-Id'],nil)
local lh=http.headers(header_cfg,{era='legacy',protocol_version='2025-06-18'},'sid')
eq(lh['MCP-Protocol-Version'],'2025-06-18'); eq(lh['Mcp-Session-Id'],'sid')
do
    local schema={type='object',properties={region={type={'string','null'},['x-mcp-header']='Region'},nested={type='object',properties={count={type='integer',['x-mcp-header']='Count'},flag={type='boolean',['x-mcp-header']='Flag'},optional={type={'string','null'},['x-mcp-header']='Optional'}}}}}
    local annotations=assert(http.validate_param_headers(schema)); eq(#annotations,4)
    local headers=assert(http.headers({}, {era='modern',method='tools/call',name='météo ',param_headers=annotations,
        arguments={region='us-west1',nested={count=-7,flag=false,optional=json.null}}}))
    eq(headers['Mcp-Name'],'=?base64?bcOpdMOpbyA=?='); eq(headers['Mcp-Param-Region'],'us-west1')
    eq(headers['Mcp-Param-Count'],'-7'); eq(headers['Mcp-Param-Flag'],'false'); eq(headers['Mcp-Param-Optional'],nil)
    for _,c in ipairs({
        {'plain','plain'}, {'Hello, 世界','=?base64?SGVsbG8sIOS4lueVjA==?='},
        {' padded ','=?base64?IHBhZGRlZCA=?='}, {'=?base64?literal?=','=?base64?PT9iYXNlNjQ/bGl0ZXJhbD89?='}
    }) do eq(http.encode_header_value(c[1]),c[2],'MCP header value encoding') end
    check(http.validate_param_headers({type='object',properties={id={type='string',['x-mcp-header']='Id'}},allOf={{type='object'}}}),
        'properties path is static despite unrelated composition')
    check(http.validate_param_headers({type='object',properties={['x-mcp-header']={type='string'}},enum={{['x-mcp-header']='data'}}}),
        'instance data is not misread as schema annotation')
    check(http.validate_param_headers({type='object',properties={enum={type='string',['x-mcp-header']='Enum'}}}),
        'instance-data keyword may also name a property')
    local bad={
        {type='string',['x-mcp-header']='Root'},
        {type='object',properties={x={type='number',['x-mcp-header']='X'}}},
        {type='object',properties={x={type='string',['x-mcp-header']=''}}},
        {type='object',properties={x={type='string',['x-mcp-header']='Bad Name'}}},
        {type='object',properties={x={type='string',['x-mcp-header']='Region'},y={type='string',['x-mcp-header']='region'}}},
        {type='object',properties={items={type='array',items={type='object',properties={r={type='string',['x-mcp-header']='X'}}}}}},
        {type='object',oneOf={{type='object',properties={r={type='string',['x-mcp-header']='X'}}}}},
        {type='object',properties={items={type='array',items={{type='string',['x-mcp-header']='X'}}}}},
        {type='object',properties={x={anyOf={{type='string',['x-mcp-header']='X'}}}}},
        {type='object',properties={x={['$ref']='#/$defs/x',['x-mcp-header']='X'}}}
    }
    for i,bad_schema in ipairs(bad) do local result,why=http.validate_param_headers(bad_schema); check(not result and why,'invalid x-mcp-header schema '..i) end
end
for i,c in ipairs({
    {{code=-32022,message='UnsupportedProtocolVersion',data={supported={'2025-11-25'}}},false},
    {{code=-32020,message='HeaderMismatch'},false},
    {{code=-32000,message='bad request',data={http_status=400,transport_fallback=true}},true},
    {{code=-32000,message='not found',data={http_status=404,transport_fallback=true}},true},
    {{code=-32601,message='modern method not found',data={http_status=404,transport_fallback=false}},false},
    {{code=-32601,message='legacy discover missing',data={http_status=404,transport_fallback=true}},true},
    {{code=-32000,message='unauthorized',data={http_status=401,auth_error=true}},false},
    {'request timed out: server/discover',true},
    {'remote server/discover: request timed out: server/discover',true},
    {'connect failed',false}, {'DNS resolution failed',false}, {'TLS handshake failed',false}, {'idle timeout',true}
}) do eq(http.should_fallback(c[1]),c[2],'era fallback '..i) end
for _,c in ipairs({
    {'connect failed','transport'}, {'TLS failed','transport'}, {'timeout','timeout'}, {'idle timeout','idle_timeout'},
    {'connection closed before response','transport'}, {'connection closed mid-response','transport'},
    {'other','transport'}, {'response too large','transport'}, {'authentication unavailable','transport'},
    {'on_head callback failed: timeout','callback'}, {'on_data callback failed: timeout','callback'}
}) do eq(http.failure_kind(c[1]),c[2],'core failure label') end
check(not http.should_fallback('on_data callback failed: timeout'),'callback failure never falls back')
check(http.methods_supported(function() return nil,'invalid HTTP request options' end),'method-capable API probe')
local old_probe_cancelled=false
check(not http.methods_supported(function() return {cancel=function() old_probe_cancelled=true end} end),'GET-only API rejected')
check(old_probe_cancelled,'unsupported API probe cancelled')
do
    local probes=0; local capable=function() probes=probes+1; return nil,'invalid HTTP request options' end
    check(http.methods_supported(capable),'method capability true'); check(http.methods_supported(capable),'method capability cached'); eq(probes,1)
end
local function http_reply(opts,cb,status,headers,body,chunks)
    headers=headers or {}; opts.on_head({status=status,headers=headers})
    for _,chunk in ipairs(chunks or (body and {body}) or {}) do opts.on_data(chunk) end
    cb({status=status,headers=headers},nil)
end
local remote={name='remote',url='https://example.test/mcp',auth='mcp.remote',headers={['X-Tenant']='acme'}}
local function injected(cfg,respond,settings_arg,timer_factory)
    local calls={}
    local function request(options,callback)
        calls[#calls+1]=options
        local handle={cancelled=false}; function handle:cancel() self.cancelled=true end
        respond(options,callback,handle,#calls); return handle
    end
    local tr,err=http.new(cfg,settings_arg or {idle_timeout_ms=4321,call_timeout_ms=300000},
        {request_fn=request,timer_factory=timer_factory}); assert(tr,err)
    local messages,errors={},{}; tr:set_callbacks(function(m) messages[#messages+1]=m end,function(e) errors[#errors+1]=e end)
    return tr,calls,messages,errors
end
do
    local now,js_timers=0,{}
    local function js_factory(ms,fn)
        local timer={at=now+ms,closed=false,fn=fn}
        function timer:is_closing() return self.closed end
        function timer:close() self.closed=true end
        function timer:fire() if not self.closed then self:close(); self.fn() end end
        js_timers[#js_timers+1]=timer; return timer
    end
    local function advance(ms)
        now=now+ms
        for _,timer in ipairs(js_timers) do if timer.at<=now then timer:fire() end end
    end
    local callback,opts,handle
    local slow=assert(http.new(remote,{idle_timeout_ms=10,call_timeout_ms=5000},{timer_factory=js_factory,request_fn=function(o,cb)
        opts=o; callback=cb; handle={cancelled=false}; function handle:cancel() self.cancelled=true end
        o.on_head({status=200,headers={['content-type']='application/json'}}); return handle
    end}))
    local rpc=Rpc.new(slow,{timeout_ms=5000,timer_factory=js_factory})
    local future=rpc:start('tools/call',{name='hello',arguments={}},{era='modern',protocol_version='2026-07-28',method='tools/call'})
    eq(opts.idle_timeout_ms,0,'core idle timeout disabled'); eq(#js_timers,1,'JSON has only total-call deadline')
    eq(js_timers[1].at,5000,'JSON response total cap is call_timeout_ms')
    advance(11); check(not future.done,'slow JSON remains pending past idle timeout')
    opts.on_data(json.encode({jsonrpc='2.0',id=1,result={ok=true}}))
    callback({status=200,headers={['content-type']='application/json'}},nil)
    check(future.done and future.value.ok,'slow JSON answer survives idle threshold'); rpc:close()
    local idle_timers,idle_factory=timers(); local idle_handle; local idle_messages={}
    local idle_http=assert(http.new(remote,{idle_timeout_ms=25},{timer_factory=idle_factory,request_fn=function(o)
        idle_handle={cancelled=false}; function idle_handle:cancel() self.cancelled=true end
        o.on_head({status=200,headers={['content-type']='text/event-stream'}}); return idle_handle
    end}))
    idle_http:set_callbacks(function(m) idle_messages[#idle_messages+1]=m end,function() end)
    idle_http:send({jsonrpc='2.0',id=55,method='tools/call',params={name='hello'}},{era='modern',protocol_version='2026-07-28',method='tools/call'})
    eq(idle_timers[1].ms,25,'SSE Lua idle timer starts at response head')
    idle_timers[1]:fire(); check(idle_handle.cancelled and idle_messages[1].error.data.transport_error=='idle_timeout','idle timeout cancels only stream')
end
do
    local stream_options,stream_handle,stream_messages
    stream_messages={}
    local notification_stream=assert(http.new(remote,{},{request_fn=function(options)
        if options.method=='GET' then
            stream_options=options
            stream_handle={cancelled=false}; function stream_handle:cancel() self.cancelled=true end
            options.on_head({status=200,headers={['content-type']='text/event-stream'}})
            options.on_data('data: '..json.encode({jsonrpc='2.0',method='notifications/tools/list_changed'})..'\n\n')
            return stream_handle
        end
        return {cancel=function() end}
    end}))
    notification_stream.protocol_version='2025-11-25'; notification_stream.session_id='legacy-session'
    notification_stream:set_callbacks(function(message) stream_messages[#stream_messages+1]=message end,function(err) error(err) end)
    check(notification_stream:open_notification_stream(),'legacy notification GET opened')
    eq(stream_options.method,'GET'); eq(stream_options.timeout_ms,0); eq(stream_options.idle_timeout_ms,0)
    eq(stream_options.headers.Accept,'text/event-stream'); eq(stream_options.headers['Content-Type'],nil)
    eq(stream_options.headers['Mcp-Session-Id'],'legacy-session'); eq(stream_options.headers['MCP-Protocol-Version'],'2025-11-25')
    eq(stream_messages[1].method,'notifications/tools/list_changed','legacy GET delivers JSON-RPC notifications')
    notification_stream:close(); check(stream_handle.cancelled,'legacy GET closes on teardown')
    local unsupported_handle,unsupported_errors
    unsupported_errors=0
    local no_stream=assert(http.new(remote,{}, {request_fn=function(options)
        if options.method=='GET' then
            unsupported_handle={cancelled=false}; function unsupported_handle:cancel() self.cancelled=true end
            options.on_head({status=405,headers={}}); return unsupported_handle
        end
        return {cancel=function() end}
    end}))
    no_stream:set_callbacks(function() end,function() unsupported_errors=unsupported_errors+1 end)
    check(not no_stream:open_notification_stream(),'405 means no notification stream')
    check(unsupported_handle.cancelled and unsupported_errors==0,'405 stream is benign and cancelled')
    no_stream:close()
end
do
    local retry_timers,retry_factory=timers(); local get_count,list_count,initialize_count=0,0,0
    local get_done,get_handles,get_options={},{},{}
    local request_fn=function(options,callback)
        if options.method=='GET' then
            get_count=get_count+1; get_options[get_count]=options; get_done[get_count]=callback
            local handle={cancelled=false}; function handle:cancel() self.cancelled=true end; get_handles[get_count]=handle
            options.on_head({status=200,headers={['content-type']='text/event-stream'}})
            return handle
        elseif options.method=='DELETE' then return {cancel=function() end} end
        local request=json.decode(options.body)
        if request.method=='initialize' then
            initialize_count=initialize_count+1
            http_reply(options,callback,200,{['content-type']='application/json',['mcp-session-id']='sid'..initialize_count},
                json.encode({jsonrpc='2.0',id=request.id,result={protocolVersion='2025-11-25',capabilities={tools={listChanged=true}}}}))
        elseif request.method=='notifications/initialized' then http_reply(options,callback,202,{})
        elseif request.method=='tools/list' then
            list_count=list_count+1
            if list_count==2 then http_reply(options,callback,404,{},'expired')
            else http_reply(options,callback,200,{['content-type']='application/json'},json.encode({jsonrpc='2.0',id=request.id,result={tools={}}})) end
        else http_reply(options,callback,200,{['content-type']='application/json'},json.encode({jsonrpc='2.0',id=request.id,result={}})) end
        return {cancel=function() end}
    end
    local eager_http={name='remote',url=remote.url,transport='http',expose='eager',auth=remote.auth,headers=remote.headers,args={},env={}}
    local client=require('panto_mcp.client').new(eager_http,settings,{timer_factory=retry_factory,request_fn=request_fn})
    check(client:connect({era='legacy',version='2025-11-25'}),'legacy eager client connects with notification stream')
    eq(get_count,1)
    get_done[1]({status=200,headers={}},nil)
    local retry_timer
    for _,timer in ipairs(retry_timers) do if timer.ms==1000 and not timer.closed then retry_timer=timer end end
    check(retry_timer,'closed legacy stream schedules an injected reconnect timer')
    retry_timer:fire(); eq(get_count,2,'closed legacy stream reopens')
    local result,err=client:request('tools/list',{})
    check(result and not err,'404 session re-init retries the original list request')
    eq(initialize_count,2); eq(get_count,3,'404 re-init opens a new notification stream')
    check(get_handles[2].cancelled,'old session stream closes before re-init')
    eq(get_options[3].headers['Mcp-Session-Id'],'sid2','reopened stream uses replacement session')
    client:close(); check(get_handles[3].cancelled,'replacement stream closes on teardown')
    local gets=0
    local proxy=require('panto_mcp.client').new({name='proxy',url=remote.url,transport='http',expose='eager'},settings,{timer_factory=retry_factory,request_fn=function(options,callback)
        if options.method=='GET' then
            gets=gets+1
            local status=gets>=9 and 401 or 200
            options.on_head({status=status,headers={['content-type']='text/event-stream'}})
            callback({status=status,headers={}})
        elseif options.method=='POST' then
            local req=json.decode(options.body)
            local result=req.method=='initialize' and {protocolVersion='2025-11-25',capabilities={tools={listChanged=true}}} or {tools={}}
            if req.id then http_reply(options,callback,200,{['content-type']='application/json'},json.encode({jsonrpc='2.0',id=req.id,result=result}))
            else http_reply(options,callback,202,{}) end
        end
        return {cancel=function() end}
    end})
    check(proxy:connect({era='legacy',version='2025-11-25'}),'proxy notification test connects')
    for _,delay in ipairs({1000,2000,4000,8000,16000,32000,60000,60000}) do
        local t=assert(proxy.notification_retry_timer); eq(t.ms,delay,'stream retry exponential delay/cap'); t:fire()
    end
    check(proxy.notification_retry_stopped and not proxy.notification_retry_timer,'401 stops notification reconnects')
    local warning_manager=Manager.new(settings,{})
    warning_manager.states.proxy={cfg=proxy.cfg,state='ready',client=proxy}
    check(require('panto_mcp.tools').status(warning_manager,{}):find('Notification stream rejected (HTTP 401)',1,true),'401 notification warning is visible in /mcp')
    warning_manager:close()
end
local active_http=require('panto').ext.http_request
if not http.methods_supported(active_http) then
    local missing,why=http.new(remote,{})
    check(not missing and why:find('require a newer panto',1,true),'missing HTTP POST API reports upgrade requirement')
end
local jt,jcalls,jm=injected(remote,function(o,cb)
    eq(o.method,'POST'); eq(o.auth,'mcp.remote'); eq(o.timeout_ms,0); eq(o.idle_timeout_ms,0)
    eq(o.headers['Mcp-Method'],'server/discover'); eq(o.headers['MCP-Protocol-Version'],'2026-07-28')
    http_reply(o,cb,200,{['content-type']='application/json'},json.encode({jsonrpc='2.0',id=1,result={ok=true}}))
end)
jt:send({jsonrpc='2.0',id=1,method='server/discover',params={}},{era='modern',protocol_version='2026-07-28',method='server/discover'})
eq(jm[1].result.ok,true); eq(jcalls[1].headers['X-Tenant'],'acme')
local sm={}; local st=injected(remote,function(o,cb)
    local n='event: message\r\ndata: {"jsonrpc":"2.0","method":"notifications/tools/list_changed"}\r\n\r\n'
    local r='event: message\r\ndata: {"jsonrpc":"2.0","id":2,"result":{"ok":true}}\r\n\r\n'
    http_reply(o,cb,200,{['content-type']='text/event-stream'},nil,{n:sub(1,31),n:sub(32)..r:sub(1,25),r:sub(26)})
end)
st:set_callbacks(function(m) sm[#sm+1]=m end,function() end)
st:send({jsonrpc='2.0',id=2,method='tools/list',params={}},{era='modern',protocol_version='2026-07-28',method='tools/list'})
eq(#sm,2); eq(sm[1].method,'notifications/tools/list_changed'); eq(sm[2].result.ok,true)
do
    local posted=0; local transport=assert(http.new(remote,{idle_timeout_ms=100},{request_fn=function(o,cb)
        posted=posted+1
        local events={
            'data: {"jsonrpc":"2.0","method":"notifications/progress"}\n\n',
            'data: {"jsonrpc":"2.0","id":1,"method":"ping"}\n\n',
            'data: {"jsonrpc":"2.0","id":1,"result":{"ok":true}}\n\n'
        }
        http_reply(o,cb,200,{['content-type']='text/event-stream'},nil,events)
        return {cancel=function() end}
    end}))
    local rpc=Rpc.new(transport,{timer_factory=function() return {close=function() end,is_closing=function() return false end} end})
    local future=rpc:start('tools/list',{}, {era='modern',protocol_version='2026-07-28'})
    check(future.done and future.value.ok,'server request with colliding id does not settle call')
    eq(posted,1,'modern response to server request is dropped, not posted')
    rpc:close()
end
do
    local count=0; local transport=assert(http.new(remote,{}, {request_fn=function(o,cb)
        count=count+1; local id=json.decode(o.body).id
        local handle={cancelled=false}; function handle:cancel() self.cancelled=true end
        if count==1 then http_reply(o,cb,200,{['content-type']='application/json'},json.encode({jsonrpc='2.0',id=id}))
        else o.on_head({status=200,headers={['content-type']='application/json'}}) end
        return handle
    end}))
    local rpc=Rpc.new(transport,{timeout_ms=5000,timer_factory=function() return {close=function() end,is_closing=function() return false end} end})
    local malformed=rpc:start('tools/list',{}, {era='modern',protocol_version='2026-07-28'})
    local other=rpc:start('tools/call',{name='hello'},{era='modern',protocol_version='2026-07-28'})
    check(malformed.done and malformed.err.code==-32000 and malformed.err.message:find('malformed JSON-RPC response',1,true),'malformed matching response is request-scoped')
    check(not rpc.closed and not other.done,'malformed response leaves other RPCs alive')
    other:cancel(); rpc:close()
end
local step=0; local lt,lc= injected({name='legacy',url='http://127.0.0.1:1234',headers={}},function(o,cb)
    if o.method=='DELETE' then return end
    local req=json.decode(o.body); step=step+1
    if req.method=='initialize' then
        http_reply(o,cb,200,{['content-type']='application/json',['mcp-session-id']='old-session'},json.encode({jsonrpc='2.0',id=req.id,result={protocolVersion='2025-11-25',capabilities={}}}))
    elseif req.method=='notifications/initialized' then http_reply(o,cb,202,{})
    else http_reply(o,cb,404,{},'expired') end
end)
local legacy_received={}; lt:set_callbacks(function(m) legacy_received[#legacy_received+1]=m end,function(e) error(e) end)
lt:send({jsonrpc='2.0',id=10,method='initialize',params={protocolVersion='2025-11-25'}},{era='legacy',protocol_version='2025-11-25',method='initialize'})
lt:send({jsonrpc='2.0',method='notifications/initialized',params={}},{era='legacy',protocol_version='2025-11-25',method='notifications/initialized'})
lt:send({jsonrpc='2.0',id=11,method='tools/list',params={}},{era='legacy',protocol_version='2025-11-25',method='tools/list'})
eq(#lc,3,'expired session signals re-handshake without DELETE'); eq(legacy_received[#legacy_received].id,11)
check(legacy_received[#legacy_received].error.data.session_expired,'404 signals client re-handshake'); eq(lt.session_id,nil)
eq(lc[1].headers['MCP-Protocol-Version'],nil); eq(lc[2].headers['MCP-Protocol-Version'],'2025-11-25')
eq(lc[3].headers['Mcp-Session-Id'],'old-session')
lt:close()
do
    local calls={}; local tr=assert(http.new({name='reply',url='https://example.test',headers={}}, {call_timeout_ms=5000},
        {request_fn=function(o,cb)
            calls[#calls+1]=o
            local req=json.decode(o.body)
            local h={cancelled=false}; function h:cancel() self.cancelled=true end
            if req.method=='tools/list' then o.on_head({status=200,headers={['content-type']='application/json'}})
            elseif req.method=='notifications/cancelled' then http_reply(o,cb,404,{},'stale session')
            elseif req.method==nil and req.error then http_reply(o,cb,400,{['content-type']='application/json'},json.encode({jsonrpc='2.0',id=req.id,error=req.error}))
            else http_reply(o,cb,202,{}) end
            return h
        end}))
    tr.era='legacy'; tr.protocol_version='2025-06-18'; tr.session_id='sid'
    local delivered,transport_errors={},{}
    tr:set_callbacks(function(m) delivered[#delivered+1]=m end,function(e) transport_errors[#transport_errors+1]=e end)
    local request_state=tr:send({jsonrpc='2.0',id=1,method='tools/list',params={}},{era='legacy',protocol_version='2025-06-18',method='tools/list'})
    tr:send({jsonrpc='2.0',id=1,result={}},{method='ping'})
    check(tr.active['id:1']==request_state,'server reply ID does not collide with client request')
    tr:send({jsonrpc='2.0',id=1,error={code=-32601,message='reply failed'}},{method='elicitation/create'})
    check(tr.active['id:1']==request_state and #delivered==0 and #transport_errors==0,'failed reply is logged but isolated')
    eq(calls[2].headers['MCP-Protocol-Version'],'2025-06-18'); eq(calls[2].headers['Mcp-Session-Id'],'sid')
    tr:cancel(1,request_state)
    local cancelled=json.decode(calls[4].body); eq(cancelled.method,'notifications/cancelled')
    eq(calls[4].headers['MCP-Protocol-Version'],'2025-06-18'); eq(calls[4].headers['Mcp-Session-Id'],'sid')
    check(not tr.closed and #delivered==0 and #transport_errors==0,'failed cancellation POST is non-fatal')
end
do
    local calls={}; local tr=assert(http.new({name='sessionless',url='http://127.0.0.1:1234',headers={}}, {},
        {request_fn=function(o,cb)
            calls[#calls+1]=o; local h={cancel=function() end}
            if json.decode(o.body).method=='notifications/cancelled' then http_reply(o,cb,202,{})
            else o.on_head({status=200,headers={['content-type']='application/json'}}) end
            return h
        end}))
    local req=tr:send({jsonrpc='2.0',id=8,method='tools/call',params={name='x'}},{era='legacy',protocol_version='2024-11-05',method='tools/call'})
    tr:cancel(8,req); eq(#calls,2,'sessionless legacy sends cancellation')
    eq(json.decode(calls[2].body).method,'notifications/cancelled'); eq(calls[2].headers['MCP-Protocol-Version'],'2024-11-05')
    eq(calls[2].headers['Mcp-Session-Id'],nil,'sessionless cancellation omits id')
    tr:close()
end
do
    local modern_posts=0
    local modern=assert(http.new({name='modern',url='https://example.test',headers={}}, {}, {request_fn=function() modern_posts=modern_posts+1; return {} end}))
    modern.era='modern'; modern.protocol_version='2026-07-28'
    modern:send({jsonrpc='2.0',id='peer',result={}},{method='ping'})
    eq(modern_posts,0,'modern era drops forbidden server-request replies')
end
do
    local errors={}
    local tr=assert(http.new({name='handshake',url='https://example.test',headers={}}, {}, {request_fn=function(o,cb)
        http_reply(o,cb,500,{['content-type']='text/plain'},'initialized rejected')
        return {cancel=function() end}
    end}))
    tr:set_callbacks(function() error('fire-and-forget reached RPC') end,function(e) errors[#errors+1]=e end)
    local handle=tr:send({jsonrpc='2.0',method='notifications/initialized',params={}},{era='legacy',protocol_version='2025-11-25',method='notifications/initialized'})
    local accepted,why=handle:await()
    check(not accepted and why:find('notifications/initialized',1,true),'initialized failure reaches handshake waiter')
    check(not tr.closed and #errors==0,'initialized failure is not promoted to transport/RPC failure')
end
do
    local fire_timers,fire_factory=timers(); local messages,errors={},{}
    local tr=assert(http.new({name='notify',url='https://example.test',headers={}}, {call_timeout_ms=999999},
        {timer_factory=fire_factory,request_fn=function() return {cancel=function() end} end}))
    tr:set_callbacks(function(m) messages[#messages+1]=m end,function(e) errors[#errors+1]=e end)
    tr:send({jsonrpc='2.0',method='notifications/cancelled',params={requestId=1}},
        {era='legacy',protocol_version='2025-11-25',method='notifications/cancelled'})
    eq(fire_timers[1].ms,10000,'fire-and-forget timeout is fixed')
    fire_timers[1]:fire(); check(not tr.closed and #messages==0 and #errors==0,'failed notification is diagnostic-only')
end
do
    local calls=0; local tr=assert(http.new({name='init',url='https://example.test',headers={}}, {},
        {request_fn=function() calls=calls+1; return {cancel=function() end} end}))
    local init=tr:send({jsonrpc='2.0',id=7,method='initialize',params={}},{era='legacy',protocol_version='2024-11-05',method='initialize'})
    tr:cancel(7,init); eq(calls,1,'initialize cancellation never POSTs notifications/cancelled')
end
local at,_,am=injected({name='github',url='https://example.test',headers={Authorization='Bearer NEVER-SURFACE'}},function(o,cb)
    http_reply(o,cb,401,{['content-type']='text/event-stream'},'Bearer NEVER-SURFACE')
end)
at:send({jsonrpc='2.0',id=12,method='server/discover',params={}},{era='modern',protocol_version='2026-07-28',method='server/discover'})
local auth_text=am[1].error.message
check(auth_text:find('github',1,true) and auth_text:find('auth = "<session>"',1,true),'401 guidance')
check(not auth_text:find('NEVER-SURFACE',1,true),'headers are not surfaced')
local body_error_t,_,body_error_m=injected({name='redact',url='https://example.test',headers={['X-Key']='SECRET'}},function(o,cb)
    http_reply(o,cb,500,{['content-type']='text/plain'},'SECRET '..string.rep('x',1200))
end)
body_error_t:send({jsonrpc='2.0',id=15,method='server/discover',params={}},{era='modern',protocol_version='2026-07-28',method='server/discover'})
check(body_error_m[1].error.message:find('500',1,true) and not body_error_m[1].error.message:find('SECRET',1,true),'HTTP status body is bounded and redacted')
do
    local token_t,_,token_messages=injected({name='redact',url='https://example.test',headers={Authorization='Bearer ACCESS_TOKEN'}},function(o,cb)
        http_reply(o,cb,500,{['content-type']='text/plain'},string.rep('x',1020)..'ACCESS_TOKEN-tail')
    end)
    token_t:send({jsonrpc='2.0',id=16,method='tools/list',params={}},{era='modern',protocol_version='2026-07-28',method='tools/list'})
    check(not token_messages[1].error.message:find('ACCESS_TOKEN',1,true) and not token_messages[1].error.message:find('ACCESS',1,true),'redaction precedes truncation and removes auth token part')
end
local json_error_t,_,json_error_m=injected({name='redact',url='https://example.test',headers={['X-Key']='SECRET'},},function(o,cb)
    http_reply(o,cb,400,{['content-type']='application/json'},json.encode({jsonrpc='2.0',id=18,error={code=-32600,message='SECRET bad header'}}))
end)
json_error_t:send({jsonrpc='2.0',id=18,method='server/discover',params={}},{era='modern',protocol_version='2026-07-28',method='server/discover'})
check(json_error_m[1].error.message:find('bad header',1,true) and not json_error_m[1].error.message:find('SECRET',1,true) and json_error_m[1].error.data.http_status==400,'HTTP JSON-RPC errors preserve message, context, status, and redaction')
do
    local null_transport,_,null_messages=injected(remote,function(o,cb)
        http_reply(o,cb,400,{['content-type']='application/json'},json.encode({jsonrpc='2.0',id=json.null,error={code=-32022,message='unsupported',data={supported={'2024-11-05'}}}}))
    end)
    null_transport:send({jsonrpc='2.0',id=19,method='server/discover',params={}},{era='modern',protocol_version='2026-07-28',method='server/discover'})
    local error_response=null_messages[1].error
    eq(error_response.code,-32022); eq(error_response.data.supported[1],'2024-11-05')
    check(not http.should_fallback(error_response),'null-id modern negotiation is not downgraded')
end
do
    local ok_transport,_,ok_messages=injected({name='redact',url='https://example.test',headers={['X-Key']='SECRET'}},function(o,cb)
        http_reply(o,cb,200,{['content-type']='application/json'},json.encode({jsonrpc='2.0',id=20,error={code=-32022,message='SECRET UnsupportedProtocolVersion',data={supported={'2025-11-25'}}}}))
    end)
    ok_transport:send({jsonrpc='2.0',id=20,method='server/discover',params={}},{era='modern',protocol_version='2026-07-28',method='server/discover'})
    check(not ok_messages[1].error.message:find('SECRET',1,true),'successful HTTP JSON-RPC errors redact static headers')
end
local et,_,em=injected(remote,function(o,cb)
    http_reply(o,cb,200,{['content-type']='text/event-stream'},nil,{'data: {"jsonrpc":"2.0","method":"notifications/progress"}\n\n'})
end)
et:send({jsonrpc='2.0',id=13,method='tools/call',params={name='hello'}},{era='modern',protocol_version='2026-07-28',method='tools/call',name='hello'})
eq(em[#em].id,13); check(em[#em].error.message:find('without a response',1,true),'SSE EOF is request-scoped')
do
    local stream,_,stream_messages=injected(remote,function(o,cb)
        http_reply(o,cb,200,{['content-type']='text/event-stream'},nil,{'data: {"jsonrpc":"2.0","id":null,"error":{"code":-32600,"message":"server rejected"}}\n\n'})
    end)
    stream:send({jsonrpc='2.0',id=23,method='tools/list',params={}},{era='modern',protocol_version='2026-07-28',method='tools/list'})
    eq(stream_messages[1].id,23); check(stream_messages[1].error.message:find('server rejected',1,true),'null-id SSE error is correlated to its request')
    check(not stream_messages[1].error.message:find('without a response',1,true),'null-id SSE error is preserved')
end
local pending_handle; local ct=assert(http.new(remote,{}, {request_fn=function() pending_handle={cancelled=false}; function pending_handle:cancel() self.cancelled=true end; return pending_handle end}))
local pending=ct:send({jsonrpc='2.0',id=14,method='tools/list',params={}},{era='modern',protocol_version='2026-07-28',method='tools/list'})
ct:cancel(14,pending); check(pending_handle.cancelled,'HTTP cancellation')
do
    local handles={}
    local closing_http=assert(http.new(remote,{}, {request_fn=function()
        local h={cancelled=false}; function h:cancel() self.cancelled=true end; handles[#handles+1]=h; return h
    end}))
    closing_http:send({jsonrpc='2.0',id=21,method='tools/list',params={}},{era='modern',protocol_version='2026-07-28',method='tools/list'})
    closing_http:send({jsonrpc='2.0',id=22,method='tools/list',params={}},{era='modern',protocol_version='2026-07-28',method='tools/list'})
    closing_http:close(); check(handles[1].cancelled and handles[2].cancelled,'session close cancels every HTTP request')
end
end

-- JSON-RPC: injected deadlines, cancellation, late responses, server requests.
local ts,tf=timers(); local t=fake_transport(); local rpc=Rpc.new(t,{timer_factory=tf,timeout_ms=99})
local a=rpc:start('one',{}); local b=rpc:start('two',{})
t.message({jsonrpc='2.0',id=2,result={v=2}}); check(b.done and not a.done,'id routing')
ts[1]:fire(); check(a.done and a.err:find('timed out',1,true),'injected timeout'); eq(t.cancels[1],1)
t.message({jsonrpc='2.0',id=1,result={late=true}}); check(a.err~=nil,'late response ignored')
local c=rpc:start('three',{}); c:cancel(); check(c.done,'cancel settles')
t.message({jsonrpc='2.0',id='server-ping',method='ping'}); check(t.sent[#t.sent].msg.result~=nil,'ping response')
t.message({jsonrpc='2.0',id='other',method='sampling/createMessage'}); eq(t.sent[#t.sent].msg.error.code,-32601)
local d=rpc:start('four',{}); rpc:close(); check(d.done and t.closed,'close settles pending')
local it,ift=timers(); local itx=fake_transport(); local irpc=Rpc.new(itx,{timer_factory=ift,timeout_ms=9})
local initialize=irpc:start('initialize',{}, {cancel_protocol=false}); it[1]:fire()
check(initialize.done and #itx.cancels==0,'initialize timeout sends no cancellation notification'); irpc:close()

-- Mapped results and capped/unsupported data.
eq(results.decode64('aGVsbG8='),'hello'); eq(results.decode64('JQ=='),'%','percent replacement'); eq(results.decode64('AAAA'),'\0\0\0','zero-byte decode'); eq(results.decode64('+/8='),'\xfb\xff','high-byte decode'); check(not results.decode64('bad!'),'invalid base64')
local large_image=assert(results.decode64(string.rep('QUJD',1747626)))
eq(#large_image,5242878,'multi-megabyte base64 length'); eq(large_image:sub(1,3),'ABC'); eq(large_image:sub(-3),'ABC')
local r=results.map('srv',{content={{type='text',text='{"a":1}'},{type='image',data='aGk=',mimeType='image/png'},
    {type='audio',data='aGk=',mimeType='audio/wav'},{type='resource_link',uri='docs://a',name='A'},
    {type='resource',resource={uri='docs://b',text='embedded'}}},structuredContent={a=1}})
eq(r.attachments[1].data,'hi'); check(r.text:find('server="srv"',1,true),'resource guidance')
local _,n=r.text:gsub('"a":1',''); eq(n,1,'structured dedup')
check(results.map('srv',{resultType='input_required'}).is_error,'input_required')
check(results.map('srv',{isError=true,content={{type='text',text='oops'}}}).is_error,'tool error')
check(results.map('srv',nil,{message='oops',code=-1}).text:find('(-1)',1,true),'rpc error')
check(results.cap(string.rep('x',results.MAX_OUTPUT+1)):find('truncated',1,true),'output cap')
-- Disk metadata: warm/cold/fingerprint/corrupt. No servers spawn on warm load.
local cfg=servers.fs
local meta={era='modern',version='2026-07-28',catalog={tools={{name='read_file',description='Read file contents',inputSchema={type='object',properties={path={type='string'}}}}},prompts={},resources={{name='guide',uri='docs://guide'}},templates={}},instructions=string.rep('x',5000)}
local cleaned=cache.normalize_catalog({tools={{name='ok',title=json.null,annotations=json.null,inputSchema={}},{name='drop',description=7,inputSchema={}}},prompts={},resources={},templates={}})
eq(#cleaned.tools,1,'malformed catalog entry dropped'); eq(cleaned.tools[1].title,nil,'null catalog field absent'); eq(cleaned.tools[1].annotations,nil,'all null catalog fields absent')
check(cache.save(cfg,meta,temp),'cache write'); check(cache.load(cfg,temp),'cache warm')
write(temp..'/fs-extra-12345678.json','keep other server cache')
check(read(cache.path(cfg,temp)):find('"prompts":%[%]'),'empty cache lists encode as arrays')
local warm=Manager.new(settings,{fs=cfg},{cache_dir=temp,transport_factory=function() error('warm activation spawned') end})
eq(warm.states.fs.state,'idle'); warm:start_cold(); eq(warm.states.fs.state,'idle','warm starts nothing')
local hits=assert(warm:search('file',{server='fs'})); eq(hits.hits[1].name,'read_file'); check(hits.hits[1].inputSchema,'schema returned'); check(hits.instructions:find('truncated',1,true),'instructions cap')
eq(assert(warm:search('guide',{})).hits[1].kind,'resources')
local other_cfg={name=cfg.name,fingerprint=config.hash('other')}
check(cache.save(other_cfg,meta,temp),'cache save changed fingerprint')
check(not read(cache.path(cfg,temp)),'old fingerprint pruned')
eq(read(temp..'/fs-extra-12345678.json'),'keep other server cache','shared-prefix server cache preserved')
write(cache.path(cfg,temp),'corrupt'); check(not cache.load(cfg,temp),'corrupt is cold')
local cfg2={name=cfg.name,fingerprint='different'}; check(not cache.load(cfg2,temp),'fingerprint cold')
warm:close()
-- Startup deadlines/retry are injected, not tested by sleeping.
local timers2,factory2=timers(); local count=0
local stalled=Manager.new(settings,{fs=cfg},{cache_dir=temp,timer_factory=factory2,transport_factory=function() count=count+1; return fake_transport() end})
local pending=stalled:start(stalled.states.fs); timers2[1]:fire()
check(pending.done and stalled.states.fs.state=='failed','startup deadline')
check(count==1,'deadline must not restart closed client')
stalled:start(stalled.states.fs); check(count==2,'failed retried lazily'); stalled:close()
local closing_ts,closing_tf=timers()
local closing=Manager.new(settings,{fs=cfg},{cache_dir=temp,timer_factory=closing_tf,transport_factory=function() return fake_transport() end})
local closing_ready=closing:start(closing.states.fs); local resumed=false
local waiter=coroutine.create(function() closing_ready:await(); resumed=true end)
assert(coroutine.resume(waiter)); eq(coroutine.status(waiter),'suspended')
closing:close()
check(not resumed and coroutine.status(waiter)=='suspended','session_end abandons waiters without resuming them'); check(closing_ready.done,'abandoned startup future settled')

-- Era selection and silent-probe fallback with scripted transports/injected
-- timers. No elapsed-time sleeps are used to manufacture timeout behavior.
local Client=require('panto_mcp.client')
local function scripted(respond)
    local tr=fake_transport()
    local send=tr.send
    function tr:send(msg,opts)
        local h=send(self,msg,opts)
        if msg.id then
            local value,err=respond(msg,opts)
            if value~=nil or err~=nil then self.message({jsonrpc='2.0',id=msg.id,result=value,error=err}) end
        end
        return h
    end
    return tr
end
do
    local t,tf=timers(); local tr=fake_transport(); local send=tr.send
    local initializes,tool_calls=0,0; local initialized=false
    function tr:send(msg,opts)
        local h=send(self,msg,opts)
        if msg.method=='initialize' then initializes=initializes+1
        elseif msg.method=='notifications/initialized' then initialized=true
        elseif msg.method=='tools/call' then
            tool_calls=tool_calls+1
            if initialized then self.message({jsonrpc='2.0',id=msg.id,result={ok=true}}) end
        end
        return h
    end
    local client=Client.new({name='remote',url='https://example.test',transport='http'},settings,
        {timer_factory=tf,transport_factory=function() return tr end})
    assert(client:open()); client.era='legacy'; client.version='2025-11-25'; tr.era='legacy'; tr.protocol_version='2025-11-25'; tr.session_generation=1
    local r1,e1,r2,e2
    async.run(function() r1,e1=client:request('tools/call',{name='hello',arguments={}}) end,function(err) error(err) end)
    async.run(function() r2,e2=client:request('tools/call',{name='hello',arguments={}}) end,function(err) error(err) end)
    eq(tool_calls,2,'parallel stale requests in flight')
    tr.message({jsonrpc='2.0',id=1,error={code=-32000,message='session expired',data={session_expired=true,session_generation=1}}})
    tr.message({jsonrpc='2.0',id=2,error={code=-32000,message='session expired',data={session_expired=true,session_generation=1}}})
    eq(initializes,1,'parallel session expiry shares one re-init')
    tr.message({jsonrpc='2.0',id=3,result={protocolVersion='2024-11-05',capabilities={}}})
    check(r1 and r1.ok and r2 and r2.ok and not e1 and not e2,'both expired calls retry once')
    eq(initializes,1); eq(tool_calls,4,'one retry per original request'); eq(tr.protocol_version,'2024-11-05')
    local initialized_version
    for _,entry in ipairs(tr.sent) do if entry.msg.method=='notifications/initialized' then initialized_version=entry.opts.protocol_version end end
    eq(initialized_version,'2024-11-05','2024 counter-offer retained during re-init'); client:close()
end
local remote_http={name='http',url='https://example.test/mcp',transport='http',headers={},args={},env={}}
do
    local function stream_client(expose,era)
        local streams=0
        local client=Client.new({name='http',url='https://example.test/mcp',transport='http',expose=expose,headers={},args={},env={}},settings,
            {transport_factory=function()
                local transport=scripted(function(message)
                    if message.method=='initialize' then return {protocolVersion='2025-11-25',capabilities={tools={listChanged=true}}} end
                    if message.method=='server/discover' then return {capabilities={tools={listChanged=true}}} end
                    if message.method=='tools/list' then return {tools={}} end
                end)
                function transport:open_notification_stream() streams=streams+1; return true end
                return transport
            end})
        local cached=era=='legacy' and {era='legacy',version='2025-11-25'} or {era='modern',version='2026-07-28'}
        check(client:connect(cached),'cached client connects for notification-stream gate')
        client:close()
        return streams
    end
    eq(stream_client('eager','legacy'),1,'only eager 2025-11-25 HTTP clients open GET stream')
    eq(stream_client('search','legacy'),0,'search HTTP client does not open GET stream')
    eq(stream_client('eager','modern'),0,'modern HTTP client does not open legacy GET stream')
end
do
    local calls,reported={},nil; local timer_list,timer_factory=timers()
    local client=Client.new(remote_http,settings,{timer_factory=timer_factory,on_error=function(err) reported=err end,
        transport_factory=function(cfg,client_settings)
            return assert(require('panto_mcp.http').new(cfg,client_settings,{timer_factory=timer_factory,request_fn=function(o,cb)
                calls[#calls+1]=o
                local handle={cancel=function() end}
                if o.method=='DELETE' then return handle end
                local req=json.decode(o.body); local status=req.method=='initialize' and 200 or 500
                local headers=req.method=='initialize' and {['content-type']='application/json',['mcp-session-id']='half-session'} or {['content-type']='text/plain'}
                local body=req.method=='initialize' and json.encode({jsonrpc='2.0',id=req.id,result={protocolVersion='2025-11-25',capabilities={}}}) or 'initialized failed'
                o.on_head({status=status,headers=headers}); o.on_data(body); cb({status=status,headers=headers},nil)
                return handle
            end}))
        end})
    assert(client:open()); client.era='legacy'; client.version='2025-11-25'
    local ready,why
    async.run(function() ready,why=client:reinitialize_legacy() end,function(err) error(err) end)
    check(not ready and why and client.rpc.closed and reported,'failed re-init fails RPC/client for next-use reconnect')
    eq(calls[3].method,'DELETE'); eq(calls[3].headers['Mcp-Session-Id'],'half-session','half-initialized session is deleted')
    client:close()
end
do
    local annotated_transport; local list_calls,call_calls,call_headers=0,0,{}
    local annotated=Client.new(remote_http,settings,{transport_factory=function()
        annotated_transport=scripted(function(msg,opts)
            if msg.method=='server/discover' then return {capabilities={tools={}}} end
            if msg.method=='tools/list' then
                list_calls=list_calls+1
                local header_name=list_calls==1 and 'Region' or 'Locale'
                return {tools={
                    {name='hello',inputSchema={type='object',properties={nested={type='object',properties={region={type='string',['x-mcp-header']=header_name}}}}}},
                    {name='bad',inputSchema={type='object',properties={x={type='number',['x-mcp-header']='Bad'}}}}
                }}
            end
            if msg.method=='tools/call' then
                call_calls=call_calls+1; call_headers[call_calls]=opts.param_headers[1].name
                if call_calls==1 then return nil,{code=-32020,message='HeaderMismatch'} end
                return {content={}}
            end
        end)
        return annotated_transport
    end})
    check(annotated:connect(),'HTTP catalog with annotations connects')
    eq(#annotated.catalog.tools,1,'invalid annotated tool excluded'); eq(annotated.catalog.tools[1].name,'hello')
    annotated:call('hello',{nested={region='us-west1'}})
    eq(list_calls,2,'HeaderMismatch re-lists tool schemas once'); eq(call_calls,2,'HeaderMismatch retries once')
    eq(call_headers[1],'Region'); eq(call_headers[2],'Locale','retry uses updated Mcp-Param annotation')
    annotated:close()
end
do
    for _,scenario in ipairs({'removed','new-schema'}) do
        local call_count,list_count=0,0
        local client=Client.new(remote_http,settings,{transport_factory=function()
            return scripted(function(msg)
                if msg.method=='server/discover' then return {capabilities={tools={}}} end
                if msg.method=='tools/list' then
                    list_count=list_count+1
                    if list_count==2 and scenario=='removed' then return {tools={}} end
                    local kind=list_count==2 and scenario=='new-schema' and 'integer' or 'string'
                    return {tools={{name='hello',inputSchema={type='object',properties={region={type=kind,['x-mcp-header']='Region'}},required={'region'}}}}}
                end
                if msg.method=='tools/call' then
                    call_count=call_count+1
                    return nil,{code=call_count==1 and -32020 or -32602,message='HeaderMismatch'}
                end
            end)
        end})
        check(client:connect(),'HeaderMismatch retry precondition')
        local _,err=client:call('hello',{region='us-west1'})
        if scenario=='removed' then eq(err.code,-32020,'removed tool returns original HeaderMismatch')
        else eq(err.code,-32602,'updated schema revalidates old input') end
        eq(call_count,1,'removed or incompatible tool is not retried')
        client:close()
    end
end
do
    local transport
    local refresh_client=Client.new(remote_http,settings,{transport_factory=function()
        transport=scripted(function(msg)
            if msg.method=='tools/list' then return {tools={{name='new',inputSchema={type='object',properties={x={type='string',['x-mcp-header']='X'}}}}}} end
            if msg.method=='prompts/list' then return nil,{code=-32000,message='list failed'} end
        end)
        return transport
    end})
    assert(refresh_client:open()); refresh_client.era='modern'; refresh_client.version='2026-07-28'
    refresh_client.capabilities={tools={},prompts={}}
    local old_catalog=json.array({{name='old'}}); local old_headers={old={{name='Old',path={'old'},type='string'}}}
    refresh_client.catalog.tools=old_catalog; refresh_client.tool_headers=old_headers
    local refreshed=refresh_client:refresh()
    check(not refreshed and refresh_client.catalog.tools==old_catalog and refresh_client.tool_headers==old_headers,
        'failed catalog refresh retains catalog and MCP parameter headers atomically')
    refresh_client:close()
end
local probe_methods={}
local fallback_http=Client.new(remote_http,settings,{transport_factory=function()
    return scripted(function(msg)
        probe_methods[#probe_methods+1]=msg.method
        if msg.method=='server/discover' then return nil,{code=-32000,message='empty HTTP 400',data={http_status=400,transport_fallback=true}} end
        if msg.method=='initialize' then return {protocolVersion='2025-11-25',capabilities={}} end
        if msg.method=='tools/list' then return {tools={}} end
    end)
end})
check(fallback_http:connect(),'HTTP empty 400 falls back to legacy'); eq(fallback_http.era,'legacy'); eq(probe_methods[1],'server/discover'); eq(probe_methods[2],'initialize'); fallback_http:close()
local mismatch_methods={}
local mismatch_http=Client.new(remote_http,settings,{transport_factory=function()
    return scripted(function(msg)
        mismatch_methods[#mismatch_methods+1]=msg.method
        if msg.method=='server/discover' then return nil,{code=-32020,message='HeaderMismatch'} end
    end)
end})
local mismatch_ok,mismatch_error=mismatch_http:connect()
check(not mismatch_ok and mismatch_error:find('HeaderMismatch',1,true),'HTTP modern JSON-RPC error is not downgraded')
eq(#mismatch_methods,1,'recognized modern error stops fallback'); mismatch_http:close()
local connection_opens,connection_methods=0,{}
local connection_client=Client.new(remote_http,settings,{transport_factory=function()
    connection_opens=connection_opens+1
    return scripted(function(msg)
        connection_methods[#connection_methods+1]=msg.method
        return nil,{code=-32000,message='connect failed',data={transport_error='connection'}}
    end)
end})
local connection_ok=connection_client:connect()
check(not connection_ok,'connection failures stay errors'); eq(connection_opens,1); eq(#connection_methods,1,'connection failure does not probe legacy')
connection_client:close()
do
    local timeout_timers,timeout_factory=timers(); local timeout_client=Client.new(remote_http,settings,
        {timer_factory=timeout_factory,transport_factory=function() return fake_transport() end})
    assert(timeout_client:open()); timeout_client.era='modern'; timeout_client.version='2026-07-28'
    local timeout_error
    async.run(function() local _,err=timeout_client:request('tools/call',{name='hello',arguments={}}); timeout_error=err end)
    timeout_timers[1]:fire()
    check(timeout_error and timeout_error:find('http tools/call: request timed out',1,true),'HTTP RPC timeout names server and method')
    timeout_client:close()
end
local cached_opens=0
local cached_connection=Client.new(remote_http,settings,{transport_factory=function()
    cached_opens=cached_opens+1
    return scripted(function() return nil,{code=-32000,message='TLS handshake failed',data={transport_error='connection'}} end)
end})
local cached_ok=cached_connection:connect({era='modern',version='2026-07-28'})
check(not cached_ok,'cached connection failure stays an error'); eq(cached_opens,1,'cached connection failure is not re-probed')
cached_connection:close()
local retry_opens=0
local retried=Manager.new(settings,{fs=cfg},{cache_dir=temp,transport_factory=function()
    retry_opens=retry_opens+1
    return scripted(function(msg)
        if msg.method=='server/discover' then return {capabilities={tools={}}} end
        if msg.method=='tools/list' then return {tools={}} end
    end)
end})
retried.states.fs.metadata=meta; retried.states.fs.state='failed'
local retried_search=assert(retried:search(nil,{server='fs'}))
eq(retry_opens,1,'search lazily retries failed servers'); eq(retried.states.fs.state,'ready')
check(retried_search.servers[1].stderr==nil,'search status strips stderr'); retried:close()
local chosen
local selection=Client.new(remote_http,settings,{transport_factory=function()
    return scripted(function(msg,opts)
        if msg.method=='server/discover' then
            eq(opts.protocol_version,'2026-07-28','transport version seam')
            return nil,{code=-32022,message='unsupported',data={supported={'2024-11-05'}}}
        end
        if msg.method=='initialize' then chosen=msg.params.protocolVersion; return {protocolVersion=chosen,capabilities={}} end
    end)
end})
check(selection:connect(),'unsupported-version selection'); eq(chosen,'2024-11-05'); selection:close()
local counteroffer_calls={}
local counteroffer_failure=Client.new(remote_http,settings,{transport_factory=function()
    return scripted(function(msg)
        counteroffer_calls[#counteroffer_calls+1]=msg.method
        if msg.method=='server/discover' then return nil,{code=-32022,message='unsupported',data={supported={'2025-11-25'}}} end
        if msg.method=='initialize' then return nil,{code=-32600,message='legacy initialize rejected'} end
    end)
end})
local counteroffer_ok,counteroffer_error=counteroffer_failure:connect()
check(not counteroffer_ok and counteroffer_error:find('legacy initialize rejected',1,true),'counter-offer failure reports legacy error')
eq(table.concat(counteroffer_calls,','),'server/discover,initialize','counter-offer is tried once'); counteroffer_failure:close()
local opens=0
local reprobe=Client.new(cfg,settings,{transport_factory=function()
    opens=opens+1
    return scripted(function(msg)
        if msg.method=='initialize' then return nil,{code=-32601,message='modern only'} end
        return {capabilities={}}
    end)
end})
check(reprobe:connect({era='legacy',version='2025-11-25'}),'cached era re-probed'); eq(opens,2); eq(reprobe.era,'modern'); reprobe:close()
local delayed_ts,delayed_tf=timers(); local delayed_opens,initialize_count,offered=0,0,nil; local delayed_done
local delayed=Client.new(cfg,settings,{timer_factory=delayed_tf,transport_factory=function()
    delayed_opens=delayed_opens+1
    local tr=fake_transport(); local send=tr.send
    function tr:send(msg,opts)
        local h=send(self,msg,opts)
        if msg.method=='initialize' then
            initialize_count=initialize_count+1; offered=msg.params.protocolVersion
            delayed_tf(2000,function() self.message({jsonrpc='2.0',id=msg.id,result={protocolVersion='2025-11-25',capabilities={}}}) end)
        end
        return h
    end
    return tr
end})
async.run(function() delayed_done=assert(delayed:connect({era='legacy',version='2025-03-26'})) end,function(err) error(err) end)
eq(delayed_ts[1].ms,settings.startup_timeout_ms,'cached handshake gets full startup budget')
eq(delayed_ts[2].ms,2000,'injectable slow legacy server start')
eq(offered,'2025-11-25','cached legacy upgrades its offered version')
delayed_ts[2]:fire()
check(delayed_done and delayed_opens==1 and initialize_count==1,'slow cached legacy starts one process and initializes once'); delayed:close()
local changed_lists,change_transport=0,nil
local changed_client=Client.new(cfg,settings,{transport_factory=function()
    change_transport=scripted(function(msg)
        if msg.method=='server/discover' then return {capabilities={tools={}}} end
        if msg.method=='tools/list' then
            changed_lists=changed_lists+1
            if changed_lists==1 then change_transport.message({jsonrpc='2.0',method='notifications/tools/list_changed'}) end
            return {tools={}}
        end
    end)
    return change_transport
end})
check(changed_client:connect(),'connect survives list_changed during initial refresh')
eq(changed_lists,2,'connect replays list_changed'); changed_client:close()
local silent_ts,silent_tf=timers(); local silent_opens=0; local silent_done
local silent=Client.new(cfg,settings,{timer_factory=silent_tf,transport_factory=function()
    silent_opens=silent_opens+1
    return scripted(function(msg)
        if msg.method=='initialize' then return {protocolVersion='2025-11-25',capabilities={}} end
    end)
end})
async.run(function() silent_done=assert(silent:connect()) end,function(err) error(err) end)
eq(silent_ts[1].ms,1500,'short modern probe'); silent_ts[1]:fire()
check(silent_done and silent.era=='legacy' and silent_opens==2,'silent legacy probe falls back fresh'); silent:close()
local slow_ts,slow_tf=timers(); local slow_opens=0; local slow_done
local slow_modern=Client.new(cfg,settings,{timer_factory=slow_tf,transport_factory=function()
    slow_opens=slow_opens+1
    local attempt=slow_opens
    return scripted(function(msg)
        if attempt==1 then return nil end
        if msg.method=='initialize' then return nil,{code=-32601,message='modern only'} end
        return {capabilities={}}
    end)
end})
async.run(function() slow_done=assert(slow_modern:connect()) end,function(err) error(err) end)
slow_ts[1]:fire()
check(slow_done and slow_modern.era=='modern' and slow_opens==2,'slow modern-only startup recovers after legacy rejection')
slow_modern:close()

-- Activation from a warm cache: checkout entry/namespace registration, stable
-- config-only guidance, zero process starts, and nonblocking command output.
local saved_panto=package.loaded.panto; local saved_std=package.loaded._std
local old_directory=cache.directory; cache.directory=function() return temp end
local activation_raw={servers={fs={command='echo',expose='eager'},alpha={command='echo'},off={enabled=false}}}
local _,activation_servers=config.parse(activation_raw,{project_root=here})
local activation_meta={era='modern',version='2026-07-28',capabilities={tools={},prompts={},resources={}},catalog={
    tools=meta.catalog.tools,prompts={{name='greet',title='Greet',arguments={{name='name',required=true}}}},
    resources=meta.catalog.resources,templates=meta.catalog.templates}}
check(cache.save(activation_servers.fs,activation_meta,temp),'activation warm cache')
check(cache.save(activation_servers.alpha,activation_meta,temp),'second activation warm cache')
local registered,events,commands,namespaces={},{},{},{}
local guidance
package.loaded.panto={ext={json=json,config={mcp=activation_raw},dirs={project_root=here},
    register_tool=function(tool) registered[#registered+1]=tool end,
    register_command=function(command) commands[command.name]=command end,
    on=function(name,fn) events[name]=fn end,
    style=function() return {dim='<dim>',reset='</dim>'} end,
    agent={add_system_message=function(_,text) guidance=text end}}}
package.loaded._std={lua_namespace=function(name,factory) namespaces[name]=factory end}
dofile(here .. '/init.lua').activate()
eq(#registered,3,'older-core eager fallback exposes search tools'); check(namespaces.mcp,'namespace installed')
check(commands['mcp:fs:greet'],'warm prompt command registered on older core')
check(commands['mcp:fs:greet'].handler(''):find('missing required arguments: name',1,true),'warm prompt validates args without starting server')
check(commands.mcp.handler(''):find('idle',1,true),'warm activation stays idle')
do
    local header={render=function(_,width) eq(width,80,'inner header width'); return {'panto',' skills: example',''} end}
    events.render_header({get_component=function() return header end,set_component=function(_,component) header=component end})
    eq(table.concat(header:render(80),'\n'),'panto\n skills: example\n<dim> mcp: alpha, fs</dim>\n',
        'header adds sorted enabled server names before trailing blank')
end
events.session_ready(); check(guidance:find('fs: stdio, search',1,true),'stable config guidance after old-core fallback')
check(commands.mcp.handler(''):find('eager not yet supported',1,true),'old-core eager fallback warning')
events.session_end()
package.loaded.panto=saved_panto; package.loaded._std=saved_std; cache.directory=old_directory
-- The live core path exposes warm eager tools and prompts from cache without a process start.
do
    cache.directory=function() return temp end
    local raw={servers={fast={command='echo',expose='eager'}}}
    local _,ss=config.parse(raw,{project_root=here})
    local warm_meta={era='modern',version='2026-07-28',capabilities={tools={listChanged=true},prompts={},resources={}},catalog={
        tools={{name='read_file',description='Read cached',inputSchema={type='object',properties={path={type='string'}}}}},
        prompts={{name='greet',title='Greet',arguments={{name='name',required=true}}}},
        resources={{name='guide',uri='docs://guide'}},templates={}}}
    check(cache.save(ss.fast,warm_meta,temp),'eager cache write')
    local tools_now,commands_now,events_now={},{},{}
    local ext={json=json,config={mcp=raw},dirs={project_root=here},
        register_tool=function(spec) tools_now[spec.name]=spec; return true end,
        unregister_tool=function(name) tools_now[name]=nil; return true end,
        register_command=function(spec) commands_now[spec.name]=spec; return true end,
        unregister_command=function(name) commands_now[name]=nil; return true end,
        on=function(name,fn) events_now[name]=fn end,
        agent={add_system_message=function() end}}
    package.loaded.panto={ext=ext}; package.loaded._std={lua_namespace=function() end}
    dofile(here .. '/init.lua').activate()
    check(tools_now[config.tool_name('fast','read_file')],'warm eager tool registered at activation')
    check(tools_now['mcp.read_resource'],'eager resource tool registered from warm capability')
    eq(tools_now['mcp.search'],nil,'eager-only mode omits search tools')
    check(commands_now['mcp:fast:greet'],'warm prompt command registered')
    check(commands_now.mcp~=nil,'status command remains available')
    check(commands_now['mcp:fast:greet'].description:find('name',1,true),'prompt description includes argument names')
    check(commands_now.mcp.handler(''):find('idle',1,true),'warm eager activation spawns nothing')
    events_now.session_end()
    package.loaded.panto=saved_panto; package.loaded._std=saved_std; cache.directory=old_directory
end
-- Reconcile connect snapshots: new/removed/changed eager tools and prompt commands.
do
    local _,ss=config.parse({servers={fast={command='echo',expose='eager',enabled_tools={'*'},disabled_tools={'disabled*'}}}},{project_root=here})
    local calls,tool_specs,command_specs,removed_tools,removed_commands={},{},{},{},{}
    local fake_manager={states={fast={cfg=ss.fast}}}
    function fake_manager:call(server,name,input)
        calls[#calls+1]={server=server,name=name,input=input}
        return {is_error=false,text='called '..name,attachments={}}
    end
    local fake_ext={
        register_tool=function(spec) tool_specs[spec.name]=spec; return true end,
        unregister_tool=function(name) removed_tools[#removed_tools+1]=name; tool_specs[name]=nil; return true end,
        register_command=function(spec) command_specs[spec.name]=spec; return true end,
        unregister_command=function(name) removed_commands[#removed_commands+1]=name; command_specs[name]=nil; return true end,
    }
    local eager=require('panto_mcp.eager').new(fake_ext,fake_manager)
    local command_set=prompts.commands(fake_ext,fake_manager,{busy=false},true)
    local function def(name,description,kind)
        return {name=name,description=description,inputSchema={type='object',properties={value={type=kind or 'string'}}}}
    end
    local initial={catalog={tools={def('a.b','old'),def('a_b','collision'),def('remove_me','remove'),def('change_me','change'),def('disabled_tool','disabled')},
        prompts={{name='first',description='First',arguments={{name='q',required=true}}}},resources={},templates={}}}
    fake_manager.states.fast.metadata=initial
    eager:reconcile(); command_set.reconcile('fast',initial,true)
    local dotted=config.tool_name('fast','a.b'); local underscored=config.tool_name('fast','a_b')
    check(dotted~=underscored,'eager sanitizer collision disambiguated')
    check(tool_specs[dotted] and tool_specs[underscored],'initial eager catalog registered')
    eq(tool_specs[config.tool_name('fast','disabled_tool')],nil,'disabled eager tool excluded')
    eq(tool_specs[dotted].handler({value='x'}).text,'called a.b','eager handler maps sanitized name back to MCP name')
    eq(calls[1].server,'fast'); eq(calls[1].name,'a.b')
    local changed={catalog={tools={def('a.b','updated','integer'),def('brand_new','new')},
        prompts={{name='second',title='Second',arguments={{name='text',required=true}}}},resources={},templates={}}}
    fake_manager.states.fast.metadata=changed
    eager:reconcile(); command_set.reconcile('fast',changed,false)
    check(tool_specs[dotted] and tool_specs[dotted].description=='updated','changed eager definition re-registered')
    eq(tool_specs[dotted].schema.properties.value.type,'integer','changed eager schema replaced')
    check(tool_specs[config.tool_name('fast','brand_new')],'new eager tool registered')
    eq(tool_specs[underscored],nil,'removed eager tool unregistered')
    check(#removed_tools>=4,'removed and changed eager registrations unregistered')
    eq(command_specs['mcp:fast:first'],nil,'removed prompt command unregistered')
    check(command_specs['mcp:fast:second'],'new prompt command registered')
    check(#removed_commands==1,'removed prompt registration reconciled')
end
do
    local warning_command,render_header
    package.loaded.panto={ext={json=json,config={mcp={servers={bad={url='file://invalid'}}}},dirs={},
        register_command=function(c) warning_command=c end,
        on=function(name,fn) if name=='render_header' then render_header=fn end end,
        style=function() return {dim='',reset=''} end}}
    dofile(here .. '/init.lua').activate()
    check(warning_command and warning_command.handler(''):find('Config warning',1,true),'invalid-only config still exposes TUI warnings')
    local header={render=function() return {'panto'} end}
    render_header({get_component=function() return header end,set_component=function(_,component) header=component end})
    eq(table.concat(header:render(80),'\n'),'panto\n mcp: (none)','header excludes invalid servers')
    package.loaded.panto=saved_panto
end
local gate=async.future(); local command
require('panto_mcp.tools').register({register_tool=function() end,register_command=function(c) command=c end,
    mount=function() error('refresh must not mount a component') end}, {servers=function() return {} end,refresh=function() return gate:await() end})
check(command.handler('refresh'):find('started',1,true),'refresh returns started while async work is parked')
gate:resolve(true)
local warning_only
require('panto_mcp.tools').register_status({register_command=function(c) warning_only=c end},{servers=function() return {} end},{'bad server'})
check(warning_only.handler(''):find('Config warning: bad server',1,true),'status displays config warnings')
do
    local tools=require('panto_mcp.tools')
    local status=tools.status({servers=function() return {{name='remote',state='idle',transport='http',tools=0,prompts=0,resources=0,templates=0,stderr=''}} end},{})
    check(status:find('HTTP URL',1,true),'status identifies URL transport')
    local ready,system_hint
    tools.hint({on=function(name,fn) ready=fn end,agent={add_system_message=function(_,text) system_hint=text end}},
        {remote={transport='http',expose='search',url='https://secret.example'}})
    ready(); check(system_hint:find('remote: HTTP URL, search',1,true),'config-only URL hint')
    check(not system_hint:find('secret.example',1,true),'system hint omits remote URL')
end

-- Real subprocess integration. A bounded watchdog protects the harness; no
-- timeout behavior is inferred from elapsed sleeps.
local integration_error
local done=false
local managers={}
local watchdog=uv.new_timer(); watchdog:start(30000,0,function()
    integration_error='integration watchdog expired'; for _,m in ipairs(managers) do m:close() end
    close(watchdog)
end)
async.run(function()
    for _,mode in ipairs({'modern','banner','legacy','legacy-close','tools-only','missing-templates','env-check'}) do
        local child_env=mode=='env-check' and {PANTO_MCP_TEST_CHILD_ENV='child'} or nil
        local _,ss=config.parse({servers={fake={command=uv.exepath(),args={'lua',here .. '/_selfcheck.lua','--fake',mode},env=child_env}}},{project_root=here})
        local m=Manager.new(settings,ss,{cache_dir=temp}); managers[#managers+1]=m
        local api=namespace.factory(m,{})
        local one,two=api.start('fake','echo',{message='first'}),api.start('fake','echo',{message='second'})
        local first=assert(one:await())
        check(not first.is_error,first.text .. '\n' .. (m.states.fake.client.transport.stderr_tail or ''))
        eq(first.text,'first',mode .. ' first call'); eq(assert(two:await()).text,'second',mode .. ' concurrent call')
        eq(m.states.fake.state,'ready'); eq(#m.states.fake.metadata.catalog.tools,2,'pagination')
        local searched=assert(m:search(nil,{server='fake'}))
        check(searched.servers[1].stderr==nil,'search omits stderr'); check(m:servers()[1].stderr~=nil,'servers retains stderr')
        eq(m.states.fake.metadata.era,(mode=='modern' or mode=='banner' or mode=='env-check') and 'modern' or 'legacy','era')
        check(m:call('fake','echo',{}).is_error,'live schema validation')
        check(m:call('fake','ecoh',{message='x'}).text:find('echo',1,true),'closest exact name')
        if mode~='tools-only' then
            check(m:read_resource('fake','docs://guide').text:find('resource body',1,true),'resource read')
            eq(#assert(api.prompts('fake')),1); eq(assert(api.prompt('fake','greet',{name='A'}))[1].role,'user')
        else eq(#m.states.fake.metadata.catalog.resources,0,'unadvertised list skipped') end
        if mode=='missing-templates' then eq(#m.states.fake.metadata.catalog.templates,0,'unimplemented list is empty') end
        if mode=='modern' then
            local changed=async.future()
            m.opts.on_catalog=function(_,data) if #data.catalog.tools==3 then changed:resolve(true) end end
            eq(m:call('fake','echo',{message='change'}).text,'change')
            check(changed:await(),'list_changed relisted')
            eq(#assert(cache.load(ss.fake,temp)).catalog.tools,3,'list_changed rewrote cache')
            local _,eager_servers=config.parse({servers={fake={command=uv.exepath(),args={'lua',here .. '/_selfcheck.lua','--fake','modern'},expose='eager'}}},{project_root=here})
            local dynamic_tools,dynamic_commands={},{}
            local registration_ext={
                register_tool=function(spec) dynamic_tools[spec.name]=spec; return true end,
                unregister_tool=function(name) dynamic_tools[name]=nil; return true end,
                register_command=function(spec) dynamic_commands[spec.name]=spec; return true end,
                unregister_command=function(name) dynamic_commands[name]=nil; return true end,
            }
            local eager_manager
            local eager_registration
            local prompt_registration
            local catalog_changed=async.future(); local catalog_removed=async.future()
            eager_manager=Manager.new(settings,eager_servers,{cache_dir=temp,on_catalog=function(server,data)
                eager_registration:reconcile()
                prompt_registration.reconcile(server,data,false)
                if dynamic_tools[config.tool_name('fake','new_tool')] and dynamic_commands['mcp:fake:wave'] then catalog_changed:resolve(true) end
                if next(dynamic_tools)==nil and dynamic_commands['mcp:fake:wave']==nil then catalog_removed:resolve(true) end
            end})
            eager_registration=require('panto_mcp.eager').new(registration_ext,eager_manager)
            prompt_registration=prompts.commands(registration_ext,eager_manager,{busy=false},true)
            eq(eager_manager:call('fake','echo',{message='change'}).text,'change','eager manager starts cold server lazily')
            check(catalog_changed:await(),'connect/list_changed adds eager tool and reconciles prompt')
            check(dynamic_tools[config.tool_name('fake','echo')] and dynamic_tools[config.tool_name('fake','new_tool')],'new eager catalog registered')
            eq(dynamic_commands['mcp:fake:greet'],nil,'removed prompt command reconciled on connect')
            check(dynamic_commands['mcp:fake:wave'],'new prompt command reconciled on connect')
            eager_manager:call('fake','echo',{message='remove'})
            check(catalog_removed:await(),'second list_changed removes live eager registrations')
            eager_manager:close()
        end
        m:close()
    end
    local _,noisy_config=config.parse({servers={noisy={command=uv.exepath(),args={'lua',here .. '/_selfcheck.lua','--fake','noisy-exit'}}}},{project_root=here})
    local noisy=Manager.new(settings,noisy_config,{cache_dir=temp}); managers[#managers+1]=noisy
    local noisy_result=noisy:call('noisy','echo',{})
    check(noisy_result.is_error and noisy_result.text:find('diagnostic-tail-from-child',1,true),'transport errors include bounded stderr tail')
    done=true; close(watchdog)
end,function(err) integration_error=err; for _,m in ipairs(managers) do m:close() end; close(watchdog) end)
uv.run()
assert(not integration_error,integration_error); check(done,'integration finished')

-- A server that ignores stdin EOF must still reach TERM/KILL escalation on
-- ordinary nonblocking transport.close(), not just on parent death.
local ignored=assert(stdio.new({command=uv.exepath(),args={'lua',here .. '/_selfcheck.lua','--fake','ignore'},env={}}))
local ignore_poll,ignore_bound=uv.new_timer(),uv.new_timer()
local ignore_pid,ignore_gone,ignore_error
ignore_poll:start(0,20,function()
    if ignored.server_pid and not ignore_pid then ignore_pid=ignored.server_pid; ignored:close() end
    if ignore_pid and not uv.kill(-ignore_pid,0) then ignore_gone=true; close(ignore_poll); close(ignore_bound) end
end)
ignore_bound:start(8000,0,function()
    ignore_error='EOF-ignoring server exceeded bounded exit wait'
    if ignore_pid then uv.kill(-ignore_pid,'sigkill') end
    ignored:close(); close(ignore_poll); close(ignore_bound)
end)
uv.run(); assert(not ignore_error,ignore_error); check(ignore_gone,'EOF-ignoring server reaped after close')
local orphaned=assert(stdio.new({command=uv.exepath(),args={'lua',here .. '/_selfcheck.lua','--fake','ignore'},env={}}))
local orphan_poll,orphan_bound=uv.new_timer(),uv.new_timer()
local orphan_pid,supervisor_killed,orphan_gone,orphan_error,supervisor_reason=nil,false,false,nil,nil
orphaned:set_callbacks(function() end,function(err) supervisor_reason=err end)
orphan_poll:start(0,20,function()
    if orphaned.server_pid and not supervisor_killed then
        orphan_pid=orphaned.server_pid; supervisor_killed=true; orphaned.proc:kill('sigkill')
    end
    if orphan_pid and not uv.kill(-orphan_pid,0) then orphan_gone=true; close(orphan_poll); close(orphan_bound) end
end)
orphan_bound:start(8000,0,function()
    orphan_error='orphan survived supervisor death'
    if orphan_pid then uv.kill(-orphan_pid,'sigkill') end
    close(orphan_poll); close(orphan_bound)
end)
uv.run(); assert(not orphan_error,orphan_error); check(orphan_gone and supervisor_reason and supervisor_reason:find('supervisor exited',1,true),'parent TERM/KILL fallback reaps group after supervisor death')
local eof=assert(stdio.new({command=uv.exepath(),args={'lua',here .. '/_selfcheck.lua','--fake','exit-on-eof'},env={}}))
local eof_done,eof_alive,eof_closed,eof_error,eof_reason=false,false,false,nil,nil
local eof_poll,eof_bound=uv.new_timer(),uv.new_timer()
eof:set_callbacks(function() end,function(err) eof_reason=err; eof_alive=uv.kill(eof.supervisor_pid,0)~=nil; eof_done=true end)
eof_poll:start(0,10,function()
    if eof.server_pid and not eof_closed then eof_closed=true; async.close(eof.stdin) end
    if eof_done then close(eof_poll); close(eof_bound) end
end)
eof_bound:start(5000,0,function() eof_error='server stdout EOF delayed until supervisor exit'; close(eof_poll); close(eof_bound); eof:close() end)
uv.run(); assert(not eof_error,eof_error); check(eof_done and eof_alive and eof_reason:find('stdout closed',1,true),'supervisor drops fd 0/1 before grace period')

-- S1: parent SIGKILL must close the fourth-fd lifeline and reap the whole
-- TERM-resistant group, including a grandchild shell/sleep tree.
local parent_out=uv.new_pipe(false); local parent_err=uv.new_pipe(false)
local parent,server_pid,orphan_error,parent_exited,group_gone
local poll=uv.new_timer(); local bound=uv.new_timer()
local function cleanup()
    close(poll); close(bound); close(parent_out); close(parent_err); close(parent)
end
parent=assert(uv.spawn(uv.exepath(),{args={'lua',here .. '/_selfcheck.lua','--parent'},stdio={nil,parent_out,parent_err},detached=true},function() parent_exited=true; close(parent) end))
local output=''
parent_out:read_start(function(e,data)
    if e then orphan_error=e; cleanup(); return end
    if data then
        output=output .. data
        local pid=tonumber(output:match('SERVER=(%d+)\n'))
        if pid and not server_pid then server_pid=pid; assert(parent:kill('sigkill')) end
    end
end)
parent_err:read_start(function(e,data) if e then orphan_error=e end; if data then output=output .. data end end)
poll:start(0,25,function()
    if server_pid and not uv.kill(-server_pid,0) then group_gone=true; cleanup() end
end)
bound:start(8000,0,function()
    orphan_error='orphan check exceeded bounded exit wait'
    if server_pid then uv.kill(-server_pid,'sigkill') end
    pcall(parent.kill,parent,'sigkill'); cleanup()
end)
uv.run()
assert(not orphan_error,orphan_error); check(server_pid and parent_exited and group_gone,'SIGKILL parent tears down server group')
-- panto lua has no active HTTP service. A scripted provider keeps this token-free.
-- Set PANTO_MCP_HTTP_E2E=1; PANTO_MCP_PANTO selects the nested test binary.
local function http_e2e(mode)
local http_panto=uv.fs_realpath(os.getenv('PANTO_MCP_PANTO') or '/tmp/panto-mcp-work/panto-full')
assert(http_panto,'HTTP E2E requires /tmp/panto-mcp-work/panto-full (or PANTO_MCP_PANTO)')
if http_panto then
    local rig=temp..'/http-rig-'..mode; local extdir=rig..'/fixture'; local data_home=temp..'/http-data-'..mode
    assert(uv.fs_mkdir(rig,448)); assert(uv.fs_mkdir(extdir,448)); assert(uv.fs_mkdir(data_home,448))
    local provider=[[local panto=require('panto')
local json=panto.ext.json
local function last_results(request)
 local out={}
 for _,m in ipairs(request.messages) do
  for _,b in ipairs(m.blocks or {}) do
   if b.type=='tool_result' then out[#out+1]=type(b.content)=='string' and b.content or json.encode(b.content) end
  end
 end
 return table.concat(out,'\\n')
end
return {name='mcp-http-selfcheck-provider',activate=function()
 panto.ext.register_protocol{name='mcp-http-selfcheck',open=function(request)
  local rounds=0
  for _,m in ipairs(request.messages) do if m.role=='assistant' then rounds=rounds+1 end end
  local event
  if rounds==0 then event={type='tool_call',id='http-search',name='mcp.search',input_json=json.encode({server='remote',query='hello'})}
  elseif rounds==1 then
   assert(last_results(request):find('hello',1,true),'HTTP tool search did not return hello')
   event={type='tool_call',id='http-call',name='mcp.call',input_json=json.encode({server='remote',tool='hello'})}
  else
   assert(last_results(request):find('HTTP_E2E_TOOL_OK',1,true),'HTTP MCP call did not return expected content')
   event={type='text_delta',text='HTTP_MCP_E2E_OK'}
  end
  local sent=false
  return {next=function() if sent then return {type='done'} end; sent=true; return event end}
 end}
end}]]
    if mode=='oauth' then
        provider=[[local panto=require('panto')
local async=require('panto_mcp.async')
local json=panto.ext.json
return {name='mcp-oauth-selfcheck-provider',activate=function()
 local settings,servers=require('panto_mcp.config').parse(panto.ext.config.mcp,panto.ext.dirs)
 local manager=require('panto_mcp.manager').new(settings,servers)
 local commands={}
 require('panto_mcp.tools').register_status({register_command=function(spec) commands[spec.name]=spec; return true end},manager,{})
 local function get(url)
  local future=async.future()
  assert(panto.ext.http_request({url=url},function(response,err) future:resolve(response,err) end))
  local response,err=future:await(); assert(response,err); return response
 end
 local function ready()
  local future=async.future(); local attempts=0
  local function poll()
   attempts=attempts+1
   if manager.states.remote.state=='ready' and not manager.states.remote.oauth.login_required and not manager.states.remote.oauth.login_url then future:resolve(true)
   elseif attempts>=500 then future:resolve(nil,'OAuth reconnect did not finish')
   else async.timer(20,poll) end
  end
  poll(); local ok,err=future:await(); assert(ok,err)
 end
 local function authorize(pasted)
  local future=async.future(); local attempts=0
  local function login_url()
   attempts=attempts+1
   local output=commands['mcp-login'].handler('remote')
   local url=output:match('\n(http[^%s]+)')
   if url then future:resolve(url)
   elseif attempts>=20 then future:resolve(nil,'login URL missing: '..output)
   else async.timer(1000,login_url) end
  end
  login_url(); local url,err=future:await(); assert(url,err)
  local response=get(url); assert(response.status==302,'authorize did not redirect')
  local callback=assert(response.headers.location,'missing authorization Location')
  if pasted then
   local accepted=commands['mcp-login'].handler('remote '..callback)
   assert(accepted:find('accepted',1,true),'headless callback not accepted')
  else assert(get(callback).status==200,'loopback callback failed') end
  ready()
 end
 panto.ext.register_tool{name='oauth-check',description='Exercise real-core MCP OAuth',schema={type='object'},handler=function()
  local client,err=manager:ensure('remote')
  assert(not client and err:find('/mcp-login remote',1,true),'initial 401 did not request login')
  authorize(false)
  local result=manager:call('remote','hello',{})
  assert(not result.is_error and result.text:find('HTTP_E2E_TOOL_OK',1,true),'refresh-on-401 failed')
  result=manager:call('remote','hello',{stepup=true})
  assert(result.is_error and result.text:find('/mcp-login remote',1,true),'missing scope consent request')
  authorize(true)
  result=manager:call('remote','hello',{stepup=true})
  assert(not result.is_error,'step-up reauthorization failed: '..result.text)
  manager:close()
  manager=require('panto_mcp.manager').new(settings,servers)
  assert(manager.states.remote.oauth.definition,'warm discovery missing')
  result=manager:call('remote','hello',{})
  assert(not result.is_error,'warm core session failed')
  manager:close()
  return 'HTTP_E2E_TOOL_OK'
 end}
 panto.ext.register_protocol{name='mcp-http-selfcheck',open=function(request)
  local done=false; local completed=false
  for _,m in ipairs(request.messages) do for _,b in ipairs(m.blocks or {}) do
   if b.type=='tool_result' then
    local text=type(b.content)=='string' and b.content or json.encode(b.content)
    assert(text:find('HTTP_E2E_TOOL_OK',1,true),'OAuth fixture tool failed: '..text); completed=true
   end
  end end
  return {next=function()
   if done then return {type='done'} end; done=true
   if completed then return {type='text_delta',text='HTTP_MCP_E2E_OK'} end
   return {type='tool_call',id='oauth-flow',name='oauth-check',input_json='{}'}
  end}
 end}
end}]]
        provider='package.path='..string.format('%q',here..'/?.lua;'..here..'/?/init.lua;')..'..package.path\n'..provider
    end
    write(extdir..'/provider.lua',provider)
    local function q(s) return '"'..s:gsub('\\','\\\\'):gsub('"','\\"')..'"' end
    local served={}; local server_error; local clients={}; local server_timers={}; local handle_client
    local oauth_seen={prm=0,metadata=0,registration=0,authorize=0,tokens=0,refresh=0,stepup=0}
    local authorized_scope='read'; local forced_refresh=false
    local function form(text)
        local out={}
        local function decode(v) return (v:gsub('+',' '):gsub('%%(%x%x)',function(hex) return string.char(tonumber(hex,16)) end)) end
        for key,value in text:gmatch('([^&=?]+)=([^&]*)') do out[decode(key)]=decode(value) end
        return out
    end
    local function escape(text) return (text:gsub('[^A-Za-z0-9_.~-]',function(c) return string.format('%%%02X',c:byte()) end)) end
    local listener=assert(uv.new_tcp()); assert(listener:bind('127.0.0.1',0)==0)
    local port=assert(listener:getsockname()).port
    assert(listener:listen(32,function(accept_err)
        if accept_err then server_error=tostring(accept_err); return end
        local client=assert(uv.new_tcp()); local accepted,why=listener:accept(client)
        if accepted~=0 then server_error=tostring(why or accepted); close(client); return end
        handle_client(client)
    end))
    local config_text=(mode=='slow' and '[mcp]\nidle_timeout_ms = 20\ncall_timeout_ms = 5000\n\n' or '')..
        '[extensions]\npaths = ['..(mode=='oauth' and '' or q(here)..', ')..q(extdir)..']\n\n'..
        '[providers.fixture]\nprotocol = "mcp-http-selfcheck"\n\n[defaults]\nmodel = "fixture:dummy"\n\n'..
        '[mcp.servers.remote]\nurl = '..q('http://127.0.0.1:'..port..'/mcp')..'\n'
    write(rig..'/config.toml',config_text)
    local function respond(client,status,body,content_type,session_id,delay_ms,extra_headers)
        local text=status==200 and 'OK' or status==202 and 'Accepted' or 'Bad Request'
        local fields='Content-Length: '..#body..'\r\nConnection: close\r\n'
        if content_type then fields='Content-Type: '..content_type..'\r\n'..fields end
        if session_id then fields=fields..'Mcp-Session-Id: '..session_id..'\r\n' end
        for name,value in pairs(extra_headers or {}) do fields=fields..name..': '..value..'\r\n' end
        local head='HTTP/1.1 '..status..' '..text..'\r\n'..fields..'\r\n'
        if delay_ms then
            client:write(head,function(err)
                if err then server_error=tostring(err); close(client); return end
                local timer=uv.new_timer(); server_timers[#server_timers+1]=timer
                timer:start(delay_ms,0,function() close(timer); client:write(body,function() close(client) end) end)
            end)
        else client:write(head..body,function() close(client) end) end
    end
    handle_client=function(client)
        clients[#clients+1]=client
        local raw=''; local answered=false
        client:read_start(function(read_err,chunk)
            if answered then return end
            if read_err then server_error=tostring(read_err); close(client); return end
            if not chunk then close(client); return end
            raw=raw..chunk
            local boundary=raw:find('\r\n\r\n',1,true); if not boundary then return end
            local head=raw:sub(1,boundary-1); local headers={}
            local request_method=head:match('^(%S+)')
            local target=head:match('^%S+ (%S+)')
            for line in (head..'\r\n'):gmatch('(.-)\r\n') do
                local name,value=line:match('^([^:]+):%s*(.*)$'); if name then headers[name:lower()]=value end
            end
            local body
            if (headers['transfer-encoding'] or ''):lower():find('chunked',1,true) then
                local chunks={}; local cursor=boundary+4
                while true do
                    local line_end=raw:find('\r\n',cursor,true); if not line_end then return end
                    local size=tonumber(raw:sub(cursor,line_end-1),16); if not size then server_error='invalid chunk size'; respond(client,400,'bad request'); return end
                    cursor=line_end+2
                    if size==0 then
                        local trailer_end=raw:find('\r\n\r\n',cursor,true)
                        if trailer_end then cursor=trailer_end+4
                        elseif raw:sub(cursor,cursor+1)=='\r\n' then cursor=cursor+2
                        else return end
                        body=table.concat(chunks); break
                    end
                    if #raw<cursor+size+1 then return end
                    chunks[#chunks+1]=raw:sub(cursor,cursor+size-1); cursor=cursor+size
                    if raw:sub(cursor,cursor+1)~='\r\n' then server_error='invalid chunk framing'; respond(client,400,'bad request'); return end
                    cursor=cursor+2
                end
            else
                local length=tonumber(headers['content-length']) or 0
                if #raw-boundary-3<length then return end
                body=raw:sub(boundary+4,boundary+3+length)
            end
            answered=true; client:read_stop()
            if request_method=='DELETE' then respond(client,200,''); return end
            if mode=='oauth' and target~='/mcp' then
                local origin='http://127.0.0.1:'..port
                local function send(value) respond(client,200,json.encode(value),'application/json') end
                if target=='/meta' then
                    oauth_seen.prm=oauth_seen.prm+1
                    if headers.authorization then server_error='OAuth discovery leaked credentials' end
                    send({resource=origin..'/mcp',authorization_servers={origin..'/tenant'},scopes_supported={'fallback'}})
                elseif target=='/.well-known/oauth-authorization-server/tenant' then
                    oauth_seen.metadata=oauth_seen.metadata+1
                    send({issuer=origin..'/tenant',authorization_endpoint=origin..'/authorize',token_endpoint=origin..'/token',registration_endpoint=origin..'/register',
                        code_challenge_methods_supported={'S256'},authorization_response_iss_parameter_supported=true})
                elseif target=='/register' then
                    oauth_seen.registration=oauth_seen.registration+1
                    local registration=json.decode(body)
                    if registration.application_type~='native' or registration.redirect_uris[1]~='http://127.0.0.1/callback' or registration.token_endpoint_auth_method~='none' then server_error='bad DCR metadata' end
                    send({client_id='native-e2e',registration_access_token='DO_NOT_PERSIST_REGISTRATION_TOKEN'})
                elseif target:match('^/authorize%?') then
                    oauth_seen.authorize=oauth_seen.authorize+1
                    local params=form(target:match('%?(.*)'))
                    if params.client_id~='native-e2e' or params.code_challenge_method~='S256' or not params.code_challenge or #params.code_challenge~=43 or params.resource~=origin..'/mcp' then server_error='bad PKCE/resource authorize params' end
                    if not params.redirect_uri:match('^http://127%.0%.0%.1:%d+/callback$') then server_error='bad loopback redirect URI' end
                    authorized_scope=params.scope
                    respond(client,302,'',nil,nil,nil,{Location=params.redirect_uri..'?code=e2e-code&state='..escape(params.state)..'&iss='..escape(origin..'/tenant')})
                elseif target=='/token' then
                    oauth_seen.tokens=oauth_seen.tokens+1
                    local params=form(body)
                    if params.resource~=origin..'/mcp' then server_error='missing token resource indicator' end
                    if params.grant_type=='refresh_token' then
                        oauth_seen.refresh=oauth_seen.refresh+1
                        if not params.refresh_token then server_error='missing refresh token' end
                    elseif params.grant_type~='authorization_code' or params.code~='e2e-code' or not params.code_verifier then server_error='bad code exchange' end
                    send({access_token='e2e-access-'..oauth_seen.tokens,refresh_token='e2e-refresh-'..oauth_seen.tokens,token_type='Bearer',expires_in=3600,scope=authorized_scope})
                else server_error='unexpected OAuth endpoint'; respond(client,404,'') end
                return
            end
            local ok,request=pcall(json.decode,body)
            if not ok or type(request)~='table' then server_error='invalid JSON request'; respond(client,400,'bad request'); return end
            served[#served+1]=request.method
            if mode=='oauth' then
                if not headers.authorization or (request.method=='tools/call' and not forced_refresh) then
                    if headers.authorization then forced_refresh=true end
                    respond(client,401,'DO_NOT_LOG_ACCESS_TOKEN',nil,nil,nil,{['WWW-Authenticate']='Bearer resource_metadata="http://127.0.0.1:'..port..'/meta", scope="read"'})
                    return
                end
                if headers.authorization~='Bearer e2e-access-'..oauth_seen.tokens then server_error='wrong core-injected Bearer' end
                if request.method=='tools/call' and request.params.arguments.stepup and not authorized_scope:find('write',1,true) then
                    oauth_seen.stepup=oauth_seen.stepup+1
                    respond(client,403,'DO_NOT_LOG_ACCESS_TOKEN',nil,nil,nil,{['WWW-Authenticate']='Bearer error="insufficient_scope", scope="write"'})
                    return
                end
            end
            local result
            if mode=='legacy' and request.method=='server/discover' then
                if headers['mcp-protocol-version']~='2026-07-28' or headers['mcp-method']~='server/discover' then server_error='bad modern probe headers' end
                respond(client,400,'legacy endpoint'); return
            elseif mode=='legacy' and request.method=='initialize' then
                if headers['mcp-protocol-version'] or headers['mcp-session-id'] then server_error='legacy initialize carried session metadata' end
                result={protocolVersion='2024-11-05',capabilities={tools={}}}
            elseif mode=='legacy' and request.method=='notifications/initialized' then
                if headers['mcp-protocol-version']~='2024-11-05' or headers['mcp-session-id']~='e2e-session' then server_error='legacy notification missing negotiated headers' end
                respond(client,202,''); return
            elseif mode=='legacy' then
                if headers['mcp-protocol-version']~='2024-11-05' or headers['mcp-session-id']~='e2e-session' or headers['mcp-method'] then server_error='legacy request headers mismatch' end
                if request.method=='tools/list' then result={tools={{name='hello',description='Say hello',inputSchema={type='object'}}}}
                elseif request.method=='tools/call' then result={content={{type='text',text='HTTP_E2E_TOOL_OK'}}}
                else server_error=server_error or ('unexpected legacy method '..tostring(request.method)); result={} end
            else
                if headers['mcp-protocol-version']~='2026-07-28' or headers['mcp-method']~=request.method then server_error='missing modern HTTP headers for '..tostring(request.method) end
                if request.method=='tools/call' and headers['mcp-name']~='hello' then server_error='missing Mcp-Name' end
                if request.method=='server/discover' then result={resultType='complete',supportedVersions={'2026-07-28'},capabilities={tools={}}}
                elseif request.method=='tools/list' then result={tools={{name='hello',description='Say hello',inputSchema={type='object'}}}}
                elseif request.method=='tools/call' then result={content={{type='text',text='HTTP_E2E_TOOL_OK'}}}
                else server_error=server_error or ('unexpected method '..tostring(request.method)); result={} end
            end
            if server_error then respond(client,400,'bad headers'); return end
            local payload=json.encode({jsonrpc='2.0',id=request.id,result=result})
            if mode=='sse' then
                local notification=json.encode({jsonrpc='2.0',method='notifications/progress',params={progress=1}})
                payload='event: message\r\ndata: '..notification..'\r\n\r\nevent: message\r\ndata: '..payload..'\r\n\r\n'
                respond(client,200,payload,'text/event-stream')
            else respond(client,200,payload,'application/json',mode=='legacy' and request.method=='initialize' and 'e2e-session' or nil,
                mode=='slow' and request.method=='tools/call' and 120 or nil) end
        end)
    end
    local child_out,child_err=uv.new_pipe(false),uv.new_pipe(false)
    local envmap=uv.os_environ(); envmap.XDG_DATA_HOME=data_home; envmap.XDG_CONFIG_HOME=data_home..'/config'; envmap.PANTO_SESSION_DIR=temp..'/http-sessions'
    local env={}; for k,v in pairs(envmap) do env[#env+1]=k..'='..v end
    table.sort(env)
    local command=assert(uv.new_timer()); local child,child_pid
    local stdout,stderr='',''; local out_eof,err_eof,exited=false,false,false; local code,signal
    local future=async.future()
    local function maybe_done()
        if exited and out_eof and err_eof then future:resolve({code=code,signal=signal,stdout=stdout,stderr=stderr}) end
    end
    child,child_pid=uv.spawn(http_panto,{args={'--print','--incognito','--rig',rig,'--model','fixture:dummy','--','test remote MCP'},cwd=rig,env=env,stdio={nil,child_out,child_err}},function(c,s)
        exited=true; code=c; signal=s; close(child); maybe_done()
    end)
    assert(child,'could not start HTTP print-mode panto: '..tostring(child_pid))
    child_out:read_start(function(e,d) if e then server_error=tostring(e) end; if d then stdout=stdout..d else out_eof=true; close(child_out); maybe_done() end end)
    child_err:read_start(function(e,d) if e then server_error=tostring(e) end; if d then stderr=stderr..d else err_eof=true; close(child_err); maybe_done() end end)
    command:start(30000,0,function()
        if not exited then server_error='print-mode HTTP integration watchdog expired'; pcall(child.kill,child,'sigkill') end
    end)
    async.run(function()
        local result=future:await(); close(command); close(listener)
        for _,client in ipairs(clients) do close(client) end
        for _,timer in ipairs(server_timers) do close(timer) end
        check(not server_error,'HTTP fake server: '..tostring(server_error))
        check(result.code==0,'HTTP print-mode exit '..tostring(result.code)..': '..result.stdout..result.stderr)
        check(result.stdout:find('HTTP_MCP_E2E_OK',1,true),'print-mode MCP tools completed: '..result.stdout..result.stderr)
        local expected=mode=='legacy' and 'server/discover,initialize,notifications/initialized,tools/list,tools/call' or 'server/discover,tools/list,tools/call'
        if mode=='oauth' then
            eq(oauth_seen.prm,1,'OAuth E2E warm/consent login reuse discovery'); eq(oauth_seen.metadata,1,'OAuth E2E AS discovery')
            eq(oauth_seen.registration,1,'OAuth E2E reuses one public DCR client across consent logins'); eq(oauth_seen.authorize,2,'OAuth E2E consent and scope step-up')
            eq(oauth_seen.tokens,3,'OAuth E2E code/refresh/code exchanges'); eq(oauth_seen.refresh,1,'OAuth E2E forced refresh exactly once')
            eq(oauth_seen.stepup,1,'OAuth E2E insufficient scope challenge')
            check(not (result.stdout..result.stderr):find('e2e%-access%-') and not (result.stdout..result.stderr):find('DO_NOT_LOG',1,true),'OAuth secrets absent from transcript/stderr')
            local remembered=assert(read(data_home..'/panto/state.toml'),'OAuth state file missing')
            check(remembered:find('native-e2e',1,true) and not remembered:find('e2e%-access%-') and not remembered:find('DO_NOT_PERSIST',1,true),'OAuth state stores registration, never tokens')
            local cache_scan=assert(uv.fs_scandir(data_home..'/panto-mcp'))
            while true do
                local name=uv.fs_scandir_next(cache_scan); if not name then break end
                local text=assert(read(data_home..'/panto-mcp/'..name))
                check(not text:find('e2e%-access%-') and not text:find('e2e%-refresh%-') and not text:find('Authorization',1,true),'OAuth catalog cache contains no credentials')
            end
        else check(table.concat(served,',')==expected,mode..' HTTP request sequence') end
        for _,path in ipairs({rig..'/config.toml',extdir..'/provider.lua'}) do uv.fs_unlink(path) end
        uv.fs_rmdir(extdir); uv.fs_rmdir(rig)
        local function remove_tree(path)
            local scan=uv.fs_scandir(path); if not scan then return end
            while true do
                local name=uv.fs_scandir_next(scan); if not name then break end
                local child_path=path..'/'..name; local stat=uv.fs_lstat(child_path)
                if stat and stat.type=='directory' then remove_tree(child_path) else uv.fs_unlink(child_path) end
            end
            uv.fs_rmdir(path)
        end
        remove_tree(data_home); remove_tree(temp..'/http-sessions')
    end,function(err)
        server_error=err; close(command); close(listener); if child and not exited then pcall(child.kill,child,'sigkill') end
        for _,client in ipairs(clients) do close(client) end
        for _,timer in ipairs(server_timers) do close(timer) end
    end)
    uv.run()
    assert(not server_error,server_error)
end
end
local function eager_print_e2e()
    local binary=uv.fs_realpath(os.getenv('PANTO_MCP_PANTO') or '/tmp/panto-mcp-work/panto-full')
    assert(binary,'new-core panto binary missing; set PANTO_MCP_PANTO')
    local rig=temp..'/eager-print-rig'; local extdir=rig..'/fixture'; local data_home=temp..'/eager-print-data'
    assert(uv.fs_mkdir(rig,448)); assert(uv.fs_mkdir(extdir,448)); assert(uv.fs_mkdir(data_home,448))
    local function q(s) return '"'..s:gsub('\\','\\\\'):gsub('"','\\"')..'"' end
    local provider=[[local panto=require('panto')
local json=panto.ext.json
local function tool_result_text(request)
 local out={}
 for _,m in ipairs(request.messages) do
  for _,b in ipairs(m.blocks or {}) do
   if b.type=='tool_result' then out[#out+1]=type(b.content)=='string' and b.content or json.encode(b.content) end
  end
 end
 return table.concat(out,'\n')
end
return {name='mcp-eager-print-provider',activate=function()
 panto.ext.register_protocol{name='mcp-eager-print',open=function(request)
  local rounds=0
  for _,message in ipairs(request.messages) do if message.role=='assistant' then rounds=rounds+1 end end
  local event
  if rounds==0 then
   event={type='tool_call',id='discover-eager',name='mcp.search',input_json=json.encode({server='eager',query='echo'})}
  elseif rounds==1 then
   assert(tool_result_text(request):find('echo',1,true),'MCP search did not return eager catalog')
   local found=false
   for _,tool in ipairs(request.tools or {}) do if tool.name=='EAGER_TOOL_NAME' then found=true end end
   assert(found,'post-activation eager tool absent from next provider request')
   event={type='tool_call',id='call-eager',name='EAGER_TOOL_NAME',input_json=json.encode({message='EAGER_E2E_OK'})}
  else
   assert(tool_result_text(request):find('EAGER_E2E_OK',1,true),'eager MCP tool result missing')
   event={type='text_delta',text='MCP_EAGER_E2E_OK'}
  end
  local sent=false
  return {next=function() if sent then return {type='done'} end; sent=true; return event end}
 end}
end}]]
    write(extdir..'/provider.lua',provider:gsub('EAGER_TOOL_NAME',config.tool_name('eager','echo')))
    local fake=here..'/_selfcheck.lua'
    local helper_raw={servers={helper={command='echo',expose='search'}}}
    local _,helper_servers=config.parse(helper_raw,{project_root=rig})
    local helper_meta={era='modern',version='2026-07-28',capabilities={tools={}},catalog={tools={},prompts={},resources={},templates={}}}
    check(cache.save(helper_servers.helper,helper_meta,data_home..'/panto-mcp'),'seed helper cache for print integration')
    local config_text='[extensions]\npaths = ['..q(here)..', '..q(extdir)..']\n\n'..
        '[providers.fixture]\nprotocol = "mcp-eager-print"\n\n[defaults]\nmodel = "fixture:dummy"\n\n'..
        '[mcp.servers.helper]\ncommand = "echo"\nexpose = "search"\n\n'..
        '[mcp.servers.eager]\ncommand = '..q(uv.exepath())..'\nargs = ["lua", '..q(fake)..', "--fake", "modern"]\nexpose = "eager"\n'
    write(rig..'/config.toml',config_text)
    local envmap=uv.os_environ(); envmap.XDG_DATA_HOME=data_home; envmap.XDG_CONFIG_HOME=data_home..'/config'; envmap.PANTO_SESSION_DIR=temp..'/eager-print-sessions'
    local env={}; for k,v in pairs(envmap) do env[#env+1]=k..'='..v end; table.sort(env)
    local out_pipe,err_pipe=uv.new_pipe(false),uv.new_pipe(false)
    local child,child_pid; local stdout,stderr='',''; local exited,out_eof,err_eof=false,false,false; local code
    local watchdog=uv.new_timer(); local future=async.future()
    local function finish_if_ready() if exited and out_eof and err_eof then future:resolve({code=code,stdout=stdout,stderr=stderr}) end end
    child,child_pid=uv.spawn(binary,{args={'--print','--incognito','--rig',rig,'--model','fixture:dummy','--','run eager MCP'},cwd=rig,env=env,stdio={nil,out_pipe,err_pipe}},function(status)
        exited=true; code=status; close(child); finish_if_ready()
    end)
    assert(child,'could not launch new-core panto: '..tostring(child_pid))
    out_pipe:read_start(function(err,data) if err then stderr=stderr..tostring(err) end; if data then stdout=stdout..data else out_eof=true; close(out_pipe); finish_if_ready() end end)
    err_pipe:read_start(function(_,data) if data then stderr=stderr..data else err_eof=true; close(err_pipe); finish_if_ready() end end)
    watchdog:start(30000,0,function() if not exited then stderr=stderr..'print-mode eager integration watchdog expired'; pcall(child.kill,child,'sigkill') end end)
    local result; local integration_failure
    async.run(function() result=future:await() end,function(err) integration_failure=err end)
    uv.run()
    close(watchdog)
    assert(not integration_failure,integration_failure)
    check(result.code==0,'new-core eager print-mode exit '..tostring(result.code)..': '..result.stderr)
    check(result.stdout:find('MCP_EAGER_E2E_OK',1,true),'post-activation eager tool was visible and callable: '..result.stdout..result.stderr)
    local function remove_tree(path)
        local scan=uv.fs_scandir(path); if not scan then return end
        while true do local name=uv.fs_scandir_next(scan); if not name then break end
            local child_path=path..'/'..name; local stat=uv.fs_lstat(child_path)
            if stat and stat.type=='directory' then remove_tree(child_path) else uv.fs_unlink(child_path) end
        end
        uv.fs_rmdir(path)
    end
    remove_tree(rig); remove_tree(data_home); remove_tree(temp..'/eager-print-sessions')
end
if os.getenv('PANTO_MCP_PRINT_E2E')=='1' then eager_print_e2e() end
if os.getenv('PANTO_MCP_HTTP_E2E')=='1' then
    local only=os.getenv('PANTO_MCP_HTTP_E2E_MODE')
    http_e2e('oauth') -- Always exercise the new core, including when this harness uses old panto.
    for _,mode in ipairs(only and {only} or {'json','sse','legacy','slow'}) do if mode~='oauth' then http_e2e(mode) end end
end
print('panto-mcp selfcheck: OK (' .. checks .. ' assertions; HTTP/stdio eras, cache, RPC, eager/prompt reconciliation, validation, resources, namespace, orphan tree)')
-- Remove only test-owned fixtures, including nested OAuth cache directories.
local function remove_test_tree(path)
    local scan=uv.fs_scandir(path); if not scan then return end
    while true do
        local name=uv.fs_scandir_next(scan); if not name then break end
        local child_path=path..'/'..name; local stat=uv.fs_lstat(child_path)
        if stat and stat.type=='directory' then remove_test_tree(child_path) else uv.fs_unlink(child_path) end
    end
    uv.fs_rmdir(path)
end
remove_test_tree(temp)