@shipfox/api-workflows-dto 2.0.0

package/dist/schemas/job.d.ts

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+export declare const jobStatusSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    pending: "pending";
+    running: "running";
+    succeeded: "succeeded";
+    failed: "failed";
+    skipped: "skipped";
+}>;
+export declare const jobStatusReasonSchema: z.ZodEnum<{
+    unknown: "unknown";
+    dependency_not_completed: "dependency_not_completed";
+    condition_false: "condition_false";
+    default_gate_rejected: "default_gate_rejected";
+    condition_rejected: "condition_rejected";
+    condition_errored: "condition_errored";
+    user_cancelled: "user_cancelled";
+    run_cancelled: "run_cancelled";
+    timed_out: "timed_out";
+    runner_lost: "runner_lost";
+    step_failed: "step_failed";
+}>;
+export declare const jobDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    run_attempt_id: z.ZodString;
+    key: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    mode: z.ZodEnum<{
+        one_shot: "one_shot";
+        listening: "listening";
+    }>;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        pending: "pending";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        skipped: "skipped";
+    }>;
+    status_reason: z.ZodNullable<z.ZodEnum<{
+        unknown: "unknown";
+        dependency_not_completed: "dependency_not_completed";
+        condition_false: "condition_false";
+        default_gate_rejected: "default_gate_rejected";
+        condition_rejected: "condition_rejected";
+        condition_errored: "condition_errored";
+        user_cancelled: "user_cancelled";
+        run_cancelled: "run_cancelled";
+        timed_out: "timed_out";
+        runner_lost: "runner_lost";
+        step_failed: "step_failed";
+    }>>;
+    carried_over: z.ZodBoolean;
+    listening: z.ZodNullable<z.ZodObject<{
+        on: z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            event: z.ZodString;
+            inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            filter: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        until: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            event: z.ZodString;
+            inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            filter: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        timeout_ms: z.ZodNullable<z.ZodNumber>;
+        max_executions: z.ZodNullable<z.ZodNumber>;
+        batch: z.ZodNullable<z.ZodObject<{
+            debounce_ms: z.ZodOptional<z.ZodNumber>;
+            max_size: z.ZodOptional<z.ZodNumber>;
+            max_wait_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        on_resolve: z.ZodEnum<{
+            finish: "finish";
+            cancel: "cancel";
+        }>;
+        execution_timeout_ms: z.ZodNullable<z.ZodNumber>;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    listener_status: z.ZodEnum<{
+        listening: "listening";
+        inactive: "inactive";
+        resolved: "resolved";
+    }>;
+    resolution_reason: z.ZodNullable<z.ZodEnum<{
+        until: "until";
+        timeout: "timeout";
+        max_executions: "max_executions";
+        cancelled: "cancelled";
+    }>>;
+    outputs: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    dependencies: z.ZodArray<z.ZodString>;
+    position: z.ZodNumber;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+export type JobDto = z.infer<typeof jobDtoSchema>;
+export type JobStatusDto = z.infer<typeof jobStatusSchema>;
+export type JobStatusReasonDto = z.infer<typeof jobStatusReasonSchema>;
+//# sourceMappingURL=job.d.ts.map

package/dist/schemas/job.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job.d.ts","sourceRoot":"","sources":["../../src/schemas/job.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAQtB,eAAO,MAAM,eAAe;;;;;;;EAO1B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;EAYhC,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBvB,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAClD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC3D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/schemas/job.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { jobListeningSchema, jobModeSchema, listenerStatusSchema, resolutionReasonSchema } from './job-listening.js';
+export const jobStatusSchema = z.enum([
+    'pending',
+    'running',
+    'succeeded',
+    'failed',
+    'cancelled',
+    'skipped'
+]);
+export const jobStatusReasonSchema = z.enum([
+    'dependency_not_completed',
+    'condition_false',
+    'default_gate_rejected',
+    'condition_rejected',
+    'condition_errored',
+    'user_cancelled',
+    'run_cancelled',
+    'timed_out',
+    'runner_lost',
+    'step_failed',
+    'unknown'
+]);
+export const jobDtoSchema = z.object({
+    id: z.string().uuid(),
+    run_attempt_id: z.string().uuid(),
+    key: z.string(),
+    name: z.string().nullable(),
+    mode: jobModeSchema,
+    status: jobStatusSchema,
+    status_reason: jobStatusReasonSchema.nullable(),
+    carried_over: z.boolean(),
+    listening: jobListeningSchema.nullable(),
+    listener_status: listenerStatusSchema,
+    resolution_reason: resolutionReasonSchema.nullable(),
+    outputs: z.record(z.string(), z.unknown()).nullable(),
+    dependencies: z.array(z.string()),
+    position: z.number(),
+    created_at: z.string(),
+    updated_at: z.string()
+});
+
+//# sourceMappingURL=job.js.map

package/dist/schemas/job.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/job.ts"],"sourcesContent":["import {z} from 'zod';\nimport {\n  jobListeningSchema,\n  jobModeSchema,\n  listenerStatusSchema,\n  resolutionReasonSchema,\n} from './job-listening.js';\n\nexport const jobStatusSchema = z.enum([\n  'pending',\n  'running',\n  'succeeded',\n  'failed',\n  'cancelled',\n  'skipped',\n]);\n\nexport const jobStatusReasonSchema = z.enum([\n  'dependency_not_completed',\n  'condition_false',\n  'default_gate_rejected',\n  'condition_rejected',\n  'condition_errored',\n  'user_cancelled',\n  'run_cancelled',\n  'timed_out',\n  'runner_lost',\n  'step_failed',\n  'unknown',\n]);\n\nexport const jobDtoSchema = z.object({\n  id: z.string().uuid(),\n  run_attempt_id: z.string().uuid(),\n  key: z.string(),\n  name: z.string().nullable(),\n  mode: jobModeSchema,\n  status: jobStatusSchema,\n  status_reason: jobStatusReasonSchema.nullable(),\n  carried_over: z.boolean(),\n  listening: jobListeningSchema.nullable(),\n  listener_status: listenerStatusSchema,\n  resolution_reason: resolutionReasonSchema.nullable(),\n  outputs: z.record(z.string(), z.unknown()).nullable(),\n  dependencies: z.array(z.string()),\n  position: z.number(),\n  created_at: z.string(),\n  updated_at: z.string(),\n});\n\nexport type JobDto = z.infer<typeof jobDtoSchema>;\nexport type JobStatusDto = z.infer<typeof jobStatusSchema>;\nexport type JobStatusReasonDto = z.infer<typeof jobStatusReasonSchema>;\n"],"names":["z","jobListeningSchema","jobModeSchema","listenerStatusSchema","resolutionReasonSchema","jobStatusSchema","enum","jobStatusReasonSchema","jobDtoSchema","object","id","string","uuid","run_attempt_id","key","name","nullable","mode","status","status_reason","carried_over","boolean","listening","listener_status","resolution_reason","outputs","record","unknown","dependencies","array","position","number","created_at","updated_at"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AACtB,SACEC,kBAAkB,EAClBC,aAAa,EACbC,oBAAoB,EACpBC,sBAAsB,QACjB,qBAAqB;AAE5B,OAAO,MAAMC,kBAAkBL,EAAEM,IAAI,CAAC;IACpC;IACA;IACA;IACA;IACA;IACA;CACD,EAAE;AAEH,OAAO,MAAMC,wBAAwBP,EAAEM,IAAI,CAAC;IAC1C;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD,EAAE;AAEH,OAAO,MAAME,eAAeR,EAAES,MAAM,CAAC;IACnCC,IAAIV,EAAEW,MAAM,GAAGC,IAAI;IACnBC,gBAAgBb,EAAEW,MAAM,GAAGC,IAAI;IAC/BE,KAAKd,EAAEW,MAAM;IACbI,MAAMf,EAAEW,MAAM,GAAGK,QAAQ;IACzBC,MAAMf;IACNgB,QAAQb;IACRc,eAAeZ,sBAAsBS,QAAQ;IAC7CI,cAAcpB,EAAEqB,OAAO;IACvBC,WAAWrB,mBAAmBe,QAAQ;IACtCO,iBAAiBpB;IACjBqB,mBAAmBpB,uBAAuBY,QAAQ;IAClDS,SAASzB,EAAE0B,MAAM,CAAC1B,EAAEW,MAAM,IAAIX,EAAE2B,OAAO,IAAIX,QAAQ;IACnDY,cAAc5B,EAAE6B,KAAK,CAAC7B,EAAEW,MAAM;IAC9BmB,UAAU9B,EAAE+B,MAAM;IAClBC,YAAYhC,EAAEW,MAAM;IACpBsB,YAAYjC,EAAEW,MAAM;AACtB,GAAG"}

package/dist/schemas/log-outcome.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const logOutcomeSchema: z.ZodEnum<{
+    drained: "drained";
+    abandoned: "abandoned";
+}>;
+export type LogOutcomeDto = z.infer<typeof logOutcomeSchema>;
+//# sourceMappingURL=log-outcome.d.ts.map

package/dist/schemas/log-outcome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-outcome.d.ts","sourceRoot":"","sources":["../../src/schemas/log-outcome.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,gBAAgB;;;EAAmC,CAAC;AAEjE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/schemas/log-outcome.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export const logOutcomeSchema = z.enum([
+    'drained',
+    'abandoned'
+]);
+
+//# sourceMappingURL=log-outcome.js.map

package/dist/schemas/log-outcome.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/log-outcome.ts"],"sourcesContent":["import {z} from 'zod';\n\nexport const logOutcomeSchema = z.enum(['drained', 'abandoned']);\n\nexport type LogOutcomeDto = z.infer<typeof logOutcomeSchema>;\n"],"names":["z","logOutcomeSchema","enum"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB,OAAO,MAAMC,mBAAmBD,EAAEE,IAAI,CAAC;IAAC;IAAW;CAAY,EAAE"}

