@shipfox/api-workflows-dto 12.1.0 → 12.2.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.
Files changed (26) hide show
  1. package/.turbo/turbo-build.log +1 -1
  2. package/CHANGELOG.md +10 -0
  3. package/dist/events.d.ts +52 -33
  4. package/dist/events.d.ts.map +1 -1
  5. package/dist/events.js +24 -1
  6. package/dist/events.js.map +1 -1
  7. package/dist/index.d.ts +1 -1
  8. package/dist/index.d.ts.map +1 -1
  9. package/dist/index.js +1 -1
  10. package/dist/index.js.map +1 -1
  11. package/dist/inter-module.d.ts +50 -50
  12. package/dist/inter-module.d.ts.map +1 -1
  13. package/dist/schemas/job-execution.d.ts +27 -27
  14. package/dist/schemas/job-listening.d.ts +6 -6
  15. package/dist/schemas/job.d.ts +22 -22
  16. package/dist/schemas/log-outcome.d.ts +1 -1
  17. package/dist/schemas/step.d.ts +36 -36
  18. package/dist/schemas/workflow-run-detail.d.ts +84 -84
  19. package/dist/schemas/workflow-run.d.ts +27 -27
  20. package/dist/tsconfig.test.tsbuildinfo +1 -1
  21. package/dist/working-directory.d.ts.map +1 -1
  22. package/package.json +2 -2
  23. package/src/events.test.ts +2 -0
  24. package/src/events.ts +31 -0
  25. package/src/index.ts +3 -0
  26. package/tsconfig.build.tsbuildinfo +1 -1
