openpond-sdk 0.2.3 → 0.2.5

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.
Files changed (21) hide show
  1. package/TASKSETS.md +38 -0
  2. package/dist/model-batch-review.js +48 -0
  3. package/dist/model-batch-review.js.map +7 -0
  4. package/dist/taskset-packages.js +790 -71
  5. package/dist/taskset-packages.js.map +4 -4
  6. package/dist/types/packages/sdk/src/model-batch-review-contracts.d.ts +568 -0
  7. package/dist/types/packages/sdk/src/model-batch-review-contracts.d.ts.map +1 -0
  8. package/dist/types/packages/sdk/src/model-batch-review-preparation.d.ts +351 -0
  9. package/dist/types/packages/sdk/src/model-batch-review-preparation.d.ts.map +1 -0
  10. package/dist/types/packages/sdk/src/model-batch-review.d.ts +543 -0
  11. package/dist/types/packages/sdk/src/model-batch-review.d.ts.map +1 -0
  12. package/dist/types/packages/sdk/src/model-projects.d.ts +2 -2
  13. package/dist/types/packages/sdk/src/taskset-package-client.d.ts +684 -0
  14. package/dist/types/packages/sdk/src/taskset-package-client.d.ts.map +1 -1
  15. package/dist/types/packages/sdk/src/taskset-package-contracts.d.ts +725 -0
  16. package/dist/types/packages/sdk/src/taskset-package-contracts.d.ts.map +1 -1
  17. package/dist/types/packages/sdk/src/taskset-package-learning.d.ts +610 -0
  18. package/dist/types/packages/sdk/src/taskset-package-learning.d.ts.map +1 -0
  19. package/dist/types/packages/sdk/src/taskset-packages.d.ts +2 -0
  20. package/dist/types/packages/sdk/src/taskset-packages.d.ts.map +1 -1
  21. package/package.json +6 -2