package/dist/schemas/step.d.ts

@@ -0,0 +1,186 @@
+import { z } from 'zod';
+export declare const stepErrorReasonSchema: z.ZodEnum<{
+    checkout_failed: "checkout_failed";
+    checkout_auth_failed: "checkout_auth_failed";
+    checkout_unavailable: "checkout_unavailable";
+    git_unavailable: "git_unavailable";
+    workspace_prep_failed: "workspace_prep_failed";
+    setup_aborted: "setup_aborted";
+    config_unresolvable: "config_unresolvable";
+    output_invalid: "output_invalid";
+    agent_config_invalid: "agent_config_invalid";
+    agent_invocation_failed: "agent_invocation_failed";
+}>;
+export type StepErrorReasonDto = z.infer<typeof stepErrorReasonSchema>;
+export declare const agentConfigIssueSchema: z.ZodEnum<{
+    step_config_invalid: "step_config_invalid";
+    provider_not_configured: "provider_not_configured";
+    provider_unsupported: "provider_unsupported";
+    model_unavailable: "model_unavailable";
+    credentials_invalid: "credentials_invalid";
+}>;
+export type AgentConfigIssueDto = z.infer<typeof agentConfigIssueSchema>;
+export declare const stepErrorCategorySchema: z.ZodEnum<{
+    setup: "setup";
+    user: "user";
+}>;
+export type StepErrorCategoryDto = z.infer<typeof stepErrorCategorySchema>;
+export declare const STEP_ERROR_MESSAGE_MAX_LENGTH = 2048;
+export declare const stepErrorDtoSchema: z.ZodNullable<z.ZodObject<{
+    message: z.ZodString;
+    exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    signal: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodEnum<{
+        checkout_failed: "checkout_failed";
+        checkout_auth_failed: "checkout_auth_failed";
+        checkout_unavailable: "checkout_unavailable";
+        git_unavailable: "git_unavailable";
+        workspace_prep_failed: "workspace_prep_failed";
+        setup_aborted: "setup_aborted";
+        config_unresolvable: "config_unresolvable";
+        output_invalid: "output_invalid";
+        agent_config_invalid: "agent_config_invalid";
+        agent_invocation_failed: "agent_invocation_failed";
+    }>>;
+    field: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    agent_config_issue: z.ZodOptional<z.ZodEnum<{
+        step_config_invalid: "step_config_invalid";
+        provider_not_configured: "provider_not_configured";
+        provider_unsupported: "provider_unsupported";
+        model_unavailable: "model_unavailable";
+        credentials_invalid: "credentials_invalid";
+    }>>;
+    category: z.ZodOptional<z.ZodEnum<{
+        setup: "setup";
+        user: "user";
+    }>>;
+}, z.core.$strip>>;
+export type StepErrorDto = z.infer<typeof stepErrorDtoSchema>;
+export declare const stepSourceLocationSchema: z.ZodObject<{
+    start_line: z.ZodNumber;
+    end_line: z.ZodNumber;
+}, z.core.$strip>;
+export type StepSourceLocationDto = z.infer<typeof stepSourceLocationSchema>;
+export declare const stepDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    job_execution_id: z.ZodString;
+    key: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    source_location: z.ZodNullable<z.ZodObject<{
+        start_line: z.ZodNumber;
+        end_line: z.ZodNumber;
+    }, z.core.$strip>>;
+    status: z.ZodString;
+    type: z.ZodString;
+    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    error: z.ZodNullable<z.ZodObject<{
+        message: z.ZodString;
+        exit_code: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        signal: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodEnum<{
+            checkout_failed: "checkout_failed";
+            checkout_auth_failed: "checkout_auth_failed";
+            checkout_unavailable: "checkout_unavailable";
+            git_unavailable: "git_unavailable";
+            workspace_prep_failed: "workspace_prep_failed";
+            setup_aborted: "setup_aborted";
+            config_unresolvable: "config_unresolvable";
+            output_invalid: "output_invalid";
+            agent_config_invalid: "agent_config_invalid";
+            agent_invocation_failed: "agent_invocation_failed";
+        }>>;
+        field: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+        agent_config_issue: z.ZodOptional<z.ZodEnum<{
+            step_config_invalid: "step_config_invalid";
+            provider_not_configured: "provider_not_configured";
+            provider_unsupported: "provider_unsupported";
+            model_unavailable: "model_unavailable";
+            credentials_invalid: "credentials_invalid";
+        }>>;
+        category: z.ZodOptional<z.ZodEnum<{
+            setup: "setup";
+            user: "user";
+        }>>;
+    }, z.core.$strip>>;
+    position: z.ZodNumber;
+    current_attempt: z.ZodNumber;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+export type StepDto = z.infer<typeof stepDtoSchema>;
+export declare const stepGateResultDtoSchema: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"none">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"not_evaluated">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"passed">;
+    passed: z.ZodLiteral<true>;
+    source: z.ZodString;
+    exit_code: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"failed">;
+    passed: z.ZodLiteral<false>;
+    source: z.ZodString;
+    exit_code: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"uncheckable">;
+    passed: z.ZodLiteral<false>;
+    uncheckable: z.ZodLiteral<true>;
+    reason: z.ZodString;
+    exit_code: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"evaluation_error">;
+    reason: z.ZodString;
+    exit_code: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"unknown">;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>], "kind">>;
+export type StepGateResultDto = z.infer<typeof stepGateResultDtoSchema>;
+export declare const stepAttemptDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    step_id: z.ZodString;
+    attempt: z.ZodNumber;
+    execution_order: z.ZodNumber;
+    status: z.ZodString;
+    exit_code: z.ZodNullable<z.ZodNumber>;
+    output: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    outputs: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    response: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    gate_result: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"none">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"not_evaluated">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"passed">;
+        passed: z.ZodLiteral<true>;
+        source: z.ZodString;
+        exit_code: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"failed">;
+        passed: z.ZodLiteral<false>;
+        source: z.ZodString;
+        exit_code: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"uncheckable">;
+        passed: z.ZodLiteral<false>;
+        uncheckable: z.ZodLiteral<true>;
+        reason: z.ZodString;
+        exit_code: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"evaluation_error">;
+        reason: z.ZodString;
+        exit_code: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>], "kind">>;
+    restart_feedback: z.ZodNullable<z.ZodString>;
+    started_at: z.ZodString;
+    finished_at: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type StepAttemptDto = z.infer<typeof stepAttemptDtoSchema>;
+//# sourceMappingURL=step.d.ts.map

