@openpond/evals 0.2.0 → 0.3.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/CONTRACT.md +13 -2
- package/RELEASING.md +6 -5
- package/dist/compatibility.js +45 -0
- package/dist/conformance.js +6 -9
- package/dist/harness-improvements.js +329 -0
- package/dist/harness-workspaces.js +368 -0
- package/dist/harness.js +4 -6
- package/dist/index.js +3 -0
- package/dist/runs.js +33 -5
- package/dist/tasksets.js +2 -3
- package/dist/types/compatibility.d.ts +11 -0
- package/dist/types/compatibility.d.ts.map +1 -0
- package/dist/types/conformance.d.ts +8 -48
- package/dist/types/conformance.d.ts.map +1 -1
- package/dist/types/evidence/conformance.d.ts +12 -12
- package/dist/types/evidence/contracts.d.ts +10 -10
- package/dist/types/harness-improvements.d.ts +523 -0
- package/dist/types/harness-improvements.d.ts.map +1 -0
- package/dist/types/harness-workspaces.d.ts +802 -0
- package/dist/types/harness-workspaces.d.ts.map +1 -0
- package/dist/types/harness.d.ts +6 -68
- package/dist/types/harness.d.ts.map +1 -1
- package/dist/types/index.d.ts +3 -0
- package/dist/types/index.d.ts.map +1 -1
- package/dist/types/runs.d.ts +46 -1
- package/dist/types/runs.d.ts.map +1 -1
- package/dist/types/tasksets.d.ts +2 -10
- package/dist/types/tasksets.d.ts.map +1 -1
- package/package.json +9 -1
|
@@ -0,0 +1,523 @@
|
|
|
1
|
+
import { z } from "zod";
|
|
2
|
+
export declare const ImprovementSafeBoundaryKindSchema: z.ZodEnum<{
|
|
3
|
+
completed_tool_batch: "completed_tool_batch";
|
|
4
|
+
before_model_step: "before_model_step";
|
|
5
|
+
turn_completed: "turn_completed";
|
|
6
|
+
turn_paused: "turn_paused";
|
|
7
|
+
}>;
|
|
8
|
+
export declare const ImprovementSafeBoundarySchema: z.ZodObject<{
|
|
9
|
+
kind: z.ZodEnum<{
|
|
10
|
+
completed_tool_batch: "completed_tool_batch";
|
|
11
|
+
before_model_step: "before_model_step";
|
|
12
|
+
turn_completed: "turn_completed";
|
|
13
|
+
turn_paused: "turn_paused";
|
|
14
|
+
}>;
|
|
15
|
+
eventSequence: z.ZodNumber;
|
|
16
|
+
occurredAt: z.ZodString;
|
|
17
|
+
}, z.core.$strict>;
|
|
18
|
+
export declare const ImprovementEventRefSchema: z.ZodObject<{
|
|
19
|
+
id: z.ZodString;
|
|
20
|
+
sequence: z.ZodNullable<z.ZodNumber>;
|
|
21
|
+
contentHash: z.ZodString;
|
|
22
|
+
}, z.core.$strict>;
|
|
23
|
+
export declare const ImprovementObservationKindSchema: z.ZodEnum<{
|
|
24
|
+
validation: "validation";
|
|
25
|
+
recovery: "recovery";
|
|
26
|
+
user_correction: "user_correction";
|
|
27
|
+
tool_failure: "tool_failure";
|
|
28
|
+
retry: "retry";
|
|
29
|
+
reusable_success: "reusable_success";
|
|
30
|
+
completion_detour: "completion_detour";
|
|
31
|
+
}>;
|
|
32
|
+
export declare const ImprovementObservationStateSchema: z.ZodEnum<{
|
|
33
|
+
terminal: "terminal";
|
|
34
|
+
open: "open";
|
|
35
|
+
recovered: "recovered";
|
|
36
|
+
}>;
|
|
37
|
+
export declare const ImprovementToolIdentitySchema: z.ZodObject<{
|
|
38
|
+
name: z.ZodString;
|
|
39
|
+
invocationKey: z.ZodString;
|
|
40
|
+
}, z.core.$strict>;
|
|
41
|
+
export declare const ImprovementObservationContentSchema: z.ZodObject<{
|
|
42
|
+
schemaVersion: z.ZodLiteral<"openpond.improvementObservation.v1">;
|
|
43
|
+
id: z.ZodString;
|
|
44
|
+
runRef: z.ZodString;
|
|
45
|
+
turnId: z.ZodString;
|
|
46
|
+
harnessRelease: z.ZodObject<{
|
|
47
|
+
id: z.ZodString;
|
|
48
|
+
contentHash: z.ZodString;
|
|
49
|
+
}, z.core.$strict>;
|
|
50
|
+
overlay: z.ZodNullable<z.ZodObject<{
|
|
51
|
+
id: z.ZodString;
|
|
52
|
+
revision: z.ZodNumber;
|
|
53
|
+
contentHash: z.ZodString;
|
|
54
|
+
}, z.core.$strict>>;
|
|
55
|
+
eventRefs: z.ZodArray<z.ZodObject<{
|
|
56
|
+
id: z.ZodString;
|
|
57
|
+
sequence: z.ZodNullable<z.ZodNumber>;
|
|
58
|
+
contentHash: z.ZodString;
|
|
59
|
+
}, z.core.$strict>>;
|
|
60
|
+
kind: z.ZodEnum<{
|
|
61
|
+
validation: "validation";
|
|
62
|
+
recovery: "recovery";
|
|
63
|
+
user_correction: "user_correction";
|
|
64
|
+
tool_failure: "tool_failure";
|
|
65
|
+
retry: "retry";
|
|
66
|
+
reusable_success: "reusable_success";
|
|
67
|
+
completion_detour: "completion_detour";
|
|
68
|
+
}>;
|
|
69
|
+
state: z.ZodEnum<{
|
|
70
|
+
terminal: "terminal";
|
|
71
|
+
open: "open";
|
|
72
|
+
recovered: "recovered";
|
|
73
|
+
}>;
|
|
74
|
+
tool: z.ZodNullable<z.ZodObject<{
|
|
75
|
+
name: z.ZodString;
|
|
76
|
+
invocationKey: z.ZodString;
|
|
77
|
+
}, z.core.$strict>>;
|
|
78
|
+
deterministicClass: z.ZodNullable<z.ZodString>;
|
|
79
|
+
summary: z.ZodString;
|
|
80
|
+
createdAt: z.ZodString;
|
|
81
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
82
|
+
}, z.core.$strict>;
|
|
83
|
+
export declare const ImprovementObservationSchema: z.ZodObject<{
|
|
84
|
+
schemaVersion: z.ZodLiteral<"openpond.improvementObservation.v1">;
|
|
85
|
+
id: z.ZodString;
|
|
86
|
+
runRef: z.ZodString;
|
|
87
|
+
turnId: z.ZodString;
|
|
88
|
+
harnessRelease: z.ZodObject<{
|
|
89
|
+
id: z.ZodString;
|
|
90
|
+
contentHash: z.ZodString;
|
|
91
|
+
}, z.core.$strict>;
|
|
92
|
+
overlay: z.ZodNullable<z.ZodObject<{
|
|
93
|
+
id: z.ZodString;
|
|
94
|
+
revision: z.ZodNumber;
|
|
95
|
+
contentHash: z.ZodString;
|
|
96
|
+
}, z.core.$strict>>;
|
|
97
|
+
eventRefs: z.ZodArray<z.ZodObject<{
|
|
98
|
+
id: z.ZodString;
|
|
99
|
+
sequence: z.ZodNullable<z.ZodNumber>;
|
|
100
|
+
contentHash: z.ZodString;
|
|
101
|
+
}, z.core.$strict>>;
|
|
102
|
+
kind: z.ZodEnum<{
|
|
103
|
+
validation: "validation";
|
|
104
|
+
recovery: "recovery";
|
|
105
|
+
user_correction: "user_correction";
|
|
106
|
+
tool_failure: "tool_failure";
|
|
107
|
+
retry: "retry";
|
|
108
|
+
reusable_success: "reusable_success";
|
|
109
|
+
completion_detour: "completion_detour";
|
|
110
|
+
}>;
|
|
111
|
+
state: z.ZodEnum<{
|
|
112
|
+
terminal: "terminal";
|
|
113
|
+
open: "open";
|
|
114
|
+
recovered: "recovered";
|
|
115
|
+
}>;
|
|
116
|
+
tool: z.ZodNullable<z.ZodObject<{
|
|
117
|
+
name: z.ZodString;
|
|
118
|
+
invocationKey: z.ZodString;
|
|
119
|
+
}, z.core.$strict>>;
|
|
120
|
+
deterministicClass: z.ZodNullable<z.ZodString>;
|
|
121
|
+
summary: z.ZodString;
|
|
122
|
+
createdAt: z.ZodString;
|
|
123
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
124
|
+
contentHash: z.ZodString;
|
|
125
|
+
}, z.core.$strict>;
|
|
126
|
+
export declare const RefinementTriggerPolicySchema: z.ZodObject<{
|
|
127
|
+
schemaVersion: z.ZodLiteral<"openpond.refinementTriggerPolicy.v1">;
|
|
128
|
+
maxEstimatedCostUsd: z.ZodNumber;
|
|
129
|
+
cooldownMs: z.ZodNumber;
|
|
130
|
+
maxPendingPlans: z.ZodNumber;
|
|
131
|
+
maxEvidenceEvents: z.ZodNumber;
|
|
132
|
+
maxProposalEdits: z.ZodNumber;
|
|
133
|
+
maxProposalBytes: z.ZodNumber;
|
|
134
|
+
}, z.core.$strict>;
|
|
135
|
+
export declare const RefinementTriggerDecisionKindSchema: z.ZodEnum<{
|
|
136
|
+
no_action: "no_action";
|
|
137
|
+
route_deterministically: "route_deterministically";
|
|
138
|
+
queue_refiner: "queue_refiner";
|
|
139
|
+
}>;
|
|
140
|
+
export declare const RefinementTriggerDecisionContentSchema: z.ZodObject<{
|
|
141
|
+
schemaVersion: z.ZodLiteral<"openpond.refinementTriggerDecision.v1">;
|
|
142
|
+
id: z.ZodString;
|
|
143
|
+
runRef: z.ZodString;
|
|
144
|
+
turnId: z.ZodString;
|
|
145
|
+
harnessRelease: z.ZodObject<{
|
|
146
|
+
id: z.ZodString;
|
|
147
|
+
contentHash: z.ZodString;
|
|
148
|
+
}, z.core.$strict>;
|
|
149
|
+
overlay: z.ZodNullable<z.ZodObject<{
|
|
150
|
+
id: z.ZodString;
|
|
151
|
+
revision: z.ZodNumber;
|
|
152
|
+
contentHash: z.ZodString;
|
|
153
|
+
}, z.core.$strict>>;
|
|
154
|
+
observations: z.ZodArray<z.ZodObject<{
|
|
155
|
+
id: z.ZodString;
|
|
156
|
+
contentHash: z.ZodString;
|
|
157
|
+
}, z.core.$strict>>;
|
|
158
|
+
decision: z.ZodEnum<{
|
|
159
|
+
no_action: "no_action";
|
|
160
|
+
route_deterministically: "route_deterministically";
|
|
161
|
+
queue_refiner: "queue_refiner";
|
|
162
|
+
}>;
|
|
163
|
+
deterministicRoute: z.ZodNullable<z.ZodEnum<{
|
|
164
|
+
agent: "agent";
|
|
165
|
+
runtime: "runtime";
|
|
166
|
+
memory: "memory";
|
|
167
|
+
prompt: "prompt";
|
|
168
|
+
skill: "skill";
|
|
169
|
+
product: "product";
|
|
170
|
+
taskset: "taskset";
|
|
171
|
+
training: "training";
|
|
172
|
+
}>>;
|
|
173
|
+
suggestedRoutes: z.ZodArray<z.ZodEnum<{
|
|
174
|
+
agent: "agent";
|
|
175
|
+
runtime: "runtime";
|
|
176
|
+
memory: "memory";
|
|
177
|
+
prompt: "prompt";
|
|
178
|
+
skill: "skill";
|
|
179
|
+
product: "product";
|
|
180
|
+
taskset: "taskset";
|
|
181
|
+
training: "training";
|
|
182
|
+
}>>;
|
|
183
|
+
reason: z.ZodString;
|
|
184
|
+
deduplicationKey: z.ZodString;
|
|
185
|
+
policy: z.ZodObject<{
|
|
186
|
+
schemaVersion: z.ZodLiteral<"openpond.refinementTriggerPolicy.v1">;
|
|
187
|
+
maxEstimatedCostUsd: z.ZodNumber;
|
|
188
|
+
cooldownMs: z.ZodNumber;
|
|
189
|
+
maxPendingPlans: z.ZodNumber;
|
|
190
|
+
maxEvidenceEvents: z.ZodNumber;
|
|
191
|
+
maxProposalEdits: z.ZodNumber;
|
|
192
|
+
maxProposalBytes: z.ZodNumber;
|
|
193
|
+
}, z.core.$strict>;
|
|
194
|
+
estimatedMaxCostUsd: z.ZodNumber;
|
|
195
|
+
pendingPlanCount: z.ZodNumber;
|
|
196
|
+
boundary: z.ZodObject<{
|
|
197
|
+
kind: z.ZodEnum<{
|
|
198
|
+
completed_tool_batch: "completed_tool_batch";
|
|
199
|
+
before_model_step: "before_model_step";
|
|
200
|
+
turn_completed: "turn_completed";
|
|
201
|
+
turn_paused: "turn_paused";
|
|
202
|
+
}>;
|
|
203
|
+
eventSequence: z.ZodNumber;
|
|
204
|
+
occurredAt: z.ZodString;
|
|
205
|
+
}, z.core.$strict>;
|
|
206
|
+
cooldownUntil: z.ZodNullable<z.ZodString>;
|
|
207
|
+
createdAt: z.ZodString;
|
|
208
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
209
|
+
}, z.core.$strict>;
|
|
210
|
+
export declare const RefinementTriggerDecisionSchema: z.ZodObject<{
|
|
211
|
+
schemaVersion: z.ZodLiteral<"openpond.refinementTriggerDecision.v1">;
|
|
212
|
+
id: z.ZodString;
|
|
213
|
+
runRef: z.ZodString;
|
|
214
|
+
turnId: z.ZodString;
|
|
215
|
+
harnessRelease: z.ZodObject<{
|
|
216
|
+
id: z.ZodString;
|
|
217
|
+
contentHash: z.ZodString;
|
|
218
|
+
}, z.core.$strict>;
|
|
219
|
+
overlay: z.ZodNullable<z.ZodObject<{
|
|
220
|
+
id: z.ZodString;
|
|
221
|
+
revision: z.ZodNumber;
|
|
222
|
+
contentHash: z.ZodString;
|
|
223
|
+
}, z.core.$strict>>;
|
|
224
|
+
observations: z.ZodArray<z.ZodObject<{
|
|
225
|
+
id: z.ZodString;
|
|
226
|
+
contentHash: z.ZodString;
|
|
227
|
+
}, z.core.$strict>>;
|
|
228
|
+
decision: z.ZodEnum<{
|
|
229
|
+
no_action: "no_action";
|
|
230
|
+
route_deterministically: "route_deterministically";
|
|
231
|
+
queue_refiner: "queue_refiner";
|
|
232
|
+
}>;
|
|
233
|
+
deterministicRoute: z.ZodNullable<z.ZodEnum<{
|
|
234
|
+
agent: "agent";
|
|
235
|
+
runtime: "runtime";
|
|
236
|
+
memory: "memory";
|
|
237
|
+
prompt: "prompt";
|
|
238
|
+
skill: "skill";
|
|
239
|
+
product: "product";
|
|
240
|
+
taskset: "taskset";
|
|
241
|
+
training: "training";
|
|
242
|
+
}>>;
|
|
243
|
+
suggestedRoutes: z.ZodArray<z.ZodEnum<{
|
|
244
|
+
agent: "agent";
|
|
245
|
+
runtime: "runtime";
|
|
246
|
+
memory: "memory";
|
|
247
|
+
prompt: "prompt";
|
|
248
|
+
skill: "skill";
|
|
249
|
+
product: "product";
|
|
250
|
+
taskset: "taskset";
|
|
251
|
+
training: "training";
|
|
252
|
+
}>>;
|
|
253
|
+
reason: z.ZodString;
|
|
254
|
+
deduplicationKey: z.ZodString;
|
|
255
|
+
policy: z.ZodObject<{
|
|
256
|
+
schemaVersion: z.ZodLiteral<"openpond.refinementTriggerPolicy.v1">;
|
|
257
|
+
maxEstimatedCostUsd: z.ZodNumber;
|
|
258
|
+
cooldownMs: z.ZodNumber;
|
|
259
|
+
maxPendingPlans: z.ZodNumber;
|
|
260
|
+
maxEvidenceEvents: z.ZodNumber;
|
|
261
|
+
maxProposalEdits: z.ZodNumber;
|
|
262
|
+
maxProposalBytes: z.ZodNumber;
|
|
263
|
+
}, z.core.$strict>;
|
|
264
|
+
estimatedMaxCostUsd: z.ZodNumber;
|
|
265
|
+
pendingPlanCount: z.ZodNumber;
|
|
266
|
+
boundary: z.ZodObject<{
|
|
267
|
+
kind: z.ZodEnum<{
|
|
268
|
+
completed_tool_batch: "completed_tool_batch";
|
|
269
|
+
before_model_step: "before_model_step";
|
|
270
|
+
turn_completed: "turn_completed";
|
|
271
|
+
turn_paused: "turn_paused";
|
|
272
|
+
}>;
|
|
273
|
+
eventSequence: z.ZodNumber;
|
|
274
|
+
occurredAt: z.ZodString;
|
|
275
|
+
}, z.core.$strict>;
|
|
276
|
+
cooldownUntil: z.ZodNullable<z.ZodString>;
|
|
277
|
+
createdAt: z.ZodString;
|
|
278
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
279
|
+
contentHash: z.ZodString;
|
|
280
|
+
}, z.core.$strict>;
|
|
281
|
+
export declare const ImprovementRouteAuthoritySchema: z.ZodEnum<{
|
|
282
|
+
runtime_service: "runtime_service";
|
|
283
|
+
refiner_model: "refiner_model";
|
|
284
|
+
human_review: "human_review";
|
|
285
|
+
evaluation_system: "evaluation_system";
|
|
286
|
+
training_system: "training_system";
|
|
287
|
+
}>;
|
|
288
|
+
export declare const ImprovementRouteDecisionContentSchema: z.ZodObject<{
|
|
289
|
+
schemaVersion: z.ZodLiteral<"openpond.improvementRouteDecision.v1">;
|
|
290
|
+
id: z.ZodString;
|
|
291
|
+
trigger: z.ZodObject<{
|
|
292
|
+
id: z.ZodString;
|
|
293
|
+
contentHash: z.ZodString;
|
|
294
|
+
}, z.core.$strict>;
|
|
295
|
+
route: z.ZodEnum<{
|
|
296
|
+
agent: "agent";
|
|
297
|
+
runtime: "runtime";
|
|
298
|
+
memory: "memory";
|
|
299
|
+
prompt: "prompt";
|
|
300
|
+
skill: "skill";
|
|
301
|
+
product: "product";
|
|
302
|
+
taskset: "taskset";
|
|
303
|
+
training: "training";
|
|
304
|
+
}>;
|
|
305
|
+
authority: z.ZodEnum<{
|
|
306
|
+
runtime_service: "runtime_service";
|
|
307
|
+
refiner_model: "refiner_model";
|
|
308
|
+
human_review: "human_review";
|
|
309
|
+
evaluation_system: "evaluation_system";
|
|
310
|
+
training_system: "training_system";
|
|
311
|
+
}>;
|
|
312
|
+
automatic: z.ZodBoolean;
|
|
313
|
+
reason: z.ZodString;
|
|
314
|
+
createdAt: z.ZodString;
|
|
315
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
316
|
+
}, z.core.$strict>;
|
|
317
|
+
export declare const ImprovementRouteDecisionSchema: z.ZodObject<{
|
|
318
|
+
schemaVersion: z.ZodLiteral<"openpond.improvementRouteDecision.v1">;
|
|
319
|
+
id: z.ZodString;
|
|
320
|
+
trigger: z.ZodObject<{
|
|
321
|
+
id: z.ZodString;
|
|
322
|
+
contentHash: z.ZodString;
|
|
323
|
+
}, z.core.$strict>;
|
|
324
|
+
route: z.ZodEnum<{
|
|
325
|
+
agent: "agent";
|
|
326
|
+
runtime: "runtime";
|
|
327
|
+
memory: "memory";
|
|
328
|
+
prompt: "prompt";
|
|
329
|
+
skill: "skill";
|
|
330
|
+
product: "product";
|
|
331
|
+
taskset: "taskset";
|
|
332
|
+
training: "training";
|
|
333
|
+
}>;
|
|
334
|
+
authority: z.ZodEnum<{
|
|
335
|
+
runtime_service: "runtime_service";
|
|
336
|
+
refiner_model: "refiner_model";
|
|
337
|
+
human_review: "human_review";
|
|
338
|
+
evaluation_system: "evaluation_system";
|
|
339
|
+
training_system: "training_system";
|
|
340
|
+
}>;
|
|
341
|
+
automatic: z.ZodBoolean;
|
|
342
|
+
reason: z.ZodString;
|
|
343
|
+
createdAt: z.ZodString;
|
|
344
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
345
|
+
contentHash: z.ZodString;
|
|
346
|
+
}, z.core.$strict>;
|
|
347
|
+
export declare const HarnessRefinerOutcomeContentSchema: z.ZodObject<{
|
|
348
|
+
schemaVersion: z.ZodLiteral<"openpond.harnessRefinerOutcome.v1">;
|
|
349
|
+
id: z.ZodString;
|
|
350
|
+
trigger: z.ZodObject<{
|
|
351
|
+
id: z.ZodString;
|
|
352
|
+
contentHash: z.ZodString;
|
|
353
|
+
}, z.core.$strict>;
|
|
354
|
+
decision: z.ZodEnum<{
|
|
355
|
+
no_action: "no_action";
|
|
356
|
+
proposed: "proposed";
|
|
357
|
+
}>;
|
|
358
|
+
proposal: z.ZodNullable<z.ZodObject<{
|
|
359
|
+
id: z.ZodString;
|
|
360
|
+
contentHash: z.ZodString;
|
|
361
|
+
}, z.core.$strict>>;
|
|
362
|
+
reason: z.ZodString;
|
|
363
|
+
evidenceRefs: z.ZodArray<z.ZodObject<{
|
|
364
|
+
id: z.ZodString;
|
|
365
|
+
contentHash: z.ZodString;
|
|
366
|
+
}, z.core.$strict>>;
|
|
367
|
+
estimatedCostUsd: z.ZodNumber;
|
|
368
|
+
createdAt: z.ZodString;
|
|
369
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
370
|
+
}, z.core.$strict>;
|
|
371
|
+
export declare const HarnessRefinerOutcomeSchema: z.ZodObject<{
|
|
372
|
+
schemaVersion: z.ZodLiteral<"openpond.harnessRefinerOutcome.v1">;
|
|
373
|
+
id: z.ZodString;
|
|
374
|
+
trigger: z.ZodObject<{
|
|
375
|
+
id: z.ZodString;
|
|
376
|
+
contentHash: z.ZodString;
|
|
377
|
+
}, z.core.$strict>;
|
|
378
|
+
decision: z.ZodEnum<{
|
|
379
|
+
no_action: "no_action";
|
|
380
|
+
proposed: "proposed";
|
|
381
|
+
}>;
|
|
382
|
+
proposal: z.ZodNullable<z.ZodObject<{
|
|
383
|
+
id: z.ZodString;
|
|
384
|
+
contentHash: z.ZodString;
|
|
385
|
+
}, z.core.$strict>>;
|
|
386
|
+
reason: z.ZodString;
|
|
387
|
+
evidenceRefs: z.ZodArray<z.ZodObject<{
|
|
388
|
+
id: z.ZodString;
|
|
389
|
+
contentHash: z.ZodString;
|
|
390
|
+
}, z.core.$strict>>;
|
|
391
|
+
estimatedCostUsd: z.ZodNumber;
|
|
392
|
+
createdAt: z.ZodString;
|
|
393
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
394
|
+
contentHash: z.ZodString;
|
|
395
|
+
}, z.core.$strict>;
|
|
396
|
+
export declare const ImprovementApplyDecisionSchema: z.ZodEnum<{
|
|
397
|
+
retained: "retained";
|
|
398
|
+
conflict: "conflict";
|
|
399
|
+
rolled_back: "rolled_back";
|
|
400
|
+
applied: "applied";
|
|
401
|
+
declined: "declined";
|
|
402
|
+
}>;
|
|
403
|
+
export declare const ImprovementApplyReceiptContentSchema: z.ZodObject<{
|
|
404
|
+
schemaVersion: z.ZodLiteral<"openpond.improvementApplyReceipt.v1">;
|
|
405
|
+
id: z.ZodString;
|
|
406
|
+
proposal: z.ZodObject<{
|
|
407
|
+
id: z.ZodString;
|
|
408
|
+
contentHash: z.ZodString;
|
|
409
|
+
}, z.core.$strict>;
|
|
410
|
+
beforeOverlay: z.ZodObject<{
|
|
411
|
+
id: z.ZodString;
|
|
412
|
+
revision: z.ZodNumber;
|
|
413
|
+
contentHash: z.ZodString;
|
|
414
|
+
}, z.core.$strict>;
|
|
415
|
+
afterOverlay: z.ZodNullable<z.ZodObject<{
|
|
416
|
+
id: z.ZodString;
|
|
417
|
+
revision: z.ZodNumber;
|
|
418
|
+
contentHash: z.ZodString;
|
|
419
|
+
}, z.core.$strict>>;
|
|
420
|
+
decision: z.ZodEnum<{
|
|
421
|
+
retained: "retained";
|
|
422
|
+
conflict: "conflict";
|
|
423
|
+
rolled_back: "rolled_back";
|
|
424
|
+
applied: "applied";
|
|
425
|
+
declined: "declined";
|
|
426
|
+
}>;
|
|
427
|
+
boundary: z.ZodObject<{
|
|
428
|
+
kind: z.ZodEnum<{
|
|
429
|
+
completed_tool_batch: "completed_tool_batch";
|
|
430
|
+
before_model_step: "before_model_step";
|
|
431
|
+
turn_completed: "turn_completed";
|
|
432
|
+
turn_paused: "turn_paused";
|
|
433
|
+
}>;
|
|
434
|
+
eventSequence: z.ZodNumber;
|
|
435
|
+
occurredAt: z.ZodString;
|
|
436
|
+
}, z.core.$strict>;
|
|
437
|
+
validationRefs: z.ZodArray<z.ZodObject<{
|
|
438
|
+
id: z.ZodString;
|
|
439
|
+
contentHash: z.ZodString;
|
|
440
|
+
}, z.core.$strict>>;
|
|
441
|
+
outcomeEvidenceRefs: z.ZodArray<z.ZodObject<{
|
|
442
|
+
id: z.ZodString;
|
|
443
|
+
sequence: z.ZodNullable<z.ZodNumber>;
|
|
444
|
+
contentHash: z.ZodString;
|
|
445
|
+
}, z.core.$strict>>;
|
|
446
|
+
rollbackOf: z.ZodNullable<z.ZodObject<{
|
|
447
|
+
id: z.ZodString;
|
|
448
|
+
contentHash: z.ZodString;
|
|
449
|
+
}, z.core.$strict>>;
|
|
450
|
+
createdAt: z.ZodString;
|
|
451
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
452
|
+
}, z.core.$strict>;
|
|
453
|
+
export declare const ImprovementApplyReceiptSchema: z.ZodObject<{
|
|
454
|
+
schemaVersion: z.ZodLiteral<"openpond.improvementApplyReceipt.v1">;
|
|
455
|
+
id: z.ZodString;
|
|
456
|
+
proposal: z.ZodObject<{
|
|
457
|
+
id: z.ZodString;
|
|
458
|
+
contentHash: z.ZodString;
|
|
459
|
+
}, z.core.$strict>;
|
|
460
|
+
beforeOverlay: z.ZodObject<{
|
|
461
|
+
id: z.ZodString;
|
|
462
|
+
revision: z.ZodNumber;
|
|
463
|
+
contentHash: z.ZodString;
|
|
464
|
+
}, z.core.$strict>;
|
|
465
|
+
afterOverlay: z.ZodNullable<z.ZodObject<{
|
|
466
|
+
id: z.ZodString;
|
|
467
|
+
revision: z.ZodNumber;
|
|
468
|
+
contentHash: z.ZodString;
|
|
469
|
+
}, z.core.$strict>>;
|
|
470
|
+
decision: z.ZodEnum<{
|
|
471
|
+
retained: "retained";
|
|
472
|
+
conflict: "conflict";
|
|
473
|
+
rolled_back: "rolled_back";
|
|
474
|
+
applied: "applied";
|
|
475
|
+
declined: "declined";
|
|
476
|
+
}>;
|
|
477
|
+
boundary: z.ZodObject<{
|
|
478
|
+
kind: z.ZodEnum<{
|
|
479
|
+
completed_tool_batch: "completed_tool_batch";
|
|
480
|
+
before_model_step: "before_model_step";
|
|
481
|
+
turn_completed: "turn_completed";
|
|
482
|
+
turn_paused: "turn_paused";
|
|
483
|
+
}>;
|
|
484
|
+
eventSequence: z.ZodNumber;
|
|
485
|
+
occurredAt: z.ZodString;
|
|
486
|
+
}, z.core.$strict>;
|
|
487
|
+
validationRefs: z.ZodArray<z.ZodObject<{
|
|
488
|
+
id: z.ZodString;
|
|
489
|
+
contentHash: z.ZodString;
|
|
490
|
+
}, z.core.$strict>>;
|
|
491
|
+
outcomeEvidenceRefs: z.ZodArray<z.ZodObject<{
|
|
492
|
+
id: z.ZodString;
|
|
493
|
+
sequence: z.ZodNullable<z.ZodNumber>;
|
|
494
|
+
contentHash: z.ZodString;
|
|
495
|
+
}, z.core.$strict>>;
|
|
496
|
+
rollbackOf: z.ZodNullable<z.ZodObject<{
|
|
497
|
+
id: z.ZodString;
|
|
498
|
+
contentHash: z.ZodString;
|
|
499
|
+
}, z.core.$strict>>;
|
|
500
|
+
createdAt: z.ZodString;
|
|
501
|
+
metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
|
|
502
|
+
contentHash: z.ZodString;
|
|
503
|
+
}, z.core.$strict>;
|
|
504
|
+
export declare function createImprovementObservation(content: z.input<typeof ImprovementObservationContentSchema>): ImprovementObservation;
|
|
505
|
+
export declare function createRefinementTriggerDecision(content: z.input<typeof RefinementTriggerDecisionContentSchema>): RefinementTriggerDecision;
|
|
506
|
+
export declare function createImprovementRouteDecision(content: z.input<typeof ImprovementRouteDecisionContentSchema>): ImprovementRouteDecision;
|
|
507
|
+
export declare function createHarnessRefinerOutcome(content: z.input<typeof HarnessRefinerOutcomeContentSchema>): HarnessRefinerOutcome;
|
|
508
|
+
export declare function createImprovementApplyReceipt(content: z.input<typeof ImprovementApplyReceiptContentSchema>): ImprovementApplyReceipt;
|
|
509
|
+
export type ImprovementSafeBoundaryKind = z.infer<typeof ImprovementSafeBoundaryKindSchema>;
|
|
510
|
+
export type ImprovementSafeBoundary = z.infer<typeof ImprovementSafeBoundarySchema>;
|
|
511
|
+
export type ImprovementEventRef = z.infer<typeof ImprovementEventRefSchema>;
|
|
512
|
+
export type ImprovementObservationKind = z.infer<typeof ImprovementObservationKindSchema>;
|
|
513
|
+
export type ImprovementObservationState = z.infer<typeof ImprovementObservationStateSchema>;
|
|
514
|
+
export type ImprovementObservation = z.infer<typeof ImprovementObservationSchema>;
|
|
515
|
+
export type RefinementTriggerPolicy = z.infer<typeof RefinementTriggerPolicySchema>;
|
|
516
|
+
export type RefinementTriggerDecisionKind = z.infer<typeof RefinementTriggerDecisionKindSchema>;
|
|
517
|
+
export type RefinementTriggerDecision = z.infer<typeof RefinementTriggerDecisionSchema>;
|
|
518
|
+
export type ImprovementRouteAuthority = z.infer<typeof ImprovementRouteAuthoritySchema>;
|
|
519
|
+
export type ImprovementRouteDecision = z.infer<typeof ImprovementRouteDecisionSchema>;
|
|
520
|
+
export type HarnessRefinerOutcome = z.infer<typeof HarnessRefinerOutcomeSchema>;
|
|
521
|
+
export type ImprovementApplyDecision = z.infer<typeof ImprovementApplyDecisionSchema>;
|
|
522
|
+
export type ImprovementApplyReceipt = z.infer<typeof ImprovementApplyReceiptSchema>;
|
|
523
|
+
//# sourceMappingURL=harness-improvements.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"harness-improvements.d.ts","sourceRoot":"","sources":["../../../../src/harness-improvements.ts"],"names":[],"mappings":"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"}
|