package/dist/types/packages/sdk/src/model-batch-review-contracts.d.ts ADDED
@@ -0,0 +1,568 @@
1
+ import { z } from "zod";
2
+ /** Editor data from a server-validated package; excludes portable file bytes. */
3
+ export declare const ModelBatchReviewInspectionSchema: z.ZodObject<{
4
+ schemaVersion: z.ZodLiteral<"openpond.modelBatchReviewInspection.v1">;
5
+ packageHash: z.ZodString;
6
+ definition: z.ZodObject<{
7
+ schemaVersion: z.ZodLiteral<"openpond.taskDefinition.v1">;
8
+ id: z.ZodString;
9
+ revision: z.ZodNumber;
10
+ name: z.ZodString;
11
+ description: z.ZodString;
12
+ instructions: z.ZodString;
13
+ category: z.ZodEnum<{
14
+ custom: "custom";
15
+ structured: "structured";
16
+ question_answering: "question_answering";
17
+ coding: "coding";
18
+ tool_workflow: "tool_workflow";
19
+ }>;
20
+ familyNamespace: z.ZodString;
21
+ inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
22
+ outputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
23
+ rewardBinding: z.ZodObject<{
24
+ id: z.ZodString;
25
+ contentHash: z.ZodString;
26
+ revision: z.ZodNumber;
27
+ }, z.core.$strict>;
28
+ harness: z.ZodNullable<z.ZodObject<{
29
+ id: z.ZodString;
30
+ contentHash: z.ZodString;
31
+ }, z.core.$strict>>;
32
+ execution: z.ZodObject<{
33
+ policy: z.ZodObject<{
34
+ policyVisibleFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
35
+ privilegedFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
36
+ hiddenGraderRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
37
+ connectedAppScopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
38
+ }, z.core.$strict>;
39
+ environment: z.ZodObject<{
40
+ protocolVersion: z.ZodLiteral<"openpond.environment.v1">;
41
+ kind: z.ZodEnum<{
42
+ text: "text";
43
+ agent: "agent";
44
+ work: "work";
45
+ custom_program: "custom_program";
46
+ }>;
47
+ entrypoint: z.ZodString;
48
+ stateful: z.ZodBoolean;
49
+ deterministicSeeds: z.ZodBoolean;
50
+ lifecycle: z.ZodArray<z.ZodEnum<{
51
+ create: "create";
52
+ reset: "reset";
53
+ step: "step";
54
+ collect: "collect";
55
+ destroy: "destroy";
56
+ }>>;
57
+ networkPolicy: z.ZodEnum<{
58
+ none: "none";
59
+ declared_read_only: "declared_read_only";
60
+ declared_scoped: "declared_scoped";
61
+ }>;
62
+ defaultTimeoutMs: z.ZodNumber;
63
+ }, z.core.$strict>;
64
+ environmentRelease: z.ZodOptional<z.ZodObject<{
65
+ id: z.ZodString;
66
+ contentHash: z.ZodString;
67
+ }, z.core.$strict>>;
68
+ tools: z.ZodArray<z.ZodObject<{
69
+ name: z.ZodString;
70
+ description: z.ZodString;
71
+ inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
72
+ inputSchemaHash: z.ZodString;
73
+ sideEffect: z.ZodEnum<{
74
+ read: "read";
75
+ write: "write";
76
+ }>;
77
+ timeoutMs: z.ZodNumber;
78
+ }, z.core.$strict>>;
79
+ capabilities: z.ZodArray<z.ZodObject<{
80
+ id: z.ZodString;
81
+ required: z.ZodBoolean;
82
+ scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
83
+ portability: z.ZodEnum<{
84
+ portable: "portable";
85
+ host_adapter: "host_adapter";
86
+ local_only: "local_only";
87
+ hosted_only: "hosted_only";
88
+ }>;
89
+ }, z.core.$strict>>;
90
+ verifierSetRelease: z.ZodOptional<z.ZodObject<{
91
+ id: z.ZodString;
92
+ contentHash: z.ZodString;
93
+ }, z.core.$strict>>;
94
+ }, z.core.$strict>;
95
+ contentHash: z.ZodString;
96
+ }, z.core.$strict>;
97
+ binding: z.ZodObject<{
98
+ schemaVersion: z.ZodLiteral<"openpond.rewardBinding.v1">;
99
+ id: z.ZodString;
100
+ revision: z.ZodNumber;
101
+ name: z.ZodOptional<z.ZodString>;
102
+ description: z.ZodOptional<z.ZodString>;
103
+ recipeRef: z.ZodOptional<z.ZodObject<{
104
+ id: z.ZodString;
105
+ contentHash: z.ZodString;
106
+ revision: z.ZodNumber;
107
+ }, z.core.$strict>>;
108
+ sources: z.ZodArray<z.ZodObject<{
109
+ graderId: z.ZodString;
110
+ reward: z.ZodObject<{
111
+ id: z.ZodString;
112
+ contentHash: z.ZodString;
113
+ revision: z.ZodNumber;
114
+ }, z.core.$strict>;
115
+ role: z.ZodEnum<{
116
+ evaluation: "evaluation";
117
+ training: "training";
118
+ }>;
119
+ normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
120
+ kind: z.ZodLiteral<"identity">;
121
+ }, z.core.$strict>, z.ZodObject<{
122
+ kind: z.ZodLiteral<"linear">;
123
+ minimum: z.ZodNumber;
124
+ maximum: z.ZodNumber;
125
+ direction: z.ZodEnum<{
126
+ higher: "higher";
127
+ lower: "lower";
128
+ }>;
129
+ }, z.core.$strict>], "kind">;
130
+ weight: z.ZodNumber;
131
+ required: z.ZodBoolean;
132
+ hardGate: z.ZodBoolean;
133
+ privileged: z.ZodBoolean;
134
+ fixtureRefs: z.ZodArray<z.ZodObject<{
135
+ id: z.ZodString;
136
+ contentHash: z.ZodString;
137
+ }, z.core.$strict>>;
138
+ }, z.core.$strict>>;
139
+ aggregation: z.ZodLiteral<"weighted_mean">;
140
+ unscorable: z.ZodLiteral<"exclude_optional_require_all_required">;
141
+ contentHash: z.ZodString;
142
+ }, z.core.$strict>;
143
+ evidence: z.ZodArray<z.ZodObject<{
144
+ schemaVersion: z.ZodLiteral<"openpond.taskEvidence.v1">;
145
+ id: z.ZodString;
146
+ revision: z.ZodNumber;
147
+ source: z.ZodObject<{
148
+ id: z.ZodString;
149
+ contentHash: z.ZodString;
150
+ revision: z.ZodNumber;
151
+ }, z.core.$strict>;
152
+ submission: z.ZodObject<{
153
+ schemaVersion: z.ZodLiteral<"openpond.taskExample.v1">;
154
+ sourceId: z.ZodString;
155
+ idempotencyKey: z.ZodString;
156
+ taskDefinition: z.ZodObject<{
157
+ id: z.ZodString;
158
+ contentHash: z.ZodString;
159
+ revision: z.ZodNumber;
160
+ }, z.core.$strict>;
161
+ exampleId: z.ZodString;
162
+ attemptId: z.ZodString;
163
+ occurredAt: z.ZodString;
164
+ familyKey: z.ZodNullable<z.ZodString>;
165
+ split: z.ZodEnum<{
166
+ train: "train";
167
+ validation: "validation";
168
+ test: "test";
169
+ frozen_eval: "frozen_eval";
170
+ }>;
171
+ input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
172
+ observedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
173
+ expected: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
174
+ evaluatorContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
175
+ assets: z.ZodArray<z.ZodObject<{
176
+ id: z.ZodString;
177
+ path: z.ZodString;
178
+ contentHash: z.ZodString;
179
+ sizeBytes: z.ZodNumber;
180
+ mediaType: z.ZodString;
181
+ visibility: z.ZodEnum<{
182
+ policy: "policy";
183
+ verifier: "verifier";
184
+ host_private: "host_private";
185
+ }>;
186
+ }, z.core.$strict>>;
187
+ provenance: z.ZodObject<{
188
+ sourceRecordRef: z.ZodNullable<z.ZodString>;
189
+ mappingHash: z.ZodNullable<z.ZodString>;
190
+ }, z.core.$strict>;
191
+ }, z.core.$strict>;
192
+ supersedes: z.ZodNullable<z.ZodObject<{
193
+ id: z.ZodString;
194
+ contentHash: z.ZodString;
195
+ revision: z.ZodNumber;
196
+ }, z.core.$strict>>;
197
+ correctionFeedbackId: z.ZodNullable<z.ZodString>;
198
+ receivedAt: z.ZodString;
199
+ contentHash: z.ZodString;
200
+ }, z.core.$strict>>;
201
+ decisions: z.ZodArray<z.ZodObject<{
202
+ schemaVersion: z.ZodLiteral<"openpond.taskAdmissionDecision.v1">;
203
+ id: z.ZodString;
204
+ revision: z.ZodNumber;
205
+ evidence: z.ZodObject<{
206
+ id: z.ZodString;
207
+ contentHash: z.ZodString;
208
+ revision: z.ZodNumber;
209
+ }, z.core.$strict>;
210
+ supersedes: z.ZodNullable<z.ZodObject<{
211
+ id: z.ZodString;
212
+ contentHash: z.ZodString;
213
+ revision: z.ZodNumber;
214
+ }, z.core.$strict>>;
215
+ actor: z.ZodObject<{
216
+ kind: z.ZodEnum<{
217
+ human: "human";
218
+ qualified_policy: "qualified_policy";
219
+ }>;
220
+ id: z.ZodString;
221
+ policy: z.ZodNullable<z.ZodObject<{
222
+ id: z.ZodString;
223
+ contentHash: z.ZodString;
224
+ revision: z.ZodNumber;
225
+ }, z.core.$strict>>;
226
+ }, z.core.$strict>;
227
+ evidenceValidity: z.ZodEnum<{
228
+ pending: "pending";
229
+ valid: "valid";
230
+ invalid: "invalid";
231
+ }>;
232
+ taskAdmissibility: z.ZodEnum<{
233
+ pending: "pending";
234
+ rejected: "rejected";
235
+ approved: "approved";
236
+ }>;
237
+ observedQuality: z.ZodEnum<{
238
+ passed: "passed";
239
+ failed: "failed";
240
+ unavailable: "unavailable";
241
+ unscored: "unscored";
242
+ }>;
243
+ targetApproval: z.ZodEnum<{
244
+ pending: "pending";
245
+ rejected: "rejected";
246
+ approved: "approved";
247
+ not_required: "not_required";
248
+ }>;
249
+ approvedTarget: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
250
+ grade: z.ZodNullable<z.ZodObject<{
251
+ schemaVersion: z.ZodLiteral<"openpond.rewardComposition.v1">;
252
+ binding: z.ZodObject<{
253
+ id: z.ZodString;
254
+ contentHash: z.ZodString;
255
+ revision: z.ZodNumber;
256
+ }, z.core.$strict>;
257
+ taskHash: z.ZodString;
258
+ outputHash: z.ZodString;
259
+ results: z.ZodArray<z.ZodObject<{
260
+ graderId: z.ZodString;
261
+ reward: z.ZodObject<{
262
+ id: z.ZodString;
263
+ contentHash: z.ZodString;
264
+ revision: z.ZodNumber;
265
+ }, z.core.$strict>;
266
+ role: z.ZodEnum<{
267
+ evaluation: "evaluation";
268
+ training: "training";
269
+ }>;
270
+ status: z.ZodEnum<{
271
+ pending: "pending";
272
+ failed: "failed";
273
+ scored: "scored";
274
+ unavailable: "unavailable";
275
+ }>;
276
+ rawScore: z.ZodNullable<z.ZodNumber>;
277
+ normalizedScore: z.ZodNullable<z.ZodNumber>;
278
+ passed: z.ZodNullable<z.ZodBoolean>;
279
+ evidenceHashes: z.ZodArray<z.ZodString>;
280
+ message: z.ZodNullable<z.ZodString>;
281
+ }, z.core.$strict>>;
282
+ training: z.ZodObject<{
283
+ status: z.ZodEnum<{
284
+ scored: "scored";
285
+ unscorable: "unscorable";
286
+ not_configured: "not_configured";
287
+ }>;
288
+ score: z.ZodNullable<z.ZodNumber>;
289
+ passed: z.ZodNullable<z.ZodBoolean>;
290
+ }, z.core.$strict>;
291
+ evaluation: z.ZodObject<{
292
+ status: z.ZodEnum<{
293
+ scored: "scored";
294
+ unscorable: "unscorable";
295
+ not_configured: "not_configured";
296
+ }>;
297
+ score: z.ZodNullable<z.ZodNumber>;
298
+ passed: z.ZodNullable<z.ZodBoolean>;
299
+ }, z.core.$strict>;
300
+ contentHash: z.ZodString;
301
+ }, z.core.$strict>>;
302
+ targetGrade: z.ZodNullable<z.ZodObject<{
303
+ schemaVersion: z.ZodLiteral<"openpond.rewardComposition.v1">;
304
+ binding: z.ZodObject<{
305
+ id: z.ZodString;
306
+ contentHash: z.ZodString;
307
+ revision: z.ZodNumber;
308
+ }, z.core.$strict>;
309
+ taskHash: z.ZodString;
310
+ outputHash: z.ZodString;
311
+ results: z.ZodArray<z.ZodObject<{
312
+ graderId: z.ZodString;
313
+ reward: z.ZodObject<{
314
+ id: z.ZodString;
315
+ contentHash: z.ZodString;
316
+ revision: z.ZodNumber;
317
+ }, z.core.$strict>;
318
+ role: z.ZodEnum<{
319
+ evaluation: "evaluation";
320
+ training: "training";
321
+ }>;
322
+ status: z.ZodEnum<{
323
+ pending: "pending";
324
+ failed: "failed";
325
+ scored: "scored";
326
+ unavailable: "unavailable";
327
+ }>;
328
+ rawScore: z.ZodNullable<z.ZodNumber>;
329
+ normalizedScore: z.ZodNullable<z.ZodNumber>;
330
+ passed: z.ZodNullable<z.ZodBoolean>;
331
+ evidenceHashes: z.ZodArray<z.ZodString>;
332
+ message: z.ZodNullable<z.ZodString>;
333
+ }, z.core.$strict>>;
334
+ training: z.ZodObject<{
335
+ status: z.ZodEnum<{
336
+ scored: "scored";
337
+ unscorable: "unscorable";
338
+ not_configured: "not_configured";
339
+ }>;
340
+ score: z.ZodNullable<z.ZodNumber>;
341
+ passed: z.ZodNullable<z.ZodBoolean>;
342
+ }, z.core.$strict>;
343
+ evaluation: z.ZodObject<{
344
+ status: z.ZodEnum<{
345
+ scored: "scored";
346
+ unscorable: "unscorable";
347
+ not_configured: "not_configured";
348
+ }>;
349
+ score: z.ZodNullable<z.ZodNumber>;
350
+ passed: z.ZodNullable<z.ZodBoolean>;
351
+ }, z.core.$strict>;
352
+ contentHash: z.ZodString;
353
+ }, z.core.$strict>>;
354
+ note: z.ZodString;
355
+ decidedAt: z.ZodString;
356
+ contentHash: z.ZodString;
357
+ }, z.core.$strict>>;
358
+ }, z.core.$strict>;
359
+ export type ModelBatchReviewInspection = z.infer<typeof ModelBatchReviewInspectionSchema>;
360
+ export declare const ModelBatchReviewRequestSchema: z.ZodObject<{
361
+ schemaVersion: z.ZodLiteral<"openpond.modelBatchReviewRequest.v1">;
362
+ operationId: z.ZodString;
363
+ modelId: z.ZodString;
364
+ expectedModelRevision: z.ZodNumber;
365
+ tasksetRef: z.ZodObject<{
366
+ id: z.ZodString;
367
+ contentHash: z.ZodString;
368
+ revision: z.ZodNumber;
369
+ }, z.core.$strict>;
370
+ rewardBindingRef: z.ZodNullable<z.ZodObject<{
371
+ id: z.ZodString;
372
+ contentHash: z.ZodString;
373
+ revision: z.ZodNumber;
374
+ }, z.core.$strict>>;
375
+ definition: z.ZodObject<{
376
+ name: z.ZodOptional<z.ZodString>;
377
+ instructions: z.ZodOptional<z.ZodString>;
378
+ inputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
379
+ outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
380
+ }, z.core.$strict>;
381
+ examples: z.ZodArray<z.ZodObject<{
382
+ evidence: z.ZodObject<{
383
+ id: z.ZodString;
384
+ contentHash: z.ZodString;
385
+ revision: z.ZodNumber;
386
+ }, z.core.$strict>;
387
+ input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
388
+ expected: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
389
+ evaluatorContext: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
390
+ proposedTarget: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
391
+ }, z.core.$strict>>;
392
+ }, z.core.$strict>;
393
+ export type ModelBatchReviewRequest = z.infer<typeof ModelBatchReviewRequestSchema>;
394
+ /** These are editable evidence and unapproved proposals, never admissions. */
395
+ export declare const ModelBatchReviewReceiptSchema: z.ZodObject<{
396
+ schemaVersion: z.ZodLiteral<"openpond.modelBatchReviewReceipt.v1">;
397
+ operationId: z.ZodString;
398
+ modelId: z.ZodString;
399
+ source: z.ZodObject<{
400
+ schemaVersion: z.ZodLiteral<"openpond.learningSource.v1">;
401
+ id: z.ZodString;
402
+ revision: z.ZodNumber;
403
+ name: z.ZodString;
404
+ kind: z.ZodEnum<{
405
+ work: "work";
406
+ provider: "provider";
407
+ direct: "direct";
408
+ benchmark: "benchmark";
409
+ opentelemetry: "opentelemetry";
410
+ }>;
411
+ taskDefinition: z.ZodObject<{
412
+ id: z.ZodString;
413
+ contentHash: z.ZodString;
414
+ revision: z.ZodNumber;
415
+ }, z.core.$strict>;
416
+ enabled: z.ZodBoolean;
417
+ allowedSplits: z.ZodArray<z.ZodEnum<{
418
+ train: "train";
419
+ validation: "validation";
420
+ test: "test";
421
+ frozen_eval: "frozen_eval";
422
+ }>>;
423
+ mapping: z.ZodNullable<z.ZodObject<{
424
+ schemaVersion: z.ZodLiteral<"openpond.taskSourceMapping.v1">;
425
+ exampleId: z.ZodString;
426
+ attemptId: z.ZodString;
427
+ occurredAt: z.ZodString;
428
+ input: z.ZodString;
429
+ observedOutput: z.ZodNullable<z.ZodString>;
430
+ expected: z.ZodNullable<z.ZodString>;
431
+ evaluatorContext: z.ZodNullable<z.ZodString>;
432
+ familyKey: z.ZodString;
433
+ split: z.ZodEnum<{
434
+ train: "train";
435
+ validation: "validation";
436
+ test: "test";
437
+ frozen_eval: "frozen_eval";
438
+ }>;
439
+ }, z.core.$strict>>;
440
+ adapterVersion: z.ZodNullable<z.ZodString>;
441
+ reviewOrigin: z.ZodOptional<z.ZodObject<{
442
+ modelId: z.ZodString;
443
+ packageHash: z.ZodString;
444
+ taskset: z.ZodObject<{
445
+ id: z.ZodString;
446
+ contentHash: z.ZodString;
447
+ revision: z.ZodNumber;
448
+ }, z.core.$strict>;
449
+ batch: z.ZodObject<{
450
+ id: z.ZodString;
451
+ contentHash: z.ZodString;
452
+ revision: z.ZodNumber;
453
+ }, z.core.$strict>;
454
+ rewardBinding: z.ZodObject<{
455
+ id: z.ZodString;
456
+ contentHash: z.ZodString;
457
+ revision: z.ZodNumber;
458
+ }, z.core.$strict>;
459
+ }, z.core.$strict>>;
460
+ contentHash: z.ZodString;
461
+ }, z.core.$strict>;
462
+ evidence: z.ZodArray<z.ZodObject<{
463
+ schemaVersion: z.ZodLiteral<"openpond.taskEvidence.v1">;
464
+ id: z.ZodString;
465
+ revision: z.ZodNumber;
466
+ source: z.ZodObject<{
467
+ id: z.ZodString;
468
+ contentHash: z.ZodString;
469
+ revision: z.ZodNumber;
470
+ }, z.core.$strict>;
471
+ submission: z.ZodObject<{
472
+ schemaVersion: z.ZodLiteral<"openpond.taskExample.v1">;
473
+ sourceId: z.ZodString;
474
+ idempotencyKey: z.ZodString;
475
+ taskDefinition: z.ZodObject<{
476
+ id: z.ZodString;
477
+ contentHash: z.ZodString;
478
+ revision: z.ZodNumber;
479
+ }, z.core.$strict>;
480
+ exampleId: z.ZodString;
481
+ attemptId: z.ZodString;
482
+ occurredAt: z.ZodString;
483
+ familyKey: z.ZodNullable<z.ZodString>;
484
+ split: z.ZodEnum<{
485
+ train: "train";
486
+ validation: "validation";
487
+ test: "test";
488
+ frozen_eval: "frozen_eval";
489
+ }>;
490
+ input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
491
+ observedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
492
+ expected: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
493
+ evaluatorContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
494
+ assets: z.ZodArray<z.ZodObject<{
495
+ id: z.ZodString;
496
+ path: z.ZodString;
497
+ contentHash: z.ZodString;
498
+ sizeBytes: z.ZodNumber;
499
+ mediaType: z.ZodString;
500
+ visibility: z.ZodEnum<{
501
+ policy: "policy";
502
+ verifier: "verifier";
503
+ host_private: "host_private";
504
+ }>;
505
+ }, z.core.$strict>>;
506
+ provenance: z.ZodObject<{
507
+ sourceRecordRef: z.ZodNullable<z.ZodString>;
508
+ mappingHash: z.ZodNullable<z.ZodString>;
509
+ }, z.core.$strict>;
510
+ }, z.core.$strict>;
511
+ supersedes: z.ZodNullable<z.ZodObject<{
512
+ id: z.ZodString;
513
+ contentHash: z.ZodString;
514
+ revision: z.ZodNumber;
515
+ }, z.core.$strict>>;
516
+ correctionFeedbackId: z.ZodNullable<z.ZodString>;
517
+ receivedAt: z.ZodString;
518
+ contentHash: z.ZodString;
519
+ }, z.core.$strict>>;
520
+ proposals: z.ZodArray<z.ZodObject<{
521
+ schemaVersion: z.ZodLiteral<"openpond.taskFeedbackRecord.v1">;
522
+ id: z.ZodString;
523
+ submission: z.ZodObject<{
524
+ schemaVersion: z.ZodLiteral<"openpond.taskFeedback.v1">;
525
+ sourceId: z.ZodString;
526
+ idempotencyKey: z.ZodString;
527
+ exampleId: z.ZodString;
528
+ attemptId: z.ZodString;
529
+ expectedEvidenceHash: z.ZodNullable<z.ZodString>;
530
+ occurredAt: z.ZodString;
531
+ kind: z.ZodEnum<{
532
+ outcome: "outcome";
533
+ target_correction: "target_correction";
534
+ ground_truth_correction: "ground_truth_correction";
535
+ input_correction: "input_correction";
536
+ family_resolution: "family_resolution";
537
+ }>;
538
+ value: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
539
+ note: z.ZodString;
540
+ }, z.core.$strict>;
541
+ status: z.ZodEnum<{
542
+ rejected: "rejected";
543
+ pending_example: "pending_example";
544
+ pending_review: "pending_review";
545
+ applied: "applied";
546
+ superseded: "superseded";
547
+ }>;
548
+ evidence: z.ZodNullable<z.ZodObject<{
549
+ id: z.ZodString;
550
+ contentHash: z.ZodString;
551
+ revision: z.ZodNumber;
552
+ }, z.core.$strict>>;
553
+ createdAt: z.ZodString;
554
+ revision: z.ZodNumber;
555
+ review: z.ZodDefault<z.ZodNullable<z.ZodObject<{
556
+ actorId: z.ZodString;
557
+ decision: z.ZodNullable<z.ZodObject<{
558
+ id: z.ZodString;
559
+ contentHash: z.ZodString;
560
+ revision: z.ZodNumber;
561
+ }, z.core.$strict>>;
562
+ note: z.ZodString;
563
+ resolvedAt: z.ZodString;
564
+ }, z.core.$strict>>>;
565
+ }, z.core.$strict>>;
566
+ }, z.core.$strict>;
567
+ export type ModelBatchReviewReceipt = z.infer<typeof ModelBatchReviewReceiptSchema>;
568
+ //# sourceMappingURL=model-batch-review-contracts.d.ts.map
package/dist/types/packages/sdk/src/model-batch-review-contracts.d.ts.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"model-batch-review-contracts.d.ts","sourceRoot":"","sources":["../../../../../src/model-batch-review-contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,iFAAiF;AACjF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAOlC,CAAC;AACZ,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoB/B,CAAC;AACZ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,8EAA8E;AAC9E,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAO/B,CAAC;AACZ,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}