@mossbear/protocol 0.1.0-alpha.109 → 0.1.0-alpha.111
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/dist/agentGuidancePaths.d.ts +2 -2
- package/dist/agentGuidancePaths.js +2 -2
- package/dist/aliasPaths.d.ts +1 -1
- package/dist/aliasPaths.js +1 -1
- package/dist/commentAnchor.d.ts +5 -0
- package/dist/commentAnchor.d.ts.map +1 -1
- package/dist/commentAnchor.js +5 -0
- package/dist/commentAnchor.js.map +1 -1
- package/dist/frameDocument.d.ts +6 -0
- package/dist/frameDocument.d.ts.map +1 -1
- package/dist/frameDocument.js +10 -8
- package/dist/frameDocument.js.map +1 -1
- package/dist/frameProtocol.d.ts +9 -1
- package/dist/frameProtocol.d.ts.map +1 -1
- package/dist/frameProtocol.js +46 -1
- package/dist/frameProtocol.js.map +1 -1
- package/dist/frameScheme.d.ts +27 -0
- package/dist/frameScheme.d.ts.map +1 -0
- package/dist/frameScheme.js +149 -0
- package/dist/frameScheme.js.map +1 -0
- package/dist/frameScheme.test.d.ts +2 -0
- package/dist/frameScheme.test.d.ts.map +1 -0
- package/dist/frameScheme.test.js +125 -0
- package/dist/frameScheme.test.js.map +1 -0
- package/dist/index.d.ts +1 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +1 -0
- package/dist/index.js.map +1 -1
- package/dist/schemas.d.ts +817 -258
- package/dist/schemas.d.ts.map +1 -1
- package/dist/schemas.js +113 -19
- package/dist/schemas.js.map +1 -1
- package/package.json +1 -1
package/dist/schemas.d.ts
CHANGED
|
@@ -1299,6 +1299,17 @@ export declare const ArtifactCommentSchema: v.ObjectSchema<{
|
|
|
1299
1299
|
readonly start: v.NumberSchema<undefined>;
|
|
1300
1300
|
readonly end: v.NumberSchema<undefined>;
|
|
1301
1301
|
}, undefined>, undefined>;
|
|
1302
|
+
/**
|
|
1303
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
1304
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
1305
|
+
* the passage has no source lines, so an agent can find a block the
|
|
1306
|
+
* page's script built.
|
|
1307
|
+
*/
|
|
1308
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
1309
|
+
readonly selector: v.StringSchema<undefined>;
|
|
1310
|
+
readonly tag: v.StringSchema<undefined>;
|
|
1311
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
1312
|
+
}, undefined>, undefined>;
|
|
1302
1313
|
}, undefined>, undefined>;
|
|
1303
1314
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
1304
1315
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -1317,22 +1328,26 @@ export declare const ArtifactCommentSchema: v.ObjectSchema<{
|
|
|
1317
1328
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
1318
1329
|
}, undefined>, undefined>;
|
|
1319
1330
|
/**
|
|
1320
|
-
* Whether the person
|
|
1321
|
-
*
|
|
1322
|
-
*
|
|
1323
|
-
*
|
|
1324
|
-
*
|
|
1325
|
-
*
|
|
1331
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
1332
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
1333
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
1334
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
1335
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
1336
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
1337
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
1338
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
1339
|
+
* receives one it would misread.
|
|
1326
1340
|
*/
|
|
1327
1341
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
1328
1342
|
/**
|
|
1329
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
1330
|
-
*
|
|
1331
|
-
*
|
|
1332
|
-
*
|
|
1333
|
-
*
|
|
1334
|
-
*
|
|
1335
|
-
*
|
|
1343
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
1344
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
1345
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
1346
|
+
* an older server, means it waits on the person: show it to the user and
|
|
1347
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
1348
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
1349
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
1350
|
+
* `state`, which already says open or resolved.
|
|
1336
1351
|
*/
|
|
1337
1352
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
1338
1353
|
/**
|
|
@@ -1430,6 +1445,17 @@ export declare const ContextItemCommentSchema: v.ObjectSchema<{
|
|
|
1430
1445
|
readonly start: v.NumberSchema<undefined>;
|
|
1431
1446
|
readonly end: v.NumberSchema<undefined>;
|
|
1432
1447
|
}, undefined>, undefined>;
|
|
1448
|
+
/**
|
|
1449
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
1450
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
1451
|
+
* the passage has no source lines, so an agent can find a block the
|
|
1452
|
+
* page's script built.
|
|
1453
|
+
*/
|
|
1454
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
1455
|
+
readonly selector: v.StringSchema<undefined>;
|
|
1456
|
+
readonly tag: v.StringSchema<undefined>;
|
|
1457
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
1458
|
+
}, undefined>, undefined>;
|
|
1433
1459
|
}, undefined>, undefined>;
|
|
1434
1460
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
1435
1461
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -1448,22 +1474,26 @@ export declare const ContextItemCommentSchema: v.ObjectSchema<{
|
|
|
1448
1474
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
1449
1475
|
}, undefined>, undefined>;
|
|
1450
1476
|
/**
|
|
1451
|
-
* Whether the person
|
|
1452
|
-
*
|
|
1453
|
-
*
|
|
1454
|
-
*
|
|
1455
|
-
*
|
|
1456
|
-
*
|
|
1477
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
1478
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
1479
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
1480
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
1481
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
1482
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
1483
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
1484
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
1485
|
+
* receives one it would misread.
|
|
1457
1486
|
*/
|
|
1458
1487
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
1459
1488
|
/**
|
|
1460
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
1461
|
-
*
|
|
1462
|
-
*
|
|
1463
|
-
*
|
|
1464
|
-
*
|
|
1465
|
-
*
|
|
1466
|
-
*
|
|
1489
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
1490
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
1491
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
1492
|
+
* an older server, means it waits on the person: show it to the user and
|
|
1493
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
1494
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
1495
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
1496
|
+
* `state`, which already says open or resolved.
|
|
1467
1497
|
*/
|
|
1468
1498
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
1469
1499
|
/**
|
|
@@ -1726,6 +1756,17 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
1726
1756
|
readonly start: v.NumberSchema<undefined>;
|
|
1727
1757
|
readonly end: v.NumberSchema<undefined>;
|
|
1728
1758
|
}, undefined>, undefined>;
|
|
1759
|
+
/**
|
|
1760
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
1761
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
1762
|
+
* the passage has no source lines, so an agent can find a block the
|
|
1763
|
+
* page's script built.
|
|
1764
|
+
*/
|
|
1765
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
1766
|
+
readonly selector: v.StringSchema<undefined>;
|
|
1767
|
+
readonly tag: v.StringSchema<undefined>;
|
|
1768
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
1769
|
+
}, undefined>, undefined>;
|
|
1729
1770
|
}, undefined>, undefined>;
|
|
1730
1771
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
1731
1772
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -1744,22 +1785,26 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
1744
1785
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
1745
1786
|
}, undefined>, undefined>;
|
|
1746
1787
|
/**
|
|
1747
|
-
* Whether the person
|
|
1748
|
-
*
|
|
1749
|
-
*
|
|
1750
|
-
*
|
|
1751
|
-
*
|
|
1752
|
-
*
|
|
1788
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
1789
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
1790
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
1791
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
1792
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
1793
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
1794
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
1795
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
1796
|
+
* receives one it would misread.
|
|
1753
1797
|
*/
|
|
1754
1798
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
1755
1799
|
/**
|
|
1756
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
1757
|
-
*
|
|
1758
|
-
*
|
|
1759
|
-
*
|
|
1760
|
-
*
|
|
1761
|
-
*
|
|
1762
|
-
*
|
|
1800
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
1801
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
1802
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
1803
|
+
* an older server, means it waits on the person: show it to the user and
|
|
1804
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
1805
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
1806
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
1807
|
+
* `state`, which already says open or resolved.
|
|
1763
1808
|
*/
|
|
1764
1809
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
1765
1810
|
/**
|
|
@@ -1853,6 +1898,11 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
1853
1898
|
start: number;
|
|
1854
1899
|
end: number;
|
|
1855
1900
|
} | null;
|
|
1901
|
+
element?: {
|
|
1902
|
+
selector: string;
|
|
1903
|
+
tag: string;
|
|
1904
|
+
label?: string | undefined;
|
|
1905
|
+
} | undefined;
|
|
1856
1906
|
} | undefined;
|
|
1857
1907
|
body: string;
|
|
1858
1908
|
finding?: {
|
|
@@ -2007,6 +2057,11 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
2007
2057
|
start: number;
|
|
2008
2058
|
end: number;
|
|
2009
2059
|
} | null;
|
|
2060
|
+
element?: {
|
|
2061
|
+
selector: string;
|
|
2062
|
+
tag: string;
|
|
2063
|
+
label?: string | undefined;
|
|
2064
|
+
} | undefined;
|
|
2010
2065
|
} | undefined;
|
|
2011
2066
|
body: string;
|
|
2012
2067
|
finding?: {
|
|
@@ -2084,6 +2139,11 @@ export declare const ContextItemSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
|
|
|
2084
2139
|
start: number;
|
|
2085
2140
|
end: number;
|
|
2086
2141
|
} | null;
|
|
2142
|
+
element?: {
|
|
2143
|
+
selector: string;
|
|
2144
|
+
tag: string;
|
|
2145
|
+
label?: string | undefined;
|
|
2146
|
+
} | undefined;
|
|
2087
2147
|
} | undefined;
|
|
2088
2148
|
body: string;
|
|
2089
2149
|
finding?: {
|
|
@@ -2246,6 +2306,17 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
2246
2306
|
readonly start: v.NumberSchema<undefined>;
|
|
2247
2307
|
readonly end: v.NumberSchema<undefined>;
|
|
2248
2308
|
}, undefined>, undefined>;
|
|
2309
|
+
/**
|
|
2310
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
2311
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
2312
|
+
* the passage has no source lines, so an agent can find a block the
|
|
2313
|
+
* page's script built.
|
|
2314
|
+
*/
|
|
2315
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
2316
|
+
readonly selector: v.StringSchema<undefined>;
|
|
2317
|
+
readonly tag: v.StringSchema<undefined>;
|
|
2318
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
2319
|
+
}, undefined>, undefined>;
|
|
2249
2320
|
}, undefined>, undefined>;
|
|
2250
2321
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
2251
2322
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -2264,22 +2335,26 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
2264
2335
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
2265
2336
|
}, undefined>, undefined>;
|
|
2266
2337
|
/**
|
|
2267
|
-
* Whether the person
|
|
2268
|
-
*
|
|
2269
|
-
*
|
|
2270
|
-
*
|
|
2271
|
-
*
|
|
2272
|
-
*
|
|
2338
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
2339
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
2340
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
2341
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
2342
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
2343
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
2344
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
2345
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
2346
|
+
* receives one it would misread.
|
|
2273
2347
|
*/
|
|
2274
2348
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
2275
2349
|
/**
|
|
2276
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
2277
|
-
*
|
|
2278
|
-
*
|
|
2279
|
-
*
|
|
2280
|
-
*
|
|
2281
|
-
*
|
|
2282
|
-
*
|
|
2350
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
2351
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
2352
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
2353
|
+
* an older server, means it waits on the person: show it to the user and
|
|
2354
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
2355
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
2356
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
2357
|
+
* `state`, which already says open or resolved.
|
|
2283
2358
|
*/
|
|
2284
2359
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
2285
2360
|
/**
|
|
@@ -2373,6 +2448,11 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
2373
2448
|
start: number;
|
|
2374
2449
|
end: number;
|
|
2375
2450
|
} | null;
|
|
2451
|
+
element?: {
|
|
2452
|
+
selector: string;
|
|
2453
|
+
tag: string;
|
|
2454
|
+
label?: string | undefined;
|
|
2455
|
+
} | undefined;
|
|
2376
2456
|
} | undefined;
|
|
2377
2457
|
body: string;
|
|
2378
2458
|
finding?: {
|
|
@@ -2527,6 +2607,11 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
2527
2607
|
start: number;
|
|
2528
2608
|
end: number;
|
|
2529
2609
|
} | null;
|
|
2610
|
+
element?: {
|
|
2611
|
+
selector: string;
|
|
2612
|
+
tag: string;
|
|
2613
|
+
label?: string | undefined;
|
|
2614
|
+
} | undefined;
|
|
2530
2615
|
} | undefined;
|
|
2531
2616
|
body: string;
|
|
2532
2617
|
finding?: {
|
|
@@ -2604,6 +2689,11 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
2604
2689
|
start: number;
|
|
2605
2690
|
end: number;
|
|
2606
2691
|
} | null;
|
|
2692
|
+
element?: {
|
|
2693
|
+
selector: string;
|
|
2694
|
+
tag: string;
|
|
2695
|
+
label?: string | undefined;
|
|
2696
|
+
} | undefined;
|
|
2607
2697
|
} | undefined;
|
|
2608
2698
|
body: string;
|
|
2609
2699
|
finding?: {
|
|
@@ -2784,6 +2874,17 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
2784
2874
|
readonly start: v.NumberSchema<undefined>;
|
|
2785
2875
|
readonly end: v.NumberSchema<undefined>;
|
|
2786
2876
|
}, undefined>, undefined>;
|
|
2877
|
+
/**
|
|
2878
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
2879
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
2880
|
+
* the passage has no source lines, so an agent can find a block the
|
|
2881
|
+
* page's script built.
|
|
2882
|
+
*/
|
|
2883
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
2884
|
+
readonly selector: v.StringSchema<undefined>;
|
|
2885
|
+
readonly tag: v.StringSchema<undefined>;
|
|
2886
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
2887
|
+
}, undefined>, undefined>;
|
|
2787
2888
|
}, undefined>, undefined>;
|
|
2788
2889
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
2789
2890
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -2802,22 +2903,26 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
2802
2903
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
2803
2904
|
}, undefined>, undefined>;
|
|
2804
2905
|
/**
|
|
2805
|
-
* Whether the person
|
|
2806
|
-
*
|
|
2807
|
-
*
|
|
2808
|
-
*
|
|
2809
|
-
*
|
|
2810
|
-
*
|
|
2906
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
2907
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
2908
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
2909
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
2910
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
2911
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
2912
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
2913
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
2914
|
+
* receives one it would misread.
|
|
2811
2915
|
*/
|
|
2812
2916
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
2813
2917
|
/**
|
|
2814
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
2815
|
-
*
|
|
2816
|
-
*
|
|
2817
|
-
*
|
|
2818
|
-
*
|
|
2819
|
-
*
|
|
2820
|
-
*
|
|
2918
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
2919
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
2920
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
2921
|
+
* an older server, means it waits on the person: show it to the user and
|
|
2922
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
2923
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
2924
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
2925
|
+
* `state`, which already says open or resolved.
|
|
2821
2926
|
*/
|
|
2822
2927
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
2823
2928
|
/**
|
|
@@ -2911,6 +3016,11 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
2911
3016
|
start: number;
|
|
2912
3017
|
end: number;
|
|
2913
3018
|
} | null;
|
|
3019
|
+
element?: {
|
|
3020
|
+
selector: string;
|
|
3021
|
+
tag: string;
|
|
3022
|
+
label?: string | undefined;
|
|
3023
|
+
} | undefined;
|
|
2914
3024
|
} | undefined;
|
|
2915
3025
|
body: string;
|
|
2916
3026
|
finding?: {
|
|
@@ -3065,6 +3175,11 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
3065
3175
|
start: number;
|
|
3066
3176
|
end: number;
|
|
3067
3177
|
} | null;
|
|
3178
|
+
element?: {
|
|
3179
|
+
selector: string;
|
|
3180
|
+
tag: string;
|
|
3181
|
+
label?: string | undefined;
|
|
3182
|
+
} | undefined;
|
|
3068
3183
|
} | undefined;
|
|
3069
3184
|
body: string;
|
|
3070
3185
|
finding?: {
|
|
@@ -3142,6 +3257,11 @@ export declare const BundleArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
3142
3257
|
start: number;
|
|
3143
3258
|
end: number;
|
|
3144
3259
|
} | null;
|
|
3260
|
+
element?: {
|
|
3261
|
+
selector: string;
|
|
3262
|
+
tag: string;
|
|
3263
|
+
label?: string | undefined;
|
|
3264
|
+
} | undefined;
|
|
3145
3265
|
} | undefined;
|
|
3146
3266
|
body: string;
|
|
3147
3267
|
finding?: {
|
|
@@ -3385,6 +3505,110 @@ export declare const AgentCommentRequestSchema: v.ObjectSchema<{
|
|
|
3385
3505
|
readonly bundleIds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MaxLengthAction<string[], 100, undefined>]>, undefined>;
|
|
3386
3506
|
}, undefined>;
|
|
3387
3507
|
export type AgentCommentRequest = v.InferOutput<typeof AgentCommentRequestSchema>;
|
|
3508
|
+
/** A batch may cover findings across several guides without one write per finding. */
|
|
3509
|
+
export declare const MAX_FINDING_DISMISSALS_PER_REQUEST = 100;
|
|
3510
|
+
export declare const FindingDismissalInputSchema: v.ObjectSchema<{
|
|
3511
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
|
|
3512
|
+
readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 1000, undefined>, v.CheckAction<string, "Use one line for the reason.">]>;
|
|
3513
|
+
}, undefined>;
|
|
3514
|
+
export declare const FindingDismissalInputsSchema: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
|
|
3515
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
|
|
3516
|
+
readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 1000, undefined>, v.CheckAction<string, "Use one line for the reason.">]>;
|
|
3517
|
+
}, undefined>, undefined>, v.MinLengthAction<{
|
|
3518
|
+
id: string;
|
|
3519
|
+
reason: string;
|
|
3520
|
+
}[], 1, undefined>, v.MaxLengthAction<{
|
|
3521
|
+
id: string;
|
|
3522
|
+
reason: string;
|
|
3523
|
+
}[], 100, undefined>, v.CheckAction<{
|
|
3524
|
+
id: string;
|
|
3525
|
+
reason: string;
|
|
3526
|
+
}[], "Name each finding only once.">]>;
|
|
3527
|
+
export declare const SuggestFindingDismissalsRequestSchema: v.ObjectSchema<{
|
|
3528
|
+
readonly suggestions: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
|
|
3529
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
|
|
3530
|
+
readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 1000, undefined>, v.CheckAction<string, "Use one line for the reason.">]>;
|
|
3531
|
+
}, undefined>, undefined>, v.MinLengthAction<{
|
|
3532
|
+
id: string;
|
|
3533
|
+
reason: string;
|
|
3534
|
+
}[], 1, undefined>, v.MaxLengthAction<{
|
|
3535
|
+
id: string;
|
|
3536
|
+
reason: string;
|
|
3537
|
+
}[], 100, undefined>, v.CheckAction<{
|
|
3538
|
+
id: string;
|
|
3539
|
+
reason: string;
|
|
3540
|
+
}[], "Name each finding only once.">]>;
|
|
3541
|
+
readonly agent: v.ObjectSchema<{
|
|
3542
|
+
readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
|
|
3543
|
+
readonly harness: v.PicklistSchema<["claude_code", "codex", "antigravity", "opencode"], undefined>;
|
|
3544
|
+
/** The agent's own statement of its model, when it knows it. */
|
|
3545
|
+
readonly model: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>]>, undefined>;
|
|
3546
|
+
readonly cliVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
|
|
3547
|
+
}, undefined>;
|
|
3548
|
+
}, undefined>;
|
|
3549
|
+
export type SuggestFindingDismissalsRequest = v.InferOutput<typeof SuggestFindingDismissalsRequestSchema>;
|
|
3550
|
+
/** Recommendations are separate from the finding's open/resolved state. */
|
|
3551
|
+
export declare const FindingDismissalSuggestionSchema: v.ObjectSchema<{
|
|
3552
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
3553
|
+
readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
3554
|
+
readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
3555
|
+
readonly agent: v.ObjectSchema<{
|
|
3556
|
+
readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
|
|
3557
|
+
readonly harness: v.PicklistSchema<["claude_code", "codex", "antigravity", "opencode"], undefined>;
|
|
3558
|
+
/** The agent's own statement of its model, when it knows it. */
|
|
3559
|
+
readonly model: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>]>, undefined>;
|
|
3560
|
+
readonly cliVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
|
|
3561
|
+
}, undefined>;
|
|
3562
|
+
readonly guideVersion: v.NumberSchema<undefined>;
|
|
3563
|
+
readonly createdAt: v.StringSchema<undefined>;
|
|
3564
|
+
}, undefined>;
|
|
3565
|
+
export type FindingDismissalSuggestion = v.InferOutput<typeof FindingDismissalSuggestionSchema>;
|
|
3566
|
+
export declare const SuggestFindingDismissalsResponseSchema: v.ObjectSchema<{
|
|
3567
|
+
readonly results: v.ArraySchema<v.ObjectSchema<{
|
|
3568
|
+
readonly suggestion: v.ObjectSchema<{
|
|
3569
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
3570
|
+
readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
3571
|
+
readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
3572
|
+
readonly agent: v.ObjectSchema<{
|
|
3573
|
+
readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
|
|
3574
|
+
readonly harness: v.PicklistSchema<["claude_code", "codex", "antigravity", "opencode"], undefined>;
|
|
3575
|
+
/** The agent's own statement of its model, when it knows it. */
|
|
3576
|
+
readonly model: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>]>, undefined>;
|
|
3577
|
+
readonly cliVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
|
|
3578
|
+
}, undefined>;
|
|
3579
|
+
readonly guideVersion: v.NumberSchema<undefined>;
|
|
3580
|
+
readonly createdAt: v.StringSchema<undefined>;
|
|
3581
|
+
}, undefined>;
|
|
3582
|
+
readonly created: v.BooleanSchema<undefined>;
|
|
3583
|
+
readonly valid: v.BooleanSchema<undefined>;
|
|
3584
|
+
}, undefined>, undefined>;
|
|
3585
|
+
}, undefined>;
|
|
3586
|
+
export type SuggestFindingDismissalsResponse = v.InferOutput<typeof SuggestFindingDismissalsResponseSchema>;
|
|
3587
|
+
export declare const FindingDismissalSuggestionsCursorSchema: v.ObjectSchema<{
|
|
3588
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
|
|
3589
|
+
readonly createdAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
|
|
3590
|
+
}, undefined>;
|
|
3591
|
+
export type FindingDismissalSuggestionsCursor = v.InferOutput<typeof FindingDismissalSuggestionsCursorSchema>;
|
|
3592
|
+
export declare const FindingDismissalSuggestionsResponseSchema: v.ObjectSchema<{
|
|
3593
|
+
readonly suggestions: v.ArraySchema<v.ObjectSchema<{
|
|
3594
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
3595
|
+
readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
3596
|
+
readonly reason: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
3597
|
+
readonly agent: v.ObjectSchema<{
|
|
3598
|
+
readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
|
|
3599
|
+
readonly harness: v.PicklistSchema<["claude_code", "codex", "antigravity", "opencode"], undefined>;
|
|
3600
|
+
/** The agent's own statement of its model, when it knows it. */
|
|
3601
|
+
readonly model: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 100, undefined>]>, undefined>;
|
|
3602
|
+
readonly cliVersion: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 64, undefined>]>, undefined>;
|
|
3603
|
+
}, undefined>;
|
|
3604
|
+
readonly guideVersion: v.NumberSchema<undefined>;
|
|
3605
|
+
readonly createdAt: v.StringSchema<undefined>;
|
|
3606
|
+
}, undefined>, undefined>;
|
|
3607
|
+
readonly nextCursor: v.NullableSchema<v.ObjectSchema<{
|
|
3608
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>]>;
|
|
3609
|
+
readonly createdAt: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
|
|
3610
|
+
}, undefined>, undefined>;
|
|
3611
|
+
}, undefined>;
|
|
3388
3612
|
/**
|
|
3389
3613
|
* The comment a create settled on. `created` is false when this agent session
|
|
3390
3614
|
* already had a whole-subject comment on the subject: that comment comes back
|
|
@@ -3428,6 +3652,17 @@ export declare const ItemCommentWithSubjectSchema: v.ObjectSchema<{
|
|
|
3428
3652
|
readonly start: v.NumberSchema<undefined>;
|
|
3429
3653
|
readonly end: v.NumberSchema<undefined>;
|
|
3430
3654
|
}, undefined>, undefined>;
|
|
3655
|
+
/**
|
|
3656
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
3657
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
3658
|
+
* the passage has no source lines, so an agent can find a block the
|
|
3659
|
+
* page's script built.
|
|
3660
|
+
*/
|
|
3661
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
3662
|
+
readonly selector: v.StringSchema<undefined>;
|
|
3663
|
+
readonly tag: v.StringSchema<undefined>;
|
|
3664
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
3665
|
+
}, undefined>, undefined>;
|
|
3431
3666
|
}, undefined>, undefined>;
|
|
3432
3667
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
3433
3668
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -3446,22 +3681,26 @@ export declare const ItemCommentWithSubjectSchema: v.ObjectSchema<{
|
|
|
3446
3681
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
3447
3682
|
}, undefined>, undefined>;
|
|
3448
3683
|
/**
|
|
3449
|
-
* Whether the person
|
|
3450
|
-
*
|
|
3451
|
-
*
|
|
3452
|
-
*
|
|
3453
|
-
*
|
|
3454
|
-
*
|
|
3684
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
3685
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
3686
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
3687
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
3688
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
3689
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
3690
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
3691
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
3692
|
+
* receives one it would misread.
|
|
3455
3693
|
*/
|
|
3456
3694
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
3457
3695
|
/**
|
|
3458
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
3459
|
-
*
|
|
3460
|
-
*
|
|
3461
|
-
*
|
|
3462
|
-
*
|
|
3463
|
-
*
|
|
3464
|
-
*
|
|
3696
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
3697
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
3698
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
3699
|
+
* an older server, means it waits on the person: show it to the user and
|
|
3700
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
3701
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
3702
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
3703
|
+
* `state`, which already says open or resolved.
|
|
3465
3704
|
*/
|
|
3466
3705
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
3467
3706
|
/**
|
|
@@ -3575,6 +3814,17 @@ export declare const ItemCommentsResponseSchema: v.ObjectSchema<{
|
|
|
3575
3814
|
readonly start: v.NumberSchema<undefined>;
|
|
3576
3815
|
readonly end: v.NumberSchema<undefined>;
|
|
3577
3816
|
}, undefined>, undefined>;
|
|
3817
|
+
/**
|
|
3818
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
3819
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
3820
|
+
* the passage has no source lines, so an agent can find a block the
|
|
3821
|
+
* page's script built.
|
|
3822
|
+
*/
|
|
3823
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
3824
|
+
readonly selector: v.StringSchema<undefined>;
|
|
3825
|
+
readonly tag: v.StringSchema<undefined>;
|
|
3826
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
3827
|
+
}, undefined>, undefined>;
|
|
3578
3828
|
}, undefined>, undefined>;
|
|
3579
3829
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
3580
3830
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -3593,22 +3843,26 @@ export declare const ItemCommentsResponseSchema: v.ObjectSchema<{
|
|
|
3593
3843
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
3594
3844
|
}, undefined>, undefined>;
|
|
3595
3845
|
/**
|
|
3596
|
-
* Whether the person
|
|
3597
|
-
*
|
|
3598
|
-
*
|
|
3599
|
-
*
|
|
3600
|
-
*
|
|
3601
|
-
*
|
|
3846
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
3847
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
3848
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
3849
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
3850
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
3851
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
3852
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
3853
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
3854
|
+
* receives one it would misread.
|
|
3602
3855
|
*/
|
|
3603
3856
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
3604
3857
|
/**
|
|
3605
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
3606
|
-
*
|
|
3607
|
-
*
|
|
3608
|
-
*
|
|
3609
|
-
*
|
|
3610
|
-
*
|
|
3611
|
-
*
|
|
3858
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
3859
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
3860
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
3861
|
+
* an older server, means it waits on the person: show it to the user and
|
|
3862
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
3863
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
3864
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
3865
|
+
* `state`, which already says open or resolved.
|
|
3612
3866
|
*/
|
|
3613
3867
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
3614
3868
|
/**
|
|
@@ -4319,6 +4573,17 @@ export declare const ArtifactSchema: v.ObjectSchema<{
|
|
|
4319
4573
|
readonly start: v.NumberSchema<undefined>;
|
|
4320
4574
|
readonly end: v.NumberSchema<undefined>;
|
|
4321
4575
|
}, undefined>, undefined>;
|
|
4576
|
+
/**
|
|
4577
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
4578
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
4579
|
+
* the passage has no source lines, so an agent can find a block the
|
|
4580
|
+
* page's script built.
|
|
4581
|
+
*/
|
|
4582
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
4583
|
+
readonly selector: v.StringSchema<undefined>;
|
|
4584
|
+
readonly tag: v.StringSchema<undefined>;
|
|
4585
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
4586
|
+
}, undefined>, undefined>;
|
|
4322
4587
|
}, undefined>, undefined>;
|
|
4323
4588
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
4324
4589
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -4337,22 +4602,26 @@ export declare const ArtifactSchema: v.ObjectSchema<{
|
|
|
4337
4602
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
4338
4603
|
}, undefined>, undefined>;
|
|
4339
4604
|
/**
|
|
4340
|
-
* Whether the person
|
|
4341
|
-
*
|
|
4342
|
-
*
|
|
4343
|
-
*
|
|
4344
|
-
*
|
|
4345
|
-
*
|
|
4605
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
4606
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
4607
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
4608
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
4609
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
4610
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
4611
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
4612
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
4613
|
+
* receives one it would misread.
|
|
4346
4614
|
*/
|
|
4347
4615
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
4348
4616
|
/**
|
|
4349
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
4350
|
-
*
|
|
4351
|
-
*
|
|
4352
|
-
*
|
|
4353
|
-
*
|
|
4354
|
-
*
|
|
4355
|
-
*
|
|
4617
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
4618
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
4619
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
4620
|
+
* an older server, means it waits on the person: show it to the user and
|
|
4621
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
4622
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
4623
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
4624
|
+
* `state`, which already says open or resolved.
|
|
4356
4625
|
*/
|
|
4357
4626
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
4358
4627
|
/**
|
|
@@ -4446,6 +4715,11 @@ export declare const ArtifactSchema: v.ObjectSchema<{
|
|
|
4446
4715
|
start: number;
|
|
4447
4716
|
end: number;
|
|
4448
4717
|
} | null;
|
|
4718
|
+
element?: {
|
|
4719
|
+
selector: string;
|
|
4720
|
+
tag: string;
|
|
4721
|
+
label?: string | undefined;
|
|
4722
|
+
} | undefined;
|
|
4449
4723
|
} | undefined;
|
|
4450
4724
|
body: string;
|
|
4451
4725
|
finding?: {
|
|
@@ -4559,6 +4833,17 @@ export declare const ArtifactMetadataSchema: v.StrictObjectSchema<Omit<{
|
|
|
4559
4833
|
readonly start: v.NumberSchema<undefined>;
|
|
4560
4834
|
readonly end: v.NumberSchema<undefined>;
|
|
4561
4835
|
}, undefined>, undefined>;
|
|
4836
|
+
/**
|
|
4837
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
4838
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
4839
|
+
* the passage has no source lines, so an agent can find a block the
|
|
4840
|
+
* page's script built.
|
|
4841
|
+
*/
|
|
4842
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
4843
|
+
readonly selector: v.StringSchema<undefined>;
|
|
4844
|
+
readonly tag: v.StringSchema<undefined>;
|
|
4845
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
4846
|
+
}, undefined>, undefined>;
|
|
4562
4847
|
}, undefined>, undefined>;
|
|
4563
4848
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
4564
4849
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -4577,22 +4862,26 @@ export declare const ArtifactMetadataSchema: v.StrictObjectSchema<Omit<{
|
|
|
4577
4862
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
4578
4863
|
}, undefined>, undefined>;
|
|
4579
4864
|
/**
|
|
4580
|
-
* Whether the person
|
|
4581
|
-
*
|
|
4582
|
-
*
|
|
4583
|
-
*
|
|
4584
|
-
*
|
|
4585
|
-
*
|
|
4865
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
4866
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
4867
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
4868
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
4869
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
4870
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
4871
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
4872
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
4873
|
+
* receives one it would misread.
|
|
4586
4874
|
*/
|
|
4587
4875
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
4588
4876
|
/**
|
|
4589
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
4590
|
-
*
|
|
4591
|
-
*
|
|
4592
|
-
*
|
|
4593
|
-
*
|
|
4594
|
-
*
|
|
4595
|
-
*
|
|
4877
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
4878
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
4879
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
4880
|
+
* an older server, means it waits on the person: show it to the user and
|
|
4881
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
4882
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
4883
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
4884
|
+
* `state`, which already says open or resolved.
|
|
4596
4885
|
*/
|
|
4597
4886
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
4598
4887
|
/**
|
|
@@ -4686,6 +4975,11 @@ export declare const ArtifactMetadataSchema: v.StrictObjectSchema<Omit<{
|
|
|
4686
4975
|
start: number;
|
|
4687
4976
|
end: number;
|
|
4688
4977
|
} | null;
|
|
4978
|
+
element?: {
|
|
4979
|
+
selector: string;
|
|
4980
|
+
tag: string;
|
|
4981
|
+
label?: string | undefined;
|
|
4982
|
+
} | undefined;
|
|
4689
4983
|
} | undefined;
|
|
4690
4984
|
body: string;
|
|
4691
4985
|
finding?: {
|
|
@@ -5576,6 +5870,17 @@ export declare const ReadArtifactResponseSchema: v.ObjectSchema<{
|
|
|
5576
5870
|
readonly start: v.NumberSchema<undefined>;
|
|
5577
5871
|
readonly end: v.NumberSchema<undefined>;
|
|
5578
5872
|
}, undefined>, undefined>;
|
|
5873
|
+
/**
|
|
5874
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
5875
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
5876
|
+
* the passage has no source lines, so an agent can find a block the
|
|
5877
|
+
* page's script built.
|
|
5878
|
+
*/
|
|
5879
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
5880
|
+
readonly selector: v.StringSchema<undefined>;
|
|
5881
|
+
readonly tag: v.StringSchema<undefined>;
|
|
5882
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
5883
|
+
}, undefined>, undefined>;
|
|
5579
5884
|
}, undefined>, undefined>;
|
|
5580
5885
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
5581
5886
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -5594,22 +5899,26 @@ export declare const ReadArtifactResponseSchema: v.ObjectSchema<{
|
|
|
5594
5899
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
5595
5900
|
}, undefined>, undefined>;
|
|
5596
5901
|
/**
|
|
5597
|
-
* Whether the person
|
|
5598
|
-
*
|
|
5599
|
-
*
|
|
5600
|
-
*
|
|
5601
|
-
*
|
|
5602
|
-
*
|
|
5902
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
5903
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
5904
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
5905
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
5906
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
5907
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
5908
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
5909
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
5910
|
+
* receives one it would misread.
|
|
5603
5911
|
*/
|
|
5604
5912
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
5605
5913
|
/**
|
|
5606
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
5607
|
-
*
|
|
5608
|
-
*
|
|
5609
|
-
*
|
|
5610
|
-
*
|
|
5611
|
-
*
|
|
5612
|
-
*
|
|
5914
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
5915
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
5916
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
5917
|
+
* an older server, means it waits on the person: show it to the user and
|
|
5918
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
5919
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
5920
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
5921
|
+
* `state`, which already says open or resolved.
|
|
5613
5922
|
*/
|
|
5614
5923
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
5615
5924
|
/**
|
|
@@ -5703,6 +6012,11 @@ export declare const ReadArtifactResponseSchema: v.ObjectSchema<{
|
|
|
5703
6012
|
start: number;
|
|
5704
6013
|
end: number;
|
|
5705
6014
|
} | null;
|
|
6015
|
+
element?: {
|
|
6016
|
+
selector: string;
|
|
6017
|
+
tag: string;
|
|
6018
|
+
label?: string | undefined;
|
|
6019
|
+
} | undefined;
|
|
5706
6020
|
} | undefined;
|
|
5707
6021
|
body: string;
|
|
5708
6022
|
finding?: {
|
|
@@ -5855,6 +6169,17 @@ export declare const CreateArtifactResponseSchema: v.ObjectSchema<{
|
|
|
5855
6169
|
readonly start: v.NumberSchema<undefined>;
|
|
5856
6170
|
readonly end: v.NumberSchema<undefined>;
|
|
5857
6171
|
}, undefined>, undefined>;
|
|
6172
|
+
/**
|
|
6173
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
6174
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
6175
|
+
* the passage has no source lines, so an agent can find a block the
|
|
6176
|
+
* page's script built.
|
|
6177
|
+
*/
|
|
6178
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
6179
|
+
readonly selector: v.StringSchema<undefined>;
|
|
6180
|
+
readonly tag: v.StringSchema<undefined>;
|
|
6181
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
6182
|
+
}, undefined>, undefined>;
|
|
5858
6183
|
}, undefined>, undefined>;
|
|
5859
6184
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
5860
6185
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -5873,22 +6198,26 @@ export declare const CreateArtifactResponseSchema: v.ObjectSchema<{
|
|
|
5873
6198
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
5874
6199
|
}, undefined>, undefined>;
|
|
5875
6200
|
/**
|
|
5876
|
-
* Whether the person
|
|
5877
|
-
*
|
|
5878
|
-
*
|
|
5879
|
-
*
|
|
5880
|
-
*
|
|
5881
|
-
*
|
|
6201
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
6202
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
6203
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
6204
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
6205
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
6206
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
6207
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
6208
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
6209
|
+
* receives one it would misread.
|
|
5882
6210
|
*/
|
|
5883
6211
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
5884
6212
|
/**
|
|
5885
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
5886
|
-
*
|
|
5887
|
-
*
|
|
5888
|
-
*
|
|
5889
|
-
*
|
|
5890
|
-
*
|
|
5891
|
-
*
|
|
6213
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
6214
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
6215
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
6216
|
+
* an older server, means it waits on the person: show it to the user and
|
|
6217
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
6218
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
6219
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
6220
|
+
* `state`, which already says open or resolved.
|
|
5892
6221
|
*/
|
|
5893
6222
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
5894
6223
|
/**
|
|
@@ -5982,6 +6311,11 @@ export declare const CreateArtifactResponseSchema: v.ObjectSchema<{
|
|
|
5982
6311
|
start: number;
|
|
5983
6312
|
end: number;
|
|
5984
6313
|
} | null;
|
|
6314
|
+
element?: {
|
|
6315
|
+
selector: string;
|
|
6316
|
+
tag: string;
|
|
6317
|
+
label?: string | undefined;
|
|
6318
|
+
} | undefined;
|
|
5985
6319
|
} | undefined;
|
|
5986
6320
|
body: string;
|
|
5987
6321
|
finding?: {
|
|
@@ -6096,6 +6430,17 @@ export declare const UpdateArtifactResponseSchema: v.ObjectSchema<{
|
|
|
6096
6430
|
readonly start: v.NumberSchema<undefined>;
|
|
6097
6431
|
readonly end: v.NumberSchema<undefined>;
|
|
6098
6432
|
}, undefined>, undefined>;
|
|
6433
|
+
/**
|
|
6434
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
6435
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
6436
|
+
* the passage has no source lines, so an agent can find a block the
|
|
6437
|
+
* page's script built.
|
|
6438
|
+
*/
|
|
6439
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
6440
|
+
readonly selector: v.StringSchema<undefined>;
|
|
6441
|
+
readonly tag: v.StringSchema<undefined>;
|
|
6442
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
6443
|
+
}, undefined>, undefined>;
|
|
6099
6444
|
}, undefined>, undefined>;
|
|
6100
6445
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
6101
6446
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -6114,22 +6459,26 @@ export declare const UpdateArtifactResponseSchema: v.ObjectSchema<{
|
|
|
6114
6459
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
6115
6460
|
}, undefined>, undefined>;
|
|
6116
6461
|
/**
|
|
6117
|
-
* Whether the person
|
|
6118
|
-
*
|
|
6119
|
-
*
|
|
6120
|
-
*
|
|
6121
|
-
*
|
|
6122
|
-
*
|
|
6462
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
6463
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
6464
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
6465
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
6466
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
6467
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
6468
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
6469
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
6470
|
+
* receives one it would misread.
|
|
6123
6471
|
*/
|
|
6124
6472
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
6125
6473
|
/**
|
|
6126
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
6127
|
-
*
|
|
6128
|
-
*
|
|
6129
|
-
*
|
|
6130
|
-
*
|
|
6131
|
-
*
|
|
6132
|
-
*
|
|
6474
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
6475
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
6476
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
6477
|
+
* an older server, means it waits on the person: show it to the user and
|
|
6478
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
6479
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
6480
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
6481
|
+
* `state`, which already says open or resolved.
|
|
6133
6482
|
*/
|
|
6134
6483
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
6135
6484
|
/**
|
|
@@ -6223,6 +6572,11 @@ export declare const UpdateArtifactResponseSchema: v.ObjectSchema<{
|
|
|
6223
6572
|
start: number;
|
|
6224
6573
|
end: number;
|
|
6225
6574
|
} | null;
|
|
6575
|
+
element?: {
|
|
6576
|
+
selector: string;
|
|
6577
|
+
tag: string;
|
|
6578
|
+
label?: string | undefined;
|
|
6579
|
+
} | undefined;
|
|
6226
6580
|
} | undefined;
|
|
6227
6581
|
body: string;
|
|
6228
6582
|
finding?: {
|
|
@@ -6403,6 +6757,17 @@ export declare const ListArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
6403
6757
|
readonly start: v.NumberSchema<undefined>;
|
|
6404
6758
|
readonly end: v.NumberSchema<undefined>;
|
|
6405
6759
|
}, undefined>, undefined>;
|
|
6760
|
+
/**
|
|
6761
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
6762
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
6763
|
+
* the passage has no source lines, so an agent can find a block the
|
|
6764
|
+
* page's script built.
|
|
6765
|
+
*/
|
|
6766
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
6767
|
+
readonly selector: v.StringSchema<undefined>;
|
|
6768
|
+
readonly tag: v.StringSchema<undefined>;
|
|
6769
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
6770
|
+
}, undefined>, undefined>;
|
|
6406
6771
|
}, undefined>, undefined>;
|
|
6407
6772
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
6408
6773
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -6421,22 +6786,26 @@ export declare const ListArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
6421
6786
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
6422
6787
|
}, undefined>, undefined>;
|
|
6423
6788
|
/**
|
|
6424
|
-
* Whether the person
|
|
6425
|
-
*
|
|
6426
|
-
*
|
|
6427
|
-
*
|
|
6428
|
-
*
|
|
6429
|
-
*
|
|
6789
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
6790
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
6791
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
6792
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
6793
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
6794
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
6795
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
6796
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
6797
|
+
* receives one it would misread.
|
|
6430
6798
|
*/
|
|
6431
6799
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
6432
6800
|
/**
|
|
6433
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
6434
|
-
*
|
|
6435
|
-
*
|
|
6436
|
-
*
|
|
6437
|
-
*
|
|
6438
|
-
*
|
|
6439
|
-
*
|
|
6801
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
6802
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
6803
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
6804
|
+
* an older server, means it waits on the person: show it to the user and
|
|
6805
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
6806
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
6807
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
6808
|
+
* `state`, which already says open or resolved.
|
|
6440
6809
|
*/
|
|
6441
6810
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
6442
6811
|
/**
|
|
@@ -6530,6 +6899,11 @@ export declare const ListArtifactsResponseSchema: v.ObjectSchema<{
|
|
|
6530
6899
|
start: number;
|
|
6531
6900
|
end: number;
|
|
6532
6901
|
} | null;
|
|
6902
|
+
element?: {
|
|
6903
|
+
selector: string;
|
|
6904
|
+
tag: string;
|
|
6905
|
+
label?: string | undefined;
|
|
6906
|
+
} | undefined;
|
|
6533
6907
|
} | undefined;
|
|
6534
6908
|
body: string;
|
|
6535
6909
|
finding?: {
|
|
@@ -6654,6 +7028,17 @@ export declare const ListArtifactMetadataResponseSchema: v.ObjectSchema<{
|
|
|
6654
7028
|
readonly start: v.NumberSchema<undefined>;
|
|
6655
7029
|
readonly end: v.NumberSchema<undefined>;
|
|
6656
7030
|
}, undefined>, undefined>;
|
|
7031
|
+
/**
|
|
7032
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
7033
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
7034
|
+
* the passage has no source lines, so an agent can find a block the
|
|
7035
|
+
* page's script built.
|
|
7036
|
+
*/
|
|
7037
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
7038
|
+
readonly selector: v.StringSchema<undefined>;
|
|
7039
|
+
readonly tag: v.StringSchema<undefined>;
|
|
7040
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
7041
|
+
}, undefined>, undefined>;
|
|
6657
7042
|
}, undefined>, undefined>;
|
|
6658
7043
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
6659
7044
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -6672,22 +7057,26 @@ export declare const ListArtifactMetadataResponseSchema: v.ObjectSchema<{
|
|
|
6672
7057
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
6673
7058
|
}, undefined>, undefined>;
|
|
6674
7059
|
/**
|
|
6675
|
-
* Whether the person
|
|
6676
|
-
*
|
|
6677
|
-
*
|
|
6678
|
-
*
|
|
6679
|
-
*
|
|
6680
|
-
*
|
|
7060
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
7061
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
7062
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
7063
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
7064
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
7065
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
7066
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
7067
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
7068
|
+
* receives one it would misread.
|
|
6681
7069
|
*/
|
|
6682
7070
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
6683
7071
|
/**
|
|
6684
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
6685
|
-
*
|
|
6686
|
-
*
|
|
6687
|
-
*
|
|
6688
|
-
*
|
|
6689
|
-
*
|
|
6690
|
-
*
|
|
7072
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
7073
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
7074
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
7075
|
+
* an older server, means it waits on the person: show it to the user and
|
|
7076
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
7077
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
7078
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
7079
|
+
* `state`, which already says open or resolved.
|
|
6691
7080
|
*/
|
|
6692
7081
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
6693
7082
|
/**
|
|
@@ -6781,6 +7170,11 @@ export declare const ListArtifactMetadataResponseSchema: v.ObjectSchema<{
|
|
|
6781
7170
|
start: number;
|
|
6782
7171
|
end: number;
|
|
6783
7172
|
} | null;
|
|
7173
|
+
element?: {
|
|
7174
|
+
selector: string;
|
|
7175
|
+
tag: string;
|
|
7176
|
+
label?: string | undefined;
|
|
7177
|
+
} | undefined;
|
|
6784
7178
|
} | undefined;
|
|
6785
7179
|
body: string;
|
|
6786
7180
|
finding?: {
|
|
@@ -7067,6 +7461,17 @@ export declare const MarkDoneResponseSchema: v.ObjectSchema<{
|
|
|
7067
7461
|
readonly start: v.NumberSchema<undefined>;
|
|
7068
7462
|
readonly end: v.NumberSchema<undefined>;
|
|
7069
7463
|
}, undefined>, undefined>;
|
|
7464
|
+
/**
|
|
7465
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
7466
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
7467
|
+
* the passage has no source lines, so an agent can find a block the
|
|
7468
|
+
* page's script built.
|
|
7469
|
+
*/
|
|
7470
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
7471
|
+
readonly selector: v.StringSchema<undefined>;
|
|
7472
|
+
readonly tag: v.StringSchema<undefined>;
|
|
7473
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
7474
|
+
}, undefined>, undefined>;
|
|
7070
7475
|
}, undefined>, undefined>;
|
|
7071
7476
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
7072
7477
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -7085,22 +7490,26 @@ export declare const MarkDoneResponseSchema: v.ObjectSchema<{
|
|
|
7085
7490
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
7086
7491
|
}, undefined>, undefined>;
|
|
7087
7492
|
/**
|
|
7088
|
-
* Whether the person
|
|
7089
|
-
*
|
|
7090
|
-
*
|
|
7091
|
-
*
|
|
7092
|
-
*
|
|
7093
|
-
*
|
|
7493
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
7494
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
7495
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
7496
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
7497
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
7498
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
7499
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
7500
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
7501
|
+
* receives one it would misread.
|
|
7094
7502
|
*/
|
|
7095
7503
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
7096
7504
|
/**
|
|
7097
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
7098
|
-
*
|
|
7099
|
-
*
|
|
7100
|
-
*
|
|
7101
|
-
*
|
|
7102
|
-
*
|
|
7103
|
-
*
|
|
7505
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
7506
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
7507
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
7508
|
+
* an older server, means it waits on the person: show it to the user and
|
|
7509
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
7510
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
7511
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
7512
|
+
* `state`, which already says open or resolved.
|
|
7104
7513
|
*/
|
|
7105
7514
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
7106
7515
|
/**
|
|
@@ -7194,6 +7603,11 @@ export declare const MarkDoneResponseSchema: v.ObjectSchema<{
|
|
|
7194
7603
|
start: number;
|
|
7195
7604
|
end: number;
|
|
7196
7605
|
} | null;
|
|
7606
|
+
element?: {
|
|
7607
|
+
selector: string;
|
|
7608
|
+
tag: string;
|
|
7609
|
+
label?: string | undefined;
|
|
7610
|
+
} | undefined;
|
|
7197
7611
|
} | undefined;
|
|
7198
7612
|
body: string;
|
|
7199
7613
|
finding?: {
|
|
@@ -7310,6 +7724,17 @@ export declare const DeleteArtifactResponseSchema: v.ObjectSchema<{
|
|
|
7310
7724
|
readonly start: v.NumberSchema<undefined>;
|
|
7311
7725
|
readonly end: v.NumberSchema<undefined>;
|
|
7312
7726
|
}, undefined>, undefined>;
|
|
7727
|
+
/**
|
|
7728
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
7729
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
7730
|
+
* the passage has no source lines, so an agent can find a block the
|
|
7731
|
+
* page's script built.
|
|
7732
|
+
*/
|
|
7733
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
7734
|
+
readonly selector: v.StringSchema<undefined>;
|
|
7735
|
+
readonly tag: v.StringSchema<undefined>;
|
|
7736
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
7737
|
+
}, undefined>, undefined>;
|
|
7313
7738
|
}, undefined>, undefined>;
|
|
7314
7739
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
7315
7740
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -7328,22 +7753,26 @@ export declare const DeleteArtifactResponseSchema: v.ObjectSchema<{
|
|
|
7328
7753
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
7329
7754
|
}, undefined>, undefined>;
|
|
7330
7755
|
/**
|
|
7331
|
-
* Whether the person
|
|
7332
|
-
*
|
|
7333
|
-
*
|
|
7334
|
-
*
|
|
7335
|
-
*
|
|
7336
|
-
*
|
|
7756
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
7757
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
7758
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
7759
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
7760
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
7761
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
7762
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
7763
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
7764
|
+
* receives one it would misread.
|
|
7337
7765
|
*/
|
|
7338
7766
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
7339
7767
|
/**
|
|
7340
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
7341
|
-
*
|
|
7342
|
-
*
|
|
7343
|
-
*
|
|
7344
|
-
*
|
|
7345
|
-
*
|
|
7346
|
-
*
|
|
7768
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
7769
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
7770
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
7771
|
+
* an older server, means it waits on the person: show it to the user and
|
|
7772
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
7773
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
7774
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
7775
|
+
* `state`, which already says open or resolved.
|
|
7347
7776
|
*/
|
|
7348
7777
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
7349
7778
|
/**
|
|
@@ -7437,6 +7866,11 @@ export declare const DeleteArtifactResponseSchema: v.ObjectSchema<{
|
|
|
7437
7866
|
start: number;
|
|
7438
7867
|
end: number;
|
|
7439
7868
|
} | null;
|
|
7869
|
+
element?: {
|
|
7870
|
+
selector: string;
|
|
7871
|
+
tag: string;
|
|
7872
|
+
label?: string | undefined;
|
|
7873
|
+
} | undefined;
|
|
7440
7874
|
} | undefined;
|
|
7441
7875
|
body: string;
|
|
7442
7876
|
finding?: {
|
|
@@ -7552,6 +7986,17 @@ export declare const WithdrawArtifactResponseSchema: v.ObjectSchema<{
|
|
|
7552
7986
|
readonly start: v.NumberSchema<undefined>;
|
|
7553
7987
|
readonly end: v.NumberSchema<undefined>;
|
|
7554
7988
|
}, undefined>, undefined>;
|
|
7989
|
+
/**
|
|
7990
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
7991
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
7992
|
+
* the passage has no source lines, so an agent can find a block the
|
|
7993
|
+
* page's script built.
|
|
7994
|
+
*/
|
|
7995
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
7996
|
+
readonly selector: v.StringSchema<undefined>;
|
|
7997
|
+
readonly tag: v.StringSchema<undefined>;
|
|
7998
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
7999
|
+
}, undefined>, undefined>;
|
|
7555
8000
|
}, undefined>, undefined>;
|
|
7556
8001
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
7557
8002
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -7570,22 +8015,26 @@ export declare const WithdrawArtifactResponseSchema: v.ObjectSchema<{
|
|
|
7570
8015
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
7571
8016
|
}, undefined>, undefined>;
|
|
7572
8017
|
/**
|
|
7573
|
-
* Whether the person
|
|
7574
|
-
*
|
|
7575
|
-
*
|
|
7576
|
-
*
|
|
7577
|
-
*
|
|
7578
|
-
*
|
|
8018
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
8019
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
8020
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
8021
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
8022
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
8023
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
8024
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
8025
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
8026
|
+
* receives one it would misread.
|
|
7579
8027
|
*/
|
|
7580
8028
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
7581
8029
|
/**
|
|
7582
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
7583
|
-
*
|
|
7584
|
-
*
|
|
7585
|
-
*
|
|
7586
|
-
*
|
|
7587
|
-
*
|
|
7588
|
-
*
|
|
8030
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
8031
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
8032
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
8033
|
+
* an older server, means it waits on the person: show it to the user and
|
|
8034
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
8035
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
8036
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
8037
|
+
* `state`, which already says open or resolved.
|
|
7589
8038
|
*/
|
|
7590
8039
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
7591
8040
|
/**
|
|
@@ -7679,6 +8128,11 @@ export declare const WithdrawArtifactResponseSchema: v.ObjectSchema<{
|
|
|
7679
8128
|
start: number;
|
|
7680
8129
|
end: number;
|
|
7681
8130
|
} | null;
|
|
8131
|
+
element?: {
|
|
8132
|
+
selector: string;
|
|
8133
|
+
tag: string;
|
|
8134
|
+
label?: string | undefined;
|
|
8135
|
+
} | undefined;
|
|
7682
8136
|
} | undefined;
|
|
7683
8137
|
body: string;
|
|
7684
8138
|
finding?: {
|
|
@@ -8285,7 +8739,7 @@ export declare const MAX_RULE_MANIFEST_FILES = 500;
|
|
|
8285
8739
|
* A rule file observed on disk in the repo `mossbear report` ran from.
|
|
8286
8740
|
*
|
|
8287
8741
|
* `path` is relative to that repo root, in exactly the form `payloadPath`
|
|
8288
|
-
* takes at import time (`packages/cli/src/
|
|
8742
|
+
* takes at import time (`packages/cli/src/guides/discover.ts`), so
|
|
8289
8743
|
* `file:{format}:{path}` reconstructs the `origin` the dashboard stored for
|
|
8290
8744
|
* the guide this file produced. That reconstruction is the whole join; nothing
|
|
8291
8745
|
* else about the file is needed and nothing else is sent.
|
|
@@ -8311,7 +8765,7 @@ export declare const RuleManifestFileSchema: v.ObjectSchema<{
|
|
|
8311
8765
|
* same account distinguishable, which is the half of review finding 5 that
|
|
8312
8766
|
* repo-root-relative origins cannot express: two repos each holding
|
|
8313
8767
|
* `.claude/skills/review` produce byte-identical origins by construction. See
|
|
8314
|
-
* `repoIdFromRoot` (`packages/cli/src/
|
|
8768
|
+
* `repoIdFromRoot` (`packages/cli/src/guides/manifest.ts`) for how it is
|
|
8315
8769
|
* derived and why that derivation is privacy-safe.
|
|
8316
8770
|
*/
|
|
8317
8771
|
export declare const RuleFileManifestSchema: v.ObjectSchema<{
|
|
@@ -9005,7 +9459,7 @@ export declare const GuideHistoryIdentifierSchema: v.SchemaWithPipe<readonly [v.
|
|
|
9005
9459
|
*
|
|
9006
9460
|
* `root` is optional and is the disambiguator, not decoration: `.claude/skills`
|
|
9007
9461
|
* is scanned under **both** discovery roots
|
|
9008
|
-
* (`packages/cli/src/
|
|
9462
|
+
* (`packages/cli/src/guides/discover.ts`), so a project skill and its
|
|
9009
9463
|
* `~/.claude/skills` twin declare the same path string. When the identifier
|
|
9010
9464
|
* reaches guides under more than one root and no root was given, the server
|
|
9011
9465
|
* refuses and names both rather than picking one — answering a question about
|
|
@@ -9574,6 +10028,17 @@ export declare const ArtifactFeedbackResponseSchema: v.ObjectSchema<{
|
|
|
9574
10028
|
readonly start: v.NumberSchema<undefined>;
|
|
9575
10029
|
readonly end: v.NumberSchema<undefined>;
|
|
9576
10030
|
}, undefined>, undefined>;
|
|
10031
|
+
/**
|
|
10032
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
10033
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
10034
|
+
* the passage has no source lines, so an agent can find a block the
|
|
10035
|
+
* page's script built.
|
|
10036
|
+
*/
|
|
10037
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
10038
|
+
readonly selector: v.StringSchema<undefined>;
|
|
10039
|
+
readonly tag: v.StringSchema<undefined>;
|
|
10040
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
10041
|
+
}, undefined>, undefined>;
|
|
9577
10042
|
}, undefined>, undefined>;
|
|
9578
10043
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
9579
10044
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -9592,22 +10057,26 @@ export declare const ArtifactFeedbackResponseSchema: v.ObjectSchema<{
|
|
|
9592
10057
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
9593
10058
|
}, undefined>, undefined>;
|
|
9594
10059
|
/**
|
|
9595
|
-
* Whether the person
|
|
9596
|
-
*
|
|
9597
|
-
*
|
|
9598
|
-
*
|
|
9599
|
-
*
|
|
9600
|
-
*
|
|
10060
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
10061
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
10062
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
10063
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
10064
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
10065
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
10066
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
10067
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
10068
|
+
* receives one it would misread.
|
|
9601
10069
|
*/
|
|
9602
10070
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
9603
10071
|
/**
|
|
9604
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
9605
|
-
*
|
|
9606
|
-
*
|
|
9607
|
-
*
|
|
9608
|
-
*
|
|
9609
|
-
*
|
|
9610
|
-
*
|
|
10072
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
10073
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
10074
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
10075
|
+
* an older server, means it waits on the person: show it to the user and
|
|
10076
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
10077
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
10078
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
10079
|
+
* `state`, which already says open or resolved.
|
|
9611
10080
|
*/
|
|
9612
10081
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
9613
10082
|
/**
|
|
@@ -9935,6 +10404,17 @@ export declare const ArtifactFeedbackBatchResponseSchema: v.ObjectSchema<{
|
|
|
9935
10404
|
readonly start: v.NumberSchema<undefined>;
|
|
9936
10405
|
readonly end: v.NumberSchema<undefined>;
|
|
9937
10406
|
}, undefined>, undefined>;
|
|
10407
|
+
/**
|
|
10408
|
+
* Where the passage sits in an `html` page as the reader saw it: a CSS
|
|
10409
|
+
* selector, the tag, and the nearest `aria-label` or heading. Sent when
|
|
10410
|
+
* the passage has no source lines, so an agent can find a block the
|
|
10411
|
+
* page's script built.
|
|
10412
|
+
*/
|
|
10413
|
+
readonly element: v.OptionalSchema<v.ObjectSchema<{
|
|
10414
|
+
readonly selector: v.StringSchema<undefined>;
|
|
10415
|
+
readonly tag: v.StringSchema<undefined>;
|
|
10416
|
+
readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
|
|
10417
|
+
}, undefined>, undefined>;
|
|
9938
10418
|
}, undefined>, undefined>;
|
|
9939
10419
|
/** The comment's text, already wrapped in the response's untrusted markers. */
|
|
9940
10420
|
readonly body: v.StringSchema<undefined>;
|
|
@@ -9953,22 +10433,26 @@ export declare const ArtifactFeedbackBatchResponseSchema: v.ObjectSchema<{
|
|
|
9953
10433
|
readonly prediction: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
9954
10434
|
}, undefined>, undefined>;
|
|
9955
10435
|
/**
|
|
9956
|
-
* Whether the person
|
|
9957
|
-
*
|
|
9958
|
-
*
|
|
9959
|
-
*
|
|
9960
|
-
*
|
|
9961
|
-
*
|
|
10436
|
+
* Whether the person handed a comment Mossbear drafted to their agent. Nothing
|
|
10437
|
+
* hands one over any more, so a current server sends `false` on every Mossbear
|
|
10438
|
+
* comment and omits it on a person's or an agent's; the field stays for
|
|
10439
|
+
* readers that predate `findingState`. It does not say whether the agent may
|
|
10440
|
+
* act: read `findingState` for that, and fall back to `approved: false`
|
|
10441
|
+
* meaning "not yet accepted" only when `findingState` is absent, from a server
|
|
10442
|
+
* that predates it. Only a client that reports a version able to mark drafts
|
|
10443
|
+
* is listed a finding at all, so an older reader that strips this field never
|
|
10444
|
+
* receives one it would misread.
|
|
9962
10445
|
*/
|
|
9963
10446
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
9964
10447
|
/**
|
|
9965
|
-
* Whether an open Mossbear finding is the agent's to act on.
|
|
9966
|
-
*
|
|
9967
|
-
*
|
|
9968
|
-
*
|
|
9969
|
-
*
|
|
9970
|
-
*
|
|
9971
|
-
*
|
|
10448
|
+
* Whether an open Mossbear finding is the agent's to act on. A current server
|
|
10449
|
+
* sends `ready` on every open finding: it is the agent's unless the person
|
|
10450
|
+
* dismisses it, and a dismissed finding is resolved. `waiting`, sent only by
|
|
10451
|
+
* an older server, means it waits on the person: show it to the user and
|
|
10452
|
+
* change nothing unless they say so. Present only on an open Mossbear
|
|
10453
|
+
* comment. A server that predates the field omits it, and a reader then
|
|
10454
|
+
* falls back to `approved`. This is a new name rather than a new meaning for
|
|
10455
|
+
* `state`, which already says open or resolved.
|
|
9972
10456
|
*/
|
|
9973
10457
|
readonly findingState: v.OptionalSchema<v.PicklistSchema<["ready", "waiting"], undefined>, undefined>;
|
|
9974
10458
|
/**
|
|
@@ -10253,6 +10737,51 @@ export declare const ArtifactFeedbackBatchResponseSchema: v.ObjectSchema<{
|
|
|
10253
10737
|
}, undefined>, undefined>;
|
|
10254
10738
|
}, undefined>;
|
|
10255
10739
|
export type ArtifactFeedbackBatchResponse = v.InferOutput<typeof ArtifactFeedbackBatchResponseSchema>;
|
|
10740
|
+
/**
|
|
10741
|
+
* How many artifacts one prompt-time announcement names. The rest are counted
|
|
10742
|
+
* in one line and named on a later prompt, so a session that wrote many
|
|
10743
|
+
* artifacts prints a few lines in front of a turn rather than a list.
|
|
10744
|
+
*/
|
|
10745
|
+
export declare const MAX_SESSION_COMMENT_ANNOUNCEMENT_ARTIFACTS = 5;
|
|
10746
|
+
/**
|
|
10747
|
+
* Ask which artifacts this agent session wrote carry open comments, and which
|
|
10748
|
+
* (`agent-hears-new-artifact-comments` slice 3).
|
|
10749
|
+
*
|
|
10750
|
+
* **A read, not a write.** Which of those comments the session has already been
|
|
10751
|
+
* told about is kept beside the session, by comment id. Not by creation time:
|
|
10752
|
+
* a comment can become readable long after it was created (a finding its owner
|
|
10753
|
+
* approves, an artifact restored from the Trash), and a time cursor would have
|
|
10754
|
+
* passed it by. The session-start announcement's per-repo count is a different
|
|
10755
|
+
* question and is not touched.
|
|
10756
|
+
*/
|
|
10757
|
+
export declare const AnnounceSessionCommentsRequestSchema: v.ObjectSchema<{
|
|
10758
|
+
/**
|
|
10759
|
+
* The harness's own id for the session, as artifact writes record it in a
|
|
10760
|
+
* version's metadata. Matched only against versions the caller's account
|
|
10761
|
+
* wrote, so naming another account's session finds nothing.
|
|
10762
|
+
*/
|
|
10763
|
+
readonly agentSessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>]>;
|
|
10764
|
+
/** The repo asking, as its committed config declares it, for repo-scoped findings. */
|
|
10765
|
+
readonly projectId: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "projectId must contain only letters, digits, underscore, dot or hyphen">]>, undefined>;
|
|
10766
|
+
}, undefined>;
|
|
10767
|
+
export type AnnounceSessionCommentsRequest = v.InferOutput<typeof AnnounceSessionCommentsRequestSchema>;
|
|
10768
|
+
export declare const AnnounceSessionCommentsResponseSchema: v.ObjectSchema<{
|
|
10769
|
+
/**
|
|
10770
|
+
* The session's artifacts that carry open comments, most recently commented
|
|
10771
|
+
* first; at most as many as one batch feedback read takes.
|
|
10772
|
+
*/
|
|
10773
|
+
readonly artifacts: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
|
|
10774
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
10775
|
+
readonly name: v.StringSchema<undefined>;
|
|
10776
|
+
/** Its open comments, newest first, at most one wire allowance of them. */
|
|
10777
|
+
readonly commentIds: v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>, v.MinLengthAction<string[], 1, undefined>, v.MaxLengthAction<string[], 20, undefined>]>;
|
|
10778
|
+
}, undefined>, undefined>, v.MaxLengthAction<{
|
|
10779
|
+
id: string;
|
|
10780
|
+
name: string;
|
|
10781
|
+
commentIds: string[];
|
|
10782
|
+
}[], 25, undefined>]>;
|
|
10783
|
+
}, undefined>;
|
|
10784
|
+
export type AnnounceSessionCommentsResponse = v.InferOutput<typeof AnnounceSessionCommentsResponseSchema>;
|
|
10256
10785
|
export declare const SessionGradeRequestSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
|
|
10257
10786
|
readonly session: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>, v.CheckAction<string, "identifier must not contain control characters">]>, undefined>;
|
|
10258
10787
|
readonly agent_session: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 256, undefined>, v.CheckAction<string, "identifier must not contain control characters">]>, undefined>;
|
|
@@ -10962,8 +11491,10 @@ export declare const SearchArtifactCommentHitSchema: v.ObjectSchema<{
|
|
|
10962
11491
|
*/
|
|
10963
11492
|
readonly matchedIn: v.PicklistSchema<["body", "suggestion"], undefined>;
|
|
10964
11493
|
/**
|
|
10965
|
-
*
|
|
10966
|
-
*
|
|
11494
|
+
* Whether a Mossbear finding's owner handed it to their agents. Nothing hands
|
|
11495
|
+
* one over any more, so a current server sends `false`. It does not say
|
|
11496
|
+
* whether an agent may act on it: every open finding is ready unless
|
|
11497
|
+
* dismissed. Absent on a person's or an agent's comment and on a reply.
|
|
10967
11498
|
*/
|
|
10968
11499
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
10969
11500
|
readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
@@ -11015,8 +11546,10 @@ export declare const SearchCommentHitSchema: v.VariantSchema<"subjectKind", [v.O
|
|
|
11015
11546
|
*/
|
|
11016
11547
|
readonly matchedIn: v.PicklistSchema<["body", "suggestion"], undefined>;
|
|
11017
11548
|
/**
|
|
11018
|
-
*
|
|
11019
|
-
*
|
|
11549
|
+
* Whether a Mossbear finding's owner handed it to their agents. Nothing hands
|
|
11550
|
+
* one over any more, so a current server sends `false`. It does not say
|
|
11551
|
+
* whether an agent may act on it: every open finding is ready unless
|
|
11552
|
+
* dismissed. Absent on a person's or an agent's comment and on a reply.
|
|
11020
11553
|
*/
|
|
11021
11554
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
11022
11555
|
readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
@@ -11233,8 +11766,10 @@ export declare const SearchCommentsReportSchema: v.VariantSchema<"status", [v.Ob
|
|
|
11233
11766
|
*/
|
|
11234
11767
|
readonly matchedIn: v.PicklistSchema<["body", "suggestion"], undefined>;
|
|
11235
11768
|
/**
|
|
11236
|
-
*
|
|
11237
|
-
*
|
|
11769
|
+
* Whether a Mossbear finding's owner handed it to their agents. Nothing hands
|
|
11770
|
+
* one over any more, so a current server sends `false`. It does not say
|
|
11771
|
+
* whether an agent may act on it: every open finding is ready unless
|
|
11772
|
+
* dismissed. Absent on a person's or an agent's comment and on a reply.
|
|
11238
11773
|
*/
|
|
11239
11774
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
11240
11775
|
readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
@@ -11477,8 +12012,10 @@ export declare const SearchResponseSchema: v.ObjectSchema<{
|
|
|
11477
12012
|
*/
|
|
11478
12013
|
readonly matchedIn: v.PicklistSchema<["body", "suggestion"], undefined>;
|
|
11479
12014
|
/**
|
|
11480
|
-
*
|
|
11481
|
-
*
|
|
12015
|
+
* Whether a Mossbear finding's owner handed it to their agents. Nothing hands
|
|
12016
|
+
* one over any more, so a current server sends `false`. It does not say
|
|
12017
|
+
* whether an agent may act on it: every open finding is ready unless
|
|
12018
|
+
* dismissed. Absent on a person's or an agent's comment and on a reply.
|
|
11482
12019
|
*/
|
|
11483
12020
|
readonly approved: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
|
|
11484
12021
|
readonly commentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
@@ -11805,6 +12342,11 @@ export declare function parseContextItemsResponse(data: unknown): {
|
|
|
11805
12342
|
start: number;
|
|
11806
12343
|
end: number;
|
|
11807
12344
|
} | null;
|
|
12345
|
+
element?: {
|
|
12346
|
+
selector: string;
|
|
12347
|
+
tag: string;
|
|
12348
|
+
label?: string | undefined;
|
|
12349
|
+
} | undefined;
|
|
11808
12350
|
} | undefined;
|
|
11809
12351
|
body: string;
|
|
11810
12352
|
finding?: {
|
|
@@ -11892,6 +12434,11 @@ export declare function parseBundleArtifactsResponse(data: unknown): {
|
|
|
11892
12434
|
start: number;
|
|
11893
12435
|
end: number;
|
|
11894
12436
|
} | null;
|
|
12437
|
+
element?: {
|
|
12438
|
+
selector: string;
|
|
12439
|
+
tag: string;
|
|
12440
|
+
label?: string | undefined;
|
|
12441
|
+
} | undefined;
|
|
11895
12442
|
} | undefined;
|
|
11896
12443
|
body: string;
|
|
11897
12444
|
finding?: {
|
|
@@ -12222,6 +12769,13 @@ export declare function parseAnnounceItemCommentsResponse(data: unknown): {
|
|
|
12222
12769
|
open: number;
|
|
12223
12770
|
announced: number;
|
|
12224
12771
|
};
|
|
12772
|
+
export declare function parseAnnounceSessionCommentsResponse(data: unknown): {
|
|
12773
|
+
artifacts: {
|
|
12774
|
+
id: string;
|
|
12775
|
+
name: string;
|
|
12776
|
+
commentIds: string[];
|
|
12777
|
+
}[];
|
|
12778
|
+
};
|
|
12225
12779
|
export declare function parseAgentCommentResponse(data: unknown): {
|
|
12226
12780
|
created: boolean;
|
|
12227
12781
|
comment: {
|
|
@@ -12248,6 +12802,11 @@ export declare function parseItemCommentsResponse(data: unknown): {
|
|
|
12248
12802
|
start: number;
|
|
12249
12803
|
end: number;
|
|
12250
12804
|
} | null;
|
|
12805
|
+
element?: {
|
|
12806
|
+
selector: string;
|
|
12807
|
+
tag: string;
|
|
12808
|
+
label?: string | undefined;
|
|
12809
|
+
} | undefined;
|
|
12251
12810
|
} | undefined;
|
|
12252
12811
|
body: string;
|
|
12253
12812
|
finding?: {
|