@mossbear/protocol 0.1.0-alpha.52 → 0.1.0-alpha.53
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/schemas.d.ts +562 -101
- package/dist/schemas.d.ts.map +1 -1
- package/dist/schemas.js +106 -76
- package/dist/schemas.js.map +1 -1
- package/dist/schemas.test.js +13 -0
- package/dist/schemas.test.js.map +1 -1
- package/package.json +1 -1
package/dist/schemas.d.ts
CHANGED
|
@@ -852,6 +852,93 @@ export declare const GuideAliasSchema: v.ObjectSchema<{
|
|
|
852
852
|
readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>;
|
|
853
853
|
}, undefined>;
|
|
854
854
|
export type GuideAlias = v.InferOutput<typeof GuideAliasSchema>;
|
|
855
|
+
/**
|
|
856
|
+
* The markers every untrusted block in a response is wrapped in, plus a
|
|
857
|
+
* statement of what they mean.
|
|
858
|
+
*
|
|
859
|
+
* Generated per response from the content itself, so no marker-like text
|
|
860
|
+
* inside a block can end it early — a property `deriveDelimiterToken` checks
|
|
861
|
+
* rather than assumes.
|
|
862
|
+
*
|
|
863
|
+
* Named for the guide-history response it was written for and shared by every
|
|
864
|
+
* payload that places somebody else's words in front of an agent: a grade's
|
|
865
|
+
* reasoning, and now an item's notes. One marker scheme, not one per payload —
|
|
866
|
+
* a second scheme is a second thing a reader has to be taught to respect.
|
|
867
|
+
* Declared here, above its first user, rather than beside that response.
|
|
868
|
+
*/
|
|
869
|
+
export declare const GuideHistoryUntrustedSchema: v.ObjectSchema<{
|
|
870
|
+
readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
871
|
+
readonly startMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
872
|
+
readonly endMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
873
|
+
readonly note: v.StringSchema<undefined>;
|
|
874
|
+
}, undefined>;
|
|
875
|
+
export type GuideHistoryUntrusted = v.InferOutput<typeof GuideHistoryUntrustedSchema>;
|
|
876
|
+
/**
|
|
877
|
+
* How many open notes one item carries on the wire, newest first.
|
|
878
|
+
*
|
|
879
|
+
* A wire bound, not a product limit: the write side refuses the note that
|
|
880
|
+
* would exceed it *by name* (see the dashboard's note mutator), so this cap is
|
|
881
|
+
* never the thing that silently drops a request a person left.
|
|
882
|
+
*/
|
|
883
|
+
export declare const MAX_ITEM_NOTES_ON_WIRE = 20;
|
|
884
|
+
/**
|
|
885
|
+
* One note a **person** left about a context item, riding the item it is about.
|
|
886
|
+
*
|
|
887
|
+
* A note is not an item: it is not a member, not projected, not versioned and
|
|
888
|
+
* not capturable. It travels on the item so that it inherits every delivery
|
|
889
|
+
* decision the item already went through — workspace scope, the archived drop,
|
|
890
|
+
* the response limit, the subscriber's mute — rather than restating them.
|
|
891
|
+
*
|
|
892
|
+
* **Every `body` here is already wrapped in the response's untrusted markers**
|
|
893
|
+
* (`ContextItemsResponseSchema.untrusted`). A reader emits the bytes as it
|
|
894
|
+
* received them and never re-wraps them: the markers are derived against the
|
|
895
|
+
* bodies the server sent, so a second wrapping cannot claim the same guarantee.
|
|
896
|
+
*/
|
|
897
|
+
export declare const ContextItemNoteSchema: v.ObjectSchema<{
|
|
898
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
899
|
+
/** The note's text, already wrapped in the response's untrusted markers. */
|
|
900
|
+
readonly body: v.StringSchema<undefined>;
|
|
901
|
+
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
902
|
+
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
903
|
+
/** ISO timestamp, machine format. */
|
|
904
|
+
readonly createdAt: v.StringSchema<undefined>;
|
|
905
|
+
/** The item's content version the note was written against. */
|
|
906
|
+
readonly itemVersion: v.NumberSchema<undefined>;
|
|
907
|
+
/** True when the item's current version is greater than `itemVersion`. */
|
|
908
|
+
readonly itemChangedSince: v.BooleanSchema<undefined>;
|
|
909
|
+
/**
|
|
910
|
+
* How many agent reads were handed this note **before** this one — so a
|
|
911
|
+
* note reaching an agent for the first time reports `0`.
|
|
912
|
+
*
|
|
913
|
+
* It is the stored count as it read at the moment the response was built;
|
|
914
|
+
* the serve this response *is* has not been counted yet. Excluded rather
|
|
915
|
+
* than included because the count is recorded best-effort: a response that
|
|
916
|
+
* claimed to include itself would be wrong whenever that record failed, and
|
|
917
|
+
* a number that is sometimes off by one is worse than one that is
|
|
918
|
+
* consistently the prior total.
|
|
919
|
+
*
|
|
920
|
+
* So `deliveredCount > 0` means an earlier read was handed this note, and
|
|
921
|
+
* `0` means this read is the first. Neither says a model took it in — only
|
|
922
|
+
* that the server handed it over.
|
|
923
|
+
*/
|
|
924
|
+
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
925
|
+
/**
|
|
926
|
+
* This note's thread root — its own id for every note written today, since
|
|
927
|
+
* no reply exists yet. Ignorable now; load-bearing once a reply is a second
|
|
928
|
+
* row with a different id here. It is on the wire from the first response
|
|
929
|
+
* because the wire contract is consumed by installed CLI versions: reshaping
|
|
930
|
+
* a flat `notes` array into threads-of-notes later would be a breaking
|
|
931
|
+
* change, while a field today's readers ignore costs them nothing.
|
|
932
|
+
*/
|
|
933
|
+
readonly threadId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
934
|
+
/**
|
|
935
|
+
* Always `null` today — no reply exists to point at. Present now so an older
|
|
936
|
+
* reader meeting a future response that carries real replies degrades to
|
|
937
|
+
* "a flat list of notes" rather than failing to parse.
|
|
938
|
+
*/
|
|
939
|
+
readonly replyToId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
|
|
940
|
+
}, undefined>;
|
|
941
|
+
export type ContextItemNote = v.InferOutput<typeof ContextItemNoteSchema>;
|
|
855
942
|
export declare const ContextItemSchema: v.ObjectSchema<{
|
|
856
943
|
readonly id: v.StringSchema<undefined>;
|
|
857
944
|
readonly type: v.PicklistSchema<string[], undefined>;
|
|
@@ -884,6 +971,71 @@ export declare const ContextItemSchema: v.ObjectSchema<{
|
|
|
884
971
|
root: "project" | "global";
|
|
885
972
|
path: string;
|
|
886
973
|
}[], 8, undefined>]>, undefined>;
|
|
974
|
+
/**
|
|
975
|
+
* Open notes a person left about this item, newest first.
|
|
976
|
+
*
|
|
977
|
+
* Optional, and absent rather than empty when there are none — the same rule
|
|
978
|
+
* `aliases` and `projectId` follow above, and for the same reason: an older
|
|
979
|
+
* reader against a newer server ignores the key, and a newer reader against
|
|
980
|
+
* an older server reads "no notes" instead of failing.
|
|
981
|
+
*
|
|
982
|
+
* **Absence is not a verdict.** No notes here means none were served on this
|
|
983
|
+
* item in this response — not that nobody has anything to say about it.
|
|
984
|
+
*/
|
|
985
|
+
readonly notes: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
|
|
986
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
987
|
+
/** The note's text, already wrapped in the response's untrusted markers. */
|
|
988
|
+
readonly body: v.StringSchema<undefined>;
|
|
989
|
+
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
990
|
+
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
991
|
+
/** ISO timestamp, machine format. */
|
|
992
|
+
readonly createdAt: v.StringSchema<undefined>;
|
|
993
|
+
/** The item's content version the note was written against. */
|
|
994
|
+
readonly itemVersion: v.NumberSchema<undefined>;
|
|
995
|
+
/** True when the item's current version is greater than `itemVersion`. */
|
|
996
|
+
readonly itemChangedSince: v.BooleanSchema<undefined>;
|
|
997
|
+
/**
|
|
998
|
+
* How many agent reads were handed this note **before** this one — so a
|
|
999
|
+
* note reaching an agent for the first time reports `0`.
|
|
1000
|
+
*
|
|
1001
|
+
* It is the stored count as it read at the moment the response was built;
|
|
1002
|
+
* the serve this response *is* has not been counted yet. Excluded rather
|
|
1003
|
+
* than included because the count is recorded best-effort: a response that
|
|
1004
|
+
* claimed to include itself would be wrong whenever that record failed, and
|
|
1005
|
+
* a number that is sometimes off by one is worse than one that is
|
|
1006
|
+
* consistently the prior total.
|
|
1007
|
+
*
|
|
1008
|
+
* So `deliveredCount > 0` means an earlier read was handed this note, and
|
|
1009
|
+
* `0` means this read is the first. Neither says a model took it in — only
|
|
1010
|
+
* that the server handed it over.
|
|
1011
|
+
*/
|
|
1012
|
+
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
1013
|
+
/**
|
|
1014
|
+
* This note's thread root — its own id for every note written today, since
|
|
1015
|
+
* no reply exists yet. Ignorable now; load-bearing once a reply is a second
|
|
1016
|
+
* row with a different id here. It is on the wire from the first response
|
|
1017
|
+
* because the wire contract is consumed by installed CLI versions: reshaping
|
|
1018
|
+
* a flat `notes` array into threads-of-notes later would be a breaking
|
|
1019
|
+
* change, while a field today's readers ignore costs them nothing.
|
|
1020
|
+
*/
|
|
1021
|
+
readonly threadId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1022
|
+
/**
|
|
1023
|
+
* Always `null` today — no reply exists to point at. Present now so an older
|
|
1024
|
+
* reader meeting a future response that carries real replies degrades to
|
|
1025
|
+
* "a flat list of notes" rather than failing to parse.
|
|
1026
|
+
*/
|
|
1027
|
+
readonly replyToId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
|
|
1028
|
+
}, undefined>, undefined>, v.MaxLengthAction<{
|
|
1029
|
+
id: string;
|
|
1030
|
+
body: string;
|
|
1031
|
+
authorName: string | null;
|
|
1032
|
+
createdAt: string;
|
|
1033
|
+
itemVersion: number;
|
|
1034
|
+
itemChangedSince: boolean;
|
|
1035
|
+
deliveredCount: number;
|
|
1036
|
+
threadId: string;
|
|
1037
|
+
replyToId: string | null;
|
|
1038
|
+
}[], 20, undefined>]>, undefined>;
|
|
887
1039
|
readonly updatedAt: v.StringSchema<undefined>;
|
|
888
1040
|
}, undefined>;
|
|
889
1041
|
export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
@@ -919,8 +1071,84 @@ export declare const ContextItemsResponseSchema: v.ObjectSchema<{
|
|
|
919
1071
|
root: "project" | "global";
|
|
920
1072
|
path: string;
|
|
921
1073
|
}[], 8, undefined>]>, undefined>;
|
|
1074
|
+
/**
|
|
1075
|
+
* Open notes a person left about this item, newest first.
|
|
1076
|
+
*
|
|
1077
|
+
* Optional, and absent rather than empty when there are none — the same rule
|
|
1078
|
+
* `aliases` and `projectId` follow above, and for the same reason: an older
|
|
1079
|
+
* reader against a newer server ignores the key, and a newer reader against
|
|
1080
|
+
* an older server reads "no notes" instead of failing.
|
|
1081
|
+
*
|
|
1082
|
+
* **Absence is not a verdict.** No notes here means none were served on this
|
|
1083
|
+
* item in this response — not that nobody has anything to say about it.
|
|
1084
|
+
*/
|
|
1085
|
+
readonly notes: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
|
|
1086
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1087
|
+
/** The note's text, already wrapped in the response's untrusted markers. */
|
|
1088
|
+
readonly body: v.StringSchema<undefined>;
|
|
1089
|
+
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
1090
|
+
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
1091
|
+
/** ISO timestamp, machine format. */
|
|
1092
|
+
readonly createdAt: v.StringSchema<undefined>;
|
|
1093
|
+
/** The item's content version the note was written against. */
|
|
1094
|
+
readonly itemVersion: v.NumberSchema<undefined>;
|
|
1095
|
+
/** True when the item's current version is greater than `itemVersion`. */
|
|
1096
|
+
readonly itemChangedSince: v.BooleanSchema<undefined>;
|
|
1097
|
+
/**
|
|
1098
|
+
* How many agent reads were handed this note **before** this one — so a
|
|
1099
|
+
* note reaching an agent for the first time reports `0`.
|
|
1100
|
+
*
|
|
1101
|
+
* It is the stored count as it read at the moment the response was built;
|
|
1102
|
+
* the serve this response *is* has not been counted yet. Excluded rather
|
|
1103
|
+
* than included because the count is recorded best-effort: a response that
|
|
1104
|
+
* claimed to include itself would be wrong whenever that record failed, and
|
|
1105
|
+
* a number that is sometimes off by one is worse than one that is
|
|
1106
|
+
* consistently the prior total.
|
|
1107
|
+
*
|
|
1108
|
+
* So `deliveredCount > 0` means an earlier read was handed this note, and
|
|
1109
|
+
* `0` means this read is the first. Neither says a model took it in — only
|
|
1110
|
+
* that the server handed it over.
|
|
1111
|
+
*/
|
|
1112
|
+
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
1113
|
+
/**
|
|
1114
|
+
* This note's thread root — its own id for every note written today, since
|
|
1115
|
+
* no reply exists yet. Ignorable now; load-bearing once a reply is a second
|
|
1116
|
+
* row with a different id here. It is on the wire from the first response
|
|
1117
|
+
* because the wire contract is consumed by installed CLI versions: reshaping
|
|
1118
|
+
* a flat `notes` array into threads-of-notes later would be a breaking
|
|
1119
|
+
* change, while a field today's readers ignore costs them nothing.
|
|
1120
|
+
*/
|
|
1121
|
+
readonly threadId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1122
|
+
/**
|
|
1123
|
+
* Always `null` today — no reply exists to point at. Present now so an older
|
|
1124
|
+
* reader meeting a future response that carries real replies degrades to
|
|
1125
|
+
* "a flat list of notes" rather than failing to parse.
|
|
1126
|
+
*/
|
|
1127
|
+
readonly replyToId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
|
|
1128
|
+
}, undefined>, undefined>, v.MaxLengthAction<{
|
|
1129
|
+
id: string;
|
|
1130
|
+
body: string;
|
|
1131
|
+
authorName: string | null;
|
|
1132
|
+
createdAt: string;
|
|
1133
|
+
itemVersion: number;
|
|
1134
|
+
itemChangedSince: boolean;
|
|
1135
|
+
deliveredCount: number;
|
|
1136
|
+
threadId: string;
|
|
1137
|
+
replyToId: string | null;
|
|
1138
|
+
}[], 20, undefined>]>, undefined>;
|
|
922
1139
|
readonly updatedAt: v.StringSchema<undefined>;
|
|
923
1140
|
}, undefined>, undefined>;
|
|
1141
|
+
/**
|
|
1142
|
+
* The markers every note `body` in this response is wrapped in, plus a
|
|
1143
|
+
* statement of what they mean. Present exactly when at least one item
|
|
1144
|
+
* carries a note — there is nothing to delimit otherwise.
|
|
1145
|
+
*/
|
|
1146
|
+
readonly untrusted: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
|
|
1147
|
+
readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1148
|
+
readonly startMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1149
|
+
readonly endMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1150
|
+
readonly note: v.StringSchema<undefined>;
|
|
1151
|
+
}, undefined>, undefined>, undefined>;
|
|
924
1152
|
}, undefined>;
|
|
925
1153
|
/** Max number of context item ids a push may cite as its transform sources. */
|
|
926
1154
|
export declare const MAX_TRANSFORM_SOURCE_IDS = 100;
|
|
@@ -986,6 +1214,71 @@ export declare const PushContextResponseSchema: v.ObjectSchema<{
|
|
|
986
1214
|
root: "project" | "global";
|
|
987
1215
|
path: string;
|
|
988
1216
|
}[], 8, undefined>]>, undefined>;
|
|
1217
|
+
/**
|
|
1218
|
+
* Open notes a person left about this item, newest first.
|
|
1219
|
+
*
|
|
1220
|
+
* Optional, and absent rather than empty when there are none — the same rule
|
|
1221
|
+
* `aliases` and `projectId` follow above, and for the same reason: an older
|
|
1222
|
+
* reader against a newer server ignores the key, and a newer reader against
|
|
1223
|
+
* an older server reads "no notes" instead of failing.
|
|
1224
|
+
*
|
|
1225
|
+
* **Absence is not a verdict.** No notes here means none were served on this
|
|
1226
|
+
* item in this response — not that nobody has anything to say about it.
|
|
1227
|
+
*/
|
|
1228
|
+
readonly notes: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
|
|
1229
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1230
|
+
/** The note's text, already wrapped in the response's untrusted markers. */
|
|
1231
|
+
readonly body: v.StringSchema<undefined>;
|
|
1232
|
+
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
1233
|
+
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
1234
|
+
/** ISO timestamp, machine format. */
|
|
1235
|
+
readonly createdAt: v.StringSchema<undefined>;
|
|
1236
|
+
/** The item's content version the note was written against. */
|
|
1237
|
+
readonly itemVersion: v.NumberSchema<undefined>;
|
|
1238
|
+
/** True when the item's current version is greater than `itemVersion`. */
|
|
1239
|
+
readonly itemChangedSince: v.BooleanSchema<undefined>;
|
|
1240
|
+
/**
|
|
1241
|
+
* How many agent reads were handed this note **before** this one — so a
|
|
1242
|
+
* note reaching an agent for the first time reports `0`.
|
|
1243
|
+
*
|
|
1244
|
+
* It is the stored count as it read at the moment the response was built;
|
|
1245
|
+
* the serve this response *is* has not been counted yet. Excluded rather
|
|
1246
|
+
* than included because the count is recorded best-effort: a response that
|
|
1247
|
+
* claimed to include itself would be wrong whenever that record failed, and
|
|
1248
|
+
* a number that is sometimes off by one is worse than one that is
|
|
1249
|
+
* consistently the prior total.
|
|
1250
|
+
*
|
|
1251
|
+
* So `deliveredCount > 0` means an earlier read was handed this note, and
|
|
1252
|
+
* `0` means this read is the first. Neither says a model took it in — only
|
|
1253
|
+
* that the server handed it over.
|
|
1254
|
+
*/
|
|
1255
|
+
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
1256
|
+
/**
|
|
1257
|
+
* This note's thread root — its own id for every note written today, since
|
|
1258
|
+
* no reply exists yet. Ignorable now; load-bearing once a reply is a second
|
|
1259
|
+
* row with a different id here. It is on the wire from the first response
|
|
1260
|
+
* because the wire contract is consumed by installed CLI versions: reshaping
|
|
1261
|
+
* a flat `notes` array into threads-of-notes later would be a breaking
|
|
1262
|
+
* change, while a field today's readers ignore costs them nothing.
|
|
1263
|
+
*/
|
|
1264
|
+
readonly threadId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1265
|
+
/**
|
|
1266
|
+
* Always `null` today — no reply exists to point at. Present now so an older
|
|
1267
|
+
* reader meeting a future response that carries real replies degrades to
|
|
1268
|
+
* "a flat list of notes" rather than failing to parse.
|
|
1269
|
+
*/
|
|
1270
|
+
readonly replyToId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
|
|
1271
|
+
}, undefined>, undefined>, v.MaxLengthAction<{
|
|
1272
|
+
id: string;
|
|
1273
|
+
body: string;
|
|
1274
|
+
authorName: string | null;
|
|
1275
|
+
createdAt: string;
|
|
1276
|
+
itemVersion: number;
|
|
1277
|
+
itemChangedSince: boolean;
|
|
1278
|
+
deliveredCount: number;
|
|
1279
|
+
threadId: string;
|
|
1280
|
+
replyToId: string | null;
|
|
1281
|
+
}[], 20, undefined>]>, undefined>;
|
|
989
1282
|
readonly updatedAt: v.StringSchema<undefined>;
|
|
990
1283
|
}, undefined>;
|
|
991
1284
|
readonly created: v.BooleanSchema<undefined>;
|
|
@@ -1037,6 +1330,71 @@ export declare const UpdateContextItemResponseSchema: v.ObjectSchema<{
|
|
|
1037
1330
|
root: "project" | "global";
|
|
1038
1331
|
path: string;
|
|
1039
1332
|
}[], 8, undefined>]>, undefined>;
|
|
1333
|
+
/**
|
|
1334
|
+
* Open notes a person left about this item, newest first.
|
|
1335
|
+
*
|
|
1336
|
+
* Optional, and absent rather than empty when there are none — the same rule
|
|
1337
|
+
* `aliases` and `projectId` follow above, and for the same reason: an older
|
|
1338
|
+
* reader against a newer server ignores the key, and a newer reader against
|
|
1339
|
+
* an older server reads "no notes" instead of failing.
|
|
1340
|
+
*
|
|
1341
|
+
* **Absence is not a verdict.** No notes here means none were served on this
|
|
1342
|
+
* item in this response — not that nobody has anything to say about it.
|
|
1343
|
+
*/
|
|
1344
|
+
readonly notes: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
|
|
1345
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1346
|
+
/** The note's text, already wrapped in the response's untrusted markers. */
|
|
1347
|
+
readonly body: v.StringSchema<undefined>;
|
|
1348
|
+
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
1349
|
+
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
1350
|
+
/** ISO timestamp, machine format. */
|
|
1351
|
+
readonly createdAt: v.StringSchema<undefined>;
|
|
1352
|
+
/** The item's content version the note was written against. */
|
|
1353
|
+
readonly itemVersion: v.NumberSchema<undefined>;
|
|
1354
|
+
/** True when the item's current version is greater than `itemVersion`. */
|
|
1355
|
+
readonly itemChangedSince: v.BooleanSchema<undefined>;
|
|
1356
|
+
/**
|
|
1357
|
+
* How many agent reads were handed this note **before** this one — so a
|
|
1358
|
+
* note reaching an agent for the first time reports `0`.
|
|
1359
|
+
*
|
|
1360
|
+
* It is the stored count as it read at the moment the response was built;
|
|
1361
|
+
* the serve this response *is* has not been counted yet. Excluded rather
|
|
1362
|
+
* than included because the count is recorded best-effort: a response that
|
|
1363
|
+
* claimed to include itself would be wrong whenever that record failed, and
|
|
1364
|
+
* a number that is sometimes off by one is worse than one that is
|
|
1365
|
+
* consistently the prior total.
|
|
1366
|
+
*
|
|
1367
|
+
* So `deliveredCount > 0` means an earlier read was handed this note, and
|
|
1368
|
+
* `0` means this read is the first. Neither says a model took it in — only
|
|
1369
|
+
* that the server handed it over.
|
|
1370
|
+
*/
|
|
1371
|
+
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
1372
|
+
/**
|
|
1373
|
+
* This note's thread root — its own id for every note written today, since
|
|
1374
|
+
* no reply exists yet. Ignorable now; load-bearing once a reply is a second
|
|
1375
|
+
* row with a different id here. It is on the wire from the first response
|
|
1376
|
+
* because the wire contract is consumed by installed CLI versions: reshaping
|
|
1377
|
+
* a flat `notes` array into threads-of-notes later would be a breaking
|
|
1378
|
+
* change, while a field today's readers ignore costs them nothing.
|
|
1379
|
+
*/
|
|
1380
|
+
readonly threadId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1381
|
+
/**
|
|
1382
|
+
* Always `null` today — no reply exists to point at. Present now so an older
|
|
1383
|
+
* reader meeting a future response that carries real replies degrades to
|
|
1384
|
+
* "a flat list of notes" rather than failing to parse.
|
|
1385
|
+
*/
|
|
1386
|
+
readonly replyToId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
|
|
1387
|
+
}, undefined>, undefined>, v.MaxLengthAction<{
|
|
1388
|
+
id: string;
|
|
1389
|
+
body: string;
|
|
1390
|
+
authorName: string | null;
|
|
1391
|
+
createdAt: string;
|
|
1392
|
+
itemVersion: number;
|
|
1393
|
+
itemChangedSince: boolean;
|
|
1394
|
+
deliveredCount: number;
|
|
1395
|
+
threadId: string;
|
|
1396
|
+
replyToId: string | null;
|
|
1397
|
+
}[], 20, undefined>]>, undefined>;
|
|
1040
1398
|
readonly updatedAt: v.StringSchema<undefined>;
|
|
1041
1399
|
}, undefined>;
|
|
1042
1400
|
readonly updated: v.BooleanSchema<undefined>;
|
|
@@ -1141,6 +1499,71 @@ export declare const ContextItemResponseSchema: v.ObjectSchema<{
|
|
|
1141
1499
|
root: "project" | "global";
|
|
1142
1500
|
path: string;
|
|
1143
1501
|
}[], 8, undefined>]>, undefined>;
|
|
1502
|
+
/**
|
|
1503
|
+
* Open notes a person left about this item, newest first.
|
|
1504
|
+
*
|
|
1505
|
+
* Optional, and absent rather than empty when there are none — the same rule
|
|
1506
|
+
* `aliases` and `projectId` follow above, and for the same reason: an older
|
|
1507
|
+
* reader against a newer server ignores the key, and a newer reader against
|
|
1508
|
+
* an older server reads "no notes" instead of failing.
|
|
1509
|
+
*
|
|
1510
|
+
* **Absence is not a verdict.** No notes here means none were served on this
|
|
1511
|
+
* item in this response — not that nobody has anything to say about it.
|
|
1512
|
+
*/
|
|
1513
|
+
readonly notes: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
|
|
1514
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1515
|
+
/** The note's text, already wrapped in the response's untrusted markers. */
|
|
1516
|
+
readonly body: v.StringSchema<undefined>;
|
|
1517
|
+
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
1518
|
+
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
1519
|
+
/** ISO timestamp, machine format. */
|
|
1520
|
+
readonly createdAt: v.StringSchema<undefined>;
|
|
1521
|
+
/** The item's content version the note was written against. */
|
|
1522
|
+
readonly itemVersion: v.NumberSchema<undefined>;
|
|
1523
|
+
/** True when the item's current version is greater than `itemVersion`. */
|
|
1524
|
+
readonly itemChangedSince: v.BooleanSchema<undefined>;
|
|
1525
|
+
/**
|
|
1526
|
+
* How many agent reads were handed this note **before** this one — so a
|
|
1527
|
+
* note reaching an agent for the first time reports `0`.
|
|
1528
|
+
*
|
|
1529
|
+
* It is the stored count as it read at the moment the response was built;
|
|
1530
|
+
* the serve this response *is* has not been counted yet. Excluded rather
|
|
1531
|
+
* than included because the count is recorded best-effort: a response that
|
|
1532
|
+
* claimed to include itself would be wrong whenever that record failed, and
|
|
1533
|
+
* a number that is sometimes off by one is worse than one that is
|
|
1534
|
+
* consistently the prior total.
|
|
1535
|
+
*
|
|
1536
|
+
* So `deliveredCount > 0` means an earlier read was handed this note, and
|
|
1537
|
+
* `0` means this read is the first. Neither says a model took it in — only
|
|
1538
|
+
* that the server handed it over.
|
|
1539
|
+
*/
|
|
1540
|
+
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
1541
|
+
/**
|
|
1542
|
+
* This note's thread root — its own id for every note written today, since
|
|
1543
|
+
* no reply exists yet. Ignorable now; load-bearing once a reply is a second
|
|
1544
|
+
* row with a different id here. It is on the wire from the first response
|
|
1545
|
+
* because the wire contract is consumed by installed CLI versions: reshaping
|
|
1546
|
+
* a flat `notes` array into threads-of-notes later would be a breaking
|
|
1547
|
+
* change, while a field today's readers ignore costs them nothing.
|
|
1548
|
+
*/
|
|
1549
|
+
readonly threadId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1550
|
+
/**
|
|
1551
|
+
* Always `null` today — no reply exists to point at. Present now so an older
|
|
1552
|
+
* reader meeting a future response that carries real replies degrades to
|
|
1553
|
+
* "a flat list of notes" rather than failing to parse.
|
|
1554
|
+
*/
|
|
1555
|
+
readonly replyToId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
|
|
1556
|
+
}, undefined>, undefined>, v.MaxLengthAction<{
|
|
1557
|
+
id: string;
|
|
1558
|
+
body: string;
|
|
1559
|
+
authorName: string | null;
|
|
1560
|
+
createdAt: string;
|
|
1561
|
+
itemVersion: number;
|
|
1562
|
+
itemChangedSince: boolean;
|
|
1563
|
+
deliveredCount: number;
|
|
1564
|
+
threadId: string;
|
|
1565
|
+
replyToId: string | null;
|
|
1566
|
+
}[], 20, undefined>]>, undefined>;
|
|
1144
1567
|
readonly updatedAt: v.StringSchema<undefined>;
|
|
1145
1568
|
}, undefined>;
|
|
1146
1569
|
}, undefined>;
|
|
@@ -1178,6 +1601,71 @@ export declare const ArchiveContextItemResponseSchema: v.ObjectSchema<{
|
|
|
1178
1601
|
root: "project" | "global";
|
|
1179
1602
|
path: string;
|
|
1180
1603
|
}[], 8, undefined>]>, undefined>;
|
|
1604
|
+
/**
|
|
1605
|
+
* Open notes a person left about this item, newest first.
|
|
1606
|
+
*
|
|
1607
|
+
* Optional, and absent rather than empty when there are none — the same rule
|
|
1608
|
+
* `aliases` and `projectId` follow above, and for the same reason: an older
|
|
1609
|
+
* reader against a newer server ignores the key, and a newer reader against
|
|
1610
|
+
* an older server reads "no notes" instead of failing.
|
|
1611
|
+
*
|
|
1612
|
+
* **Absence is not a verdict.** No notes here means none were served on this
|
|
1613
|
+
* item in this response — not that nobody has anything to say about it.
|
|
1614
|
+
*/
|
|
1615
|
+
readonly notes: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
|
|
1616
|
+
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1617
|
+
/** The note's text, already wrapped in the response's untrusted markers. */
|
|
1618
|
+
readonly body: v.StringSchema<undefined>;
|
|
1619
|
+
/** The author's display name as the workspace shows it, or null. Never an email. */
|
|
1620
|
+
readonly authorName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
1621
|
+
/** ISO timestamp, machine format. */
|
|
1622
|
+
readonly createdAt: v.StringSchema<undefined>;
|
|
1623
|
+
/** The item's content version the note was written against. */
|
|
1624
|
+
readonly itemVersion: v.NumberSchema<undefined>;
|
|
1625
|
+
/** True when the item's current version is greater than `itemVersion`. */
|
|
1626
|
+
readonly itemChangedSince: v.BooleanSchema<undefined>;
|
|
1627
|
+
/**
|
|
1628
|
+
* How many agent reads were handed this note **before** this one — so a
|
|
1629
|
+
* note reaching an agent for the first time reports `0`.
|
|
1630
|
+
*
|
|
1631
|
+
* It is the stored count as it read at the moment the response was built;
|
|
1632
|
+
* the serve this response *is* has not been counted yet. Excluded rather
|
|
1633
|
+
* than included because the count is recorded best-effort: a response that
|
|
1634
|
+
* claimed to include itself would be wrong whenever that record failed, and
|
|
1635
|
+
* a number that is sometimes off by one is worse than one that is
|
|
1636
|
+
* consistently the prior total.
|
|
1637
|
+
*
|
|
1638
|
+
* So `deliveredCount > 0` means an earlier read was handed this note, and
|
|
1639
|
+
* `0` means this read is the first. Neither says a model took it in — only
|
|
1640
|
+
* that the server handed it over.
|
|
1641
|
+
*/
|
|
1642
|
+
readonly deliveredCount: v.NumberSchema<undefined>;
|
|
1643
|
+
/**
|
|
1644
|
+
* This note's thread root — its own id for every note written today, since
|
|
1645
|
+
* no reply exists yet. Ignorable now; load-bearing once a reply is a second
|
|
1646
|
+
* row with a different id here. It is on the wire from the first response
|
|
1647
|
+
* because the wire contract is consumed by installed CLI versions: reshaping
|
|
1648
|
+
* a flat `notes` array into threads-of-notes later would be a breaking
|
|
1649
|
+
* change, while a field today's readers ignore costs them nothing.
|
|
1650
|
+
*/
|
|
1651
|
+
readonly threadId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
1652
|
+
/**
|
|
1653
|
+
* Always `null` today — no reply exists to point at. Present now so an older
|
|
1654
|
+
* reader meeting a future response that carries real replies degrades to
|
|
1655
|
+
* "a flat list of notes" rather than failing to parse.
|
|
1656
|
+
*/
|
|
1657
|
+
readonly replyToId: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>, undefined>;
|
|
1658
|
+
}, undefined>, undefined>, v.MaxLengthAction<{
|
|
1659
|
+
id: string;
|
|
1660
|
+
body: string;
|
|
1661
|
+
authorName: string | null;
|
|
1662
|
+
createdAt: string;
|
|
1663
|
+
itemVersion: number;
|
|
1664
|
+
itemChangedSince: boolean;
|
|
1665
|
+
deliveredCount: number;
|
|
1666
|
+
threadId: string;
|
|
1667
|
+
replyToId: string | null;
|
|
1668
|
+
}[], 20, undefined>]>, undefined>;
|
|
1181
1669
|
readonly updatedAt: v.StringSchema<undefined>;
|
|
1182
1670
|
}, undefined>;
|
|
1183
1671
|
}, undefined>;
|
|
@@ -1197,6 +1685,7 @@ export declare const InboxCaptureRequestSchema: v.ObjectSchema<{
|
|
|
1197
1685
|
* from it. The one in-repo caller is the dashboard composer.)
|
|
1198
1686
|
*/
|
|
1199
1687
|
readonly id: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 8, "id must be at least 8 characters">, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "id must contain only letters, digits, underscore, dot or hyphen">]>, undefined>;
|
|
1688
|
+
readonly bundleId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
|
|
1200
1689
|
readonly contentType: v.PicklistSchema<("document" | "reference" | "asset")[], undefined>;
|
|
1201
1690
|
readonly content: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "content must be at most 262144 bytes">]>;
|
|
1202
1691
|
readonly name: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
|
|
@@ -2542,20 +3031,6 @@ export declare const GuideHistoryGuideSchema: v.ObjectSchema<{
|
|
|
2542
3031
|
readonly path: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 512, undefined>, v.CheckAction<string, "path must use forward slashes">, v.CheckAction<string, "path must be relative">, v.CheckAction<string, "path must not contain control characters">, v.CheckAction<string, "path must not contain empty, \".\" or \"..\" segments">]>, undefined>;
|
|
2543
3032
|
readonly root: v.NullableSchema<v.PicklistSchema<["project", "global"], undefined>, undefined>;
|
|
2544
3033
|
}, undefined>;
|
|
2545
|
-
/**
|
|
2546
|
-
* The markers every `reasoning` block in this response is wrapped in, plus a
|
|
2547
|
-
* statement of what they mean.
|
|
2548
|
-
*
|
|
2549
|
-
* Generated per response from the content itself, so no marker-like text inside
|
|
2550
|
-
* a block can end it early — a property `deriveDelimiterToken` checks rather
|
|
2551
|
-
* than assumes.
|
|
2552
|
-
*/
|
|
2553
|
-
export declare const GuideHistoryUntrustedSchema: v.ObjectSchema<{
|
|
2554
|
-
readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
2555
|
-
readonly startMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
2556
|
-
readonly endMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
2557
|
-
readonly note: v.StringSchema<undefined>;
|
|
2558
|
-
}, undefined>;
|
|
2559
3034
|
export declare const GuideHistoryResponseSchema: v.ObjectSchema<{
|
|
2560
3035
|
readonly guide: v.ObjectSchema<{
|
|
2561
3036
|
readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
@@ -2849,77 +3324,6 @@ export declare const SessionGradeResponseSchema: v.ObjectSchema<{
|
|
|
2849
3324
|
}, undefined>, undefined>;
|
|
2850
3325
|
}, undefined>;
|
|
2851
3326
|
export type SessionGradeResponse = v.InferOutput<typeof SessionGradeResponseSchema>;
|
|
2852
|
-
/**
|
|
2853
|
-
* The five kinds of session residue the server used to extract on session
|
|
2854
|
-
* close. No longer produced by anything — kept so an already-installed CLI's
|
|
2855
|
-
* parse of the (now always-empty) response still type-checks against the
|
|
2856
|
-
* same shape it always has.
|
|
2857
|
-
*/
|
|
2858
|
-
export declare const SessionResidueKindSchema: v.PicklistSchema<["decision", "deferral", "assumption", "question", "found_not_fixed"], undefined>;
|
|
2859
|
-
export type SessionResidueKind = v.InferOutput<typeof SessionResidueKindSchema>;
|
|
2860
|
-
/**
|
|
2861
|
-
* How many residue items one read returns at most — the same cap the
|
|
2862
|
-
* extractor applies per session, applied again across sessions: the handoff a
|
|
2863
|
-
* session reads at start is a glance, not a log.
|
|
2864
|
-
*/
|
|
2865
|
-
export declare const MAX_SESSION_RESIDUE_ITEMS = 5;
|
|
2866
|
-
/** `?project=` — the committed project id whose recent sessions to read. */
|
|
2867
|
-
export declare const SessionResidueRequestSchema: v.ObjectSchema<{
|
|
2868
|
-
readonly project: 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">]>;
|
|
2869
|
-
}, undefined>;
|
|
2870
|
-
export type SessionResidueRequest = v.InferOutput<typeof SessionResidueRequestSchema>;
|
|
2871
|
-
/** One item a recent session in the project left behind. */
|
|
2872
|
-
export declare const SessionResidueItemSchema: v.ObjectSchema<{
|
|
2873
|
-
readonly kind: v.PicklistSchema<["decision", "deferral", "assumption", "question", "found_not_fixed"], undefined>;
|
|
2874
|
-
/**
|
|
2875
|
-
* The item's text, **already wrapped in the response's untrusted markers**
|
|
2876
|
-
* — model-authored, transcript-derived, and about to be placed in front of
|
|
2877
|
-
* an agent, so delimited at the source exactly as a grade's reasoning is.
|
|
2878
|
-
*/
|
|
2879
|
-
readonly text: v.StringSchema<undefined>;
|
|
2880
|
-
/** The run the item came from; what `mossbear sessions <id>` takes. */
|
|
2881
|
-
readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
2882
|
-
readonly agentSessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
2883
|
-
/** ISO timestamp of the session's close; null while it is still open. */
|
|
2884
|
-
readonly endedAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
2885
|
-
}, undefined>;
|
|
2886
|
-
export type SessionResidueItem = v.InferOutput<typeof SessionResidueItemSchema>;
|
|
2887
|
-
export declare const SessionResidueResponseSchema: v.ObjectSchema<{
|
|
2888
|
-
readonly project: 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">]>;
|
|
2889
|
-
/**
|
|
2890
|
-
* Newest session first, then in the order the session recorded them; at
|
|
2891
|
-
* most {@link MAX_SESSION_RESIDUE_ITEMS}. Empty is the ordinary answer and
|
|
2892
|
-
* says "nothing on record", never "nothing happened".
|
|
2893
|
-
*/
|
|
2894
|
-
readonly items: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
|
|
2895
|
-
readonly kind: v.PicklistSchema<["decision", "deferral", "assumption", "question", "found_not_fixed"], undefined>;
|
|
2896
|
-
/**
|
|
2897
|
-
* The item's text, **already wrapped in the response's untrusted markers**
|
|
2898
|
-
* — model-authored, transcript-derived, and about to be placed in front of
|
|
2899
|
-
* an agent, so delimited at the source exactly as a grade's reasoning is.
|
|
2900
|
-
*/
|
|
2901
|
-
readonly text: v.StringSchema<undefined>;
|
|
2902
|
-
/** The run the item came from; what `mossbear sessions <id>` takes. */
|
|
2903
|
-
readonly sessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
2904
|
-
readonly agentSessionId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
2905
|
-
/** ISO timestamp of the session's close; null while it is still open. */
|
|
2906
|
-
readonly endedAt: v.NullableSchema<v.StringSchema<undefined>, undefined>;
|
|
2907
|
-
}, undefined>, undefined>, v.MaxLengthAction<{
|
|
2908
|
-
kind: "decision" | "deferral" | "assumption" | "question" | "found_not_fixed";
|
|
2909
|
-
text: string;
|
|
2910
|
-
sessionId: string;
|
|
2911
|
-
agentSessionId: string;
|
|
2912
|
-
endedAt: string | null;
|
|
2913
|
-
}[], 5, undefined>]>;
|
|
2914
|
-
/** The markers every `text` is wrapped in; present exactly when `items` is non-empty. */
|
|
2915
|
-
readonly untrusted: v.NullableSchema<v.ObjectSchema<{
|
|
2916
|
-
readonly token: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
2917
|
-
readonly startMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
2918
|
-
readonly endMarker: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
|
|
2919
|
-
readonly note: v.StringSchema<undefined>;
|
|
2920
|
-
}, undefined>, undefined>;
|
|
2921
|
-
}, undefined>;
|
|
2922
|
-
export type SessionResidueResponse = v.InferOutput<typeof SessionResidueResponseSchema>;
|
|
2923
3327
|
export declare function parseAgentConfig(data: unknown): {
|
|
2924
3328
|
id: string;
|
|
2925
3329
|
name: string;
|
|
@@ -3098,6 +3502,17 @@ export declare function parseContextItem(data: unknown): {
|
|
|
3098
3502
|
root: "project" | "global";
|
|
3099
3503
|
path: string;
|
|
3100
3504
|
}[] | undefined;
|
|
3505
|
+
notes?: {
|
|
3506
|
+
id: string;
|
|
3507
|
+
body: string;
|
|
3508
|
+
authorName: string | null;
|
|
3509
|
+
createdAt: string;
|
|
3510
|
+
itemVersion: number;
|
|
3511
|
+
itemChangedSince: boolean;
|
|
3512
|
+
deliveredCount: number;
|
|
3513
|
+
threadId: string;
|
|
3514
|
+
replyToId: string | null;
|
|
3515
|
+
}[] | undefined;
|
|
3101
3516
|
updatedAt: string;
|
|
3102
3517
|
};
|
|
3103
3518
|
export declare function parseContextItemsResponse(data: unknown): {
|
|
@@ -3117,8 +3532,25 @@ export declare function parseContextItemsResponse(data: unknown): {
|
|
|
3117
3532
|
root: "project" | "global";
|
|
3118
3533
|
path: string;
|
|
3119
3534
|
}[] | undefined;
|
|
3535
|
+
notes?: {
|
|
3536
|
+
id: string;
|
|
3537
|
+
body: string;
|
|
3538
|
+
authorName: string | null;
|
|
3539
|
+
createdAt: string;
|
|
3540
|
+
itemVersion: number;
|
|
3541
|
+
itemChangedSince: boolean;
|
|
3542
|
+
deliveredCount: number;
|
|
3543
|
+
threadId: string;
|
|
3544
|
+
replyToId: string | null;
|
|
3545
|
+
}[] | undefined;
|
|
3120
3546
|
updatedAt: string;
|
|
3121
3547
|
}[];
|
|
3548
|
+
untrusted?: {
|
|
3549
|
+
token: string;
|
|
3550
|
+
startMarker: string;
|
|
3551
|
+
endMarker: string;
|
|
3552
|
+
note: string;
|
|
3553
|
+
} | null | undefined;
|
|
3122
3554
|
};
|
|
3123
3555
|
export declare function parsePushContextRequest(data: unknown): {
|
|
3124
3556
|
name: string;
|
|
@@ -3147,6 +3579,17 @@ export declare function parsePushContextResponse(data: unknown): {
|
|
|
3147
3579
|
root: "project" | "global";
|
|
3148
3580
|
path: string;
|
|
3149
3581
|
}[] | undefined;
|
|
3582
|
+
notes?: {
|
|
3583
|
+
id: string;
|
|
3584
|
+
body: string;
|
|
3585
|
+
authorName: string | null;
|
|
3586
|
+
createdAt: string;
|
|
3587
|
+
itemVersion: number;
|
|
3588
|
+
itemChangedSince: boolean;
|
|
3589
|
+
deliveredCount: number;
|
|
3590
|
+
threadId: string;
|
|
3591
|
+
replyToId: string | null;
|
|
3592
|
+
}[] | undefined;
|
|
3150
3593
|
updatedAt: string;
|
|
3151
3594
|
};
|
|
3152
3595
|
created: boolean;
|
|
@@ -3176,6 +3619,17 @@ export declare function parseUpdateContextItemResponse(data: unknown): {
|
|
|
3176
3619
|
root: "project" | "global";
|
|
3177
3620
|
path: string;
|
|
3178
3621
|
}[] | undefined;
|
|
3622
|
+
notes?: {
|
|
3623
|
+
id: string;
|
|
3624
|
+
body: string;
|
|
3625
|
+
authorName: string | null;
|
|
3626
|
+
createdAt: string;
|
|
3627
|
+
itemVersion: number;
|
|
3628
|
+
itemChangedSince: boolean;
|
|
3629
|
+
deliveredCount: number;
|
|
3630
|
+
threadId: string;
|
|
3631
|
+
replyToId: string | null;
|
|
3632
|
+
}[] | undefined;
|
|
3179
3633
|
updatedAt: string;
|
|
3180
3634
|
};
|
|
3181
3635
|
updated: boolean;
|
|
@@ -3204,6 +3658,17 @@ export declare function parseContextItemResponse(data: unknown): {
|
|
|
3204
3658
|
root: "project" | "global";
|
|
3205
3659
|
path: string;
|
|
3206
3660
|
}[] | undefined;
|
|
3661
|
+
notes?: {
|
|
3662
|
+
id: string;
|
|
3663
|
+
body: string;
|
|
3664
|
+
authorName: string | null;
|
|
3665
|
+
createdAt: string;
|
|
3666
|
+
itemVersion: number;
|
|
3667
|
+
itemChangedSince: boolean;
|
|
3668
|
+
deliveredCount: number;
|
|
3669
|
+
threadId: string;
|
|
3670
|
+
replyToId: string | null;
|
|
3671
|
+
}[] | undefined;
|
|
3207
3672
|
updatedAt: string;
|
|
3208
3673
|
};
|
|
3209
3674
|
};
|
|
@@ -3225,11 +3690,23 @@ export declare function parseArchiveContextItemResponse(data: unknown): {
|
|
|
3225
3690
|
root: "project" | "global";
|
|
3226
3691
|
path: string;
|
|
3227
3692
|
}[] | undefined;
|
|
3693
|
+
notes?: {
|
|
3694
|
+
id: string;
|
|
3695
|
+
body: string;
|
|
3696
|
+
authorName: string | null;
|
|
3697
|
+
createdAt: string;
|
|
3698
|
+
itemVersion: number;
|
|
3699
|
+
itemChangedSince: boolean;
|
|
3700
|
+
deliveredCount: number;
|
|
3701
|
+
threadId: string;
|
|
3702
|
+
replyToId: string | null;
|
|
3703
|
+
}[] | undefined;
|
|
3228
3704
|
updatedAt: string;
|
|
3229
3705
|
};
|
|
3230
3706
|
};
|
|
3231
3707
|
export declare function parseInboxCaptureRequest(data: unknown): {
|
|
3232
3708
|
id?: string | undefined;
|
|
3709
|
+
bundleId?: string | null | undefined;
|
|
3233
3710
|
contentType: "document" | "reference" | "asset";
|
|
3234
3711
|
content: string;
|
|
3235
3712
|
name?: string | undefined;
|
|
@@ -3578,21 +4055,5 @@ export declare function parseSessionGradeResponse(data: unknown): {
|
|
|
3578
4055
|
note: string;
|
|
3579
4056
|
} | null;
|
|
3580
4057
|
};
|
|
3581
|
-
export declare function parseSessionResidueResponse(data: unknown): {
|
|
3582
|
-
project: string;
|
|
3583
|
-
items: {
|
|
3584
|
-
kind: "decision" | "deferral" | "assumption" | "question" | "found_not_fixed";
|
|
3585
|
-
text: string;
|
|
3586
|
-
sessionId: string;
|
|
3587
|
-
agentSessionId: string;
|
|
3588
|
-
endedAt: string | null;
|
|
3589
|
-
}[];
|
|
3590
|
-
untrusted: {
|
|
3591
|
-
token: string;
|
|
3592
|
-
startMarker: string;
|
|
3593
|
-
endMarker: string;
|
|
3594
|
-
note: string;
|
|
3595
|
-
} | null;
|
|
3596
|
-
};
|
|
3597
4058
|
export {};
|
|
3598
4059
|
//# sourceMappingURL=schemas.d.ts.map
|