@heynixie/contract 0.74.0 → 0.76.0
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/contract/approval-contract.d.ts +137 -0
- package/dist/contract/build-query-utils.d.ts +360 -2
- package/dist/contract/challenge-for-schema.d.ts +4 -0
- package/dist/contract/contract.d.ts +376 -0
- package/dist/contract/forgettable-kinds.d.ts +1 -1
- package/dist/contract/forgotten-items-schema.d.ts +16 -0
- package/dist/contract/host-contract.d.ts +56 -0
- package/dist/contract/host-mandates-contract.d.ts +32 -0
- package/dist/contract/memory-view-contract.d.ts +7 -0
- package/dist/contract/passkey-contract.d.ts +4 -0
- package/dist/contract/rule-contract.d.ts +123 -0
- package/dist/contract/schedule-schema.d.ts +31 -0
- package/dist/contract/trigger-schema.d.ts +36 -0
- package/dist/index.d.ts +4 -0
- package/dist/index.js +532 -313
- package/package.json +1 -1
package/dist/index.js
CHANGED
|
@@ -152,6 +152,7 @@ var clientHeaderName = "x-nixie-client";
|
|
|
152
152
|
var forgettableKinds = [
|
|
153
153
|
"action.outcome",
|
|
154
154
|
"action.queued",
|
|
155
|
+
"action.reconcile_checked",
|
|
155
156
|
"action.retry_scheduled",
|
|
156
157
|
"model.compaction_failed",
|
|
157
158
|
"model.reply",
|
|
@@ -165,6 +166,8 @@ var forgettableKinds = [
|
|
|
165
166
|
"proposals.deferred",
|
|
166
167
|
"session.enrolled",
|
|
167
168
|
"session.labelled",
|
|
169
|
+
"rules.mandate_proposed",
|
|
170
|
+
"rules.rule_proposed",
|
|
168
171
|
"session_kept",
|
|
169
172
|
"skills.write_rejected",
|
|
170
173
|
"task.created",
|
|
@@ -468,6 +471,7 @@ var reviewReasonSchema = z8.enum([
|
|
|
468
471
|
"from_photo",
|
|
469
472
|
"sensitive",
|
|
470
473
|
"subject_change",
|
|
474
|
+
"labels",
|
|
471
475
|
"ask_rule"
|
|
472
476
|
]);
|
|
473
477
|
var proposalSourceSchema = z8.object({
|
|
@@ -475,6 +479,12 @@ var proposalSourceSchema = z8.object({
|
|
|
475
479
|
proposedAt: z8.date(),
|
|
476
480
|
thread: z8.string().nullable()
|
|
477
481
|
});
|
|
482
|
+
var proposalLabelsSchema = z8.object({
|
|
483
|
+
gist: z8.string(),
|
|
484
|
+
isLabelOnly: z8.boolean(),
|
|
485
|
+
topic: z8.string(),
|
|
486
|
+
triggers: z8.array(z8.string())
|
|
487
|
+
});
|
|
478
488
|
var memoryProposalSchema = z8.object({
|
|
479
489
|
actionHash: z8.string(),
|
|
480
490
|
createdAt: z8.date(),
|
|
@@ -484,6 +494,7 @@ var memoryProposalSchema = z8.object({
|
|
|
484
494
|
isSensitive: z8.boolean(),
|
|
485
495
|
itemID: z8.string(),
|
|
486
496
|
kind: kindSchema,
|
|
497
|
+
labels: proposalLabelsSchema.nullable(),
|
|
487
498
|
lapseAt: z8.date(),
|
|
488
499
|
newSubject: subjectSchema.nullable(),
|
|
489
500
|
operation: z8.enum(["remember", "retire", "pin"]),
|
|
@@ -642,6 +653,7 @@ var bodySchema = z11.object({
|
|
|
642
653
|
fields: z11.record(z11.string(), z11.string()),
|
|
643
654
|
ruleSentence: z11.string().nullable(),
|
|
644
655
|
approveLabel: z11.string(),
|
|
656
|
+
rule: z11.record(z11.string(), z11.unknown()).optional(),
|
|
645
657
|
memory: memoryProposalSchema.optional()
|
|
646
658
|
});
|
|
647
659
|
var itemSchema = z11.object({
|
|
@@ -652,6 +664,35 @@ var itemSchema = z11.object({
|
|
|
652
664
|
choices: z11.array(choiceSchema),
|
|
653
665
|
passkeyChoices: z11.array(choiceSchema)
|
|
654
666
|
});
|
|
667
|
+
var unknownReasonSchema = z11.enum([
|
|
668
|
+
"inconclusive",
|
|
669
|
+
"unknown_streak",
|
|
670
|
+
"no_reconcile",
|
|
671
|
+
"key_expired",
|
|
672
|
+
"not_found_ask"
|
|
673
|
+
]);
|
|
674
|
+
var checkAnswerSchema = z11.enum(["found", "not_found", "inconclusive"]);
|
|
675
|
+
var attemptSchema = z11.object({ attempt: z11.int().nonnegative(), at: z11.date() });
|
|
676
|
+
var checkSchema = z11.object({ answer: checkAnswerSchema, at: z11.date() });
|
|
677
|
+
var unknownOutcomeSchema = z11.object({
|
|
678
|
+
actionID: z11.string(),
|
|
679
|
+
tool: z11.string(),
|
|
680
|
+
sentence: z11.string(),
|
|
681
|
+
fields: z11.record(z11.string(), z11.string()),
|
|
682
|
+
riskClass: z11.enum(["routine", "always_ask", "lifting"]),
|
|
683
|
+
reason: unknownReasonSchema,
|
|
684
|
+
becameUnknownAt: z11.date(),
|
|
685
|
+
attempts: z11.array(attemptSchema),
|
|
686
|
+
checks: z11.array(checkSchema)
|
|
687
|
+
});
|
|
688
|
+
var unknownChoiceSchema = z11.enum(["happened", "retry", "drop"]);
|
|
689
|
+
var unknownItemSchema = z11.object({
|
|
690
|
+
group: z11.literal("unknown_outcome"),
|
|
691
|
+
action: unknownOutcomeSchema,
|
|
692
|
+
task: taskSchema.nullable(),
|
|
693
|
+
choices: z11.array(unknownChoiceSchema),
|
|
694
|
+
passkeyChoices: z11.array(unknownChoiceSchema)
|
|
695
|
+
});
|
|
655
696
|
var readItemSchema = z11.object({
|
|
656
697
|
proposal: proposalSchema,
|
|
657
698
|
body: bodySchema.nullable(),
|
|
@@ -730,7 +771,27 @@ var answerErrors = signedIn.errors(reusedIDErrors).errors({
|
|
|
730
771
|
...noPasskeyError,
|
|
731
772
|
...passkeyFailedError
|
|
732
773
|
});
|
|
733
|
-
var listedSchema = z11.object({
|
|
774
|
+
var listedSchema = z11.object({
|
|
775
|
+
defer: deferSettingsSchema,
|
|
776
|
+
items: z11.array(itemSchema),
|
|
777
|
+
unknownOutcomes: z11.array(unknownItemSchema)
|
|
778
|
+
});
|
|
779
|
+
var unknownAnswerSchema = z11.object({
|
|
780
|
+
actionID: z11.string().min(1).max(200),
|
|
781
|
+
choice: unknownChoiceSchema,
|
|
782
|
+
clientActionID: z11.uuid(),
|
|
783
|
+
passkey: authenticationResponseSchema.optional()
|
|
784
|
+
});
|
|
785
|
+
var unknownAnswerErrors = signedIn.errors(reusedIDErrors).errors({
|
|
786
|
+
NOT_ALLOWED: {
|
|
787
|
+
message: "The action waits for no answer about its outcome",
|
|
788
|
+
status: 403,
|
|
789
|
+
data: z11.object({ reason: z11.string() })
|
|
790
|
+
},
|
|
791
|
+
PASSKEY_REQUIRED: { message: "This answer needs a passkey check", status: 403 },
|
|
792
|
+
...noPasskeyError,
|
|
793
|
+
...passkeyFailedError
|
|
794
|
+
});
|
|
734
795
|
var readInputSchema = z11.object({
|
|
735
796
|
proposalIDs: z11.array(z11.string().min(1).max(200)).min(1).max(100)
|
|
736
797
|
});
|
|
@@ -740,6 +801,7 @@ var approvalContract = {
|
|
|
740
801
|
listItems: signedIn.output(listedSchema),
|
|
741
802
|
readProposals: signedIn.input(readInputSchema).output(z11.object({ proposals: z11.array(readItemSchema) })),
|
|
742
803
|
answerProposal: answerErrors.input(passkeyAnswerSchema).output(resultSchema),
|
|
804
|
+
answerUnknownOutcome: unknownAnswerErrors.input(unknownAnswerSchema).output(z11.object({ actionID: z11.string(), choice: unknownChoiceSchema })),
|
|
743
805
|
answerProposals: signedIn.errors(reusedIDErrors).input(batchInputSchema).output(batchResultSchema)
|
|
744
806
|
};
|
|
745
807
|
|
|
@@ -782,6 +844,11 @@ var challengeForSchema = z13.discriminatedUnion("kind", [
|
|
|
782
844
|
choice: choiceSchema,
|
|
783
845
|
ruleHash: z13.string().optional()
|
|
784
846
|
}),
|
|
847
|
+
z13.object({
|
|
848
|
+
kind: z13.literal("unknown_outcome"),
|
|
849
|
+
actionID: z13.string().min(1).max(200),
|
|
850
|
+
choice: z13.literal("retry")
|
|
851
|
+
}),
|
|
785
852
|
z13.object({ kind: z13.literal("register") }),
|
|
786
853
|
z13.object({ kind: z13.literal("revoke"), passkeyID: z13.string().min(1).max(200) })
|
|
787
854
|
]);
|
|
@@ -958,9 +1025,31 @@ var ruleChange = signedIn.errors(reusedIDErrors).errors({
|
|
|
958
1025
|
NOT_ALLOWED: {
|
|
959
1026
|
message: "The rule takes no such change",
|
|
960
1027
|
status: 403,
|
|
961
|
-
data: z23.object({ reason: z23.enum(["widens", "empty"]) })
|
|
1028
|
+
data: z23.object({ reason: z23.enum(["widens", "empty", "mandate"]) })
|
|
962
1029
|
}
|
|
963
1030
|
});
|
|
1031
|
+
var currentHashSchema = z23.object({ current: z23.object({ actionHash: z23.string() }) });
|
|
1032
|
+
var closedStateSchema = z23.object({
|
|
1033
|
+
state: z23.enum(["approved", "declined", "lapsed", "withdrawn"])
|
|
1034
|
+
});
|
|
1035
|
+
var proposalIDSchema = z23.string().min(1).max(64);
|
|
1036
|
+
var ruleFormSchema = z23.record(z23.string(), z23.unknown());
|
|
1037
|
+
var mandateRuleSchema = z23.object({ ruleID: z23.string(), sentence: z23.string() });
|
|
1038
|
+
var mandateSchema = z23.object({
|
|
1039
|
+
mandateID: z23.string(),
|
|
1040
|
+
title: z23.string().nullable(),
|
|
1041
|
+
rules: z23.array(mandateRuleSchema),
|
|
1042
|
+
startedAt: z23.date(),
|
|
1043
|
+
expires: z23.date()
|
|
1044
|
+
});
|
|
1045
|
+
var faultsSchema = z23.object({ faults: z23.array(z23.string()) });
|
|
1046
|
+
var invalid = {
|
|
1047
|
+
INVALID: {
|
|
1048
|
+
message: "The rule or the mandate breaks the rule format or its limits",
|
|
1049
|
+
status: 400,
|
|
1050
|
+
data: faultsSchema
|
|
1051
|
+
}
|
|
1052
|
+
};
|
|
964
1053
|
var destinationsSchema = z23.array(z23.string().regex(/^\S+$/u)).max(100);
|
|
965
1054
|
var ruleContract = {
|
|
966
1055
|
readRule: signedIn.errors(notFound).input(z23.object({ ruleID: ruleIDSchema })).output(ruleSchema),
|
|
@@ -970,7 +1059,34 @@ var ruleContract = {
|
|
|
970
1059
|
revision: revisionSchema,
|
|
971
1060
|
destinations: destinationsSchema,
|
|
972
1061
|
clientActionID: z23.uuid()
|
|
973
|
-
})).output(z23.object({ ruleID: z23.string(), revision: revisionSchema }))
|
|
1062
|
+
})).output(z23.object({ ruleID: z23.string(), revision: revisionSchema })),
|
|
1063
|
+
editProposedRule: signedIn.errors(reusedIDErrors).errors({
|
|
1064
|
+
...invalid,
|
|
1065
|
+
NOT_FOUND: { message: "No proposed rule has this ID", status: 404 },
|
|
1066
|
+
CONFLICT: {
|
|
1067
|
+
message: "The proposed rule changed since the card showed it",
|
|
1068
|
+
status: 409,
|
|
1069
|
+
data: currentHashSchema
|
|
1070
|
+
},
|
|
1071
|
+
CLOSED: {
|
|
1072
|
+
message: "The proposed rule is no longer open",
|
|
1073
|
+
status: 409,
|
|
1074
|
+
data: closedStateSchema
|
|
1075
|
+
}
|
|
1076
|
+
}).input(z23.object({
|
|
1077
|
+
proposalID: proposalIDSchema,
|
|
1078
|
+
actionHash: z23.string(),
|
|
1079
|
+
rule: ruleFormSchema,
|
|
1080
|
+
clientActionID: z23.uuid()
|
|
1081
|
+
})).output(z23.object({ proposalID: z23.string() })),
|
|
1082
|
+
proposeMandate: signedIn.errors(reusedIDErrors).errors(invalid).input(z23.object({
|
|
1083
|
+
title: z23.string(),
|
|
1084
|
+
rules: z23.array(ruleFormSchema),
|
|
1085
|
+
expires: z23.string().optional(),
|
|
1086
|
+
clientActionID: z23.uuid()
|
|
1087
|
+
})).output(z23.object({ proposalID: z23.string(), mandateID: z23.string(), expires: z23.date() })),
|
|
1088
|
+
listMandates: signedIn.output(z23.object({ mandates: z23.array(mandateSchema) })),
|
|
1089
|
+
endMandate: signedIn.errors(reusedIDErrors).errors({ NOT_FOUND: { message: "No mandate has this ID", status: 404 } }).input(z23.object({ mandateID: z23.string().min(1).max(64), clientActionID: z23.uuid() })).output(z23.object({ mandateID: z23.string(), state: z23.enum(["ended", "expired"]) }))
|
|
974
1090
|
};
|
|
975
1091
|
|
|
976
1092
|
// src/contract/task-schema.ts
|
|
@@ -1086,6 +1202,7 @@ var recordSchema = z26.object({
|
|
|
1086
1202
|
proposal: z26.object({ proposalID: z26.string(), shortID: z26.string() }).optional(),
|
|
1087
1203
|
recall: recallSchema.optional(),
|
|
1088
1204
|
recordedAt: z26.date(),
|
|
1205
|
+
removal: z26.object({ kind: z26.string(), sequence: sequenceSchema, callSequence: sequenceSchema.optional() }).optional(),
|
|
1089
1206
|
sequence: sequenceSchema,
|
|
1090
1207
|
stop: z26.object({ cancelledActions: z26.array(listedActionSchema) }).optional(),
|
|
1091
1208
|
summary: summarySchema.optional(),
|
|
@@ -1127,12 +1244,15 @@ var listedTaskSchema = z26.object({
|
|
|
1127
1244
|
started: actionCountSchema
|
|
1128
1245
|
}),
|
|
1129
1246
|
brief: z26.string(),
|
|
1247
|
+
closedBy: z26.enum(["owner", "nixie", "disposable"]).optional(),
|
|
1130
1248
|
controls: z26.array(taskControlSchema),
|
|
1249
|
+
disposable: z26.boolean().nullable(),
|
|
1131
1250
|
isPauseRequested: z26.boolean(),
|
|
1132
1251
|
isPausedByNixie: z26.boolean(),
|
|
1133
1252
|
isTakingMessages: z26.boolean(),
|
|
1134
1253
|
lastActivityAt: z26.date(),
|
|
1135
1254
|
name: z26.string(),
|
|
1255
|
+
runner: z26.string(),
|
|
1136
1256
|
state: taskStateSchema2,
|
|
1137
1257
|
taskID: threadSchema,
|
|
1138
1258
|
waitingOn: threadSchema.optional()
|
|
@@ -1149,8 +1269,17 @@ var taskControl = checkedAction.errors({
|
|
|
1149
1269
|
message: "The task is in a state that does not take this control",
|
|
1150
1270
|
status: 409,
|
|
1151
1271
|
data: z26.object({ isPauseRequested: z26.boolean(), state: taskStateSchema2 })
|
|
1272
|
+
},
|
|
1273
|
+
RUNNER_LACKS_CONTROL: {
|
|
1274
|
+
message: "The runner of the task does not take this control",
|
|
1275
|
+
status: 409
|
|
1152
1276
|
}
|
|
1153
1277
|
}).input(z26.object({ clientActionID: clientActionIDSchema2, taskID: threadSchema })).output(controlledTaskSchema);
|
|
1278
|
+
var markedTaskSchema = z26.object({
|
|
1279
|
+
changedAt: z26.date(),
|
|
1280
|
+
disposable: z26.boolean(),
|
|
1281
|
+
taskID: threadSchema
|
|
1282
|
+
});
|
|
1154
1283
|
var nixieControl = checkedAction.input(z26.object({ clientActionID: clientActionIDSchema2 })).output(z26.object({ paused: pauseStateSchema }));
|
|
1155
1284
|
var backupNoticeSchema = z26.object({
|
|
1156
1285
|
cause: z26.enum(["failed", "missing"]),
|
|
@@ -1224,7 +1353,20 @@ var contract = {
|
|
|
1224
1353
|
close: taskControl.errors({
|
|
1225
1354
|
CONVERSATION_NEVER_CLOSES: { message: "The conversation is never closed", status: 409 }
|
|
1226
1355
|
}),
|
|
1227
|
-
interrupt: taskControl
|
|
1356
|
+
interrupt: taskControl,
|
|
1357
|
+
setDisposable: checkedAction.errors({
|
|
1358
|
+
TASK_NOT_FOUND: { message: "No task has this ID", status: 404 },
|
|
1359
|
+
TASK_HAS_NO_MARK: { message: "The task has no disposable mark", status: 409 },
|
|
1360
|
+
TASK_STATE_REFUSED: {
|
|
1361
|
+
message: "The task is in a state that does not take this change",
|
|
1362
|
+
status: 409,
|
|
1363
|
+
data: z26.object({ state: taskStateSchema2 })
|
|
1364
|
+
}
|
|
1365
|
+
}).input(z26.object({
|
|
1366
|
+
clientActionID: clientActionIDSchema2,
|
|
1367
|
+
disposable: z26.boolean(),
|
|
1368
|
+
taskID: threadSchema
|
|
1369
|
+
})).output(markedTaskSchema)
|
|
1228
1370
|
},
|
|
1229
1371
|
memory: {
|
|
1230
1372
|
readVersions: signedIn.input(z26.object({ versions: z26.array(versionRefSchema).min(1).max(100) })).output(z26.object({ versions: z26.array(versionTextSchema) })),
|
|
@@ -1279,8 +1421,8 @@ var contract = {
|
|
|
1279
1421
|
}
|
|
1280
1422
|
};
|
|
1281
1423
|
// src/contract/host-contract.ts
|
|
1282
|
-
import { oc as
|
|
1283
|
-
import { z as
|
|
1424
|
+
import { oc as oc6 } from "@orpc/contract";
|
|
1425
|
+
import { z as z35 } from "zod";
|
|
1284
1426
|
|
|
1285
1427
|
// src/contract/action-proposal-schema.ts
|
|
1286
1428
|
import { z as z27 } from "zod";
|
|
@@ -1302,49 +1444,75 @@ var actionProposalSchema = z27.object({
|
|
|
1302
1444
|
lapseAt: z27.date()
|
|
1303
1445
|
});
|
|
1304
1446
|
|
|
1305
|
-
// src/contract/
|
|
1306
|
-
import { oc as oc3 } from "@orpc/contract";
|
|
1447
|
+
// src/contract/forgotten-items-schema.ts
|
|
1307
1448
|
import { z as z28 } from "zod";
|
|
1308
|
-
var
|
|
1309
|
-
|
|
1310
|
-
|
|
1311
|
-
|
|
1312
|
-
|
|
1313
|
-
|
|
1314
|
-
|
|
1315
|
-
|
|
1316
|
-
|
|
1317
|
-
|
|
1449
|
+
var forgottenItemsSchema = z28.object({
|
|
1450
|
+
itemIDs: z28.array(z28.string()),
|
|
1451
|
+
backup: forgetBackupSchema
|
|
1452
|
+
});
|
|
1453
|
+
|
|
1454
|
+
// src/contract/host-mandates-contract.ts
|
|
1455
|
+
import { oc as oc3 } from "@orpc/contract";
|
|
1456
|
+
import { z as z29 } from "zod";
|
|
1457
|
+
var mandates = oc3.errors({
|
|
1458
|
+
NOT_FOUND: { message: "no mandate has that ID", status: 404 }
|
|
1459
|
+
});
|
|
1460
|
+
var hostMandateRuleSchema = z29.object({ ruleID: z29.string(), sentence: z29.string() });
|
|
1461
|
+
var hostMandateSchema = z29.object({
|
|
1462
|
+
mandateID: z29.string(),
|
|
1463
|
+
title: z29.string().nullable(),
|
|
1464
|
+
rules: z29.array(hostMandateRuleSchema),
|
|
1465
|
+
startedAt: z29.date(),
|
|
1466
|
+
expires: z29.date()
|
|
1467
|
+
});
|
|
1468
|
+
var hostMandatesContract = {
|
|
1469
|
+
list: mandates.output(z29.array(hostMandateSchema)),
|
|
1470
|
+
end: mandates.input(z29.strictObject({ mandateID: z29.string().min(1) })).output(z29.object({ mandateID: z29.string(), state: z29.enum(["ended", "expired"]) }))
|
|
1471
|
+
};
|
|
1472
|
+
|
|
1473
|
+
// src/contract/host-passkey-contract.ts
|
|
1474
|
+
import { oc as oc4 } from "@orpc/contract";
|
|
1475
|
+
import { z as z30 } from "zod";
|
|
1476
|
+
var hostPasskeySchema = z30.object({
|
|
1477
|
+
passkeyID: z30.string(),
|
|
1478
|
+
label: z30.string(),
|
|
1479
|
+
synced: z30.boolean(),
|
|
1480
|
+
origin: z30.string(),
|
|
1481
|
+
registeredBy: z30.string(),
|
|
1482
|
+
authorizedBy: z30.string(),
|
|
1483
|
+
registeredAt: z30.date(),
|
|
1484
|
+
lastUsedAt: z30.date().nullable(),
|
|
1485
|
+
revokedAt: z30.date().nullable()
|
|
1318
1486
|
});
|
|
1319
1487
|
var hostPasskeyContract = {
|
|
1320
|
-
issueCode:
|
|
1321
|
-
list:
|
|
1322
|
-
revoke:
|
|
1488
|
+
issueCode: oc4.output(z30.object({ code: z30.string(), expiresAt: z30.date() })),
|
|
1489
|
+
list: oc4.output(z30.array(hostPasskeySchema)),
|
|
1490
|
+
revoke: oc4.errors({
|
|
1323
1491
|
PASSKEY_NOT_FOUND: { message: "no passkey has that ID", status: 404 }
|
|
1324
|
-
}).input(
|
|
1492
|
+
}).input(z30.strictObject({ passkeyID: z30.string().min(1) })).output(z30.object({ passkeyID: z30.string(), revokedAt: z30.date() }))
|
|
1325
1493
|
};
|
|
1326
1494
|
|
|
1327
1495
|
// src/contract/known-contact-schema.ts
|
|
1328
|
-
import { z as
|
|
1329
|
-
var knownContactSchema =
|
|
1330
|
-
contactID:
|
|
1331
|
-
name:
|
|
1332
|
-
destination:
|
|
1333
|
-
markedAt:
|
|
1496
|
+
import { z as z31 } from "zod";
|
|
1497
|
+
var knownContactSchema = z31.object({
|
|
1498
|
+
contactID: z31.string(),
|
|
1499
|
+
name: z31.string().nullable(),
|
|
1500
|
+
destination: z31.string().nullable(),
|
|
1501
|
+
markedAt: z31.date()
|
|
1334
1502
|
});
|
|
1335
1503
|
|
|
1336
1504
|
// src/contract/turn-inputs-contract.ts
|
|
1337
|
-
import { oc as
|
|
1338
|
-
import { z as
|
|
1505
|
+
import { oc as oc5 } from "@orpc/contract";
|
|
1506
|
+
import { z as z34 } from "zod";
|
|
1339
1507
|
|
|
1340
1508
|
// src/contract/input-miss-schema.ts
|
|
1341
|
-
import { z as
|
|
1342
|
-
var inputMissSchema =
|
|
1343
|
-
missID:
|
|
1344
|
-
captureID:
|
|
1345
|
-
taskID:
|
|
1346
|
-
stepRunID:
|
|
1347
|
-
reason:
|
|
1509
|
+
import { z as z32 } from "zod";
|
|
1510
|
+
var inputMissSchema = z32.object({
|
|
1511
|
+
missID: z32.string(),
|
|
1512
|
+
captureID: z32.string().nullable(),
|
|
1513
|
+
taskID: z32.string(),
|
|
1514
|
+
stepRunID: z32.string(),
|
|
1515
|
+
reason: z32.enum([
|
|
1348
1516
|
"queue_full",
|
|
1349
1517
|
"spool_full",
|
|
1350
1518
|
"spool_write_failed",
|
|
@@ -1356,46 +1524,46 @@ var inputMissSchema = z30.object({
|
|
|
1356
1524
|
"intake_failed",
|
|
1357
1525
|
"holds_own_value"
|
|
1358
1526
|
]),
|
|
1359
|
-
count:
|
|
1360
|
-
writer:
|
|
1361
|
-
counter:
|
|
1362
|
-
createdAt:
|
|
1527
|
+
count: z32.int().positive(),
|
|
1528
|
+
writer: z32.string().nullable(),
|
|
1529
|
+
counter: z32.int().nullable(),
|
|
1530
|
+
createdAt: z32.date()
|
|
1363
1531
|
});
|
|
1364
1532
|
|
|
1365
1533
|
// src/contract/logged-input-schema.ts
|
|
1366
|
-
import { z as
|
|
1367
|
-
var loggedInputSchema =
|
|
1368
|
-
inputID:
|
|
1369
|
-
captureID:
|
|
1370
|
-
taskID:
|
|
1371
|
-
stepRunID:
|
|
1372
|
-
writer:
|
|
1373
|
-
counter:
|
|
1374
|
-
role:
|
|
1375
|
-
profile:
|
|
1376
|
-
model:
|
|
1377
|
-
harness:
|
|
1378
|
-
api:
|
|
1379
|
-
endpoint:
|
|
1380
|
-
route:
|
|
1381
|
-
isRewritten:
|
|
1382
|
-
upstreamStatus:
|
|
1383
|
-
bytes:
|
|
1384
|
-
intakeSequence:
|
|
1385
|
-
receivedAt:
|
|
1386
|
-
takenAt:
|
|
1387
|
-
state:
|
|
1388
|
-
removedCause:
|
|
1534
|
+
import { z as z33 } from "zod";
|
|
1535
|
+
var loggedInputSchema = z33.object({
|
|
1536
|
+
inputID: z33.string(),
|
|
1537
|
+
captureID: z33.string(),
|
|
1538
|
+
taskID: z33.string(),
|
|
1539
|
+
stepRunID: z33.string(),
|
|
1540
|
+
writer: z33.string(),
|
|
1541
|
+
counter: z33.int(),
|
|
1542
|
+
role: z33.string(),
|
|
1543
|
+
profile: z33.string(),
|
|
1544
|
+
model: z33.string(),
|
|
1545
|
+
harness: z33.string(),
|
|
1546
|
+
api: z33.string(),
|
|
1547
|
+
endpoint: z33.string(),
|
|
1548
|
+
route: z33.string(),
|
|
1549
|
+
isRewritten: z33.boolean(),
|
|
1550
|
+
upstreamStatus: z33.int(),
|
|
1551
|
+
bytes: z33.int(),
|
|
1552
|
+
intakeSequence: z33.int(),
|
|
1553
|
+
receivedAt: z33.date(),
|
|
1554
|
+
takenAt: z33.date(),
|
|
1555
|
+
state: z33.enum(["writing", "stored", "missing", "removed"]),
|
|
1556
|
+
removedCause: z33.enum(["retention_days", "retention_bytes", "forget", "dropped", "restore", "reset"]).nullable()
|
|
1389
1557
|
});
|
|
1390
1558
|
|
|
1391
1559
|
// src/contract/turn-inputs-contract.ts
|
|
1392
|
-
var turnInputOn =
|
|
1393
|
-
state:
|
|
1394
|
-
forMs:
|
|
1560
|
+
var turnInputOn = z34.strictObject({
|
|
1561
|
+
state: z34.literal("on"),
|
|
1562
|
+
forMs: z34.int().positive().nullable()
|
|
1395
1563
|
});
|
|
1396
|
-
var turnInputOff =
|
|
1397
|
-
var turnInputSetSchema =
|
|
1398
|
-
var turnInputs =
|
|
1564
|
+
var turnInputOff = z34.strictObject({ state: z34.literal("off"), drop: z34.boolean() });
|
|
1565
|
+
var turnInputSetSchema = z34.discriminatedUnion("state", [turnInputOn, turnInputOff]);
|
|
1566
|
+
var turnInputs = oc5.errors({
|
|
1399
1567
|
NOT_FOUND: { message: "no logged request has that ID", status: 404 },
|
|
1400
1568
|
REMOVED: { message: "that request is removed or its body is missing", status: 410 },
|
|
1401
1569
|
OPEN_NOT_RECORDED: {
|
|
@@ -1404,27 +1572,27 @@ var turnInputs = oc4.errors({
|
|
|
1404
1572
|
},
|
|
1405
1573
|
NOT_CONFIGURED: { message: "the turn-input log is not configured", status: 409 }
|
|
1406
1574
|
});
|
|
1407
|
-
var listedInputsSchema =
|
|
1408
|
-
inputs:
|
|
1409
|
-
misses:
|
|
1575
|
+
var listedInputsSchema = z34.object({
|
|
1576
|
+
inputs: z34.array(loggedInputSchema),
|
|
1577
|
+
misses: z34.array(inputMissSchema)
|
|
1410
1578
|
});
|
|
1411
1579
|
var turnInputsContract = {
|
|
1412
|
-
list: turnInputs.input(
|
|
1413
|
-
open: turnInputs.input(
|
|
1414
|
-
set: turnInputs.input(turnInputSetSchema).output(
|
|
1580
|
+
list: turnInputs.input(z34.strictObject({ limit: z34.int().positive().max(500).default(50) })).output(listedInputsSchema),
|
|
1581
|
+
open: turnInputs.input(z34.strictObject({ inputID: z34.string().min(1) })).output(z34.object({ inputID: z34.string(), body: z34.base64() })),
|
|
1582
|
+
set: turnInputs.input(turnInputSetSchema).output(z34.object({ state: z34.enum(["on", "off"]), until: z34.number().nullable() }))
|
|
1415
1583
|
};
|
|
1416
1584
|
|
|
1417
1585
|
// src/contract/host-contract.ts
|
|
1418
|
-
var versionRefSchema2 =
|
|
1419
|
-
var versionTargetSchema2 =
|
|
1420
|
-
itemID:
|
|
1421
|
-
version:
|
|
1422
|
-
});
|
|
1423
|
-
var itemTextSchema =
|
|
1424
|
-
var proposalOriginSchema2 =
|
|
1425
|
-
var memoryOriginSchema =
|
|
1426
|
-
var contentSourceSchema =
|
|
1427
|
-
var reviewReasonSchema2 =
|
|
1586
|
+
var versionRefSchema2 = z35.object({ itemID: z35.string(), version: z35.int().positive() });
|
|
1587
|
+
var versionTargetSchema2 = z35.strictObject({
|
|
1588
|
+
itemID: z35.string().min(1),
|
|
1589
|
+
version: z35.int().positive()
|
|
1590
|
+
});
|
|
1591
|
+
var itemTextSchema = z35.string().max(2000).regex(/\S/u);
|
|
1592
|
+
var proposalOriginSchema2 = z35.enum(["owner", "conversation", "task"]);
|
|
1593
|
+
var memoryOriginSchema = z35.enum([...proposalOriginSchema2.options, "lapse"]);
|
|
1594
|
+
var contentSourceSchema = z35.enum(["owner", "owner_data", "untrusted"]);
|
|
1595
|
+
var reviewReasonSchema2 = z35.enum([
|
|
1428
1596
|
"no_quote",
|
|
1429
1597
|
"quote_not_typed",
|
|
1430
1598
|
"quote_in_quoted_block",
|
|
@@ -1441,71 +1609,72 @@ var reviewReasonSchema2 = z33.enum([
|
|
|
1441
1609
|
"from_photo",
|
|
1442
1610
|
"sensitive",
|
|
1443
1611
|
"subject_change",
|
|
1612
|
+
"labels",
|
|
1444
1613
|
"ask_rule"
|
|
1445
1614
|
]);
|
|
1446
|
-
var proposalSourceSchema2 =
|
|
1615
|
+
var proposalSourceSchema2 = z35.object({
|
|
1447
1616
|
origin: proposalOriginSchema2,
|
|
1448
|
-
thread:
|
|
1449
|
-
proposedAt:
|
|
1450
|
-
});
|
|
1451
|
-
var pendingProposalSchema =
|
|
1452
|
-
proposalID:
|
|
1453
|
-
operation:
|
|
1454
|
-
itemID:
|
|
1455
|
-
targetVersion:
|
|
1456
|
-
isPinned:
|
|
1457
|
-
subject:
|
|
1458
|
-
newSubject:
|
|
1459
|
-
isSensitive:
|
|
1460
|
-
kind:
|
|
1617
|
+
thread: z35.string().nullable(),
|
|
1618
|
+
proposedAt: z35.date()
|
|
1619
|
+
});
|
|
1620
|
+
var pendingProposalSchema = z35.object({
|
|
1621
|
+
proposalID: z35.string(),
|
|
1622
|
+
operation: z35.enum(["remember", "retire", "pin"]),
|
|
1623
|
+
itemID: z35.string(),
|
|
1624
|
+
targetVersion: z35.int().nullable(),
|
|
1625
|
+
isPinned: z35.boolean(),
|
|
1626
|
+
subject: z35.enum(["owner", "self", "shared"]),
|
|
1627
|
+
newSubject: z35.enum(["owner", "self", "shared"]).nullable(),
|
|
1628
|
+
isSensitive: z35.boolean(),
|
|
1629
|
+
kind: z35.enum(["fact", "self"]),
|
|
1461
1630
|
reason: reviewReasonSchema2,
|
|
1462
|
-
actionHash:
|
|
1631
|
+
actionHash: z35.string(),
|
|
1463
1632
|
origin: proposalOriginSchema2,
|
|
1464
1633
|
source: contentSourceSchema,
|
|
1465
|
-
createdAt:
|
|
1466
|
-
lapseAt:
|
|
1467
|
-
sources:
|
|
1468
|
-
text:
|
|
1469
|
-
quote:
|
|
1470
|
-
});
|
|
1471
|
-
var closeMatchSchema2 =
|
|
1472
|
-
var approvalResultSchema =
|
|
1473
|
-
|
|
1474
|
-
|
|
1634
|
+
createdAt: z35.date(),
|
|
1635
|
+
lapseAt: z35.date(),
|
|
1636
|
+
sources: z35.array(proposalSourceSchema2),
|
|
1637
|
+
text: z35.string(),
|
|
1638
|
+
quote: z35.string().nullable()
|
|
1639
|
+
});
|
|
1640
|
+
var closeMatchSchema2 = z35.object({ itemID: z35.string(), version: z35.int(), text: z35.string() });
|
|
1641
|
+
var approvalResultSchema = z35.discriminatedUnion("status", [
|
|
1642
|
+
z35.object({ status: z35.literal("applied"), itemID: z35.string(), version: z35.int() }),
|
|
1643
|
+
z35.object({ status: z35.literal("close_match"), item: closeMatchSchema2 })
|
|
1475
1644
|
]);
|
|
1476
|
-
var historyVersionSchema =
|
|
1477
|
-
version:
|
|
1478
|
-
change:
|
|
1479
|
-
state:
|
|
1645
|
+
var historyVersionSchema = z35.object({
|
|
1646
|
+
version: z35.int(),
|
|
1647
|
+
change: z35.enum(["created", "edited", "retired", "restored", "undone"]),
|
|
1648
|
+
state: z35.enum(["active", "retired"]),
|
|
1480
1649
|
origin: memoryOriginSchema,
|
|
1481
1650
|
source: contentSourceSchema,
|
|
1482
|
-
recordedAt:
|
|
1483
|
-
status:
|
|
1484
|
-
text:
|
|
1485
|
-
});
|
|
1486
|
-
var itemHistorySchema =
|
|
1487
|
-
itemID:
|
|
1488
|
-
subject:
|
|
1489
|
-
kind:
|
|
1490
|
-
state:
|
|
1491
|
-
versions:
|
|
1492
|
-
});
|
|
1493
|
-
var proposalAnswerSchema =
|
|
1494
|
-
proposalID:
|
|
1495
|
-
actionHash:
|
|
1496
|
-
});
|
|
1497
|
-
var hostSessionSchema =
|
|
1498
|
-
sessionID:
|
|
1499
|
-
deviceName:
|
|
1500
|
-
createdAt:
|
|
1501
|
-
lastUsedAt:
|
|
1502
|
-
});
|
|
1503
|
-
var subjectCountSchema =
|
|
1504
|
-
owner:
|
|
1505
|
-
shared:
|
|
1506
|
-
self:
|
|
1507
|
-
});
|
|
1508
|
-
var memory =
|
|
1651
|
+
recordedAt: z35.date(),
|
|
1652
|
+
status: z35.enum(["readable", "shredded", "unreadable"]),
|
|
1653
|
+
text: z35.string().nullable()
|
|
1654
|
+
});
|
|
1655
|
+
var itemHistorySchema = z35.object({
|
|
1656
|
+
itemID: z35.string(),
|
|
1657
|
+
subject: z35.enum(["owner", "self", "shared"]),
|
|
1658
|
+
kind: z35.enum(["fact", "self"]),
|
|
1659
|
+
state: z35.enum(["active", "retired", "forgetting", "forgotten"]),
|
|
1660
|
+
versions: z35.array(historyVersionSchema)
|
|
1661
|
+
});
|
|
1662
|
+
var proposalAnswerSchema = z35.strictObject({
|
|
1663
|
+
proposalID: z35.string().min(1),
|
|
1664
|
+
actionHash: z35.string().min(1)
|
|
1665
|
+
});
|
|
1666
|
+
var hostSessionSchema = z35.object({
|
|
1667
|
+
sessionID: z35.string(),
|
|
1668
|
+
deviceName: z35.string(),
|
|
1669
|
+
createdAt: z35.date(),
|
|
1670
|
+
lastUsedAt: z35.date()
|
|
1671
|
+
});
|
|
1672
|
+
var subjectCountSchema = z35.object({
|
|
1673
|
+
owner: z35.int().nonnegative(),
|
|
1674
|
+
shared: z35.int().nonnegative(),
|
|
1675
|
+
self: z35.int().nonnegative()
|
|
1676
|
+
});
|
|
1677
|
+
var memory = oc6.errors({
|
|
1509
1678
|
MEMORY_NOT_STARTED: { message: "the memory store has not started yet", status: 503 },
|
|
1510
1679
|
NOT_FOUND: { message: "nothing has that ID", status: 404 },
|
|
1511
1680
|
PROPOSAL_HASH: { message: "the action hash names another proposal", status: 409 },
|
|
@@ -1518,30 +1687,30 @@ var memory = oc5.errors({
|
|
|
1518
1687
|
PIN_EDIT: { message: "a pin takes no edited text", status: 400 },
|
|
1519
1688
|
SELF_NOTE_REFUSED: { message: "a self-note never takes that change", status: 409 }
|
|
1520
1689
|
});
|
|
1521
|
-
var skillFileSchema =
|
|
1522
|
-
var pendingSkillProposalSchema =
|
|
1523
|
-
proposalID:
|
|
1524
|
-
name:
|
|
1525
|
-
skillHash:
|
|
1526
|
-
baseHash:
|
|
1527
|
-
files:
|
|
1528
|
-
inForce:
|
|
1529
|
-
skillHash:
|
|
1530
|
-
origin:
|
|
1531
|
-
files:
|
|
1690
|
+
var skillFileSchema = z35.object({ path: z35.string(), text: z35.string() });
|
|
1691
|
+
var pendingSkillProposalSchema = z35.object({
|
|
1692
|
+
proposalID: z35.string(),
|
|
1693
|
+
name: z35.string(),
|
|
1694
|
+
skillHash: z35.string(),
|
|
1695
|
+
baseHash: z35.string().nullable(),
|
|
1696
|
+
files: z35.array(skillFileSchema),
|
|
1697
|
+
inForce: z35.object({
|
|
1698
|
+
skillHash: z35.string(),
|
|
1699
|
+
origin: z35.enum(["definitions", "vendored", "nixie"]),
|
|
1700
|
+
files: z35.array(skillFileSchema)
|
|
1532
1701
|
}).nullable(),
|
|
1533
|
-
untypedToken:
|
|
1534
|
-
thread:
|
|
1535
|
-
provenance:
|
|
1536
|
-
createdAt:
|
|
1537
|
-
lapseAt:
|
|
1538
|
-
isStale:
|
|
1539
|
-
});
|
|
1540
|
-
var skillAnswerSchema =
|
|
1541
|
-
proposalID:
|
|
1542
|
-
skillHash:
|
|
1543
|
-
});
|
|
1544
|
-
var skills =
|
|
1702
|
+
untypedToken: z35.object({ kind: z35.string(), raw: z35.string() }).nullable(),
|
|
1703
|
+
thread: z35.string().nullable(),
|
|
1704
|
+
provenance: z35.object({ runID: z35.string(), callID: z35.string(), profile: z35.string() }),
|
|
1705
|
+
createdAt: z35.date(),
|
|
1706
|
+
lapseAt: z35.date(),
|
|
1707
|
+
isStale: z35.boolean()
|
|
1708
|
+
});
|
|
1709
|
+
var skillAnswerSchema = z35.strictObject({
|
|
1710
|
+
proposalID: z35.string().min(1),
|
|
1711
|
+
skillHash: z35.string().min(1)
|
|
1712
|
+
});
|
|
1713
|
+
var skills = oc6.errors({
|
|
1545
1714
|
NOT_FOUND: { message: "nothing has that ID", status: 404 },
|
|
1546
1715
|
PROPOSAL_HASH: { message: "the skill hash names other files", status: 409 },
|
|
1547
1716
|
PROPOSAL_CLOSED: { message: "the proposal is answered or lapsed", status: 409 },
|
|
@@ -1549,103 +1718,99 @@ var skills = oc5.errors({
|
|
|
1549
1718
|
SKILL_CHECK: { message: "the files fail the seed checks", status: 400 },
|
|
1550
1719
|
WRONG_STATE: { message: "the skill nixie wrote is no longer in force", status: 409 }
|
|
1551
1720
|
});
|
|
1552
|
-
var definitionsSkillSchema =
|
|
1553
|
-
var writtenSkillSchema =
|
|
1554
|
-
approvalID:
|
|
1555
|
-
proposalID:
|
|
1556
|
-
name:
|
|
1557
|
-
skillHash:
|
|
1721
|
+
var definitionsSkillSchema = z35.object({ skillHash: z35.string(), origin: z35.enum(["definitions", "vendored"]) }).nullable();
|
|
1722
|
+
var writtenSkillSchema = z35.object({
|
|
1723
|
+
approvalID: z35.string(),
|
|
1724
|
+
proposalID: z35.string(),
|
|
1725
|
+
name: z35.string(),
|
|
1726
|
+
skillHash: z35.string(),
|
|
1558
1727
|
base: definitionsSkillSchema,
|
|
1559
1728
|
definitions: definitionsSkillSchema,
|
|
1560
|
-
isConflict:
|
|
1561
|
-
pullRequestURL:
|
|
1562
|
-
approvedAt:
|
|
1563
|
-
});
|
|
1564
|
-
var promptPartFileSchema =
|
|
1565
|
-
var promptEntrySchema =
|
|
1566
|
-
var pendingPromptProposalSchema =
|
|
1567
|
-
proposalID:
|
|
1568
|
-
promptID:
|
|
1569
|
-
proposalHash:
|
|
1570
|
-
baseHash:
|
|
1729
|
+
isConflict: z35.boolean(),
|
|
1730
|
+
pullRequestURL: z35.url().nullable(),
|
|
1731
|
+
approvedAt: z35.date()
|
|
1732
|
+
});
|
|
1733
|
+
var promptPartFileSchema = z35.object({ path: z35.string(), text: z35.string() });
|
|
1734
|
+
var promptEntrySchema = z35.record(z35.string(), z35.string());
|
|
1735
|
+
var pendingPromptProposalSchema = z35.object({
|
|
1736
|
+
proposalID: z35.string(),
|
|
1737
|
+
promptID: z35.string(),
|
|
1738
|
+
proposalHash: z35.string(),
|
|
1739
|
+
baseHash: z35.string().nullable(),
|
|
1571
1740
|
entry: promptEntrySchema,
|
|
1572
|
-
files:
|
|
1573
|
-
reason:
|
|
1574
|
-
inForce:
|
|
1575
|
-
thread:
|
|
1576
|
-
provenance:
|
|
1577
|
-
createdAt:
|
|
1578
|
-
lapseAt:
|
|
1579
|
-
isStale:
|
|
1580
|
-
});
|
|
1581
|
-
var promptAnswerSchema =
|
|
1582
|
-
proposalID:
|
|
1583
|
-
proposalHash:
|
|
1584
|
-
});
|
|
1585
|
-
var prompts =
|
|
1741
|
+
files: z35.array(promptPartFileSchema),
|
|
1742
|
+
reason: z35.string(),
|
|
1743
|
+
inForce: z35.object({ parts: promptEntrySchema, template: z35.string().nullable() }).nullable(),
|
|
1744
|
+
thread: z35.string().nullable(),
|
|
1745
|
+
provenance: z35.object({ runID: z35.string(), callID: z35.string(), profile: z35.string() }),
|
|
1746
|
+
createdAt: z35.date(),
|
|
1747
|
+
lapseAt: z35.date(),
|
|
1748
|
+
isStale: z35.boolean()
|
|
1749
|
+
});
|
|
1750
|
+
var promptAnswerSchema = z35.strictObject({
|
|
1751
|
+
proposalID: z35.string().min(1),
|
|
1752
|
+
proposalHash: z35.string().min(1)
|
|
1753
|
+
});
|
|
1754
|
+
var prompts = oc6.errors({
|
|
1586
1755
|
NOT_FOUND: { message: "nothing has that ID", status: 404 },
|
|
1587
1756
|
PROPOSAL_HASH: { message: "the proposal hash names another override", status: 409 },
|
|
1588
1757
|
PROPOSAL_CLOSED: { message: "the proposal is answered or lapsed", status: 409 },
|
|
1589
1758
|
STALE_BASE: { message: "the override in force moved past the proposal", status: 409 },
|
|
1590
1759
|
PROMPT_CHECK: { message: "the override fails the definitions checks", status: 400 }
|
|
1591
1760
|
});
|
|
1592
|
-
var ruleVersionSchema =
|
|
1593
|
-
var ruleInForceSchema =
|
|
1594
|
-
ruleID:
|
|
1595
|
-
revision:
|
|
1596
|
-
ruleHash:
|
|
1597
|
-
sentence:
|
|
1598
|
-
origin:
|
|
1599
|
-
changeID:
|
|
1600
|
-
lastFiredAt:
|
|
1601
|
-
});
|
|
1602
|
-
var ruleConflictSchema =
|
|
1603
|
-
ruleID:
|
|
1604
|
-
changeID:
|
|
1761
|
+
var ruleVersionSchema = z35.object({ ruleHash: z35.string(), sentence: z35.string() }).nullable();
|
|
1762
|
+
var ruleInForceSchema = z35.object({
|
|
1763
|
+
ruleID: z35.string(),
|
|
1764
|
+
revision: z35.int().positive(),
|
|
1765
|
+
ruleHash: z35.string(),
|
|
1766
|
+
sentence: z35.string(),
|
|
1767
|
+
origin: z35.enum(["definitions", "nixie"]),
|
|
1768
|
+
changeID: z35.string().nullable(),
|
|
1769
|
+
lastFiredAt: z35.date().nullable()
|
|
1770
|
+
});
|
|
1771
|
+
var ruleConflictSchema = z35.object({
|
|
1772
|
+
ruleID: z35.string(),
|
|
1773
|
+
changeID: z35.string(),
|
|
1605
1774
|
nixie: ruleVersionSchema,
|
|
1606
1775
|
repo: ruleVersionSchema,
|
|
1607
1776
|
base: ruleVersionSchema,
|
|
1608
|
-
changedBy:
|
|
1609
|
-
reason:
|
|
1610
|
-
changedAt:
|
|
1777
|
+
changedBy: z35.enum(["owner", "nixie"]),
|
|
1778
|
+
reason: z35.string(),
|
|
1779
|
+
changedAt: z35.date()
|
|
1611
1780
|
});
|
|
1612
|
-
var ruleProposalChangeSchema =
|
|
1613
|
-
ruleID:
|
|
1781
|
+
var ruleProposalChangeSchema = z35.object({
|
|
1782
|
+
ruleID: z35.string(),
|
|
1614
1783
|
before: ruleVersionSchema,
|
|
1615
1784
|
after: ruleVersionSchema
|
|
1616
1785
|
});
|
|
1617
|
-
var effectChangeSchema =
|
|
1618
|
-
tool:
|
|
1619
|
-
remove:
|
|
1620
|
-
sentence:
|
|
1786
|
+
var effectChangeSchema = z35.object({
|
|
1787
|
+
tool: z35.string(),
|
|
1788
|
+
remove: z35.array(z35.string()),
|
|
1789
|
+
sentence: z35.string()
|
|
1621
1790
|
});
|
|
1622
|
-
var pendingRuleProposalSchema =
|
|
1623
|
-
proposalID:
|
|
1624
|
-
changes:
|
|
1625
|
-
effectChanges:
|
|
1626
|
-
createdAt:
|
|
1627
|
-
lapseAt:
|
|
1791
|
+
var pendingRuleProposalSchema = z35.object({
|
|
1792
|
+
proposalID: z35.string(),
|
|
1793
|
+
changes: z35.array(ruleProposalChangeSchema),
|
|
1794
|
+
effectChanges: z35.array(effectChangeSchema),
|
|
1795
|
+
createdAt: z35.date(),
|
|
1796
|
+
lapseAt: z35.date()
|
|
1628
1797
|
});
|
|
1629
|
-
var ruleProposalAnswerSchema =
|
|
1798
|
+
var ruleProposalAnswerSchema = z35.strictObject({ proposalID: z35.string().min(1) });
|
|
1630
1799
|
var ruleProposalRejectionSchema = ruleProposalAnswerSchema.extend({
|
|
1631
|
-
reason:
|
|
1800
|
+
reason: z35.string().max(500).regex(/\S/u)
|
|
1632
1801
|
});
|
|
1633
1802
|
var actionRejectionSchema = ruleProposalAnswerSchema.extend({
|
|
1634
|
-
reason:
|
|
1803
|
+
reason: z35.string().max(500).regex(/\S/u).optional()
|
|
1635
1804
|
});
|
|
1636
1805
|
var ruleProposalErrors = {
|
|
1637
1806
|
NOT_FOUND: { message: "nothing has that ID", status: 404 },
|
|
1638
1807
|
PROPOSAL_CLOSED: { message: "the proposal is answered, withdrawn or lapsed", status: 409 }
|
|
1639
1808
|
};
|
|
1640
|
-
var rules =
|
|
1641
|
-
var contacts =
|
|
1809
|
+
var rules = oc6.errors(ruleProposalErrors);
|
|
1810
|
+
var contacts = oc6.errors({
|
|
1642
1811
|
NOT_FOUND: { message: "no known contact has that ID", status: 404 }
|
|
1643
1812
|
});
|
|
1644
|
-
var
|
|
1645
|
-
itemIDs: z33.array(z33.string()),
|
|
1646
|
-
backup: forgetBackupSchema
|
|
1647
|
-
});
|
|
1648
|
-
var hostTaskStateSchema = z33.enum([
|
|
1813
|
+
var hostTaskStateSchema = z35.enum([
|
|
1649
1814
|
"ready",
|
|
1650
1815
|
"running",
|
|
1651
1816
|
"waiting",
|
|
@@ -1655,35 +1820,39 @@ var hostTaskStateSchema = z33.enum([
|
|
|
1655
1820
|
"failed",
|
|
1656
1821
|
"closed"
|
|
1657
1822
|
]);
|
|
1658
|
-
var taskControl2 =
|
|
1823
|
+
var taskControl2 = oc6.errors({
|
|
1659
1824
|
TASK_NOT_FOUND: { message: "no task has that ID", status: 404 },
|
|
1660
1825
|
TASK_STATE_REFUSED: {
|
|
1661
1826
|
message: "the task is in a state that does not take this control",
|
|
1662
1827
|
status: 409
|
|
1828
|
+
},
|
|
1829
|
+
RUNNER_LACKS_CONTROL: {
|
|
1830
|
+
message: "the runner of the task does not take this control",
|
|
1831
|
+
status: 409
|
|
1663
1832
|
}
|
|
1664
|
-
}).input(
|
|
1665
|
-
taskID:
|
|
1833
|
+
}).input(z35.strictObject({ taskID: z35.string().min(1) })).output(z35.object({
|
|
1834
|
+
taskID: z35.string(),
|
|
1666
1835
|
state: hostTaskStateSchema,
|
|
1667
|
-
isPauseRequested:
|
|
1836
|
+
isPauseRequested: z35.boolean()
|
|
1668
1837
|
}));
|
|
1669
1838
|
var hostContract = {
|
|
1670
|
-
reset:
|
|
1671
|
-
resetAt:
|
|
1672
|
-
lastSequence:
|
|
1673
|
-
keptSessions:
|
|
1839
|
+
reset: oc6.output(z35.object({
|
|
1840
|
+
resetAt: z35.date(),
|
|
1841
|
+
lastSequence: z35.int().nonnegative(),
|
|
1842
|
+
keptSessions: z35.int().nonnegative()
|
|
1674
1843
|
})),
|
|
1675
|
-
resetConversations:
|
|
1676
|
-
resetAt:
|
|
1677
|
-
lastSequence:
|
|
1678
|
-
shreddedRecords:
|
|
1844
|
+
resetConversations: oc6.output(z35.object({
|
|
1845
|
+
resetAt: z35.date(),
|
|
1846
|
+
lastSequence: z35.int().nonnegative(),
|
|
1847
|
+
shreddedRecords: z35.int().nonnegative(),
|
|
1679
1848
|
backup: forgetBackupSchema
|
|
1680
1849
|
})),
|
|
1681
1850
|
nixie: {
|
|
1682
|
-
pause:
|
|
1683
|
-
resume:
|
|
1851
|
+
pause: oc6.output(z35.object({ paused: pauseStateSchema })),
|
|
1852
|
+
resume: oc6.output(z35.object({ paused: pauseStateSchema }))
|
|
1684
1853
|
},
|
|
1685
1854
|
recovery: {
|
|
1686
|
-
read:
|
|
1855
|
+
read: oc6.output(z35.object({ recovery: recoverySchema }))
|
|
1687
1856
|
},
|
|
1688
1857
|
tasks: {
|
|
1689
1858
|
pause: taskControl2,
|
|
@@ -1694,105 +1863,106 @@ var hostContract = {
|
|
|
1694
1863
|
CONVERSATION_NEVER_CLOSES: { message: "the conversation is never closed", status: 409 }
|
|
1695
1864
|
}),
|
|
1696
1865
|
interrupt: taskControl2,
|
|
1697
|
-
raise:
|
|
1866
|
+
raise: oc6.errors({
|
|
1698
1867
|
TASK_NOT_FOUND: { message: "no task has that ID", status: 404 },
|
|
1699
1868
|
TASK_NOT_AT_LIMIT: { message: "the task is not paused at its limit", status: 409 },
|
|
1700
1869
|
LIMIT_NOT_RAISED: { message: "the new limits are not above the old ones", status: 409 }
|
|
1701
|
-
}).input(
|
|
1702
|
-
taskID:
|
|
1703
|
-
turns:
|
|
1704
|
-
dollars:
|
|
1870
|
+
}).input(z35.strictObject({
|
|
1871
|
+
taskID: z35.string().min(1),
|
|
1872
|
+
turns: z35.int().positive().optional(),
|
|
1873
|
+
dollars: z35.number().positive().optional()
|
|
1705
1874
|
}).refine((input) => input.turns !== undefined || input.dollars !== undefined, {
|
|
1706
1875
|
message: "a raise sets turns, dollars or both"
|
|
1707
|
-
})).output(
|
|
1708
|
-
taskID:
|
|
1876
|
+
})).output(z35.object({
|
|
1877
|
+
taskID: z35.string(),
|
|
1709
1878
|
state: hostTaskStateSchema,
|
|
1710
|
-
isPauseRequested:
|
|
1711
|
-
turns:
|
|
1712
|
-
dollars:
|
|
1879
|
+
isPauseRequested: z35.boolean(),
|
|
1880
|
+
turns: z35.int().positive(),
|
|
1881
|
+
dollars: z35.number().positive()
|
|
1713
1882
|
}))
|
|
1714
1883
|
},
|
|
1715
1884
|
sessions: {
|
|
1716
|
-
issueCode:
|
|
1717
|
-
list:
|
|
1718
|
-
label:
|
|
1885
|
+
issueCode: oc6.output(z35.object({ code: z35.string(), expiresAt: z35.date() })),
|
|
1886
|
+
list: oc6.output(z35.array(hostSessionSchema)),
|
|
1887
|
+
label: oc6.errors({
|
|
1719
1888
|
SESSION_NOT_FOUND: {
|
|
1720
1889
|
message: "no device session that is still signed in has that ID",
|
|
1721
1890
|
status: 404
|
|
1722
1891
|
},
|
|
1723
1892
|
LABEL_INVALID: { message: "a label holds 1 to 100 characters besides spaces", status: 400 }
|
|
1724
|
-
}).input(
|
|
1893
|
+
}).input(z35.strictObject({ sessionID: z35.string().min(1), label: z35.string() })).output(z35.object({ sessionID: z35.string(), label: z35.string() }))
|
|
1725
1894
|
},
|
|
1726
1895
|
passkeys: hostPasskeyContract,
|
|
1727
1896
|
memory: {
|
|
1728
1897
|
proposals: {
|
|
1729
|
-
list: memory.output(
|
|
1898
|
+
list: memory.output(z35.array(pendingProposalSchema)),
|
|
1730
1899
|
approve: memory.input(proposalAnswerSchema.extend({
|
|
1731
1900
|
revisionOf: versionTargetSchema2.optional(),
|
|
1732
|
-
ignoreCloseMatch:
|
|
1901
|
+
ignoreCloseMatch: z35.boolean().optional(),
|
|
1733
1902
|
editedText: itemTextSchema.optional()
|
|
1734
1903
|
})).output(approvalResultSchema),
|
|
1735
|
-
reject: memory.input(proposalAnswerSchema.extend({ reason:
|
|
1904
|
+
reject: memory.input(proposalAnswerSchema.extend({ reason: z35.string().max(500).regex(/\S/u).optional() })).output(z35.object({ proposalID: z35.string() }))
|
|
1736
1905
|
},
|
|
1737
|
-
subjects: memory.output(
|
|
1906
|
+
subjects: memory.output(z35.object({ items: subjectCountSchema, proposals: subjectCountSchema })),
|
|
1738
1907
|
items: {
|
|
1739
|
-
read: memory.input(
|
|
1908
|
+
read: memory.input(z35.strictObject({ itemID: z35.string().min(1) })).output(itemHistorySchema),
|
|
1740
1909
|
edit: memory.input(versionTargetSchema2.extend({ text: itemTextSchema })).output(versionRefSchema2),
|
|
1741
1910
|
retire: memory.input(versionTargetSchema2).output(versionRefSchema2),
|
|
1742
1911
|
restore: memory.input(versionTargetSchema2).output(versionRefSchema2),
|
|
1743
|
-
forget: memory.input(versionTargetSchema2).output(
|
|
1912
|
+
forget: memory.input(versionTargetSchema2).output(z35.object({ itemID: z35.string(), backup: forgetBackupSchema })),
|
|
1744
1913
|
forgetAll: memory.output(forgottenItemsSchema),
|
|
1745
|
-
pin: memory.input(
|
|
1914
|
+
pin: memory.input(z35.strictObject({ itemID: z35.string().min(1), isPinned: z35.boolean() })).output(z35.object({ itemID: z35.string(), isPinned: z35.boolean() }))
|
|
1746
1915
|
}
|
|
1747
1916
|
},
|
|
1748
1917
|
skills: {
|
|
1749
1918
|
proposals: {
|
|
1750
|
-
list: skills.output(
|
|
1751
|
-
approve: skills.input(skillAnswerSchema.extend({ files:
|
|
1752
|
-
reject: skills.input(skillAnswerSchema.extend({ reason:
|
|
1919
|
+
list: skills.output(z35.array(pendingSkillProposalSchema)),
|
|
1920
|
+
approve: skills.input(skillAnswerSchema.extend({ files: z35.array(skillFileSchema).min(1).optional() })).output(z35.object({ proposalID: z35.string(), approvalID: z35.string(), skillHash: z35.string() })),
|
|
1921
|
+
reject: skills.input(skillAnswerSchema.extend({ reason: z35.string().max(500).regex(/\S/u) })).output(z35.object({ proposalID: z35.string() }))
|
|
1753
1922
|
},
|
|
1754
1923
|
written: {
|
|
1755
|
-
list: skills.output(
|
|
1756
|
-
resolve: skills.input(
|
|
1757
|
-
approvalID:
|
|
1758
|
-
keep:
|
|
1759
|
-
})).output(
|
|
1924
|
+
list: skills.output(z35.array(writtenSkillSchema)),
|
|
1925
|
+
resolve: skills.input(z35.strictObject({
|
|
1926
|
+
approvalID: z35.string().min(1),
|
|
1927
|
+
keep: z35.enum(["nixie", "definitions"])
|
|
1928
|
+
})).output(z35.object({ approvalID: z35.string(), keep: z35.enum(["nixie", "definitions"]) }))
|
|
1760
1929
|
}
|
|
1761
1930
|
},
|
|
1762
1931
|
rules: {
|
|
1763
|
-
list: rules.output(
|
|
1764
|
-
conflicts: rules.output(
|
|
1765
|
-
resolve: rules.input(
|
|
1932
|
+
list: rules.output(z35.array(ruleInForceSchema)),
|
|
1933
|
+
conflicts: rules.output(z35.array(ruleConflictSchema)),
|
|
1934
|
+
resolve: rules.input(z35.strictObject({ ruleID: z35.string().min(1), keep: z35.enum(["nixie", "repo"]) })).output(z35.object({ ruleID: z35.string(), changeID: z35.string(), keep: z35.enum(["nixie", "repo"]) })),
|
|
1766
1935
|
proposals: {
|
|
1767
|
-
list: rules.output(
|
|
1768
|
-
approve: rules.input(ruleProposalAnswerSchema).output(
|
|
1769
|
-
reject: rules.input(ruleProposalRejectionSchema).output(
|
|
1936
|
+
list: rules.output(z35.array(pendingRuleProposalSchema)),
|
|
1937
|
+
approve: rules.input(ruleProposalAnswerSchema).output(z35.object({ proposalID: z35.string() })),
|
|
1938
|
+
reject: rules.input(ruleProposalRejectionSchema).output(z35.object({ proposalID: z35.string() }))
|
|
1770
1939
|
}
|
|
1771
1940
|
},
|
|
1772
1941
|
actions: {
|
|
1773
1942
|
proposals: {
|
|
1774
|
-
list: rules.output(
|
|
1775
|
-
approve: rules.input(ruleProposalAnswerSchema).output(
|
|
1776
|
-
reject: rules.input(actionRejectionSchema).output(
|
|
1943
|
+
list: rules.output(z35.array(actionProposalSchema)),
|
|
1944
|
+
approve: rules.input(ruleProposalAnswerSchema).output(z35.object({ proposalID: z35.string() })),
|
|
1945
|
+
reject: rules.input(actionRejectionSchema).output(z35.object({ proposalID: z35.string() }))
|
|
1777
1946
|
}
|
|
1778
1947
|
},
|
|
1948
|
+
mandates: hostMandatesContract,
|
|
1779
1949
|
contacts: {
|
|
1780
|
-
list: contacts.output(
|
|
1781
|
-
markKnown: contacts.input(
|
|
1782
|
-
destination:
|
|
1783
|
-
name:
|
|
1784
|
-
})).output(
|
|
1785
|
-
unmark: contacts.input(
|
|
1950
|
+
list: contacts.output(z35.array(knownContactSchema)),
|
|
1951
|
+
markKnown: contacts.input(z35.strictObject({
|
|
1952
|
+
destination: z35.string().min(1).max(500),
|
|
1953
|
+
name: z35.string().min(1).max(200).optional()
|
|
1954
|
+
})).output(z35.object({ contact: knownContactSchema, isNew: z35.boolean() })),
|
|
1955
|
+
unmark: contacts.input(z35.strictObject({ contactID: z35.string().min(1) })).output(z35.object({ contactID: z35.string() }))
|
|
1786
1956
|
},
|
|
1787
1957
|
turnInputs: turnInputsContract,
|
|
1788
1958
|
prompts: {
|
|
1789
1959
|
proposals: {
|
|
1790
|
-
list: prompts.output(
|
|
1960
|
+
list: prompts.output(z35.array(pendingPromptProposalSchema)),
|
|
1791
1961
|
approve: prompts.input(promptAnswerSchema.extend({
|
|
1792
1962
|
entry: promptEntrySchema.optional(),
|
|
1793
|
-
files:
|
|
1794
|
-
})).output(
|
|
1795
|
-
reject: prompts.input(promptAnswerSchema.extend({ reason:
|
|
1963
|
+
files: z35.array(promptPartFileSchema).optional()
|
|
1964
|
+
})).output(z35.object({ proposalID: z35.string(), approvalID: z35.string(), proposalHash: z35.string() })),
|
|
1965
|
+
reject: prompts.input(promptAnswerSchema.extend({ reason: z35.string().max(500).regex(/\S/u) })).output(z35.object({ proposalID: z35.string() }))
|
|
1796
1966
|
}
|
|
1797
1967
|
}
|
|
1798
1968
|
};
|
|
@@ -1804,6 +1974,52 @@ function isTimeZone(zone) {
|
|
|
1804
1974
|
return false;
|
|
1805
1975
|
}
|
|
1806
1976
|
}
|
|
1977
|
+
// src/contract/schedule-schema.ts
|
|
1978
|
+
import { z as z36 } from "zod";
|
|
1979
|
+
var clockTimeSchema = z36.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/u, "a time is HH:MM, 24-hour");
|
|
1980
|
+
var minutesSchema = z36.strictObject({
|
|
1981
|
+
minutes: z36.int().min(5).max(1440)
|
|
1982
|
+
});
|
|
1983
|
+
var weekdaySchema = z36.enum(["mon", "tue", "wed", "thu", "fri", "sat", "sun"]);
|
|
1984
|
+
var scheduleSchema = z36.strictObject({
|
|
1985
|
+
every: z36.union([z36.enum(["day", "week", "hour"]), minutesSchema]),
|
|
1986
|
+
at: clockTimeSchema.optional(),
|
|
1987
|
+
on: weekdaySchema.optional(),
|
|
1988
|
+
window: z36.strictObject({ from: clockTimeSchema, until: clockTimeSchema }).optional(),
|
|
1989
|
+
idleMinutes: z36.int().min(1).max(720).optional(),
|
|
1990
|
+
zone: z36.string().refine((zone) => zone === "owner" || isTimeZone(zone), "a zone is owner or an IANA zone").default("owner"),
|
|
1991
|
+
catchUp: z36.enum(["once", "skip"]).default("once")
|
|
1992
|
+
}).superRefine((schedule, context) => {
|
|
1993
|
+
const isCalendar = schedule.every === "day" || schedule.every === "week";
|
|
1994
|
+
if (isCalendar && schedule.at === undefined && schedule.window === undefined) {
|
|
1995
|
+
context.addIssue({ code: "custom", message: "day and week need at or window" });
|
|
1996
|
+
}
|
|
1997
|
+
if (isCalendar && schedule.at !== undefined && schedule.window !== undefined) {
|
|
1998
|
+
context.addIssue({ code: "custom", message: "at and window never come together" });
|
|
1999
|
+
}
|
|
2000
|
+
if (!isCalendar && schedule.at !== undefined) {
|
|
2001
|
+
context.addIssue({ code: "custom", message: "hour and minutes schedules take no at" });
|
|
2002
|
+
}
|
|
2003
|
+
if (!isCalendar && schedule.window !== undefined) {
|
|
2004
|
+
context.addIssue({ code: "custom", message: "hour and minutes schedules take no window" });
|
|
2005
|
+
}
|
|
2006
|
+
if (schedule.every === "week" && schedule.on === undefined) {
|
|
2007
|
+
context.addIssue({ code: "custom", message: "a week schedule needs on" });
|
|
2008
|
+
}
|
|
2009
|
+
if (schedule.every !== "week" && schedule.on !== undefined) {
|
|
2010
|
+
context.addIssue({ code: "custom", message: "only a week schedule takes on" });
|
|
2011
|
+
}
|
|
2012
|
+
if (schedule.idleMinutes !== undefined && schedule.window === undefined) {
|
|
2013
|
+
context.addIssue({ code: "custom", message: "idleMinutes needs window" });
|
|
2014
|
+
}
|
|
2015
|
+
});
|
|
2016
|
+
// src/contract/trigger-schema.ts
|
|
2017
|
+
import { z as z37 } from "zod";
|
|
2018
|
+
var triggerAtSchema = z37.iso.datetime({ offset: true });
|
|
2019
|
+
var triggerSchema = z37.union([
|
|
2020
|
+
z37.strictObject({ schedule: scheduleSchema }),
|
|
2021
|
+
z37.strictObject({ at: triggerAtSchema })
|
|
2022
|
+
]);
|
|
1807
2023
|
// src/contract/session-cookie-name.ts
|
|
1808
2024
|
var sessionCookieName = "nixie_session";
|
|
1809
2025
|
|
|
@@ -1814,11 +2030,11 @@ function renderSessionCookie(token) {
|
|
|
1814
2030
|
return `${sessionCookieName}=${token ?? ""}; Path=/; HttpOnly; Secure; SameSite=Lax; Max-Age=${maxAgeS}`;
|
|
1815
2031
|
}
|
|
1816
2032
|
// src/message/task-message-input-schema.ts
|
|
1817
|
-
import { z as
|
|
2033
|
+
import { z as z39 } from "zod";
|
|
1818
2034
|
|
|
1819
2035
|
// src/message/task-message-kind-schema.ts
|
|
1820
|
-
import { z as
|
|
1821
|
-
var taskMessageKindSchema =
|
|
2036
|
+
import { z as z38 } from "zod";
|
|
2037
|
+
var taskMessageKindSchema = z38.enum([
|
|
1822
2038
|
"progress",
|
|
1823
2039
|
"question",
|
|
1824
2040
|
"request",
|
|
@@ -1828,21 +2044,21 @@ var taskMessageKindSchema = z34.enum([
|
|
|
1828
2044
|
]);
|
|
1829
2045
|
|
|
1830
2046
|
// src/message/task-message-input-schema.ts
|
|
1831
|
-
var taskMessageInputSchema =
|
|
1832
|
-
to:
|
|
2047
|
+
var taskMessageInputSchema = z39.object({
|
|
2048
|
+
to: z39.string(),
|
|
1833
2049
|
kind: taskMessageKindSchema,
|
|
1834
|
-
body:
|
|
1835
|
-
replyTo:
|
|
1836
|
-
onBehalfOf:
|
|
1837
|
-
wake:
|
|
2050
|
+
body: z39.string(),
|
|
2051
|
+
replyTo: z39.string().optional(),
|
|
2052
|
+
onBehalfOf: z39.string().array().optional(),
|
|
2053
|
+
wake: z39.boolean().optional()
|
|
1838
2054
|
});
|
|
1839
2055
|
// src/message/task-message-result-schema.ts
|
|
1840
|
-
import { z as
|
|
1841
|
-
var taskMessageResultSchema =
|
|
1842
|
-
messageID:
|
|
1843
|
-
woke:
|
|
1844
|
-
hop:
|
|
1845
|
-
note:
|
|
2056
|
+
import { z as z40 } from "zod";
|
|
2057
|
+
var taskMessageResultSchema = z40.object({
|
|
2058
|
+
messageID: z40.string(),
|
|
2059
|
+
woke: z40.boolean(),
|
|
2060
|
+
hop: z40.int().nonnegative(),
|
|
2061
|
+
note: z40.string().optional()
|
|
1846
2062
|
});
|
|
1847
2063
|
export {
|
|
1848
2064
|
buildPendingInput,
|
|
@@ -1856,9 +2072,12 @@ export {
|
|
|
1856
2072
|
isTimeZone,
|
|
1857
2073
|
pickSpanSource,
|
|
1858
2074
|
renderSessionCookie,
|
|
2075
|
+
scheduleSchema,
|
|
1859
2076
|
sessionCookieName,
|
|
1860
2077
|
spanSchema,
|
|
1861
2078
|
taskMessageInputSchema,
|
|
1862
2079
|
taskMessageKindSchema,
|
|
1863
|
-
taskMessageResultSchema
|
|
2080
|
+
taskMessageResultSchema,
|
|
2081
|
+
triggerAtSchema,
|
|
2082
|
+
triggerSchema
|
|
1864
2083
|
};
|