package/dist/inter-module.d.ts CHANGED
@@ -7,8 +7,8 @@ import { z } from 'zod';
7
7
  export declare const workflowsInterModuleContract: import("@shipfox/inter-module").InterModuleContract<{
8
8
  readonly module: "workflows";
9
9
  readonly methods: {
10
- readonly startRunFromTrigger: {
11
- readonly input: z.ZodObject<{
10
+ startRunFromTrigger: {
11
+ input: z.ZodObject<{
12
12
  workspaceId: z.ZodString;
13
13
  projectId: z.ZodString;
14
14
  definitionId: z.ZodString;
@@ -34,60 +34,60 @@ export declare const workflowsInterModuleContract: import("@shipfox/inter-module
34
34
  inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
35
35
  idempotencyKey: z.ZodString;
36
36
  }, z.core.$strip>;
37
- readonly output: z.ZodObject<{
37
+ output: z.ZodObject<{
38
38
  id: z.ZodString;
39
39
  name: z.ZodString;
40
40
  }, z.core.$strip>;
41
- readonly errors: {
42
- readonly 'workspace-not-found': z.ZodObject<{
41
+ errors: {
42
+ 'workspace-not-found': z.ZodObject<{
43
43
  workspaceId: z.ZodString;
44
44
  }, z.core.$strip>;
45
- readonly 'workspace-suspended': z.ZodObject<{
45
+ 'workspace-suspended': z.ZodObject<{
46
46
  workspaceId: z.ZodString;
47
47
  }, z.core.$strip>;
48
- readonly 'workspace-deleted': z.ZodObject<{
48
+ 'workspace-deleted': z.ZodObject<{
49
49
  workspaceId: z.ZodString;
50
50
  }, z.core.$strip>;
51
- readonly 'definition-not-found': z.ZodObject<{
51
+ 'definition-not-found': z.ZodObject<{
52
52
  definitionId: z.ZodString;
53
53
  }, z.core.$strip>;
54
- readonly 'project-mismatch': z.ZodObject<{}, z.core.$strip>;
55
- readonly 'agent-config-unresolvable': z.ZodObject<{
54
+ 'project-mismatch': z.ZodObject<{}, z.core.$strip>;
55
+ 'agent-config-unresolvable': z.ZodObject<{
56
56
  definitionId: z.ZodString;
57
57
  }, z.core.$strip>;
58
- readonly 'agent-integration-materialization-failed': z.ZodObject<{}, z.core.$strip>;
59
- readonly 'interpolation-unresolvable': z.ZodObject<{
58
+ 'agent-integration-materialization-failed': z.ZodObject<{}, z.core.$strip>;
59
+ 'interpolation-unresolvable': z.ZodObject<{
60
60
  definitionId: z.ZodString;
61
61
  field: z.ZodEnum<{
62
- run: "run";
63
- env: "env";
64
- "agent.prompt": "agent.prompt";
65
62
  "agent.model": "agent.model";
63
+ "agent.prompt": "agent.prompt";
66
64
  "agent.provider": "agent.provider";
67
65
  "agent.thinking": "agent.thinking";
68
- "job.runner": "job.runner";
69
- "job.outputs": "job.outputs";
66
+ "checkout.connection": "checkout.connection";
67
+ "checkout.path": "checkout.path";
68
+ "checkout.project": "checkout.project";
69
+ "checkout.ref": "checkout.ref";
70
+ "checkout.repository": "checkout.repository";
71
+ env: "env";
70
72
  "job.execution_name": "job.execution_name";
71
- "workflow.run_name": "workflow.run_name";
73
+ "job.outputs": "job.outputs";
74
+ "job.runner": "job.runner";
75
+ run: "run";
76
+ "step.feedback": "step.feedback";
72
77
  "step.name": "step.name";
73
78
  "step.working_directory": "step.working_directory";
74
- "step.feedback": "step.feedback";
75
- "checkout.project": "checkout.project";
76
- "checkout.connection": "checkout.connection";
77
- "checkout.repository": "checkout.repository";
78
- "checkout.ref": "checkout.ref";
79
- "checkout.path": "checkout.path";
79
+ "workflow.run_name": "workflow.run_name";
80
80
  }>;
81
81
  source: z.ZodString;
82
82
  envKey: z.ZodOptional<z.ZodString>;
83
83
  }, z.core.$strip>;
84
- readonly 'invalid-job-runner-labels': z.ZodObject<{
84
+ 'invalid-job-runner-labels': z.ZodObject<{
85
85
  labels: z.ZodArray<z.ZodString>;
86
86
  }, z.core.$strip>;
87
87
  };
88
88
  };
89
- readonly resolveWorkflowRunTriggerReference: {
90
- readonly input: z.ZodObject<{
89
+ resolveWorkflowRunTriggerReference: {
90
+ input: z.ZodObject<{
91
91
  workspaceId: z.ZodString;
92
92
  triggerConnectionId: z.ZodString;
93
93
  triggerPayload: z.ZodUnion<readonly [z.ZodObject<{
@@ -109,7 +109,7 @@ export declare const workflowsInterModuleContract: import("@shipfox/inter-module
109
109
  data: z.ZodUnknown;
110
110
  }, z.core.$strip>]>;
111
111
  }, z.core.$strip>;
112
- readonly output: z.ZodNullable<z.ZodObject<{
112
+ output: z.ZodNullable<z.ZodObject<{
113
113
  project: z.ZodNullable<z.ZodObject<{
114
114
  id: z.ZodString;
115
115
  }, z.core.$strip>>;
@@ -119,8 +119,8 @@ export declare const workflowsInterModuleContract: import("@shipfox/inter-module
119
119
  actor: z.ZodNullable<z.ZodString>;
120
120
  }, z.core.$strip>>;
121
121
  };
122
- readonly deliverEventToJobListener: {
123
- readonly input: z.ZodObject<{
122
+ deliverEventToJobListener: {
123
+ input: z.ZodObject<{
124
124
  jobId: z.ZodString;
125
125
  disposition: z.ZodEnum<{
126
126
  fire: "fire";
@@ -144,42 +144,42 @@ export declare const workflowsInterModuleContract: import("@shipfox/inter-module
144
144
  payload: z.ZodUnknown;
145
145
  receivedAt: z.ZodString;
146
146
  }, z.core.$strip>;
147
- readonly output: z.ZodObject<{
147
+ output: z.ZodObject<{
148
148
  buffered: z.ZodBoolean;
149
149
  skipped: z.ZodBoolean;
150
150
  }, z.core.$strip>;
151
- readonly errors: {
152
- readonly 'workspace-not-found': z.ZodObject<{
151
+ errors: {
152
+ 'workspace-not-found': z.ZodObject<{
153
153
  workspaceId: z.ZodString;
154
154
  }, z.core.$strip>;
155
- readonly 'workspace-suspended': z.ZodObject<{
155
+ 'workspace-suspended': z.ZodObject<{
156
156
  workspaceId: z.ZodString;
157
157
  }, z.core.$strip>;
158
- readonly 'workspace-deleted': z.ZodObject<{
158
+ 'workspace-deleted': z.ZodObject<{
159
159
  workspaceId: z.ZodString;
160
160
  }, z.core.$strip>;
161
161
  };
162
162
  };
163
- readonly getStepLogContext: {
164
- readonly input: z.ZodObject<{
163
+ getStepLogContext: {
164
+ input: z.ZodObject<{
165
165
  stepId: z.ZodString;
166
166
  }, z.core.$strip>;
167
- readonly output: z.ZodObject<{
167
+ output: z.ZodObject<{
168
168
  harness: z.ZodEnum<{
169
- pi: "pi";
170
169
  claude: "claude";
170
+ pi: "pi";
171
171
  }>;
172
172
  }, z.core.$strip>;
173
173
  };
174
- readonly getLeasedAgentToolContext: {
175
- readonly input: z.ZodObject<{
174
+ getLeasedAgentToolContext: {
175
+ input: z.ZodObject<{
176
176
  jobId: z.ZodString;
177
177
  jobExecutionId: z.ZodString;
178
178
  runnerSessionId: z.ZodString;
179
179
  stepId: z.ZodString;
180
180
  attempt: z.ZodNumber;
181
181
  }, z.core.$strip>;
182
- readonly output: z.ZodObject<{
182
+ output: z.ZodObject<{
183
183
  workspaceId: z.ZodString;
184
184
  integrations: z.ZodArray<z.ZodObject<{
185
185
  connectionId: z.ZodString;
@@ -210,14 +210,14 @@ export declare const workflowsInterModuleContract: import("@shipfox/inter-module
210
210
  }, z.core.$strict>>;
211
211
  }, z.core.$strict>>;
212
212
  }, z.core.$strip>;
213
- readonly errors: {
214
- readonly 'lease-not-active': z.ZodObject<{}, z.core.$strip>;
215
- readonly 'step-not-found': z.ZodObject<{}, z.core.$strip>;
216
- readonly 'job-not-found': z.ZodObject<{}, z.core.$strip>;
217
- readonly 'step-attempt-mismatch': z.ZodObject<{}, z.core.$strip>;
218
- readonly 'step-not-running': z.ZodObject<{}, z.core.$strip>;
219
- readonly 'leased-step-not-agent': z.ZodObject<{}, z.core.$strip>;
220
- readonly 'agent-step-config-invalid': z.ZodObject<{}, z.core.$strip>;
213
+ errors: {
214
+ 'lease-not-active': z.ZodObject<{}, z.core.$strip>;
215
+ 'step-not-found': z.ZodObject<{}, z.core.$strip>;
216
+ 'job-not-found': z.ZodObject<{}, z.core.$strip>;
217
+ 'step-attempt-mismatch': z.ZodObject<{}, z.core.$strip>;
218
+ 'step-not-running': z.ZodObject<{}, z.core.$strip>;
219
+ 'leased-step-not-agent': z.ZodObject<{}, z.core.$strip>;
220
+ 'agent-step-config-invalid': z.ZodObject<{}, z.core.$strip>;
221
221
  };
222
222
  };
223
223
  };
package/dist/inter-module.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"inter-module.d.ts","sourceRoot":"","sources":["../src/inter-module.ts"],"names":[],"mappings":"AACA,OAAO,EAA4B,KAAK,iBAAiB,EAAC,MAAM,uBAAuB,CAAC;AACxF,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAsDtB;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuFvC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,CAAC,OAAO,4BAA4B,CAAC,CAAC"}
1
+ {"version":3,"file":"inter-module.d.ts","sourceRoot":"","sources":["../src/inter-module.ts"],"names":[],"mappings":"AACA,OAAO,EAA4B,KAAK,iBAAiB,EAAC,MAAM,uBAAuB,CAAC;AACxF,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAsDtB;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;QAGrC,mBAAmB;YACjB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;YASL,MAAM;;;;YACN,MAAM;gBACJ,qBAAqB;;;gBACrB,qBAAqB;;;gBACrB,mBAAmB;;;gBACnB,sBAAsB;;;gBACtB,kBAAkB;gBAClB,2BAA2B;;;gBAC3B,0CAA0C;gBAC1C,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;gBAM5B,2BAA2B;;;;;QAG/B,kCAAkC;YAChC,KAAK;;;;;;;;;;;;;;;;;;;;;;YAKL,MAAM;;;;;;;;;;QAER,yBAAyB;YACvB,KAAK;;;;;;;;;;;;;;;;;;;;;;;;YAaL,MAAM;;;;YACN,MAAM;gBACJ,qBAAqB;;;gBACrB,qBAAqB;;;gBACrB,mBAAmB;;;;;QAGvB,iBAAiB;YACf,KAAK;;;YACL,MAAM;;;;;;;QAER,yBAAyB;YACvB,KAAK;;;;;;;YAOL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAIN,MAAM;gBACJ,kBAAkB;gBAClB,gBAAgB;gBAChB,eAAe;gBACf,uBAAuB;gBACvB,kBAAkB;gBAClB,uBAAuB;gBACvB,2BAA2B;;;;EAIjC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,CAAC,OAAO,4BAA4B,CAAC,CAAC"}
package/dist/schemas/job-execution.d.ts CHANGED
@@ -23,28 +23,28 @@ export declare const nextStepResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
23
23
  exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
24
24
  signal: z.ZodOptional<z.ZodString>;
25
25
  reason: z.ZodOptional<z.ZodEnum<{
26
- checkout_failed: "checkout_failed";
26
+ agent_config_invalid: "agent_config_invalid";
27
+ agent_harness_unavailable: "agent_harness_unavailable";
28
+ agent_invocation_failed: "agent_invocation_failed";
27
29
  checkout_auth_failed: "checkout_auth_failed";
28
- checkout_unavailable: "checkout_unavailable";
29
- checkout_path_invalid: "checkout_path_invalid";
30
30
  checkout_destination_occupied: "checkout_destination_occupied";
31
- git_unavailable: "git_unavailable";
32
- workspace_prep_failed: "workspace_prep_failed";
33
- setup_aborted: "setup_aborted";
31
+ checkout_failed: "checkout_failed";
32
+ checkout_path_invalid: "checkout_path_invalid";
33
+ checkout_unavailable: "checkout_unavailable";
34
34
  config_unresolvable: "config_unresolvable";
35
+ git_unavailable: "git_unavailable";
35
36
  output_invalid: "output_invalid";
36
- agent_config_invalid: "agent_config_invalid";
37
- agent_invocation_failed: "agent_invocation_failed";
38
- agent_harness_unavailable: "agent_harness_unavailable";
37
+ setup_aborted: "setup_aborted";
38
+ workspace_prep_failed: "workspace_prep_failed";
39
39
  }>>;
40
40
  field: z.ZodOptional<z.ZodString>;
41
41
  source: z.ZodOptional<z.ZodString>;
42
42
  agent_config_issue: z.ZodOptional<z.ZodEnum<{
43
- step_config_invalid: "step_config_invalid";
43
+ credentials_invalid: "credentials_invalid";
44
+ model_unavailable: "model_unavailable";
44
45
  provider_not_configured: "provider_not_configured";
45
46
  provider_unsupported: "provider_unsupported";
46
- model_unavailable: "model_unavailable";
47
- credentials_invalid: "credentials_invalid";
47
+ step_config_invalid: "step_config_invalid";
48
48
  }>>;
49
49
  category: z.ZodOptional<z.ZodEnum<{
50
50
  setup: "setup";
@@ -61,8 +61,8 @@ export declare const nextStepResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObjec
61
61
  }, z.core.$strip>, z.ZodObject<{
62
62
  kind: z.ZodLiteral<"done">;
63
63
  status: z.ZodEnum<{
64
- succeeded: "succeeded";
65
64
  failed: "failed";
65
+ succeeded: "succeeded";
66
66
  }>;
67
67
  }, z.core.$strip>], "kind">;
68
68
  export type NextStepResponseDto = z.infer<typeof nextStepResponseSchema>;
@@ -75,36 +75,36 @@ export declare const checkoutResultSchema: z.ZodObject<{
75
75
  export type CheckoutResultDto = z.infer<typeof checkoutResultSchema>;
76
76
  export declare const reportStepBodySchema: z.ZodObject<{
77
77
  status: z.ZodEnum<{
78
- succeeded: "succeeded";
79
78
  failed: "failed";
79
+ succeeded: "succeeded";
80
80
  }>;
81
81
  error: z.ZodOptional<z.ZodNullable<z.ZodObject<{
82
82
  message: z.ZodString;
83
83
  exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
84
84
  signal: z.ZodOptional<z.ZodString>;
85
85
  reason: z.ZodOptional<z.ZodEnum<{
86
- checkout_failed: "checkout_failed";
86
+ agent_config_invalid: "agent_config_invalid";
87
+ agent_harness_unavailable: "agent_harness_unavailable";
88
+ agent_invocation_failed: "agent_invocation_failed";
87
89
  checkout_auth_failed: "checkout_auth_failed";
88
- checkout_unavailable: "checkout_unavailable";
89
- checkout_path_invalid: "checkout_path_invalid";
90
90
  checkout_destination_occupied: "checkout_destination_occupied";
91
- git_unavailable: "git_unavailable";
92
- workspace_prep_failed: "workspace_prep_failed";
93
- setup_aborted: "setup_aborted";
91
+ checkout_failed: "checkout_failed";
92
+ checkout_path_invalid: "checkout_path_invalid";
93
+ checkout_unavailable: "checkout_unavailable";
94
94
  config_unresolvable: "config_unresolvable";
95
+ git_unavailable: "git_unavailable";
95
96
  output_invalid: "output_invalid";
96
- agent_config_invalid: "agent_config_invalid";
97
- agent_invocation_failed: "agent_invocation_failed";
98
- agent_harness_unavailable: "agent_harness_unavailable";
97
+ setup_aborted: "setup_aborted";
98
+ workspace_prep_failed: "workspace_prep_failed";
99
99
  }>>;
100
100
  field: z.ZodOptional<z.ZodString>;
101
101
  source: z.ZodOptional<z.ZodString>;
102
102
  agent_config_issue: z.ZodOptional<z.ZodEnum<{
103
- step_config_invalid: "step_config_invalid";
103
+ credentials_invalid: "credentials_invalid";
104
+ model_unavailable: "model_unavailable";
104
105
  provider_not_configured: "provider_not_configured";
105
106
  provider_unsupported: "provider_unsupported";
106
- model_unavailable: "model_unavailable";
107
- credentials_invalid: "credentials_invalid";
107
+ step_config_invalid: "step_config_invalid";
108
108
  }>>;
109
109
  category: z.ZodOptional<z.ZodEnum<{
110
110
  setup: "setup";
@@ -122,8 +122,8 @@ export declare const reportStepBodySchema: z.ZodObject<{
122
122
  }, z.core.$strip>>;
123
123
  response: z.ZodOptional<z.ZodString>;
124
124
  log_outcome: z.ZodEnum<{
125
- drained: "drained";
126
125
  abandoned: "abandoned";
126
+ drained: "drained";
127
127
  }>;
128
128
  }, z.core.$strip>;
129
129
  export type ReportStepBodyDto = z.infer<typeof reportStepBodySchema>;
package/dist/schemas/job-listening.d.ts CHANGED
@@ -1,18 +1,18 @@
1
1
  import { z } from 'zod';
2
2
  export declare const jobModeSchema: z.ZodEnum<{
3
- one_shot: "one_shot";
4
3
  listening: "listening";
4
+ one_shot: "one_shot";
5
5
  }>;
6
6
  export declare const listenerStatusSchema: z.ZodEnum<{
7
- listening: "listening";
8
7
  inactive: "inactive";
8
+ listening: "listening";
9
9
  resolved: "resolved";
10
10
  }>;
11
11
  export declare const resolutionReasonSchema: z.ZodEnum<{
12
- until: "until";
13
- timeout: "timeout";
14
- max_executions: "max_executions";
15
12
  cancelled: "cancelled";
13
+ max_executions: "max_executions";
14
+ timeout: "timeout";
15
+ until: "until";
16
16
  }>;
17
17
  export declare const listeningTriggerSchema: z.ZodObject<{
18
18
  source: z.ZodString;
@@ -46,8 +46,8 @@ export declare const jobListeningSchema: z.ZodObject<{
46
46
  max_wait_ms: z.ZodOptional<z.ZodNumber>;
47
47
  }, z.core.$strip>>;
48
48
  on_resolve: z.ZodEnum<{
49
- finish: "finish";
50
49
  cancel: "cancel";
50
+ finish: "finish";
51
51
  }>;
52
52
  execution_timeout_ms: z.ZodNullable<z.ZodNumber>;
53
53
  name: z.ZodNullable<z.ZodString>;
package/dist/schemas/job.d.ts CHANGED
@@ -1,24 +1,24 @@
1
1
  import { z } from 'zod';
2
2
  export declare const jobStatusSchema: z.ZodEnum<{
3
3
  cancelled: "cancelled";
4
+ failed: "failed";
4
5
  pending: "pending";
5
6
  running: "running";
6
- succeeded: "succeeded";
7
- failed: "failed";
8
7
  skipped: "skipped";
8
+ succeeded: "succeeded";
9
9
  }>;
10
10
  export declare const jobStatusReasonSchema: z.ZodEnum<{
11
- unknown: "unknown";
12
- dependency_not_completed: "dependency_not_completed";
11
+ condition_errored: "condition_errored";
13
12
  condition_false: "condition_false";
14
- default_gate_rejected: "default_gate_rejected";
15
13
  condition_rejected: "condition_rejected";
16
- condition_errored: "condition_errored";
17
- user_cancelled: "user_cancelled";
14
+ default_gate_rejected: "default_gate_rejected";
15
+ dependency_not_completed: "dependency_not_completed";
18
16
  run_cancelled: "run_cancelled";
19
- timed_out: "timed_out";
20
17
  runner_lost: "runner_lost";
21
18
  step_failed: "step_failed";
19
+ timed_out: "timed_out";
20
+ unknown: "unknown";
21
+ user_cancelled: "user_cancelled";
22
22
  }>;
23
23
  export declare const jobDtoSchema: z.ZodObject<{
24
24
  id: z.ZodString;
@@ -26,29 +26,29 @@ export declare const jobDtoSchema: z.ZodObject<{
26
26
  key: z.ZodString;
27
27
  name: z.ZodNullable<z.ZodString>;
28
28
  mode: z.ZodEnum<{
29
- one_shot: "one_shot";
30
29
  listening: "listening";
30
+ one_shot: "one_shot";
31
31
  }>;
32
32
  status: z.ZodEnum<{
33
33
  cancelled: "cancelled";
34
+ failed: "failed";
34
35
  pending: "pending";
35
36
  running: "running";
36
- succeeded: "succeeded";
37
- failed: "failed";
38
37
  skipped: "skipped";
38
+ succeeded: "succeeded";
39
39
  }>;
40
40
  status_reason: z.ZodNullable<z.ZodEnum<{
41
- unknown: "unknown";
42
- dependency_not_completed: "dependency_not_completed";
41
+ condition_errored: "condition_errored";
43
42
  condition_false: "condition_false";
44
- default_gate_rejected: "default_gate_rejected";
45
43
  condition_rejected: "condition_rejected";
46
- condition_errored: "condition_errored";
47
- user_cancelled: "user_cancelled";
44
+ default_gate_rejected: "default_gate_rejected";
45
+ dependency_not_completed: "dependency_not_completed";
48
46
  run_cancelled: "run_cancelled";
49
- timed_out: "timed_out";
50
47
  runner_lost: "runner_lost";
51
48
  step_failed: "step_failed";
49
+ timed_out: "timed_out";
50
+ unknown: "unknown";
51
+ user_cancelled: "user_cancelled";
52
52
  }>>;
53
53
  carried_over: z.ZodBoolean;
54
54
  listening: z.ZodNullable<z.ZodObject<{
@@ -72,22 +72,22 @@ export declare const jobDtoSchema: z.ZodObject<{
72
72
  max_wait_ms: z.ZodOptional<z.ZodNumber>;
73
73
  }, z.core.$strip>>;
74
74
  on_resolve: z.ZodEnum<{
75
- finish: "finish";
76
75
  cancel: "cancel";
76
+ finish: "finish";
77
77
  }>;
78
78
  execution_timeout_ms: z.ZodNullable<z.ZodNumber>;
79
79
  name: z.ZodNullable<z.ZodString>;
80
80
  }, z.core.$strip>>;
81
81
  listener_status: z.ZodEnum<{
82
- listening: "listening";
83
82
  inactive: "inactive";
83
+ listening: "listening";
84
84
  resolved: "resolved";
85
85
  }>;
86
86
  resolution_reason: z.ZodNullable<z.ZodEnum<{
87
- until: "until";
88
- timeout: "timeout";
89
- max_executions: "max_executions";
90
87
  cancelled: "cancelled";
88
+ max_executions: "max_executions";
89
+ timeout: "timeout";
90
+ until: "until";
91
91
  }>>;
92
92
  outputs: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
93
93
  dependencies: z.ZodArray<z.ZodString>;
package/dist/schemas/log-outcome.d.ts CHANGED
@@ -1,7 +1,7 @@
1
1
  import { z } from 'zod';
2
2
  export declare const logOutcomeSchema: z.ZodEnum<{
3
- drained: "drained";
4
3
  abandoned: "abandoned";
4
+ drained: "drained";
5
5
  }>;
6
6
  export type LogOutcomeDto = z.infer<typeof logOutcomeSchema>;
7
7
  //# sourceMappingURL=log-outcome.d.ts.map
package/dist/schemas/step.d.ts CHANGED
@@ -1,26 +1,26 @@
1
1
  import { z } from 'zod';
2
2
  export declare const stepErrorReasonSchema: z.ZodEnum<{
3
- checkout_failed: "checkout_failed";
3
+ agent_config_invalid: "agent_config_invalid";
4
+ agent_harness_unavailable: "agent_harness_unavailable";
5
+ agent_invocation_failed: "agent_invocation_failed";
4
6
  checkout_auth_failed: "checkout_auth_failed";
5
- checkout_unavailable: "checkout_unavailable";
6
- checkout_path_invalid: "checkout_path_invalid";
7
7
  checkout_destination_occupied: "checkout_destination_occupied";
8
- git_unavailable: "git_unavailable";
9
- workspace_prep_failed: "workspace_prep_failed";
10
- setup_aborted: "setup_aborted";
8
+ checkout_failed: "checkout_failed";
9
+ checkout_path_invalid: "checkout_path_invalid";
10
+ checkout_unavailable: "checkout_unavailable";
11
11
  config_unresolvable: "config_unresolvable";
12
+ git_unavailable: "git_unavailable";
12
13
  output_invalid: "output_invalid";
13
- agent_config_invalid: "agent_config_invalid";
14
- agent_invocation_failed: "agent_invocation_failed";
15
- agent_harness_unavailable: "agent_harness_unavailable";
14
+ setup_aborted: "setup_aborted";
15
+ workspace_prep_failed: "workspace_prep_failed";
16
16
  }>;
17
17
  export type StepErrorReasonDto = z.infer<typeof stepErrorReasonSchema>;
18
18
  export declare const agentConfigIssueSchema: z.ZodEnum<{
19
- step_config_invalid: "step_config_invalid";
19
+ credentials_invalid: "credentials_invalid";
20
+ model_unavailable: "model_unavailable";
20
21
  provider_not_configured: "provider_not_configured";
21
22
  provider_unsupported: "provider_unsupported";
22
- model_unavailable: "model_unavailable";
23
- credentials_invalid: "credentials_invalid";
23
+ step_config_invalid: "step_config_invalid";
24
24
  }>;
25
25
  export type AgentConfigIssueDto = z.infer<typeof agentConfigIssueSchema>;
26
26
  export declare const stepErrorCategorySchema: z.ZodEnum<{
@@ -34,28 +34,28 @@ export declare const stepErrorDtoSchema: z.ZodNullable<z.ZodObject<{
34
34
  exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
35
35
  signal: z.ZodOptional<z.ZodString>;
36
36
  reason: z.ZodOptional<z.ZodEnum<{
37
- checkout_failed: "checkout_failed";
37
+ agent_config_invalid: "agent_config_invalid";
38
+ agent_harness_unavailable: "agent_harness_unavailable";
39
+ agent_invocation_failed: "agent_invocation_failed";
38
40
  checkout_auth_failed: "checkout_auth_failed";
39
- checkout_unavailable: "checkout_unavailable";
40
- checkout_path_invalid: "checkout_path_invalid";
41
41
  checkout_destination_occupied: "checkout_destination_occupied";
42
- git_unavailable: "git_unavailable";
43
- workspace_prep_failed: "workspace_prep_failed";
44
- setup_aborted: "setup_aborted";
42
+ checkout_failed: "checkout_failed";
43
+ checkout_path_invalid: "checkout_path_invalid";
44
+ checkout_unavailable: "checkout_unavailable";
45
45
  config_unresolvable: "config_unresolvable";
46
+ git_unavailable: "git_unavailable";
46
47
  output_invalid: "output_invalid";
47
- agent_config_invalid: "agent_config_invalid";
48
- agent_invocation_failed: "agent_invocation_failed";
49
- agent_harness_unavailable: "agent_harness_unavailable";
48
+ setup_aborted: "setup_aborted";
49
+ workspace_prep_failed: "workspace_prep_failed";
50
50
  }>>;
51
51
  field: z.ZodOptional<z.ZodString>;
52
52
  source: z.ZodOptional<z.ZodString>;
53
53
  agent_config_issue: z.ZodOptional<z.ZodEnum<{
54
- step_config_invalid: "step_config_invalid";
54
+ credentials_invalid: "credentials_invalid";
55
+ model_unavailable: "model_unavailable";
55
56
  provider_not_configured: "provider_not_configured";
56
57
  provider_unsupported: "provider_unsupported";
57
- model_unavailable: "model_unavailable";
58
- credentials_invalid: "credentials_invalid";
58
+ step_config_invalid: "step_config_invalid";
59
59
  }>>;
60
60
  category: z.ZodOptional<z.ZodEnum<{
61
61
  setup: "setup";
@@ -85,28 +85,28 @@ export declare const stepDtoSchema: z.ZodObject<{
85
85
  exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
86
86
  signal: z.ZodOptional<z.ZodString>;
87
87
  reason: z.ZodOptional<z.ZodEnum<{
88
- checkout_failed: "checkout_failed";
88
+ agent_config_invalid: "agent_config_invalid";
89
+ agent_harness_unavailable: "agent_harness_unavailable";
90
+ agent_invocation_failed: "agent_invocation_failed";
89
91
  checkout_auth_failed: "checkout_auth_failed";
90
- checkout_unavailable: "checkout_unavailable";
91
- checkout_path_invalid: "checkout_path_invalid";
92
92
  checkout_destination_occupied: "checkout_destination_occupied";
93
- git_unavailable: "git_unavailable";
94
- workspace_prep_failed: "workspace_prep_failed";
95
- setup_aborted: "setup_aborted";
93
+ checkout_failed: "checkout_failed";
94
+ checkout_path_invalid: "checkout_path_invalid";
95
+ checkout_unavailable: "checkout_unavailable";
96
96
  config_unresolvable: "config_unresolvable";
97
+ git_unavailable: "git_unavailable";
97
98
  output_invalid: "output_invalid";
98
- agent_config_invalid: "agent_config_invalid";
99
- agent_invocation_failed: "agent_invocation_failed";
100
- agent_harness_unavailable: "agent_harness_unavailable";
99
+ setup_aborted: "setup_aborted";
100
+ workspace_prep_failed: "workspace_prep_failed";
101
101
  }>>;
102
102
  field: z.ZodOptional<z.ZodString>;
103
103
  source: z.ZodOptional<z.ZodString>;
104
104
  agent_config_issue: z.ZodOptional<z.ZodEnum<{
105
- step_config_invalid: "step_config_invalid";
105
+ credentials_invalid: "credentials_invalid";
106
+ model_unavailable: "model_unavailable";
106
107
  provider_not_configured: "provider_not_configured";
107
108
  provider_unsupported: "provider_unsupported";
108
- model_unavailable: "model_unavailable";
109
- credentials_invalid: "credentials_invalid";
109
+ step_config_invalid: "step_config_invalid";
110
110
  }>>;
111
111
  category: z.ZodOptional<z.ZodEnum<{
112
112
  setup: "setup";