@shipfox/api-workflows-dto 12.1.0 → 12.3.0

package/dist/working-directory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"working-directory.d.ts","sourceRoot":"","sources":["../src/working-directory.ts"],"names":[],"mappings":"AAGA,qBAAa,4BAA6B,SAAQ,KAAK;gBACzC,KAAK,EAAE,OAAO;CAM3B;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,MAAM,CAW9E"}
+{"version":3,"file":"working-directory.d.ts","sourceRoot":"","sources":["../src/working-directory.ts"],"names":[],"mappings":"AAGA,qBAAa,4BAA6B,SAAQ,KAAK;IACrD,YAAY,KAAK,EAAE,OAAO,EAKzB;CACF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,MAAM,CAW9E"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shipfox/api-workflows-dto",
   "license": "MIT",
-  "version": "12.1.0",
+  "version": "12.3.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShipfoxHQ/shipfox.git",
@@ -23,7 +23,7 @@
   },
   "dependencies": {
     "zod": "^4.4.3",
-    "@shipfox/api-agent-dto": "12.0.0",
+    "@shipfox/api-agent-dto": "12.2.0",
     "@shipfox/inter-module": "0.2.3"
   },
   "imports": {

package/src/events.test.ts

@@ -100,6 +100,7 @@ const validStepAttemptTerminated = {
   projectId: 'proj-1',
   stepId: 'step-1',
   attempt: 1,
+  status: 'failed',
   logOutcome: 'drained',
 };
 
@@ -226,6 +227,7 @@ describe('workflowsJobActivatedSchema', () => {
           event: 'pull_request_review',
           filter: 'jobs.build.outputs.pr_number == event.pull_request.number',
           filter_snapshot: {jobs: {build: {outputs: {pr_number: 42}}}},
+          filter_output_types: {build: {pr_number: 'int'}},
         },
       ],
       until: [
@@ -234,6 +236,7 @@ describe('workflowsJobActivatedSchema', () => {
           event: 'pull_request',
           filter: 'jobs.build.outputs.pr_number == event.pull_request.number',
           filter_snapshot: {jobs: {build: {outputs: {pr_number: 42}}}},
+          filter_output_types: {build: {pr_number: 'int'}},
         },
       ],
     };

package/src/events.ts

@@ -80,8 +80,39 @@ const workflowsJobActivatedBaseSchema = z.object({
   workspaceId: nonEmptyStringSchema,
 });
 
+// Keep this passive DTO schema local so the transport package does not depend on expression runtime code.
+export type ListenerFilterExpressionType =
+  | 'string'
+  | 'int'
+  | 'double'
+  | 'bool'
+  | 'null'
+  | 'timestamp'
+  | {kind: 'object'; fields: Record<string, ListenerFilterExpressionType>}
+  | {kind: 'map'}
+  | {kind: 'list'; element: ListenerFilterExpressionType};
+
+const listenerFilterExpressionTypeSchema: z.ZodType<ListenerFilterExpressionType> = z.lazy(() =>
+  z.union([
+    z.enum(['string', 'int', 'double', 'bool', 'null', 'timestamp']),
+    z.object({
+      kind: z.literal('object'),
+      fields: z.record(z.string(), listenerFilterExpressionTypeSchema),
+    }),
+    z.object({kind: z.literal('map')}),
+    z.object({kind: z.literal('list'), element: listenerFilterExpressionTypeSchema}),
+  ]),
+);
+
+export const listenerFilterOutputTypesSchema = z.record(
+  z.string(),
+  z.record(z.string(), listenerFilterExpressionTypeSchema),
+);
+export type ListenerFilterOutputTypes = z.infer<typeof listenerFilterOutputTypesSchema>;
+
 const resolvedListeningTriggerSchema = listeningTriggerSchema.extend({
   filter_snapshot: z.record(z.string(), z.unknown()).optional(),
+  filter_output_types: listenerFilterOutputTypesSchema.optional(),
 });
 
 export const workflowsJobActivatedSchema = z.discriminatedUnion('mode', [
@@ -108,6 +139,10 @@ export type WorkflowsJobEventDeliveredEventDto = z.infer<typeof workflowsJobEven
 
 export const workflowsJobTerminatedSchema = z.object({
   jobId: nonEmptyStringSchema,
+  // Optional for compatibility with terminal events written before the current execution
+  // identity became part of the event contract. New events always include the value, or null
+  // when the job was terminated before an execution was created.
+  jobExecutionId: nonEmptyStringSchema.nullable().optional(),
   workflowRunId: nonEmptyStringSchema,
   workflowRunAttemptId: nonEmptyStringSchema,
   status: jobTerminalStatusSchema,
@@ -147,6 +182,9 @@ export const workflowsStepAttemptTerminatedSchema = z.object({
   projectId: nonEmptyStringSchema,
   stepId: nonEmptyStringSchema,
   attempt: z.number().int().positive(),
+  // Optional so the subscriber can continue to consume terminal events written
+  // before the status field was added. New outbox events always include it.
+  status: terminalStatusSchema.optional(),
   logOutcome: logOutcomeSchema,
 });
 export type WorkflowsStepAttemptTerminatedEventDto = z.infer<

package/src/index.ts

@@ -15,6 +15,10 @@ export {
   checkoutTokenParamsSchema,
   checkoutTokenQuerySchema,
   checkoutTokenResponseSchema,
+  type EvaluationTraceDto,
+  type EvaluationTraceEntryDto,
+  evaluationTraceEntrySchema,
+  evaluationTraceSchema,
   type JobDto,
   type JobExecutionDto,
   type JobListeningDto,
@@ -45,18 +49,25 @@ export {
   resolutionReasonSchema,
   STEP_ERROR_MESSAGE_MAX_LENGTH,
   STEP_RESPONSE_MAX_LENGTH,
+  STEP_STATUS_REASONS,
+  type StepAttemptDetailDto,
+  type StepAttemptDetailResponseDto,
   type StepAttemptDto,
   type StepDto,
   type StepErrorCategoryDto,
   type StepErrorDto,
   type StepErrorReasonDto,
   type StepGateResultDto,
+  type StepStatusReasonDto,
+  stepAttemptDetailDtoSchema,
+  stepAttemptDetailResponseSchema,
   stepAttemptDtoSchema,
   stepDtoSchema,
   stepErrorCategorySchema,
   stepErrorDtoSchema,
   stepErrorReasonSchema,
   stepGateResultDtoSchema,
+  stepStatusReasonSchema,
   type TriggerEventsBatchDto,
   triggerEventsBatchSchema,
   type WorkflowExecutionContextDto,
@@ -108,6 +119,9 @@ export {
 } from '#schemas/workflow-run.js';
 export {
   jobTerminalStatusSchema,
+  type ListenerFilterExpressionType,
+  type ListenerFilterOutputTypes,
+  listenerFilterOutputTypesSchema,
   terminalStatusSchema,
   WORKFLOWS_JOB_ACTIVATED,
   WORKFLOWS_JOB_EVENT_DELIVERED,

package/src/schemas/evaluation-trace.test.ts

@@ -0,0 +1,40 @@
+import {evaluationTraceSchema} from './evaluation-trace.js';
+
+describe('evaluation trace schema', () => {
+  it('accepts value entries with resolved and diagnostic metadata', () => {
+    const trace = evaluationTraceSchema.parse([
+      {
+        expression: 'inputs.environment',
+        roots: ['inputs.environment'],
+        fill_target: 'agent.prompt',
+        evaluated_at: '2026-08-05T12:00:00.000Z',
+        field: 'agent.prompt',
+        value: 'production',
+        reference: true,
+        degraded: false,
+        env_key: 'ENVIRONMENT',
+      },
+    ]);
+
+    expect(trace[0]).toMatchObject({
+      field: 'agent.prompt',
+      value: 'production',
+      reference: true,
+      env_key: 'ENVIRONMENT',
+    });
+  });
+
+  it('accepts an explicit trace budget marker', () => {
+    expect(evaluationTraceSchema.parse([{truncated: true, dropped: 3}])).toEqual([
+      {truncated: true, dropped: 3},
+    ]);
+  });
+
+  it('rejects malformed trace entries', () => {
+    const result = evaluationTraceSchema.safeParse([
+      {expression: 'inputs.environment', field: 'agent.prompt'},
+    ]);
+
+    expect(result.success).toBe(false);
+  });
+});

package/src/schemas/evaluation-trace.ts

@@ -0,0 +1,30 @@
+import {z} from 'zod';
+
+const evaluationTraceValueSchema = z.object({
+  expression: z.string(),
+  roots: z.array(z.string()),
+  fill_target: z.string(),
+  evaluated_at: z.string(),
+  field: z.string(),
+  value: z.string().optional(),
+  truncated: z.boolean().optional(),
+  expr_truncated: z.boolean().optional(),
+  reference: z.boolean().optional(),
+  degraded: z.boolean().optional(),
+  env_key: z.string().optional(),
+});
+
+const evaluationTraceLimitSchema = z.object({
+  truncated: z.literal(true),
+  dropped: z.number().int().nonnegative(),
+});
+
+export const evaluationTraceEntrySchema = z.union([
+  evaluationTraceValueSchema,
+  evaluationTraceLimitSchema,
+]);
+
+export const evaluationTraceSchema = z.array(evaluationTraceEntrySchema);
+
+export type EvaluationTraceEntryDto = z.infer<typeof evaluationTraceEntrySchema>;
+export type EvaluationTraceDto = z.infer<typeof evaluationTraceSchema>;

package/src/schemas/index.ts

@@ -13,6 +13,12 @@ export {
   checkoutTokenQuerySchema,
   checkoutTokenResponseSchema,
 } from './checkout-token.js';
+export {
+  type EvaluationTraceDto,
+  type EvaluationTraceEntryDto,
+  evaluationTraceEntrySchema,
+  evaluationTraceSchema,
+} from './evaluation-trace.js';
 export {
   type JobDto,
   type JobStatusDto,
@@ -56,18 +62,23 @@ export {
   type AgentConfigIssueDto,
   agentConfigIssueSchema,
   STEP_ERROR_MESSAGE_MAX_LENGTH,
+  STEP_STATUS_REASONS,
+  type StepAttemptDetailDto,
   type StepAttemptDto,
   type StepDto,
   type StepErrorCategoryDto,
   type StepErrorDto,
   type StepErrorReasonDto,
   type StepGateResultDto,
+  type StepStatusReasonDto,
+  stepAttemptDetailDtoSchema,
   stepAttemptDtoSchema,
   stepDtoSchema,
   stepErrorCategorySchema,
   stepErrorDtoSchema,
   stepErrorReasonSchema,
   stepGateResultDtoSchema,
+  stepStatusReasonSchema,
 } from './step.js';
 export {
   type RerunWorkflowRunBodyDto,
@@ -108,6 +119,8 @@ export {
   type JobExecutionDto,
   jobExecutionDtoSchema,
   jobExecutionStatusSchema,
+  type StepAttemptDetailResponseDto,
+  stepAttemptDetailResponseSchema,
   type WorkflowRunDetailResponseDto,
   type WorkflowRunJobDetailDto,
   type WorkflowRunJobExecutionDetailDto,

package/src/schemas/job.test.ts

@@ -9,6 +9,9 @@ const baseJob = {
   status: 'pending',
   status_reason: null,
   carried_over: false,
+  success: null,
+  runner: null,
+  evaluation_trace: null,
   listening: null,
   listener_status: 'inactive',
   resolution_reason: null,

package/src/schemas/job.ts

@@ -1,4 +1,5 @@
 import {z} from 'zod';
+import {evaluationTraceSchema} from './evaluation-trace.js';
 import {
   jobListeningSchema,
   jobModeSchema,
@@ -38,6 +39,9 @@ export const jobDtoSchema = z.object({
   status: jobStatusSchema,
   status_reason: jobStatusReasonSchema.nullable(),
   carried_over: z.boolean(),
+  success: z.string().nullable(),
+  runner: z.array(z.string()).nullable(),
+  evaluation_trace: evaluationTraceSchema.nullable(),
   listening: jobListeningSchema.nullable(),
   listener_status: listenerStatusSchema,
   resolution_reason: resolutionReasonSchema.nullable(),

package/src/schemas/step-source-location.test.ts

@@ -6,8 +6,10 @@ const baseStep = {
   key: null,
   name: 'echo hello',
   status: 'pending',
+  status_reason: null,
   type: 'run',
   config: {run: 'echo hello'},
+  evaluation_trace: null,
   error: null,
   position: 1,
   current_attempt: 1,

package/src/schemas/step.test.ts

@@ -1,4 +1,10 @@
-import {STEP_ERROR_MESSAGE_MAX_LENGTH, stepAttemptDtoSchema, stepErrorDtoSchema} from './step.js';
+import {
+  STEP_ERROR_MESSAGE_MAX_LENGTH,
+  STEP_STATUS_REASONS,
+  stepAttemptDtoSchema,
+  stepErrorDtoSchema,
+  stepStatusReasonSchema,
+} from './step.js';
 
 const baseAttempt = {
   id: '11111111-1111-4111-8111-111111111111',
@@ -111,6 +117,16 @@ describe('stepErrorDtoSchema', () => {
   });
 });
 
+describe('stepStatusReasonSchema', () => {
+  it.each(STEP_STATUS_REASONS)('accepts the domain reason %s', (reason) => {
+    expect(stepStatusReasonSchema.parse(reason)).toBe(reason);
+  });
+
+  it('rejects an unknown step status reason', () => {
+    expect(stepStatusReasonSchema.safeParse('runner_lost').success).toBe(false);
+  });
+});
+
 describe('stepAttemptDtoSchema', () => {
   it('accepts an attempt with no gate or restart feedback', () => {
     const attempt = {...baseAttempt, gate_result: {kind: 'none'}};

package/src/schemas/step.ts

@@ -1,4 +1,15 @@
 import {z} from 'zod';
+import {evaluationTraceSchema} from './evaluation-trace.js';
+
+export const STEP_STATUS_REASONS = [
+  'default_gate_rejected',
+  'condition_rejected',
+  'condition_errored',
+] as const;
+
+export const stepStatusReasonSchema = z.enum(STEP_STATUS_REASONS);
+
+export type StepStatusReasonDto = z.infer<typeof stepStatusReasonSchema>;
 
 // Machine-readable cause of a step failure, for DB troubleshooting. The runner
 // reports it and the server stores it as-is. The `checkout_*`, `git_unavailable`,
@@ -86,8 +97,10 @@ export const stepDtoSchema = z.object({
   name: z.string(),
   source_location: stepSourceLocationSchema.nullable(),
   status: z.string(),
+  status_reason: stepStatusReasonSchema.nullable(),
   type: z.string(),
   config: z.record(z.string(), z.unknown()),
+  evaluation_trace: evaluationTraceSchema.nullable(),
   error: stepErrorDtoSchema,
   position: z.number(),
   // Execution-attempt identity of the current projection (>1 after a restart).
@@ -165,3 +178,10 @@ export const stepAttemptDtoSchema = z.object({
 });
 
 export type StepAttemptDto = z.infer<typeof stepAttemptDtoSchema>;
+
+export const stepAttemptDetailDtoSchema = stepAttemptDtoSchema.extend({
+  config: z.record(z.string(), z.unknown()).nullable(),
+  evaluation_trace: evaluationTraceSchema.nullable(),
+});
+
+export type StepAttemptDetailDto = z.infer<typeof stepAttemptDetailDtoSchema>;

package/src/schemas/workflow-run-detail.ts

@@ -1,7 +1,8 @@
 import {z} from 'zod';
+import {evaluationTraceSchema} from './evaluation-trace.js';
 import {jobDtoSchema} from './job.js';
 import {workflowExecutionEventSchema} from './job-listening.js';
-import {stepAttemptDtoSchema, stepDtoSchema} from './step.js';
+import {stepAttemptDetailDtoSchema, stepAttemptDtoSchema, stepDtoSchema} from './step.js';
 import {workflowRunAttemptDtoSchema, workflowRunResponseSchema} from './workflow-run.js';
 
 export const jobExecutionStatusSchema = z.enum([
@@ -19,8 +20,10 @@ export const jobExecutionDtoSchema = z.object({
   name: z.string(),
   status: jobExecutionStatusSchema,
   status_reason: z.string().nullable(),
+  runner: z.array(z.string()).nullable(),
   trigger_events: z.array(workflowExecutionEventSchema).default([]),
   outputs: z.record(z.string(), z.unknown()).nullable(),
+  evaluation_trace: evaluationTraceSchema.nullable(),
   queued_at: z.string().nullable(),
   started_at: z.string().nullable(),
   finished_at: z.string().nullable(),
@@ -43,6 +46,16 @@ export const workflowRunStepDetailDtoSchema = stepDtoSchema.extend({
 
 export type WorkflowRunStepDetailDto = z.infer<typeof workflowRunStepDetailDtoSchema>;
 
+export const stepAttemptDetailResponseSchema = z.object({
+  step_id: z.string().uuid(),
+  attempt: stepAttemptDetailDtoSchema.shape.attempt,
+  authored_config: z.record(z.string(), z.unknown()).nullable(),
+  config: stepAttemptDetailDtoSchema.shape.config,
+  evaluation_trace: stepAttemptDetailDtoSchema.shape.evaluation_trace,
+});
+
+export type StepAttemptDetailResponseDto = z.infer<typeof stepAttemptDetailResponseSchema>;
+
 export const workflowRunJobExecutionDetailDtoSchema = jobExecutionDtoSchema.extend({
   steps: z.array(workflowRunStepDetailDtoSchema),
 });