@openpond/evals 0.7.0 → 0.7.2
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/LEARNING.md +14 -0
- package/dist/javascript-verifier-worker-source.js +1 -1
- package/dist/learning/authoring-service.js +49 -0
- package/dist/learning/authoring.js +37 -0
- package/dist/learning/index.js +1 -0
- package/dist/learning/operations.js +7 -3
- package/dist/learning/repository.js +2 -0
- package/dist/learning/service.js +22 -0
- package/dist/learning/transport.js +10 -0
- package/dist/task-schema-meta-validator.js +2 -0
- package/dist/task-schema-validation.js +113 -0
- package/dist/task-schema.js +4 -142
- package/dist/task-value-validator.js +37 -0
- package/dist/types/learning/authoring-service.d.ts +25 -0
- package/dist/types/learning/authoring-service.d.ts.map +1 -0
- package/dist/types/learning/authoring.d.ts +672 -0
- package/dist/types/learning/authoring.d.ts.map +1 -0
- package/dist/types/learning/index.d.ts +1 -0
- package/dist/types/learning/index.d.ts.map +1 -1
- package/dist/types/learning/operations.d.ts +557 -1
- package/dist/types/learning/operations.d.ts.map +1 -1
- package/dist/types/learning/repository.d.ts +192 -0
- package/dist/types/learning/repository.d.ts.map +1 -1
- package/dist/types/learning/service.d.ts +14 -0
- package/dist/types/learning/service.d.ts.map +1 -1
- package/dist/types/learning/transport.d.ts +505 -2
- package/dist/types/learning/transport.d.ts.map +1 -1
- package/dist/types/task-schema-meta-validator.d.ts +3 -0
- package/dist/types/task-schema-validation.d.ts +18 -0
- package/dist/types/task-schema-validation.d.ts.map +1 -0
- package/dist/types/task-schema.d.ts +2 -17
- package/dist/types/task-schema.d.ts.map +1 -1
- package/dist/types/task-value-validator.d.ts +3 -0
- package/dist/types/task-value-validator.d.ts.map +1 -0
- package/package.json +2 -2
- package/schemas/learning/v1/command-request.schema.json +757 -366
- package/schemas/learning/v1/draft.schema.json +562 -0
- package/schemas/learning/v1/evidence-inspection.schema.json +106 -0
- package/schemas/learning/v1/read-request.schema.json +42 -0
|
@@ -4,10 +4,185 @@ export declare function assertLearningRequestJson(raw: unknown): void;
|
|
|
4
4
|
/** Scope selection is never authorization; each host resolves its authenticated owner. */
|
|
5
5
|
export declare const LearningCommandRequestSchema: z.ZodObject<{
|
|
6
6
|
scope: z.ZodString;
|
|
7
|
-
command: z.ZodUnion<readonly [z.
|
|
7
|
+
command: z.ZodUnion<readonly [z.ZodObject<{
|
|
8
|
+
operationId: z.ZodString;
|
|
9
|
+
action: z.ZodLiteral<"save_draft">;
|
|
10
|
+
expectedRevision: z.ZodNumber;
|
|
11
|
+
draft: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
12
|
+
id: z.ZodString;
|
|
13
|
+
targetId: z.ZodString;
|
|
14
|
+
baseRelease: z.ZodNullable<z.ZodObject<{
|
|
15
|
+
id: z.ZodString;
|
|
16
|
+
contentHash: z.ZodString;
|
|
17
|
+
revision: z.ZodNumber;
|
|
18
|
+
}, z.core.$strict>>;
|
|
19
|
+
editorVersion: z.ZodLiteral<"openpond.modelsEditor.v1">;
|
|
20
|
+
targetKind: z.ZodLiteral<"definition">;
|
|
21
|
+
fields: z.ZodObject<{
|
|
22
|
+
name: z.ZodString;
|
|
23
|
+
description: z.ZodString;
|
|
24
|
+
instructions: z.ZodString;
|
|
25
|
+
input: z.ZodString;
|
|
26
|
+
output: z.ZodString;
|
|
27
|
+
familyNamespace: z.ZodString;
|
|
28
|
+
sources: z.ZodArray<z.ZodObject<{
|
|
29
|
+
graderId: z.ZodString;
|
|
30
|
+
reward: z.ZodObject<{
|
|
31
|
+
id: z.ZodString;
|
|
32
|
+
contentHash: z.ZodString;
|
|
33
|
+
revision: z.ZodNumber;
|
|
34
|
+
}, z.core.$strict>;
|
|
35
|
+
role: z.ZodEnum<{
|
|
36
|
+
evaluation: "evaluation";
|
|
37
|
+
training: "training";
|
|
38
|
+
}>;
|
|
39
|
+
normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
40
|
+
kind: z.ZodLiteral<"identity">;
|
|
41
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
42
|
+
kind: z.ZodLiteral<"linear">;
|
|
43
|
+
minimum: z.ZodNumber;
|
|
44
|
+
maximum: z.ZodNumber;
|
|
45
|
+
direction: z.ZodEnum<{
|
|
46
|
+
higher: "higher";
|
|
47
|
+
lower: "lower";
|
|
48
|
+
}>;
|
|
49
|
+
}, z.core.$strict>], "kind">;
|
|
50
|
+
weight: z.ZodNumber;
|
|
51
|
+
required: z.ZodBoolean;
|
|
52
|
+
hardGate: z.ZodBoolean;
|
|
53
|
+
privileged: z.ZodBoolean;
|
|
54
|
+
fixtureRefs: z.ZodArray<z.ZodObject<{
|
|
55
|
+
id: z.ZodString;
|
|
56
|
+
contentHash: z.ZodString;
|
|
57
|
+
}, z.core.$strict>>;
|
|
58
|
+
}, z.core.$strict>>;
|
|
59
|
+
recipeRef: z.ZodOptional<z.ZodObject<{
|
|
60
|
+
id: z.ZodString;
|
|
61
|
+
contentHash: z.ZodString;
|
|
62
|
+
revision: z.ZodNumber;
|
|
63
|
+
}, z.core.$strict>>;
|
|
64
|
+
}, z.core.$strict>;
|
|
65
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
66
|
+
id: z.ZodString;
|
|
67
|
+
targetId: z.ZodString;
|
|
68
|
+
baseRelease: z.ZodNullable<z.ZodObject<{
|
|
69
|
+
id: z.ZodString;
|
|
70
|
+
contentHash: z.ZodString;
|
|
71
|
+
revision: z.ZodNumber;
|
|
72
|
+
}, z.core.$strict>>;
|
|
73
|
+
editorVersion: z.ZodLiteral<"openpond.modelsEditor.v1">;
|
|
74
|
+
targetKind: z.ZodLiteral<"reward">;
|
|
75
|
+
fields: z.ZodObject<{
|
|
76
|
+
name: z.ZodString;
|
|
77
|
+
description: z.ZodString;
|
|
78
|
+
kind: z.ZodEnum<{
|
|
79
|
+
content: "content";
|
|
80
|
+
schema: "schema";
|
|
81
|
+
artifact: "artifact";
|
|
82
|
+
runtime_event: "runtime_event";
|
|
83
|
+
state: "state";
|
|
84
|
+
model_judge: "model_judge";
|
|
85
|
+
custom_verifier: "custom_verifier";
|
|
86
|
+
human: "human";
|
|
87
|
+
learned_model: "learned_model";
|
|
88
|
+
}>;
|
|
89
|
+
fields: z.ZodString;
|
|
90
|
+
outputField: z.ZodString;
|
|
91
|
+
expectedField: z.ZodString;
|
|
92
|
+
expectedValue: z.ZodString;
|
|
93
|
+
schema: z.ZodString;
|
|
94
|
+
reference: z.ZodString;
|
|
95
|
+
events: z.ZodString;
|
|
96
|
+
code: z.ZodString;
|
|
97
|
+
exportName: z.ZodString;
|
|
98
|
+
timeout: z.ZodString;
|
|
99
|
+
rubric: z.ZodString;
|
|
100
|
+
providerId: z.ZodString;
|
|
101
|
+
modelId: z.ZodString;
|
|
102
|
+
modelRevision: z.ZodString;
|
|
103
|
+
temperature: z.ZodString;
|
|
104
|
+
reviewerRole: z.ZodString;
|
|
105
|
+
learnedId: z.ZodString;
|
|
106
|
+
learnedHash: z.ZodString;
|
|
107
|
+
inputContract: z.ZodString;
|
|
108
|
+
minimum: z.ZodString;
|
|
109
|
+
maximum: z.ZodString;
|
|
110
|
+
}, z.core.$strict>;
|
|
111
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
112
|
+
id: z.ZodString;
|
|
113
|
+
targetId: z.ZodString;
|
|
114
|
+
baseRelease: z.ZodNullable<z.ZodObject<{
|
|
115
|
+
id: z.ZodString;
|
|
116
|
+
contentHash: z.ZodString;
|
|
117
|
+
revision: z.ZodNumber;
|
|
118
|
+
}, z.core.$strict>>;
|
|
119
|
+
editorVersion: z.ZodLiteral<"openpond.modelsEditor.v1">;
|
|
120
|
+
targetKind: z.ZodLiteral<"binding">;
|
|
121
|
+
fields: z.ZodObject<{
|
|
122
|
+
name: z.ZodString;
|
|
123
|
+
description: z.ZodString;
|
|
124
|
+
sources: z.ZodArray<z.ZodObject<{
|
|
125
|
+
graderId: z.ZodString;
|
|
126
|
+
reward: z.ZodObject<{
|
|
127
|
+
id: z.ZodString;
|
|
128
|
+
contentHash: z.ZodString;
|
|
129
|
+
revision: z.ZodNumber;
|
|
130
|
+
}, z.core.$strict>;
|
|
131
|
+
role: z.ZodEnum<{
|
|
132
|
+
evaluation: "evaluation";
|
|
133
|
+
training: "training";
|
|
134
|
+
}>;
|
|
135
|
+
normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
136
|
+
kind: z.ZodLiteral<"identity">;
|
|
137
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
138
|
+
kind: z.ZodLiteral<"linear">;
|
|
139
|
+
minimum: z.ZodNumber;
|
|
140
|
+
maximum: z.ZodNumber;
|
|
141
|
+
direction: z.ZodEnum<{
|
|
142
|
+
higher: "higher";
|
|
143
|
+
lower: "lower";
|
|
144
|
+
}>;
|
|
145
|
+
}, z.core.$strict>], "kind">;
|
|
146
|
+
weight: z.ZodNumber;
|
|
147
|
+
required: z.ZodBoolean;
|
|
148
|
+
hardGate: z.ZodBoolean;
|
|
149
|
+
privileged: z.ZodBoolean;
|
|
150
|
+
fixtureRefs: z.ZodArray<z.ZodObject<{
|
|
151
|
+
id: z.ZodString;
|
|
152
|
+
contentHash: z.ZodString;
|
|
153
|
+
}, z.core.$strict>>;
|
|
154
|
+
}, z.core.$strict>>;
|
|
155
|
+
}, z.core.$strict>;
|
|
156
|
+
}, z.core.$strict>], "targetKind">;
|
|
157
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
158
|
+
operationId: z.ZodString;
|
|
159
|
+
action: z.ZodLiteral<"archive_draft">;
|
|
160
|
+
draft: z.ZodObject<{
|
|
161
|
+
id: z.ZodString;
|
|
162
|
+
contentHash: z.ZodString;
|
|
163
|
+
revision: z.ZodNumber;
|
|
164
|
+
}, z.core.$strict>;
|
|
165
|
+
}, z.core.$strict>, z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
8
166
|
operationId: z.ZodString;
|
|
9
167
|
action: z.ZodLiteral<"publish">;
|
|
10
168
|
expectedRevision: z.ZodNumber;
|
|
169
|
+
finalizeDraft: z.ZodOptional<z.ZodObject<{
|
|
170
|
+
draft: z.ZodObject<{
|
|
171
|
+
id: z.ZodString;
|
|
172
|
+
contentHash: z.ZodString;
|
|
173
|
+
revision: z.ZodNumber;
|
|
174
|
+
}, z.core.$strict>;
|
|
175
|
+
targetKind: z.ZodEnum<{
|
|
176
|
+
reward: "reward";
|
|
177
|
+
binding: "binding";
|
|
178
|
+
definition: "definition";
|
|
179
|
+
}>;
|
|
180
|
+
release: z.ZodObject<{
|
|
181
|
+
id: z.ZodString;
|
|
182
|
+
contentHash: z.ZodString;
|
|
183
|
+
revision: z.ZodNumber;
|
|
184
|
+
}, z.core.$strict>;
|
|
185
|
+
}, z.core.$strict>>;
|
|
11
186
|
kind: z.ZodLiteral<"asset">;
|
|
12
187
|
content: z.ZodObject<{
|
|
13
188
|
schemaVersion: z.ZodLiteral<"openpond.learningTextAsset.v1">;
|
|
@@ -31,6 +206,23 @@ export declare const LearningCommandRequestSchema: z.ZodObject<{
|
|
|
31
206
|
operationId: z.ZodString;
|
|
32
207
|
action: z.ZodLiteral<"publish">;
|
|
33
208
|
expectedRevision: z.ZodNumber;
|
|
209
|
+
finalizeDraft: z.ZodOptional<z.ZodObject<{
|
|
210
|
+
draft: z.ZodObject<{
|
|
211
|
+
id: z.ZodString;
|
|
212
|
+
contentHash: z.ZodString;
|
|
213
|
+
revision: z.ZodNumber;
|
|
214
|
+
}, z.core.$strict>;
|
|
215
|
+
targetKind: z.ZodEnum<{
|
|
216
|
+
reward: "reward";
|
|
217
|
+
binding: "binding";
|
|
218
|
+
definition: "definition";
|
|
219
|
+
}>;
|
|
220
|
+
release: z.ZodObject<{
|
|
221
|
+
id: z.ZodString;
|
|
222
|
+
contentHash: z.ZodString;
|
|
223
|
+
revision: z.ZodNumber;
|
|
224
|
+
}, z.core.$strict>;
|
|
225
|
+
}, z.core.$strict>>;
|
|
34
226
|
kind: z.ZodLiteral<"definition">;
|
|
35
227
|
content: z.ZodObject<{
|
|
36
228
|
schemaVersion: z.ZodLiteral<"openpond.taskDefinition.v1">;
|
|
@@ -126,6 +318,23 @@ export declare const LearningCommandRequestSchema: z.ZodObject<{
|
|
|
126
318
|
operationId: z.ZodString;
|
|
127
319
|
action: z.ZodLiteral<"publish">;
|
|
128
320
|
expectedRevision: z.ZodNumber;
|
|
321
|
+
finalizeDraft: z.ZodOptional<z.ZodObject<{
|
|
322
|
+
draft: z.ZodObject<{
|
|
323
|
+
id: z.ZodString;
|
|
324
|
+
contentHash: z.ZodString;
|
|
325
|
+
revision: z.ZodNumber;
|
|
326
|
+
}, z.core.$strict>;
|
|
327
|
+
targetKind: z.ZodEnum<{
|
|
328
|
+
reward: "reward";
|
|
329
|
+
binding: "binding";
|
|
330
|
+
definition: "definition";
|
|
331
|
+
}>;
|
|
332
|
+
release: z.ZodObject<{
|
|
333
|
+
id: z.ZodString;
|
|
334
|
+
contentHash: z.ZodString;
|
|
335
|
+
revision: z.ZodNumber;
|
|
336
|
+
}, z.core.$strict>;
|
|
337
|
+
}, z.core.$strict>>;
|
|
129
338
|
kind: z.ZodLiteral<"reward">;
|
|
130
339
|
content: z.ZodObject<{
|
|
131
340
|
schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
|
|
@@ -239,6 +448,23 @@ export declare const LearningCommandRequestSchema: z.ZodObject<{
|
|
|
239
448
|
operationId: z.ZodString;
|
|
240
449
|
action: z.ZodLiteral<"publish">;
|
|
241
450
|
expectedRevision: z.ZodNumber;
|
|
451
|
+
finalizeDraft: z.ZodOptional<z.ZodObject<{
|
|
452
|
+
draft: z.ZodObject<{
|
|
453
|
+
id: z.ZodString;
|
|
454
|
+
contentHash: z.ZodString;
|
|
455
|
+
revision: z.ZodNumber;
|
|
456
|
+
}, z.core.$strict>;
|
|
457
|
+
targetKind: z.ZodEnum<{
|
|
458
|
+
reward: "reward";
|
|
459
|
+
binding: "binding";
|
|
460
|
+
definition: "definition";
|
|
461
|
+
}>;
|
|
462
|
+
release: z.ZodObject<{
|
|
463
|
+
id: z.ZodString;
|
|
464
|
+
contentHash: z.ZodString;
|
|
465
|
+
revision: z.ZodNumber;
|
|
466
|
+
}, z.core.$strict>;
|
|
467
|
+
}, z.core.$strict>>;
|
|
242
468
|
kind: z.ZodLiteral<"binding">;
|
|
243
469
|
content: z.ZodObject<{
|
|
244
470
|
schemaVersion: z.ZodLiteral<"openpond.rewardBinding.v1">;
|
|
@@ -289,6 +515,23 @@ export declare const LearningCommandRequestSchema: z.ZodObject<{
|
|
|
289
515
|
operationId: z.ZodString;
|
|
290
516
|
action: z.ZodLiteral<"publish">;
|
|
291
517
|
expectedRevision: z.ZodNumber;
|
|
518
|
+
finalizeDraft: z.ZodOptional<z.ZodObject<{
|
|
519
|
+
draft: z.ZodObject<{
|
|
520
|
+
id: z.ZodString;
|
|
521
|
+
contentHash: z.ZodString;
|
|
522
|
+
revision: z.ZodNumber;
|
|
523
|
+
}, z.core.$strict>;
|
|
524
|
+
targetKind: z.ZodEnum<{
|
|
525
|
+
reward: "reward";
|
|
526
|
+
binding: "binding";
|
|
527
|
+
definition: "definition";
|
|
528
|
+
}>;
|
|
529
|
+
release: z.ZodObject<{
|
|
530
|
+
id: z.ZodString;
|
|
531
|
+
contentHash: z.ZodString;
|
|
532
|
+
revision: z.ZodNumber;
|
|
533
|
+
}, z.core.$strict>;
|
|
534
|
+
}, z.core.$strict>>;
|
|
292
535
|
kind: z.ZodLiteral<"source">;
|
|
293
536
|
content: z.ZodObject<{
|
|
294
537
|
schemaVersion: z.ZodLiteral<"openpond.learningSource.v1">;
|
|
@@ -337,6 +580,23 @@ export declare const LearningCommandRequestSchema: z.ZodObject<{
|
|
|
337
580
|
operationId: z.ZodString;
|
|
338
581
|
action: z.ZodLiteral<"publish">;
|
|
339
582
|
expectedRevision: z.ZodNumber;
|
|
583
|
+
finalizeDraft: z.ZodOptional<z.ZodObject<{
|
|
584
|
+
draft: z.ZodObject<{
|
|
585
|
+
id: z.ZodString;
|
|
586
|
+
contentHash: z.ZodString;
|
|
587
|
+
revision: z.ZodNumber;
|
|
588
|
+
}, z.core.$strict>;
|
|
589
|
+
targetKind: z.ZodEnum<{
|
|
590
|
+
reward: "reward";
|
|
591
|
+
binding: "binding";
|
|
592
|
+
definition: "definition";
|
|
593
|
+
}>;
|
|
594
|
+
release: z.ZodObject<{
|
|
595
|
+
id: z.ZodString;
|
|
596
|
+
contentHash: z.ZodString;
|
|
597
|
+
revision: z.ZodNumber;
|
|
598
|
+
}, z.core.$strict>;
|
|
599
|
+
}, z.core.$strict>>;
|
|
340
600
|
kind: z.ZodLiteral<"policy">;
|
|
341
601
|
content: z.ZodObject<{
|
|
342
602
|
schemaVersion: z.ZodLiteral<"openpond.learningPolicy.v1">;
|
|
@@ -444,6 +704,23 @@ export declare const LearningCommandRequestSchema: z.ZodObject<{
|
|
|
444
704
|
}, z.core.$strict>], "kind">, z.ZodObject<{
|
|
445
705
|
operationId: z.ZodString;
|
|
446
706
|
action: z.ZodLiteral<"publish_resources">;
|
|
707
|
+
finalizeDraft: z.ZodOptional<z.ZodObject<{
|
|
708
|
+
draft: z.ZodObject<{
|
|
709
|
+
id: z.ZodString;
|
|
710
|
+
contentHash: z.ZodString;
|
|
711
|
+
revision: z.ZodNumber;
|
|
712
|
+
}, z.core.$strict>;
|
|
713
|
+
targetKind: z.ZodEnum<{
|
|
714
|
+
reward: "reward";
|
|
715
|
+
binding: "binding";
|
|
716
|
+
definition: "definition";
|
|
717
|
+
}>;
|
|
718
|
+
release: z.ZodObject<{
|
|
719
|
+
id: z.ZodString;
|
|
720
|
+
contentHash: z.ZodString;
|
|
721
|
+
revision: z.ZodNumber;
|
|
722
|
+
}, z.core.$strict>;
|
|
723
|
+
}, z.core.$strict>>;
|
|
447
724
|
resources: z.ZodArray<z.ZodUnion<(z.ZodObject<{
|
|
448
725
|
kind: z.ZodLiteral<"definition">;
|
|
449
726
|
content: z.ZodObject<{
|
|
@@ -1030,6 +1307,14 @@ export declare const LearningCommandRequestSchema: z.ZodObject<{
|
|
|
1030
1307
|
}, z.core.$strict>]>;
|
|
1031
1308
|
}, z.core.$strict>;
|
|
1032
1309
|
export declare const LearningReadRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
1310
|
+
action: z.ZodLiteral<"inspect_evidence">;
|
|
1311
|
+
scope: z.ZodString;
|
|
1312
|
+
evidence: z.ZodObject<{
|
|
1313
|
+
id: z.ZodString;
|
|
1314
|
+
contentHash: z.ZodString;
|
|
1315
|
+
revision: z.ZodNumber;
|
|
1316
|
+
}, z.core.$strict>;
|
|
1317
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
1033
1318
|
action: z.ZodLiteral<"get">;
|
|
1034
1319
|
scope: z.ZodString;
|
|
1035
1320
|
kind: z.ZodEnum<{
|
|
@@ -1044,6 +1329,7 @@ export declare const LearningReadRequestSchema: z.ZodDiscriminatedUnion<[z.ZodOb
|
|
|
1044
1329
|
batch: "batch";
|
|
1045
1330
|
asset: "asset";
|
|
1046
1331
|
definition: "definition";
|
|
1332
|
+
draft: "draft";
|
|
1047
1333
|
iteration: "iteration";
|
|
1048
1334
|
package: "package";
|
|
1049
1335
|
}>;
|
|
@@ -1064,6 +1350,7 @@ export declare const LearningReadRequestSchema: z.ZodDiscriminatedUnion<[z.ZodOb
|
|
|
1064
1350
|
batch: "batch";
|
|
1065
1351
|
asset: "asset";
|
|
1066
1352
|
definition: "definition";
|
|
1353
|
+
draft: "draft";
|
|
1067
1354
|
iteration: "iteration";
|
|
1068
1355
|
package: "package";
|
|
1069
1356
|
}>;
|
|
@@ -1072,6 +1359,32 @@ export declare const LearningReadRequestSchema: z.ZodDiscriminatedUnion<[z.ZodOb
|
|
|
1072
1359
|
afterId: z.ZodOptional<z.ZodString>;
|
|
1073
1360
|
limit: z.ZodDefault<z.ZodNumber>;
|
|
1074
1361
|
}, z.core.$strict>], "action">;
|
|
1362
|
+
export declare const TaskEvidenceInspectionResultSchema: z.ZodObject<{
|
|
1363
|
+
evidence: z.ZodObject<{
|
|
1364
|
+
id: z.ZodString;
|
|
1365
|
+
contentHash: z.ZodString;
|
|
1366
|
+
revision: z.ZodNumber;
|
|
1367
|
+
}, z.core.$strict>;
|
|
1368
|
+
definition: z.ZodObject<{
|
|
1369
|
+
id: z.ZodString;
|
|
1370
|
+
contentHash: z.ZodString;
|
|
1371
|
+
revision: z.ZodNumber;
|
|
1372
|
+
}, z.core.$strict>;
|
|
1373
|
+
inspection: z.ZodObject<{
|
|
1374
|
+
evidenceValidity: z.ZodEnum<{
|
|
1375
|
+
valid: "valid";
|
|
1376
|
+
invalid: "invalid";
|
|
1377
|
+
}>;
|
|
1378
|
+
taskReady: z.ZodBoolean;
|
|
1379
|
+
observedOutputValid: z.ZodNullable<z.ZodBoolean>;
|
|
1380
|
+
issues: z.ZodArray<z.ZodObject<{
|
|
1381
|
+
path: z.ZodString;
|
|
1382
|
+
code: z.ZodString;
|
|
1383
|
+
message: z.ZodString;
|
|
1384
|
+
}, z.core.$strict>>;
|
|
1385
|
+
}, z.core.$strict>;
|
|
1386
|
+
}, z.core.$strict>;
|
|
1387
|
+
export type TaskEvidenceInspectionResult = z.infer<typeof TaskEvidenceInspectionResultSchema>;
|
|
1075
1388
|
export declare const LearningOperationResultSchema: z.ZodObject<{
|
|
1076
1389
|
operationId: z.ZodString;
|
|
1077
1390
|
resources: z.ZodArray<z.ZodUnion<(z.ZodObject<{
|
|
@@ -2134,6 +2447,196 @@ export declare const LearningOperationResultSchema: z.ZodObject<{
|
|
|
2134
2447
|
}, z.core.$strict>;
|
|
2135
2448
|
text: z.ZodString;
|
|
2136
2449
|
contentHash: z.ZodString;
|
|
2137
|
-
}, z.core.$strict>
|
|
2450
|
+
}, z.core.$strict> | z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
2451
|
+
id: z.ZodString;
|
|
2452
|
+
targetId: z.ZodString;
|
|
2453
|
+
baseRelease: z.ZodNullable<z.ZodObject<{
|
|
2454
|
+
id: z.ZodString;
|
|
2455
|
+
contentHash: z.ZodString;
|
|
2456
|
+
revision: z.ZodNumber;
|
|
2457
|
+
}, z.core.$strict>>;
|
|
2458
|
+
editorVersion: z.ZodLiteral<"openpond.modelsEditor.v1">;
|
|
2459
|
+
targetKind: z.ZodLiteral<"definition">;
|
|
2460
|
+
fields: z.ZodObject<{
|
|
2461
|
+
name: z.ZodString;
|
|
2462
|
+
description: z.ZodString;
|
|
2463
|
+
instructions: z.ZodString;
|
|
2464
|
+
input: z.ZodString;
|
|
2465
|
+
output: z.ZodString;
|
|
2466
|
+
familyNamespace: z.ZodString;
|
|
2467
|
+
sources: z.ZodArray<z.ZodObject<{
|
|
2468
|
+
graderId: z.ZodString;
|
|
2469
|
+
reward: z.ZodObject<{
|
|
2470
|
+
id: z.ZodString;
|
|
2471
|
+
contentHash: z.ZodString;
|
|
2472
|
+
revision: z.ZodNumber;
|
|
2473
|
+
}, z.core.$strict>;
|
|
2474
|
+
role: z.ZodEnum<{
|
|
2475
|
+
evaluation: "evaluation";
|
|
2476
|
+
training: "training";
|
|
2477
|
+
}>;
|
|
2478
|
+
normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
2479
|
+
kind: z.ZodLiteral<"identity">;
|
|
2480
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
2481
|
+
kind: z.ZodLiteral<"linear">;
|
|
2482
|
+
minimum: z.ZodNumber;
|
|
2483
|
+
maximum: z.ZodNumber;
|
|
2484
|
+
direction: z.ZodEnum<{
|
|
2485
|
+
higher: "higher";
|
|
2486
|
+
lower: "lower";
|
|
2487
|
+
}>;
|
|
2488
|
+
}, z.core.$strict>], "kind">;
|
|
2489
|
+
weight: z.ZodNumber;
|
|
2490
|
+
required: z.ZodBoolean;
|
|
2491
|
+
hardGate: z.ZodBoolean;
|
|
2492
|
+
privileged: z.ZodBoolean;
|
|
2493
|
+
fixtureRefs: z.ZodArray<z.ZodObject<{
|
|
2494
|
+
id: z.ZodString;
|
|
2495
|
+
contentHash: z.ZodString;
|
|
2496
|
+
}, z.core.$strict>>;
|
|
2497
|
+
}, z.core.$strict>>;
|
|
2498
|
+
recipeRef: z.ZodOptional<z.ZodObject<{
|
|
2499
|
+
id: z.ZodString;
|
|
2500
|
+
contentHash: z.ZodString;
|
|
2501
|
+
revision: z.ZodNumber;
|
|
2502
|
+
}, z.core.$strict>>;
|
|
2503
|
+
}, z.core.$strict>;
|
|
2504
|
+
schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
|
|
2505
|
+
revision: z.ZodNumber;
|
|
2506
|
+
status: z.ZodEnum<{
|
|
2507
|
+
draft: "draft";
|
|
2508
|
+
archived: "archived";
|
|
2509
|
+
published: "published";
|
|
2510
|
+
}>;
|
|
2511
|
+
publishedRelease: z.ZodNullable<z.ZodObject<{
|
|
2512
|
+
id: z.ZodString;
|
|
2513
|
+
contentHash: z.ZodString;
|
|
2514
|
+
revision: z.ZodNumber;
|
|
2515
|
+
}, z.core.$strict>>;
|
|
2516
|
+
createdAt: z.ZodString;
|
|
2517
|
+
updatedAt: z.ZodString;
|
|
2518
|
+
contentHash: z.ZodString;
|
|
2519
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
2520
|
+
id: z.ZodString;
|
|
2521
|
+
targetId: z.ZodString;
|
|
2522
|
+
baseRelease: z.ZodNullable<z.ZodObject<{
|
|
2523
|
+
id: z.ZodString;
|
|
2524
|
+
contentHash: z.ZodString;
|
|
2525
|
+
revision: z.ZodNumber;
|
|
2526
|
+
}, z.core.$strict>>;
|
|
2527
|
+
editorVersion: z.ZodLiteral<"openpond.modelsEditor.v1">;
|
|
2528
|
+
targetKind: z.ZodLiteral<"reward">;
|
|
2529
|
+
fields: z.ZodObject<{
|
|
2530
|
+
name: z.ZodString;
|
|
2531
|
+
description: z.ZodString;
|
|
2532
|
+
kind: z.ZodEnum<{
|
|
2533
|
+
content: "content";
|
|
2534
|
+
schema: "schema";
|
|
2535
|
+
artifact: "artifact";
|
|
2536
|
+
runtime_event: "runtime_event";
|
|
2537
|
+
state: "state";
|
|
2538
|
+
model_judge: "model_judge";
|
|
2539
|
+
custom_verifier: "custom_verifier";
|
|
2540
|
+
human: "human";
|
|
2541
|
+
learned_model: "learned_model";
|
|
2542
|
+
}>;
|
|
2543
|
+
fields: z.ZodString;
|
|
2544
|
+
outputField: z.ZodString;
|
|
2545
|
+
expectedField: z.ZodString;
|
|
2546
|
+
expectedValue: z.ZodString;
|
|
2547
|
+
schema: z.ZodString;
|
|
2548
|
+
reference: z.ZodString;
|
|
2549
|
+
events: z.ZodString;
|
|
2550
|
+
code: z.ZodString;
|
|
2551
|
+
exportName: z.ZodString;
|
|
2552
|
+
timeout: z.ZodString;
|
|
2553
|
+
rubric: z.ZodString;
|
|
2554
|
+
providerId: z.ZodString;
|
|
2555
|
+
modelId: z.ZodString;
|
|
2556
|
+
modelRevision: z.ZodString;
|
|
2557
|
+
temperature: z.ZodString;
|
|
2558
|
+
reviewerRole: z.ZodString;
|
|
2559
|
+
learnedId: z.ZodString;
|
|
2560
|
+
learnedHash: z.ZodString;
|
|
2561
|
+
inputContract: z.ZodString;
|
|
2562
|
+
minimum: z.ZodString;
|
|
2563
|
+
maximum: z.ZodString;
|
|
2564
|
+
}, z.core.$strict>;
|
|
2565
|
+
schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
|
|
2566
|
+
revision: z.ZodNumber;
|
|
2567
|
+
status: z.ZodEnum<{
|
|
2568
|
+
draft: "draft";
|
|
2569
|
+
archived: "archived";
|
|
2570
|
+
published: "published";
|
|
2571
|
+
}>;
|
|
2572
|
+
publishedRelease: z.ZodNullable<z.ZodObject<{
|
|
2573
|
+
id: z.ZodString;
|
|
2574
|
+
contentHash: z.ZodString;
|
|
2575
|
+
revision: z.ZodNumber;
|
|
2576
|
+
}, z.core.$strict>>;
|
|
2577
|
+
createdAt: z.ZodString;
|
|
2578
|
+
updatedAt: z.ZodString;
|
|
2579
|
+
contentHash: z.ZodString;
|
|
2580
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
2581
|
+
id: z.ZodString;
|
|
2582
|
+
targetId: z.ZodString;
|
|
2583
|
+
baseRelease: z.ZodNullable<z.ZodObject<{
|
|
2584
|
+
id: z.ZodString;
|
|
2585
|
+
contentHash: z.ZodString;
|
|
2586
|
+
revision: z.ZodNumber;
|
|
2587
|
+
}, z.core.$strict>>;
|
|
2588
|
+
editorVersion: z.ZodLiteral<"openpond.modelsEditor.v1">;
|
|
2589
|
+
targetKind: z.ZodLiteral<"binding">;
|
|
2590
|
+
fields: z.ZodObject<{
|
|
2591
|
+
name: z.ZodString;
|
|
2592
|
+
description: z.ZodString;
|
|
2593
|
+
sources: z.ZodArray<z.ZodObject<{
|
|
2594
|
+
graderId: z.ZodString;
|
|
2595
|
+
reward: z.ZodObject<{
|
|
2596
|
+
id: z.ZodString;
|
|
2597
|
+
contentHash: z.ZodString;
|
|
2598
|
+
revision: z.ZodNumber;
|
|
2599
|
+
}, z.core.$strict>;
|
|
2600
|
+
role: z.ZodEnum<{
|
|
2601
|
+
evaluation: "evaluation";
|
|
2602
|
+
training: "training";
|
|
2603
|
+
}>;
|
|
2604
|
+
normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
2605
|
+
kind: z.ZodLiteral<"identity">;
|
|
2606
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
2607
|
+
kind: z.ZodLiteral<"linear">;
|
|
2608
|
+
minimum: z.ZodNumber;
|
|
2609
|
+
maximum: z.ZodNumber;
|
|
2610
|
+
direction: z.ZodEnum<{
|
|
2611
|
+
higher: "higher";
|
|
2612
|
+
lower: "lower";
|
|
2613
|
+
}>;
|
|
2614
|
+
}, z.core.$strict>], "kind">;
|
|
2615
|
+
weight: z.ZodNumber;
|
|
2616
|
+
required: z.ZodBoolean;
|
|
2617
|
+
hardGate: z.ZodBoolean;
|
|
2618
|
+
privileged: z.ZodBoolean;
|
|
2619
|
+
fixtureRefs: z.ZodArray<z.ZodObject<{
|
|
2620
|
+
id: z.ZodString;
|
|
2621
|
+
contentHash: z.ZodString;
|
|
2622
|
+
}, z.core.$strict>>;
|
|
2623
|
+
}, z.core.$strict>>;
|
|
2624
|
+
}, z.core.$strict>;
|
|
2625
|
+
schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
|
|
2626
|
+
revision: z.ZodNumber;
|
|
2627
|
+
status: z.ZodEnum<{
|
|
2628
|
+
draft: "draft";
|
|
2629
|
+
archived: "archived";
|
|
2630
|
+
published: "published";
|
|
2631
|
+
}>;
|
|
2632
|
+
publishedRelease: z.ZodNullable<z.ZodObject<{
|
|
2633
|
+
id: z.ZodString;
|
|
2634
|
+
contentHash: z.ZodString;
|
|
2635
|
+
revision: z.ZodNumber;
|
|
2636
|
+
}, z.core.$strict>>;
|
|
2637
|
+
createdAt: z.ZodString;
|
|
2638
|
+
updatedAt: z.ZodString;
|
|
2639
|
+
contentHash: z.ZodString;
|
|
2640
|
+
}, z.core.$strict>], "targetKind">)[]>>;
|
|
2138
2641
|
}, z.core.$strict>;
|
|
2139
2642
|
//# sourceMappingURL=transport.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../../../../src/learning/transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;
|
|
1
|
+
{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../../../../src/learning/transport.ts"],"names":[],"mappings":"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"}
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
export declare const TASK_JSON_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
|
|
2
|
+
export declare const TASK_VALUE_MAX_BYTES = 1048576;
|
|
3
|
+
export declare const TASK_SCHEMA_MAX_BYTES = 32768;
|
|
4
|
+
export type TaskSchemaIssue = {
|
|
5
|
+
path: string;
|
|
6
|
+
code: string;
|
|
7
|
+
message: string;
|
|
8
|
+
};
|
|
9
|
+
export type TaskSchemaResult = {
|
|
10
|
+
valid: boolean;
|
|
11
|
+
issues: TaskSchemaIssue[];
|
|
12
|
+
};
|
|
13
|
+
/** Bound producer-controlled JSON before hashing, schema compilation or validation. */
|
|
14
|
+
export declare function assertBoundedTaskJson(value: unknown, maxBytes?: number): void;
|
|
15
|
+
/** No remote resolution, custom code, data mutation, regex or format plugins. */
|
|
16
|
+
export declare function validateTaskSchema(schema: unknown): TaskSchemaResult;
|
|
17
|
+
export declare function assertTaskSchema(schema: unknown): void;
|
|
18
|
+
//# sourceMappingURL=task-schema-validation.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"task-schema-validation.d.ts","sourceRoot":"","sources":["../../../../src/task-schema-validation.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,wBAAwB,iDAAiD,CAAC;AACvF,eAAO,MAAM,oBAAoB,UAAY,CAAC;AAC9C,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAE5C,MAAM,MAAM,eAAe,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAC9E,MAAM,MAAM,gBAAgB,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,eAAe,EAAE,CAAA;CAAE,CAAC;AAM7E,uFAAuF;AACvF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,SAAuB,GAAG,IAAI,CA0B3F;AAED,iFAAiF;AACjF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAOpE;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAOtD"}
|
|
@@ -1,18 +1,3 @@
|
|
|
1
|
-
export
|
|
2
|
-
export
|
|
3
|
-
export declare const TASK_SCHEMA_MAX_BYTES = 32768;
|
|
4
|
-
export type TaskSchemaIssue = {
|
|
5
|
-
path: string;
|
|
6
|
-
code: string;
|
|
7
|
-
message: string;
|
|
8
|
-
};
|
|
9
|
-
export type TaskSchemaResult = {
|
|
10
|
-
valid: boolean;
|
|
11
|
-
issues: TaskSchemaIssue[];
|
|
12
|
-
};
|
|
13
|
-
/** Bound producer-controlled JSON before hashing, schema compilation or validation. */
|
|
14
|
-
export declare function assertBoundedTaskJson(value: unknown, maxBytes?: number): void;
|
|
15
|
-
/** No remote resolution, custom code, data mutation, regex or format plugins. */
|
|
16
|
-
export declare function validateTaskSchema(schema: unknown): TaskSchemaResult;
|
|
17
|
-
export declare function validateTaskValue(schema: unknown, value: unknown): TaskSchemaResult;
|
|
1
|
+
export { TASK_JSON_SCHEMA_DIALECT, TASK_VALUE_MAX_BYTES, TASK_SCHEMA_MAX_BYTES, assertBoundedTaskJson, validateTaskSchema, type TaskSchemaIssue, type TaskSchemaResult, } from "./task-schema-validation.js";
|
|
2
|
+
export { validateTaskValue } from "./task-value-validator.js";
|
|
18
3
|
//# sourceMappingURL=task-schema.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"task-schema.d.ts","sourceRoot":"","sources":["../../../../src/task-schema.ts"],"names":[],"mappings":"
|
|
1
|
+
{"version":3,"file":"task-schema.d.ts","sourceRoot":"","sources":["../../../../src/task-schema.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,wBAAwB,EACxB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACtB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC"}
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"task-value-validator.d.ts","sourceRoot":"","sources":["../../../../src/task-value-validator.ts"],"names":[],"mappings":"AAIA,OAAO,EAA2C,KAAK,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAI7G,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,gBAAgB,CAgBnF"}
|