@brain-protocol/mcp 0.3.6 → 0.4.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +28 -5
- package/dist/cli.d.ts +2 -2
- package/dist/cli.js +1 -1
- package/dist/schemas.d.ts +86 -0
- package/dist/schemas.d.ts.map +1 -1
- package/dist/schemas.js +34 -0
- package/dist/schemas.js.map +1 -1
- package/dist/store/adapter.d.ts +3 -1
- package/dist/store/adapter.d.ts.map +1 -1
- package/dist/store/cloud.d.ts +3 -1
- package/dist/store/cloud.d.ts.map +1 -1
- package/dist/store/cloud.js +7 -0
- package/dist/store/cloud.js.map +1 -1
- package/dist/tools/archive-stats.d.ts +5 -0
- package/dist/tools/archive-stats.d.ts.map +1 -0
- package/dist/tools/archive-stats.js +7 -0
- package/dist/tools/archive-stats.js.map +1 -0
- package/dist/tools/bulk-archive.d.ts +5 -0
- package/dist/tools/bulk-archive.d.ts.map +1 -0
- package/dist/tools/bulk-archive.js +9 -0
- package/dist/tools/bulk-archive.js.map +1 -0
- package/dist/tools/decisions.d.ts +18 -0
- package/dist/tools/decisions.d.ts.map +1 -0
- package/dist/tools/decisions.js +113 -0
- package/dist/tools/decisions.js.map +1 -0
- package/dist/tools/index.d.ts +460 -0
- package/dist/tools/index.d.ts.map +1 -1
- package/dist/tools/index.js +87 -0
- package/dist/tools/index.js.map +1 -1
- package/dist/types.d.ts +18 -0
- package/dist/types.d.ts.map +1 -1
- package/package.json +12 -13
package/dist/tools/index.d.ts
CHANGED
|
@@ -74,6 +74,17 @@ export declare const toolDefinitions: ({
|
|
|
74
74
|
description?: undefined;
|
|
75
75
|
proof_entry_id?: undefined;
|
|
76
76
|
target_entry_id?: undefined;
|
|
77
|
+
decision?: undefined;
|
|
78
|
+
options?: undefined;
|
|
79
|
+
chosen?: undefined;
|
|
80
|
+
rationale?: undefined;
|
|
81
|
+
chain_id?: undefined;
|
|
82
|
+
task_description?: undefined;
|
|
83
|
+
date_before?: undefined;
|
|
84
|
+
date_after?: undefined;
|
|
85
|
+
ids?: undefined;
|
|
86
|
+
confidence_max?: undefined;
|
|
87
|
+
dry_run?: undefined;
|
|
77
88
|
};
|
|
78
89
|
required?: undefined;
|
|
79
90
|
};
|
|
@@ -157,6 +168,17 @@ export declare const toolDefinitions: ({
|
|
|
157
168
|
description?: undefined;
|
|
158
169
|
proof_entry_id?: undefined;
|
|
159
170
|
target_entry_id?: undefined;
|
|
171
|
+
decision?: undefined;
|
|
172
|
+
options?: undefined;
|
|
173
|
+
chosen?: undefined;
|
|
174
|
+
rationale?: undefined;
|
|
175
|
+
chain_id?: undefined;
|
|
176
|
+
task_description?: undefined;
|
|
177
|
+
date_before?: undefined;
|
|
178
|
+
date_after?: undefined;
|
|
179
|
+
ids?: undefined;
|
|
180
|
+
confidence_max?: undefined;
|
|
181
|
+
dry_run?: undefined;
|
|
160
182
|
};
|
|
161
183
|
required: string[];
|
|
162
184
|
};
|
|
@@ -243,6 +265,17 @@ export declare const toolDefinitions: ({
|
|
|
243
265
|
description?: undefined;
|
|
244
266
|
proof_entry_id?: undefined;
|
|
245
267
|
target_entry_id?: undefined;
|
|
268
|
+
decision?: undefined;
|
|
269
|
+
options?: undefined;
|
|
270
|
+
chosen?: undefined;
|
|
271
|
+
rationale?: undefined;
|
|
272
|
+
chain_id?: undefined;
|
|
273
|
+
task_description?: undefined;
|
|
274
|
+
date_before?: undefined;
|
|
275
|
+
date_after?: undefined;
|
|
276
|
+
ids?: undefined;
|
|
277
|
+
confidence_max?: undefined;
|
|
278
|
+
dry_run?: undefined;
|
|
246
279
|
};
|
|
247
280
|
required: string[];
|
|
248
281
|
};
|
|
@@ -302,6 +335,17 @@ export declare const toolDefinitions: ({
|
|
|
302
335
|
description?: undefined;
|
|
303
336
|
proof_entry_id?: undefined;
|
|
304
337
|
target_entry_id?: undefined;
|
|
338
|
+
decision?: undefined;
|
|
339
|
+
options?: undefined;
|
|
340
|
+
chosen?: undefined;
|
|
341
|
+
rationale?: undefined;
|
|
342
|
+
chain_id?: undefined;
|
|
343
|
+
task_description?: undefined;
|
|
344
|
+
date_before?: undefined;
|
|
345
|
+
date_after?: undefined;
|
|
346
|
+
ids?: undefined;
|
|
347
|
+
confidence_max?: undefined;
|
|
348
|
+
dry_run?: undefined;
|
|
305
349
|
};
|
|
306
350
|
required: string[];
|
|
307
351
|
};
|
|
@@ -370,6 +414,17 @@ export declare const toolDefinitions: ({
|
|
|
370
414
|
description?: undefined;
|
|
371
415
|
proof_entry_id?: undefined;
|
|
372
416
|
target_entry_id?: undefined;
|
|
417
|
+
decision?: undefined;
|
|
418
|
+
options?: undefined;
|
|
419
|
+
chosen?: undefined;
|
|
420
|
+
rationale?: undefined;
|
|
421
|
+
chain_id?: undefined;
|
|
422
|
+
task_description?: undefined;
|
|
423
|
+
date_before?: undefined;
|
|
424
|
+
date_after?: undefined;
|
|
425
|
+
ids?: undefined;
|
|
426
|
+
confidence_max?: undefined;
|
|
427
|
+
dry_run?: undefined;
|
|
373
428
|
};
|
|
374
429
|
required: string[];
|
|
375
430
|
};
|
|
@@ -432,6 +487,17 @@ export declare const toolDefinitions: ({
|
|
|
432
487
|
description?: undefined;
|
|
433
488
|
proof_entry_id?: undefined;
|
|
434
489
|
target_entry_id?: undefined;
|
|
490
|
+
decision?: undefined;
|
|
491
|
+
options?: undefined;
|
|
492
|
+
chosen?: undefined;
|
|
493
|
+
rationale?: undefined;
|
|
494
|
+
chain_id?: undefined;
|
|
495
|
+
task_description?: undefined;
|
|
496
|
+
date_before?: undefined;
|
|
497
|
+
date_after?: undefined;
|
|
498
|
+
ids?: undefined;
|
|
499
|
+
confidence_max?: undefined;
|
|
500
|
+
dry_run?: undefined;
|
|
435
501
|
};
|
|
436
502
|
required: string[];
|
|
437
503
|
};
|
|
@@ -488,6 +554,17 @@ export declare const toolDefinitions: ({
|
|
|
488
554
|
description?: undefined;
|
|
489
555
|
proof_entry_id?: undefined;
|
|
490
556
|
target_entry_id?: undefined;
|
|
557
|
+
decision?: undefined;
|
|
558
|
+
options?: undefined;
|
|
559
|
+
chosen?: undefined;
|
|
560
|
+
rationale?: undefined;
|
|
561
|
+
chain_id?: undefined;
|
|
562
|
+
task_description?: undefined;
|
|
563
|
+
date_before?: undefined;
|
|
564
|
+
date_after?: undefined;
|
|
565
|
+
ids?: undefined;
|
|
566
|
+
confidence_max?: undefined;
|
|
567
|
+
dry_run?: undefined;
|
|
491
568
|
};
|
|
492
569
|
required?: undefined;
|
|
493
570
|
};
|
|
@@ -547,6 +624,17 @@ export declare const toolDefinitions: ({
|
|
|
547
624
|
description?: undefined;
|
|
548
625
|
proof_entry_id?: undefined;
|
|
549
626
|
target_entry_id?: undefined;
|
|
627
|
+
decision?: undefined;
|
|
628
|
+
options?: undefined;
|
|
629
|
+
chosen?: undefined;
|
|
630
|
+
rationale?: undefined;
|
|
631
|
+
chain_id?: undefined;
|
|
632
|
+
task_description?: undefined;
|
|
633
|
+
date_before?: undefined;
|
|
634
|
+
date_after?: undefined;
|
|
635
|
+
ids?: undefined;
|
|
636
|
+
confidence_max?: undefined;
|
|
637
|
+
dry_run?: undefined;
|
|
550
638
|
};
|
|
551
639
|
required: string[];
|
|
552
640
|
};
|
|
@@ -606,6 +694,17 @@ export declare const toolDefinitions: ({
|
|
|
606
694
|
description?: undefined;
|
|
607
695
|
proof_entry_id?: undefined;
|
|
608
696
|
target_entry_id?: undefined;
|
|
697
|
+
decision?: undefined;
|
|
698
|
+
options?: undefined;
|
|
699
|
+
chosen?: undefined;
|
|
700
|
+
rationale?: undefined;
|
|
701
|
+
chain_id?: undefined;
|
|
702
|
+
task_description?: undefined;
|
|
703
|
+
date_before?: undefined;
|
|
704
|
+
date_after?: undefined;
|
|
705
|
+
ids?: undefined;
|
|
706
|
+
confidence_max?: undefined;
|
|
707
|
+
dry_run?: undefined;
|
|
609
708
|
};
|
|
610
709
|
required?: undefined;
|
|
611
710
|
};
|
|
@@ -674,6 +773,17 @@ export declare const toolDefinitions: ({
|
|
|
674
773
|
description?: undefined;
|
|
675
774
|
proof_entry_id?: undefined;
|
|
676
775
|
target_entry_id?: undefined;
|
|
776
|
+
decision?: undefined;
|
|
777
|
+
options?: undefined;
|
|
778
|
+
chosen?: undefined;
|
|
779
|
+
rationale?: undefined;
|
|
780
|
+
chain_id?: undefined;
|
|
781
|
+
task_description?: undefined;
|
|
782
|
+
date_before?: undefined;
|
|
783
|
+
date_after?: undefined;
|
|
784
|
+
ids?: undefined;
|
|
785
|
+
confidence_max?: undefined;
|
|
786
|
+
dry_run?: undefined;
|
|
677
787
|
};
|
|
678
788
|
required: string[];
|
|
679
789
|
};
|
|
@@ -763,6 +873,17 @@ export declare const toolDefinitions: ({
|
|
|
763
873
|
description?: undefined;
|
|
764
874
|
proof_entry_id?: undefined;
|
|
765
875
|
target_entry_id?: undefined;
|
|
876
|
+
decision?: undefined;
|
|
877
|
+
options?: undefined;
|
|
878
|
+
chosen?: undefined;
|
|
879
|
+
rationale?: undefined;
|
|
880
|
+
chain_id?: undefined;
|
|
881
|
+
task_description?: undefined;
|
|
882
|
+
date_before?: undefined;
|
|
883
|
+
date_after?: undefined;
|
|
884
|
+
ids?: undefined;
|
|
885
|
+
confidence_max?: undefined;
|
|
886
|
+
dry_run?: undefined;
|
|
766
887
|
};
|
|
767
888
|
required: string[];
|
|
768
889
|
};
|
|
@@ -825,6 +946,17 @@ export declare const toolDefinitions: ({
|
|
|
825
946
|
description?: undefined;
|
|
826
947
|
proof_entry_id?: undefined;
|
|
827
948
|
target_entry_id?: undefined;
|
|
949
|
+
decision?: undefined;
|
|
950
|
+
options?: undefined;
|
|
951
|
+
chosen?: undefined;
|
|
952
|
+
rationale?: undefined;
|
|
953
|
+
chain_id?: undefined;
|
|
954
|
+
task_description?: undefined;
|
|
955
|
+
date_before?: undefined;
|
|
956
|
+
date_after?: undefined;
|
|
957
|
+
ids?: undefined;
|
|
958
|
+
confidence_max?: undefined;
|
|
959
|
+
dry_run?: undefined;
|
|
828
960
|
};
|
|
829
961
|
required: string[];
|
|
830
962
|
};
|
|
@@ -887,6 +1019,17 @@ export declare const toolDefinitions: ({
|
|
|
887
1019
|
description?: undefined;
|
|
888
1020
|
proof_entry_id?: undefined;
|
|
889
1021
|
target_entry_id?: undefined;
|
|
1022
|
+
decision?: undefined;
|
|
1023
|
+
options?: undefined;
|
|
1024
|
+
chosen?: undefined;
|
|
1025
|
+
rationale?: undefined;
|
|
1026
|
+
chain_id?: undefined;
|
|
1027
|
+
task_description?: undefined;
|
|
1028
|
+
date_before?: undefined;
|
|
1029
|
+
date_after?: undefined;
|
|
1030
|
+
ids?: undefined;
|
|
1031
|
+
confidence_max?: undefined;
|
|
1032
|
+
dry_run?: undefined;
|
|
890
1033
|
};
|
|
891
1034
|
required: string[];
|
|
892
1035
|
};
|
|
@@ -946,6 +1089,17 @@ export declare const toolDefinitions: ({
|
|
|
946
1089
|
description?: undefined;
|
|
947
1090
|
proof_entry_id?: undefined;
|
|
948
1091
|
target_entry_id?: undefined;
|
|
1092
|
+
decision?: undefined;
|
|
1093
|
+
options?: undefined;
|
|
1094
|
+
chosen?: undefined;
|
|
1095
|
+
rationale?: undefined;
|
|
1096
|
+
chain_id?: undefined;
|
|
1097
|
+
task_description?: undefined;
|
|
1098
|
+
date_before?: undefined;
|
|
1099
|
+
date_after?: undefined;
|
|
1100
|
+
ids?: undefined;
|
|
1101
|
+
confidence_max?: undefined;
|
|
1102
|
+
dry_run?: undefined;
|
|
949
1103
|
};
|
|
950
1104
|
required?: undefined;
|
|
951
1105
|
};
|
|
@@ -1051,6 +1205,17 @@ export declare const toolDefinitions: ({
|
|
|
1051
1205
|
days?: undefined;
|
|
1052
1206
|
proof_entry_id?: undefined;
|
|
1053
1207
|
target_entry_id?: undefined;
|
|
1208
|
+
decision?: undefined;
|
|
1209
|
+
options?: undefined;
|
|
1210
|
+
chosen?: undefined;
|
|
1211
|
+
rationale?: undefined;
|
|
1212
|
+
chain_id?: undefined;
|
|
1213
|
+
task_description?: undefined;
|
|
1214
|
+
date_before?: undefined;
|
|
1215
|
+
date_after?: undefined;
|
|
1216
|
+
ids?: undefined;
|
|
1217
|
+
confidence_max?: undefined;
|
|
1218
|
+
dry_run?: undefined;
|
|
1054
1219
|
};
|
|
1055
1220
|
required: string[];
|
|
1056
1221
|
};
|
|
@@ -1122,6 +1287,17 @@ export declare const toolDefinitions: ({
|
|
|
1122
1287
|
description?: undefined;
|
|
1123
1288
|
proof_entry_id?: undefined;
|
|
1124
1289
|
target_entry_id?: undefined;
|
|
1290
|
+
decision?: undefined;
|
|
1291
|
+
options?: undefined;
|
|
1292
|
+
chosen?: undefined;
|
|
1293
|
+
rationale?: undefined;
|
|
1294
|
+
chain_id?: undefined;
|
|
1295
|
+
task_description?: undefined;
|
|
1296
|
+
date_before?: undefined;
|
|
1297
|
+
date_after?: undefined;
|
|
1298
|
+
ids?: undefined;
|
|
1299
|
+
confidence_max?: undefined;
|
|
1300
|
+
dry_run?: undefined;
|
|
1125
1301
|
};
|
|
1126
1302
|
required?: undefined;
|
|
1127
1303
|
};
|
|
@@ -1187,9 +1363,293 @@ export declare const toolDefinitions: ({
|
|
|
1187
1363
|
timestamp?: undefined;
|
|
1188
1364
|
attester_signatures?: undefined;
|
|
1189
1365
|
description?: undefined;
|
|
1366
|
+
decision?: undefined;
|
|
1367
|
+
options?: undefined;
|
|
1368
|
+
chosen?: undefined;
|
|
1369
|
+
rationale?: undefined;
|
|
1370
|
+
chain_id?: undefined;
|
|
1371
|
+
task_description?: undefined;
|
|
1372
|
+
date_before?: undefined;
|
|
1373
|
+
date_after?: undefined;
|
|
1374
|
+
ids?: undefined;
|
|
1375
|
+
confidence_max?: undefined;
|
|
1376
|
+
dry_run?: undefined;
|
|
1190
1377
|
};
|
|
1191
1378
|
required: string[];
|
|
1192
1379
|
};
|
|
1380
|
+
} | {
|
|
1381
|
+
name: string;
|
|
1382
|
+
description: string;
|
|
1383
|
+
inputSchema: {
|
|
1384
|
+
type: "object";
|
|
1385
|
+
properties: {
|
|
1386
|
+
decision: {
|
|
1387
|
+
type: string;
|
|
1388
|
+
description: string;
|
|
1389
|
+
};
|
|
1390
|
+
context: {
|
|
1391
|
+
type: string;
|
|
1392
|
+
description: string;
|
|
1393
|
+
};
|
|
1394
|
+
options: {
|
|
1395
|
+
type: string;
|
|
1396
|
+
items: {
|
|
1397
|
+
type: string;
|
|
1398
|
+
};
|
|
1399
|
+
description: string;
|
|
1400
|
+
};
|
|
1401
|
+
chosen: {
|
|
1402
|
+
type: string;
|
|
1403
|
+
description: string;
|
|
1404
|
+
};
|
|
1405
|
+
rationale: {
|
|
1406
|
+
type: string;
|
|
1407
|
+
description: string;
|
|
1408
|
+
};
|
|
1409
|
+
chain_id: {
|
|
1410
|
+
type: string;
|
|
1411
|
+
description: string;
|
|
1412
|
+
};
|
|
1413
|
+
confidence: {
|
|
1414
|
+
type: string;
|
|
1415
|
+
description: string;
|
|
1416
|
+
};
|
|
1417
|
+
tags: {
|
|
1418
|
+
type: string;
|
|
1419
|
+
items: {
|
|
1420
|
+
type: string;
|
|
1421
|
+
};
|
|
1422
|
+
description: string;
|
|
1423
|
+
};
|
|
1424
|
+
category: {
|
|
1425
|
+
type: string;
|
|
1426
|
+
description: string;
|
|
1427
|
+
};
|
|
1428
|
+
author: {
|
|
1429
|
+
type: string;
|
|
1430
|
+
description: string;
|
|
1431
|
+
};
|
|
1432
|
+
brain_id: {
|
|
1433
|
+
type: string;
|
|
1434
|
+
description: string;
|
|
1435
|
+
};
|
|
1436
|
+
q?: undefined;
|
|
1437
|
+
limit?: undefined;
|
|
1438
|
+
offset?: undefined;
|
|
1439
|
+
content?: undefined;
|
|
1440
|
+
content_type?: undefined;
|
|
1441
|
+
is_public?: undefined;
|
|
1442
|
+
id?: undefined;
|
|
1443
|
+
source_id?: undefined;
|
|
1444
|
+
target_id?: undefined;
|
|
1445
|
+
edge_type?: undefined;
|
|
1446
|
+
entry_id?: undefined;
|
|
1447
|
+
depth?: undefined;
|
|
1448
|
+
format?: undefined;
|
|
1449
|
+
entries?: undefined;
|
|
1450
|
+
edges?: undefined;
|
|
1451
|
+
agent_name?: undefined;
|
|
1452
|
+
task_type?: undefined;
|
|
1453
|
+
model?: undefined;
|
|
1454
|
+
provider?: undefined;
|
|
1455
|
+
prompt_tokens?: undefined;
|
|
1456
|
+
completion_tokens?: undefined;
|
|
1457
|
+
total_tokens?: undefined;
|
|
1458
|
+
cost_usd?: undefined;
|
|
1459
|
+
latency_ms?: undefined;
|
|
1460
|
+
status?: undefined;
|
|
1461
|
+
metadata?: undefined;
|
|
1462
|
+
code?: undefined;
|
|
1463
|
+
file_type?: undefined;
|
|
1464
|
+
days?: undefined;
|
|
1465
|
+
proof_id?: undefined;
|
|
1466
|
+
model_id?: undefined;
|
|
1467
|
+
version_id?: undefined;
|
|
1468
|
+
input_hash?: undefined;
|
|
1469
|
+
output_value?: undefined;
|
|
1470
|
+
proof_tx?: undefined;
|
|
1471
|
+
verified?: undefined;
|
|
1472
|
+
timestamp?: undefined;
|
|
1473
|
+
attester_signatures?: undefined;
|
|
1474
|
+
description?: undefined;
|
|
1475
|
+
proof_entry_id?: undefined;
|
|
1476
|
+
target_entry_id?: undefined;
|
|
1477
|
+
task_description?: undefined;
|
|
1478
|
+
date_before?: undefined;
|
|
1479
|
+
date_after?: undefined;
|
|
1480
|
+
ids?: undefined;
|
|
1481
|
+
confidence_max?: undefined;
|
|
1482
|
+
dry_run?: undefined;
|
|
1483
|
+
};
|
|
1484
|
+
required: string[];
|
|
1485
|
+
};
|
|
1486
|
+
} | {
|
|
1487
|
+
name: string;
|
|
1488
|
+
description: string;
|
|
1489
|
+
inputSchema: {
|
|
1490
|
+
type: "object";
|
|
1491
|
+
properties: {
|
|
1492
|
+
task_description: {
|
|
1493
|
+
type: string;
|
|
1494
|
+
description: string;
|
|
1495
|
+
};
|
|
1496
|
+
limit: {
|
|
1497
|
+
type: string;
|
|
1498
|
+
description: string;
|
|
1499
|
+
};
|
|
1500
|
+
brain_id: {
|
|
1501
|
+
type: string;
|
|
1502
|
+
description: string;
|
|
1503
|
+
};
|
|
1504
|
+
q?: undefined;
|
|
1505
|
+
category?: undefined;
|
|
1506
|
+
author?: undefined;
|
|
1507
|
+
tags?: undefined;
|
|
1508
|
+
offset?: undefined;
|
|
1509
|
+
content?: undefined;
|
|
1510
|
+
content_type?: undefined;
|
|
1511
|
+
confidence?: undefined;
|
|
1512
|
+
is_public?: undefined;
|
|
1513
|
+
id?: undefined;
|
|
1514
|
+
source_id?: undefined;
|
|
1515
|
+
target_id?: undefined;
|
|
1516
|
+
edge_type?: undefined;
|
|
1517
|
+
entry_id?: undefined;
|
|
1518
|
+
depth?: undefined;
|
|
1519
|
+
format?: undefined;
|
|
1520
|
+
entries?: undefined;
|
|
1521
|
+
edges?: undefined;
|
|
1522
|
+
agent_name?: undefined;
|
|
1523
|
+
task_type?: undefined;
|
|
1524
|
+
model?: undefined;
|
|
1525
|
+
provider?: undefined;
|
|
1526
|
+
prompt_tokens?: undefined;
|
|
1527
|
+
completion_tokens?: undefined;
|
|
1528
|
+
total_tokens?: undefined;
|
|
1529
|
+
cost_usd?: undefined;
|
|
1530
|
+
latency_ms?: undefined;
|
|
1531
|
+
status?: undefined;
|
|
1532
|
+
metadata?: undefined;
|
|
1533
|
+
code?: undefined;
|
|
1534
|
+
file_type?: undefined;
|
|
1535
|
+
context?: undefined;
|
|
1536
|
+
days?: undefined;
|
|
1537
|
+
proof_id?: undefined;
|
|
1538
|
+
model_id?: undefined;
|
|
1539
|
+
version_id?: undefined;
|
|
1540
|
+
input_hash?: undefined;
|
|
1541
|
+
output_value?: undefined;
|
|
1542
|
+
proof_tx?: undefined;
|
|
1543
|
+
verified?: undefined;
|
|
1544
|
+
timestamp?: undefined;
|
|
1545
|
+
attester_signatures?: undefined;
|
|
1546
|
+
description?: undefined;
|
|
1547
|
+
proof_entry_id?: undefined;
|
|
1548
|
+
target_entry_id?: undefined;
|
|
1549
|
+
decision?: undefined;
|
|
1550
|
+
options?: undefined;
|
|
1551
|
+
chosen?: undefined;
|
|
1552
|
+
rationale?: undefined;
|
|
1553
|
+
chain_id?: undefined;
|
|
1554
|
+
date_before?: undefined;
|
|
1555
|
+
date_after?: undefined;
|
|
1556
|
+
ids?: undefined;
|
|
1557
|
+
confidence_max?: undefined;
|
|
1558
|
+
dry_run?: undefined;
|
|
1559
|
+
};
|
|
1560
|
+
required: string[];
|
|
1561
|
+
};
|
|
1562
|
+
} | {
|
|
1563
|
+
name: string;
|
|
1564
|
+
description: string;
|
|
1565
|
+
inputSchema: {
|
|
1566
|
+
type: "object";
|
|
1567
|
+
properties: {
|
|
1568
|
+
category: {
|
|
1569
|
+
type: string;
|
|
1570
|
+
description: string;
|
|
1571
|
+
};
|
|
1572
|
+
date_before: {
|
|
1573
|
+
type: string;
|
|
1574
|
+
description: string;
|
|
1575
|
+
};
|
|
1576
|
+
date_after: {
|
|
1577
|
+
type: string;
|
|
1578
|
+
description: string;
|
|
1579
|
+
};
|
|
1580
|
+
author: {
|
|
1581
|
+
type: string;
|
|
1582
|
+
description: string;
|
|
1583
|
+
};
|
|
1584
|
+
ids: {
|
|
1585
|
+
type: string;
|
|
1586
|
+
items: {
|
|
1587
|
+
type: string;
|
|
1588
|
+
};
|
|
1589
|
+
description: string;
|
|
1590
|
+
};
|
|
1591
|
+
confidence_max: {
|
|
1592
|
+
type: string;
|
|
1593
|
+
description: string;
|
|
1594
|
+
};
|
|
1595
|
+
dry_run: {
|
|
1596
|
+
type: string;
|
|
1597
|
+
description: string;
|
|
1598
|
+
};
|
|
1599
|
+
q?: undefined;
|
|
1600
|
+
tags?: undefined;
|
|
1601
|
+
limit?: undefined;
|
|
1602
|
+
offset?: undefined;
|
|
1603
|
+
brain_id?: undefined;
|
|
1604
|
+
content?: undefined;
|
|
1605
|
+
content_type?: undefined;
|
|
1606
|
+
confidence?: undefined;
|
|
1607
|
+
is_public?: undefined;
|
|
1608
|
+
id?: undefined;
|
|
1609
|
+
source_id?: undefined;
|
|
1610
|
+
target_id?: undefined;
|
|
1611
|
+
edge_type?: undefined;
|
|
1612
|
+
entry_id?: undefined;
|
|
1613
|
+
depth?: undefined;
|
|
1614
|
+
format?: undefined;
|
|
1615
|
+
entries?: undefined;
|
|
1616
|
+
edges?: undefined;
|
|
1617
|
+
agent_name?: undefined;
|
|
1618
|
+
task_type?: undefined;
|
|
1619
|
+
model?: undefined;
|
|
1620
|
+
provider?: undefined;
|
|
1621
|
+
prompt_tokens?: undefined;
|
|
1622
|
+
completion_tokens?: undefined;
|
|
1623
|
+
total_tokens?: undefined;
|
|
1624
|
+
cost_usd?: undefined;
|
|
1625
|
+
latency_ms?: undefined;
|
|
1626
|
+
status?: undefined;
|
|
1627
|
+
metadata?: undefined;
|
|
1628
|
+
code?: undefined;
|
|
1629
|
+
file_type?: undefined;
|
|
1630
|
+
context?: undefined;
|
|
1631
|
+
days?: undefined;
|
|
1632
|
+
proof_id?: undefined;
|
|
1633
|
+
model_id?: undefined;
|
|
1634
|
+
version_id?: undefined;
|
|
1635
|
+
input_hash?: undefined;
|
|
1636
|
+
output_value?: undefined;
|
|
1637
|
+
proof_tx?: undefined;
|
|
1638
|
+
verified?: undefined;
|
|
1639
|
+
timestamp?: undefined;
|
|
1640
|
+
attester_signatures?: undefined;
|
|
1641
|
+
description?: undefined;
|
|
1642
|
+
proof_entry_id?: undefined;
|
|
1643
|
+
target_entry_id?: undefined;
|
|
1644
|
+
decision?: undefined;
|
|
1645
|
+
options?: undefined;
|
|
1646
|
+
chosen?: undefined;
|
|
1647
|
+
rationale?: undefined;
|
|
1648
|
+
chain_id?: undefined;
|
|
1649
|
+
task_description?: undefined;
|
|
1650
|
+
};
|
|
1651
|
+
required?: undefined;
|
|
1652
|
+
};
|
|
1193
1653
|
})[];
|
|
1194
1654
|
export declare function handleTool(store: StoreAdapter, name: string, args: Record<string, unknown>): Promise<unknown>;
|
|
1195
1655
|
//# sourceMappingURL=index.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;
|
|
1
|
+
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAmBxD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiX3B,CAAC;AAEF,wBAAsB,UAAU,CAC9B,KAAK,EAAE,YAAY,EACnB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,OAAO,CAAC,CAwDlB"}
|
package/dist/tools/index.js
CHANGED
|
@@ -1,8 +1,11 @@
|
|
|
1
1
|
import { getAgentStats, logAgentTask } from "./agents.js";
|
|
2
2
|
import { archiveKnowledge } from "./archive.js";
|
|
3
|
+
import { getArchiveStats } from "./archive-stats.js";
|
|
4
|
+
import { bulkArchive } from "./bulk-archive.js";
|
|
3
5
|
import { createEdge } from "./edge.js";
|
|
4
6
|
import { deleteKnowledge } from "./delete.js";
|
|
5
7
|
import { suggestPatterns, detectAntiPatterns, getArchitecturalAdvice } from "./development.js";
|
|
8
|
+
import { recordDecision, getDecisionChain, getMemoryGuidance } from "./decisions.js";
|
|
6
9
|
import { archiveGizaProof, queryGizaProofs, linkProofToEntry } from "./giza.js";
|
|
7
10
|
import { exportData } from "./export.js";
|
|
8
11
|
import { getGraph } from "./graph.js";
|
|
@@ -307,6 +310,80 @@ export const toolDefinitions = [
|
|
|
307
310
|
required: ["proof_entry_id", "target_entry_id"],
|
|
308
311
|
},
|
|
309
312
|
},
|
|
313
|
+
{
|
|
314
|
+
name: "record_decision",
|
|
315
|
+
description: "Record a structured agent decision with context, options, rationale, and optional chain linking to previous decisions",
|
|
316
|
+
inputSchema: {
|
|
317
|
+
type: "object",
|
|
318
|
+
properties: {
|
|
319
|
+
decision: { type: "string", description: "The decision made (concise summary)" },
|
|
320
|
+
context: { type: "string", description: "Context/situation that led to this decision" },
|
|
321
|
+
options: {
|
|
322
|
+
type: "array",
|
|
323
|
+
items: { type: "string" },
|
|
324
|
+
description: "Options that were considered (minimum 2)",
|
|
325
|
+
},
|
|
326
|
+
chosen: { type: "string", description: "The option that was chosen" },
|
|
327
|
+
rationale: { type: "string", description: "Why this option was chosen over alternatives" },
|
|
328
|
+
chain_id: { type: "string", description: "UUID of a previous decision to chain to (creates derives_from edge)" },
|
|
329
|
+
confidence: { type: "number", description: "Decision confidence 0-1 (default 0.85)" },
|
|
330
|
+
tags: { type: "array", items: { type: "string" }, description: "Tags" },
|
|
331
|
+
category: { type: "string", description: "Category (default: decision)" },
|
|
332
|
+
author: { type: "string", description: "Author (default: agent)" },
|
|
333
|
+
brain_id: { type: "string", description: "Target brain UUID" },
|
|
334
|
+
},
|
|
335
|
+
required: ["decision", "context", "options", "chosen", "rationale"],
|
|
336
|
+
},
|
|
337
|
+
},
|
|
338
|
+
{
|
|
339
|
+
name: "get_decision_chain",
|
|
340
|
+
description: "Traverse the decision graph from a starting decision to see the chain of related decisions",
|
|
341
|
+
inputSchema: {
|
|
342
|
+
type: "object",
|
|
343
|
+
properties: {
|
|
344
|
+
entry_id: { type: "string", description: "Starting decision entry UUID" },
|
|
345
|
+
depth: { type: "number", description: "Max traversal depth (default 3, max 5)" },
|
|
346
|
+
},
|
|
347
|
+
required: ["entry_id"],
|
|
348
|
+
},
|
|
349
|
+
},
|
|
350
|
+
{
|
|
351
|
+
name: "get_memory_guidance",
|
|
352
|
+
description: "Get relevant past decisions and high-confidence patterns before acting on a task (Retrieval-Augmented Execution)",
|
|
353
|
+
inputSchema: {
|
|
354
|
+
type: "object",
|
|
355
|
+
properties: {
|
|
356
|
+
task_description: { type: "string", description: "Description of the task the agent is about to perform" },
|
|
357
|
+
limit: { type: "number", description: "Max results (default 10, max 50)" },
|
|
358
|
+
brain_id: { type: "string", description: "Filter by brain UUID" },
|
|
359
|
+
},
|
|
360
|
+
required: ["task_description"],
|
|
361
|
+
},
|
|
362
|
+
},
|
|
363
|
+
{
|
|
364
|
+
name: "bulk_archive",
|
|
365
|
+
description: "Archive multiple knowledge entries in bulk by category, date range, author, IDs, or confidence threshold. Supports dry_run preview (cloud mode only)",
|
|
366
|
+
inputSchema: {
|
|
367
|
+
type: "object",
|
|
368
|
+
properties: {
|
|
369
|
+
category: { type: "string", description: "Filter by category" },
|
|
370
|
+
date_before: { type: "string", description: "ISO date: archive entries created before this date" },
|
|
371
|
+
date_after: { type: "string", description: "ISO date: archive entries created after this date" },
|
|
372
|
+
author: { type: "string", description: "Filter by author" },
|
|
373
|
+
ids: { type: "array", items: { type: "string" }, description: "Specific entry UUIDs (max 1000)" },
|
|
374
|
+
confidence_max: { type: "number", description: "Archive entries with confidence at or below this value (0-1)" },
|
|
375
|
+
dry_run: { type: "boolean", description: "Preview without archiving (default true)" },
|
|
376
|
+
},
|
|
377
|
+
},
|
|
378
|
+
},
|
|
379
|
+
{
|
|
380
|
+
name: "get_archive_stats",
|
|
381
|
+
description: "Get archive statistics: count by reason (manual, duplicate, consolidated), by category, and total archived entries (cloud mode only)",
|
|
382
|
+
inputSchema: {
|
|
383
|
+
type: "object",
|
|
384
|
+
properties: {},
|
|
385
|
+
},
|
|
386
|
+
},
|
|
310
387
|
];
|
|
311
388
|
export async function handleTool(store, name, args) {
|
|
312
389
|
switch (name) {
|
|
@@ -352,6 +429,16 @@ export async function handleTool(store, name, args) {
|
|
|
352
429
|
return queryGizaProofs(store, args);
|
|
353
430
|
case "link_proof_to_entry":
|
|
354
431
|
return linkProofToEntry(store, args);
|
|
432
|
+
case "record_decision":
|
|
433
|
+
return recordDecision(store, args);
|
|
434
|
+
case "get_decision_chain":
|
|
435
|
+
return getDecisionChain(store, args);
|
|
436
|
+
case "get_memory_guidance":
|
|
437
|
+
return getMemoryGuidance(store, args);
|
|
438
|
+
case "bulk_archive":
|
|
439
|
+
return bulkArchive(store, args);
|
|
440
|
+
case "get_archive_stats":
|
|
441
|
+
return getArchiveStats(store);
|
|
355
442
|
default:
|
|
356
443
|
return { error: `Unknown tool: ${name}` };
|
|
357
444
|
}
|