package/dist/schemas/step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../src/schemas/step.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAUtB,eAAO,MAAM,qBAAqB;;;;;;;;;;;EAWhC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEvE,eAAO,MAAM,sBAAsB;;;;;;EAMjC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAIzE,eAAO,MAAM,uBAAuB;;;EAA4B,CAAC;AAEjE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE3E,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAElD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkBlB,CAAC;AAEd,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D,eAAO,MAAM,wBAAwB;;;iBAQjC,CAAC;AAEL,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE7E,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAexB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAqCvB,CAAC;AAEd,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAIxE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqB/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/schemas/step.js

@@ -0,0 +1,137 @@
+import { z } from 'zod';
+// 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`,
+// `workspace_prep_failed`, and `setup_aborted` values cover setup-phase failures.
+// For agent steps the cause is split: `agent_config_invalid` is a user-fixable
+// configuration error (unknown provider, missing provider credentials on the runner,
+// wrong provider/model pair, missing model or prompt), while `agent_invocation_failed`
+// covers a genuine provider/API failure once the config is valid (network, 5xx, auth
+// rejected at call time). (Aborts are never reported: the step loop stops before reporting.)
+export const stepErrorReasonSchema = z.enum([
+    'checkout_failed',
+    'checkout_auth_failed',
+    'checkout_unavailable',
+    'git_unavailable',
+    'workspace_prep_failed',
+    'setup_aborted',
+    'config_unresolvable',
+    'output_invalid',
+    'agent_config_invalid',
+    'agent_invocation_failed'
+]);
+export const agentConfigIssueSchema = z.enum([
+    'step_config_invalid',
+    'provider_not_configured',
+    'provider_unsupported',
+    'model_unavailable',
+    'credentials_invalid'
+]);
+// Whether a failure is infrastructure (`setup`) or user-code (`user`). Server-derived
+// from the step's type on the read path; the runner never sends it.
+export const stepErrorCategorySchema = z.enum([
+    'setup',
+    'user'
+]);
+export const STEP_ERROR_MESSAGE_MAX_LENGTH = 2048;
+export const stepErrorDtoSchema = z.object({
+    message: z.string().max(STEP_ERROR_MESSAGE_MAX_LENGTH),
+    exit_code: z.number().int().nullable().optional(),
+    signal: z.string().optional(),
+    reason: stepErrorReasonSchema.optional(),
+    field: z.string().optional(),
+    source: z.string().optional(),
+    agent_config_issue: agentConfigIssueSchema.optional(),
+    category: stepErrorCategorySchema.optional()
+}).refine((error)=>error.agent_config_issue === undefined || error.reason === 'agent_config_invalid', {
+    message: 'agent_config_issue requires reason to be agent_config_invalid',
+    path: [
+        'agent_config_issue'
+    ]
+}).nullable();
+export const stepSourceLocationSchema = z.object({
+    start_line: z.number().int().positive(),
+    end_line: z.number().int().positive()
+}).refine((value)=>value.end_line >= value.start_line, {
+    message: 'end_line must be greater than or equal to start_line',
+    path: [
+        'end_line'
+    ]
+});
+export const stepDtoSchema = z.object({
+    id: z.string().uuid(),
+    job_execution_id: z.string().uuid(),
+    key: z.string().nullable(),
+    name: z.string(),
+    source_location: stepSourceLocationSchema.nullable(),
+    status: z.string(),
+    type: z.string(),
+    config: z.record(z.string(), z.unknown()),
+    error: stepErrorDtoSchema,
+    position: z.number(),
+    // Execution-attempt identity of the current projection (>1 after a restart).
+    current_attempt: z.number().int(),
+    created_at: z.string(),
+    updated_at: z.string()
+});
+export const stepGateResultDtoSchema = z.discriminatedUnion('kind', [
+    z.object({
+        kind: z.literal('none')
+    }),
+    z.object({
+        kind: z.literal('not_evaluated')
+    }),
+    z.object({
+        kind: z.literal('passed'),
+        passed: z.literal(true),
+        source: z.string(),
+        exit_code: z.number().int().nullable()
+    }),
+    z.object({
+        kind: z.literal('failed'),
+        passed: z.literal(false),
+        source: z.string(),
+        exit_code: z.number().int().nullable()
+    }),
+    z.object({
+        kind: z.literal('uncheckable'),
+        passed: z.literal(false),
+        uncheckable: z.literal(true),
+        reason: z.string(),
+        exit_code: z.number().int().nullable()
+    }),
+    z.object({
+        kind: z.literal('evaluation_error'),
+        reason: z.string(),
+        exit_code: z.number().int().nullable()
+    }),
+    z.object({
+        kind: z.literal('unknown'),
+        data: z.record(z.string(), z.unknown())
+    })
+]).nullable();
+// One execution attempt of a step (the durable history behind the current
+// projection). Surfaced in run details so a restarted step's attempts are visible.
+export const stepAttemptDtoSchema = z.object({
+    id: z.string().uuid(),
+    step_id: z.string().uuid(),
+    attempt: z.number().int().positive(),
+    execution_order: z.number().int().positive(),
+    status: z.string(),
+    exit_code: z.number().int().nullable(),
+    // `output` and `error` are opaque audit blobs: the raw jsonb persisted for the
+    // attempt, NOT snake_case-normalized (their nested keys may be camelCase, e.g.
+    // `error.exitCode`). Consume the top-level snake_case `exit_code` for the
+    // numeric code; treat these as display/debug payloads.
+    output: z.record(z.string(), z.unknown()).nullable(),
+    outputs: z.record(z.string(), z.unknown()).nullable(),
+    response: z.string().nullable(),
+    error: z.record(z.string(), z.unknown()).nullable(),
+    // `unknown.data` is the raw jsonb gate payload for legacy or unrecognized
+    // rows; nested keys are not snake_case-normalized.
+    gate_result: stepGateResultDtoSchema,
+    restart_feedback: z.string().nullable(),
+    started_at: z.string(),
+    finished_at: z.string().nullable()
+});
+
+//# sourceMappingURL=step.js.map

package/dist/schemas/step.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/step.ts"],"sourcesContent":["import {z} from 'zod';\n\n// Machine-readable cause of a step failure, for DB troubleshooting. The runner\n// reports it and the server stores it as-is. The `checkout_*`, `git_unavailable`,\n// `workspace_prep_failed`, and `setup_aborted` values cover setup-phase failures.\n// For agent steps the cause is split: `agent_config_invalid` is a user-fixable\n// configuration error (unknown provider, missing provider credentials on the runner,\n// wrong provider/model pair, missing model or prompt), while `agent_invocation_failed`\n// covers a genuine provider/API failure once the config is valid (network, 5xx, auth\n// rejected at call time). (Aborts are never reported: the step loop stops before reporting.)\nexport const stepErrorReasonSchema = z.enum([\n  'checkout_failed',\n  'checkout_auth_failed',\n  'checkout_unavailable',\n  'git_unavailable',\n  'workspace_prep_failed',\n  'setup_aborted',\n  'config_unresolvable',\n  'output_invalid',\n  'agent_config_invalid',\n  'agent_invocation_failed',\n]);\n\nexport type StepErrorReasonDto = z.infer<typeof stepErrorReasonSchema>;\n\nexport const agentConfigIssueSchema = z.enum([\n  'step_config_invalid',\n  'provider_not_configured',\n  'provider_unsupported',\n  'model_unavailable',\n  'credentials_invalid',\n]);\n\nexport type AgentConfigIssueDto = z.infer<typeof agentConfigIssueSchema>;\n\n// Whether a failure is infrastructure (`setup`) or user-code (`user`). Server-derived\n// from the step's type on the read path; the runner never sends it.\nexport const stepErrorCategorySchema = z.enum(['setup', 'user']);\n\nexport type StepErrorCategoryDto = z.infer<typeof stepErrorCategorySchema>;\n\nexport const STEP_ERROR_MESSAGE_MAX_LENGTH = 2048;\n\nexport const stepErrorDtoSchema = z\n  .object({\n    message: z.string().max(STEP_ERROR_MESSAGE_MAX_LENGTH),\n    exit_code: z.number().int().nullable().optional(),\n    signal: z.string().optional(),\n    reason: stepErrorReasonSchema.optional(),\n    field: z.string().optional(),\n    source: z.string().optional(),\n    agent_config_issue: agentConfigIssueSchema.optional(),\n    category: stepErrorCategorySchema.optional(),\n  })\n  .refine(\n    (error) => error.agent_config_issue === undefined || error.reason === 'agent_config_invalid',\n    {\n      message: 'agent_config_issue requires reason to be agent_config_invalid',\n      path: ['agent_config_issue'],\n    },\n  )\n  .nullable();\n\nexport type StepErrorDto = z.infer<typeof stepErrorDtoSchema>;\n\nexport const stepSourceLocationSchema = z\n  .object({\n    start_line: z.number().int().positive(),\n    end_line: z.number().int().positive(),\n  })\n  .refine((value) => value.end_line >= value.start_line, {\n    message: 'end_line must be greater than or equal to start_line',\n    path: ['end_line'],\n  });\n\nexport type StepSourceLocationDto = z.infer<typeof stepSourceLocationSchema>;\n\nexport const stepDtoSchema = z.object({\n  id: z.string().uuid(),\n  job_execution_id: z.string().uuid(),\n  key: z.string().nullable(),\n  name: z.string(),\n  source_location: stepSourceLocationSchema.nullable(),\n  status: z.string(),\n  type: z.string(),\n  config: z.record(z.string(), z.unknown()),\n  error: stepErrorDtoSchema,\n  position: z.number(),\n  // Execution-attempt identity of the current projection (>1 after a restart).\n  current_attempt: z.number().int(),\n  created_at: z.string(),\n  updated_at: z.string(),\n});\n\nexport type StepDto = z.infer<typeof stepDtoSchema>;\n\nexport const stepGateResultDtoSchema = z\n  .discriminatedUnion('kind', [\n    z.object({\n      kind: z.literal('none'),\n    }),\n    z.object({\n      kind: z.literal('not_evaluated'),\n    }),\n    z.object({\n      kind: z.literal('passed'),\n      passed: z.literal(true),\n      source: z.string(),\n      exit_code: z.number().int().nullable(),\n    }),\n    z.object({\n      kind: z.literal('failed'),\n      passed: z.literal(false),\n      source: z.string(),\n      exit_code: z.number().int().nullable(),\n    }),\n    z.object({\n      kind: z.literal('uncheckable'),\n      passed: z.literal(false),\n      uncheckable: z.literal(true),\n      reason: z.string(),\n      exit_code: z.number().int().nullable(),\n    }),\n    z.object({\n      kind: z.literal('evaluation_error'),\n      reason: z.string(),\n      exit_code: z.number().int().nullable(),\n    }),\n    z.object({\n      kind: z.literal('unknown'),\n      data: z.record(z.string(), z.unknown()),\n    }),\n  ])\n  .nullable();\n\nexport type StepGateResultDto = z.infer<typeof stepGateResultDtoSchema>;\n\n// One execution attempt of a step (the durable history behind the current\n// projection). Surfaced in run details so a restarted step's attempts are visible.\nexport const stepAttemptDtoSchema = z.object({\n  id: z.string().uuid(),\n  step_id: z.string().uuid(),\n  attempt: z.number().int().positive(),\n  execution_order: z.number().int().positive(),\n  status: z.string(),\n  exit_code: z.number().int().nullable(),\n  // `output` and `error` are opaque audit blobs: the raw jsonb persisted for the\n  // attempt, NOT snake_case-normalized (their nested keys may be camelCase, e.g.\n  // `error.exitCode`). Consume the top-level snake_case `exit_code` for the\n  // numeric code; treat these as display/debug payloads.\n  output: z.record(z.string(), z.unknown()).nullable(),\n  outputs: z.record(z.string(), z.unknown()).nullable(),\n  response: z.string().nullable(),\n  error: z.record(z.string(), z.unknown()).nullable(),\n  // `unknown.data` is the raw jsonb gate payload for legacy or unrecognized\n  // rows; nested keys are not snake_case-normalized.\n  gate_result: stepGateResultDtoSchema,\n  restart_feedback: z.string().nullable(),\n  started_at: z.string(),\n  finished_at: z.string().nullable(),\n});\n\nexport type StepAttemptDto = z.infer<typeof stepAttemptDtoSchema>;\n"],"names":["z","stepErrorReasonSchema","enum","agentConfigIssueSchema","stepErrorCategorySchema","STEP_ERROR_MESSAGE_MAX_LENGTH","stepErrorDtoSchema","object","message","string","max","exit_code","number","int","nullable","optional","signal","reason","field","source","agent_config_issue","category","refine","error","undefined","path","stepSourceLocationSchema","start_line","positive","end_line","value","stepDtoSchema","id","uuid","job_execution_id","key","name","source_location","status","type","config","record","unknown","position","current_attempt","created_at","updated_at","stepGateResultDtoSchema","discriminatedUnion","kind","literal","passed","uncheckable","data","stepAttemptDtoSchema","step_id","attempt","execution_order","output","outputs","response","gate_result","restart_feedback","started_at","finished_at"],"mappings":"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"}