@shipfox/api-workflows-dto 2.0.0

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+$ shipfox-swc
+Successfully compiled: 13 files with swc (44.11ms)

package/.turbo/turbo-type$colon$emit.log

@@ -0,0 +1 @@
+$ shipfox-tsc-emit

package/.turbo/turbo-type.log

@@ -0,0 +1 @@
+$ shipfox-tsc-check

package/CHANGELOG.md

@@ -0,0 +1,46 @@
+# @shipfox/api-workflows-dto
+
+## 2.0.0
+
+### Minor Changes
+
+- 1b0d344: Publishes the complete API runtime closure with packed-consumer-safe internal imports and records its exact package set in application releases.
+
+## 0.1.0
+
+### Minor Changes
+
+- 5c18360: Durable gate restart: a failing gate's `on_failure.restart_from` now records the failed attempt, rewinds the job's step projection from the named earlier step back to pending (opening fresh attempts), and leaves the job running so it re-executes from there — all in one transaction with the report. A per-step attempt cap (default 3) bounds restart loops, exhausting to a `restart_exhausted` failure. Adds the `workflows.step.restart_enqueued` event.
+- 7a9943d: Adds the backend contract for per-step execution: job claims mint a lease token for the step API, step reports carry attempts and exit codes, and workflow completion can be signalled through the workflows outbox. The runner-side step loop is intentionally owned by the follow-up runner protocol work.
+- 736249b: Expose step attempts in the read API: the run-detail endpoint now returns `current_attempt` on each step plus its per-attempt history (`attempts[]`, with status, exit code, gate result and restart reason), so a restarted step's attempts are visible.
+- 2bc5595: Adds workflow-run cancellation across the API, orchestration queue cleanup, event contract, and run-page cancel action.
+- 940696a: Adds the credential-free checkout intent type and a checkout-token response DTO (basic/bearer auth with a validated expiry) to the Orchestration DTO package, establishing the contract for runner-managed repository checkouts over the lease-scoped checkout flow.
+- e9396c9: Give every runner-dispatched job a synthetic "Set up job" step at position 0 (à la GitHub Actions), so failures that happen around the user steps — workspace preparation today, the repository checkout next — are reported through the existing per-step protocol instead of hanging the job until the lease/timeout fires. The runner prepares the per-job workspace inside this step and reports the outcome; a failed setup flows through the existing fail-job cascade, finalizing the job `failed` in seconds with no user step run.
+
+  Extends `stepErrorDtoSchema` with an optional machine-readable `reason` (`workspace_prep_failed`, `git_unavailable`, `checkout_*`, `setup_aborted`) and a `category` (`setup` | `user`). The runner reports `reason`; the server derives `category` from the step type on read (the runner is an untrusted boundary). The restart resolver now skips the synthetic step so a user step named "Set up job" can never rewind setup mid-job.
+
+- 3afb7e3: Adds job execution success expressions and execution timeouts to workflow documents.
+  Renames job execution IDs in auth, runner, workflow, and timeout event contracts to the explicit `jobExecutionId` / `job_execution_id` shape.
+- c652a68: Add a single reliable job-terminal event: `workflows.job.terminated` is now written in the same transaction as every terminal job-status flip (normal completion, DAG cancellation, lease-expiry resolution, and timeout), and the run-level `workflows.workflow_run.terminated` is emitted the same way. All workflows event names are aligned on one `WORKFLOWS_<entity>_<verb>` scheme, so the run and job terminal events read as the same event at two scopes.
+
+  Internal breaking change (`WORKFLOWS_JOB_COMPLETED` → `WORKFLOWS_JOB_STEPS_SETTLED`, `WORKFLOW_RUN_*` → `WORKFLOWS_WORKFLOW_RUN_*`, with matching DTO type renames) consumed only within this monorepo.
+
+- c0a883c: Adds the runner-facing per-step endpoints (`POST /runs/jobs/current/steps/next` and `/steps/:stepId/report`) authed by a locally-verified job lease token, with the matching request/response schemas.
+- d69b164: Adds workflow run attempt lineage APIs and a run summary switcher for navigating rerun attempts.
+- e699508: Adds first-class skipped workflow jobs with persisted status reasons across API DTOs, orchestration, events, and client run views.
+
+### Patch Changes
+
+- eb40964: Add an inline `agent` workflow step that the runner runs with the pi harness. A step is an agent step when it carries `model` + `prompt` and no `run`; it takes a free-text `model`, a single `prompt`, and an optional `thinking` level (default `high`). The step runs to process-success (the agent ran to completion) and reports through the existing step protocol with no runner/backend protocol change, so change quality is judged by a downstream `run` + `gate` step. v1 does not persist the agent's work (no diff, commit, or PR).
+- c17dd6e: Adds run-step output emission through `$SHIPFOX_OUTPUT` with runner-side parsing, caps, masking, and report plumbing.
+- f98c2be: [api/workflows] Add the lease-authed `POST /runs/jobs/current/checkout-token` endpoint. The runner exchanges its job lease for short-lived, read-only repository checkout credentials. The job's checkout intent is resolved server-side from the authoritative `jobId` claim (`job -> run -> project` source metadata) and minted on demand via the integration service's `createCheckoutSpec()`; no credential material is ever stored on the job/run or queued. `checkoutTokenResponseSchema.auth` stays optional so credential-free providers can return a public clone URL with no token, and `integrationRouteErrorHandler` is exported from `@shipfox/api-integration-core` so the route reuses the shared provider-error mapping.
+- b525dcd: Let an agent workflow step pick its pi provider with an optional free-text `provider` field (default `anthropic`), threaded to the runner's pi model lookup, and split agent-step failures into a user-fixable `agent_config_invalid` reason (unknown provider, missing runner credentials, wrong provider/model pair) versus `agent_invocation_failed` for genuine provider/API errors.
+- 795f440: Adds the listener orchestration loop for long-lived listening jobs: durable event draining, one execution per buffered event, resolution on until, listening deadline, or max executions, and a run-timeout backstop that resolves active listeners.
+- 3dcd751: Adds listener filter snapshots to job activation events and persists them on listener subscriptions.
+- 362b3eb: Scope runner log append authorization to the dispatched step attempt carried by the job lease token.
+- 2fb3e87: Derives workflow run attempt durations on the client and displays them in the run list and run header.
+- ef1e917: Adds listening-job authoring fields and trusted execution context validation for listening jobs.
+  Separates workflow identifiers so internal rows use UUID `id`, authored workflow/job/step
+  references use `key`, and UI labels use `name`.
+- 2933c33: Adds drain-boundary Zod validation for current outbox publisher event payloads.
+- 8ecc121: Track queue/run/finish timing for workflow runs and jobs. Adds nullable `started_at`/`finished_at` to workflow runs and `queued_at`/`started_at`/`finished_at` to jobs, exposed on the run and job DTOs. The runners module emits two new authoritative-timestamp events (`runners.job.queued`, `runners.job.started`) in the same transaction as the enqueue/claim; workflows projects them onto the job row with a first-write-wins `coalesce`, so the at-least-once outbox can redeliver out of order safely. Run `started_at`/`finished_at` and job `finished_at` are stamped in-module at the status transitions. All columns are nullable and eventually consistent, so consumers must treat a missing endpoint as "not yet known" and clamp any duration math.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shipfox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/events.d.ts

@@ -0,0 +1,316 @@
+import { z } from 'zod';
+export declare const WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED: "workflows.workflow_run_attempt.created";
+export declare const WORKFLOWS_WORKFLOW_RUN_TERMINATED: "workflows.workflow_run.terminated";
+export declare const WORKFLOWS_WORKFLOW_RUN_CANCELLED: "workflows.workflow_run.cancelled";
+export declare const WORKFLOWS_JOB_EXECUTION_TIMED_OUT: "workflows.job_execution.timed_out";
+export declare const WORKFLOWS_JOB_ACTIVATED: "workflows.job.activated";
+export declare const WORKFLOWS_JOB_EVENT_DELIVERED: "workflows.job_event.delivered";
+export declare const WORKFLOWS_JOB_TERMINATED: "workflows.job.terminated";
+export declare const WORKFLOWS_JOB_STEPS_SETTLED: "workflows.job.steps_settled";
+export declare const WORKFLOWS_STEP_RESTART_ENQUEUED: "workflows.step.restart_enqueued";
+export declare const WORKFLOWS_STEP_ATTEMPT_TERMINATED: "workflows.step_attempt.terminated";
+export declare const workflowsWorkflowRunAttemptCreatedSchema: z.ZodObject<{
+    workflowRunId: z.ZodString;
+    workflowRunAttemptId: z.ZodString;
+    attempt: z.ZodNumber;
+    workspaceId: z.ZodString;
+    projectId: z.ZodString;
+    definitionId: z.ZodString;
+}, z.core.$strip>;
+export type WorkflowsWorkflowRunAttemptCreatedEventDto = z.infer<typeof workflowsWorkflowRunAttemptCreatedSchema>;
+export declare const workflowRunTerminalStatusSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    succeeded: "succeeded";
+    failed: "failed";
+}>;
+export declare const jobTerminalStatusSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    succeeded: "succeeded";
+    failed: "failed";
+    skipped: "skipped";
+}>;
+export declare const terminalStatusSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    succeeded: "succeeded";
+    failed: "failed";
+}>;
+export declare const workflowsWorkflowRunTerminatedSchema: z.ZodObject<{
+    workflowRunId: z.ZodString;
+    workflowRunAttemptId: z.ZodString;
+    projectId: z.ZodString;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+}, z.core.$strip>;
+export type WorkflowsWorkflowRunTerminatedEventDto = z.infer<typeof workflowsWorkflowRunTerminatedSchema>;
+export declare const workflowsWorkflowRunCancelledSchema: z.ZodObject<{
+    workflowRunId: z.ZodString;
+    workflowRunAttemptId: z.ZodString;
+    projectId: z.ZodString;
+}, z.core.$strip>;
+export type WorkflowsWorkflowRunCancelledEventDto = z.infer<typeof workflowsWorkflowRunCancelledSchema>;
+export declare const workflowsJobExecutionTimedOutSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    jobExecutionId: z.ZodString;
+    workflowRunAttemptId: z.ZodString;
+}, z.core.$strip>;
+export type WorkflowsJobExecutionTimedOutEventDto = z.infer<typeof workflowsJobExecutionTimedOutSchema>;
+export declare const workflowsJobActivatedSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    jobId: z.ZodString;
+    workflowRunId: z.ZodString;
+    workspaceId: z.ZodString;
+    mode: z.ZodLiteral<"one_shot">;
+    on: z.ZodOptional<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>;
+        filter_snapshot: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>>;
+    until: z.ZodOptional<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>;
+        filter_snapshot: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>, z.ZodObject<{
+    jobId: z.ZodString;
+    workflowRunId: z.ZodString;
+    workspaceId: z.ZodString;
+    mode: z.ZodLiteral<"listening">;
+    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>;
+        filter_snapshot: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, 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>;
+        filter_snapshot: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>], "mode">;
+export type WorkflowsJobActivatedEventDto = z.infer<typeof workflowsJobActivatedSchema>;
+export declare const workflowsJobEventDeliveredSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    disposition: z.ZodEnum<{
+        fire: "fire";
+        resolve: "resolve";
+    }>;
+    eventRef: z.ZodString;
+    eventName: z.ZodString;
+}, z.core.$strip>;
+export type WorkflowsJobEventDeliveredEventDto = z.infer<typeof workflowsJobEventDeliveredSchema>;
+export declare const workflowsJobTerminatedSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    workflowRunId: z.ZodString;
+    workflowRunAttemptId: z.ZodString;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        succeeded: "succeeded";
+        failed: "failed";
+        skipped: "skipped";
+    }>;
+    statusReason: 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";
+    }>>;
+}, z.core.$strip>;
+export type WorkflowsJobTerminatedEventDto = z.infer<typeof workflowsJobTerminatedSchema>;
+export declare const workflowsJobStepsSettledSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    jobExecutionId: z.ZodString;
+    workflowRunId: z.ZodString;
+    workflowRunAttemptId: z.ZodString;
+    status: z.ZodEnum<{
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+}, z.core.$strip>;
+export type WorkflowsJobStepsSettledEventDto = z.infer<typeof workflowsJobStepsSettledSchema>;
+export declare const workflowsStepRestartEnqueuedSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    workflowRunId: z.ZodString;
+    workflowRunAttemptId: z.ZodString;
+    failedStepId: z.ZodString;
+    failedStepAttempt: z.ZodNumber;
+    restartFromStepId: z.ZodString;
+    feedback: z.ZodString;
+}, z.core.$strip>;
+export type WorkflowsStepRestartEnqueuedEventDto = z.infer<typeof workflowsStepRestartEnqueuedSchema>;
+export declare const workflowsStepAttemptTerminatedSchema: z.ZodObject<{
+    jobId: z.ZodString;
+    workflowRunId: z.ZodString;
+    workflowRunAttemptId: z.ZodString;
+    workspaceId: z.ZodString;
+    projectId: z.ZodString;
+    stepId: z.ZodString;
+    attempt: z.ZodNumber;
+    logOutcome: z.ZodEnum<{
+        drained: "drained";
+        abandoned: "abandoned";
+    }>;
+}, z.core.$strip>;
+export type WorkflowsStepAttemptTerminatedEventDto = z.infer<typeof workflowsStepAttemptTerminatedSchema>;
+export interface WorkflowsEventMapDto {
+    [WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED]: WorkflowsWorkflowRunAttemptCreatedEventDto;
+    [WORKFLOWS_WORKFLOW_RUN_TERMINATED]: WorkflowsWorkflowRunTerminatedEventDto;
+    [WORKFLOWS_WORKFLOW_RUN_CANCELLED]: WorkflowsWorkflowRunCancelledEventDto;
+    [WORKFLOWS_JOB_EXECUTION_TIMED_OUT]: WorkflowsJobExecutionTimedOutEventDto;
+    [WORKFLOWS_JOB_ACTIVATED]: WorkflowsJobActivatedEventDto;
+    [WORKFLOWS_JOB_EVENT_DELIVERED]: WorkflowsJobEventDeliveredEventDto;
+    [WORKFLOWS_JOB_TERMINATED]: WorkflowsJobTerminatedEventDto;
+    [WORKFLOWS_JOB_STEPS_SETTLED]: WorkflowsJobStepsSettledEventDto;
+    [WORKFLOWS_STEP_RESTART_ENQUEUED]: WorkflowsStepRestartEnqueuedEventDto;
+    [WORKFLOWS_STEP_ATTEMPT_TERMINATED]: WorkflowsStepAttemptTerminatedEventDto;
+}
+export declare const workflowsEventSchemas: {
+    "workflows.workflow_run_attempt.created": z.ZodObject<{
+        workflowRunId: z.ZodString;
+        workflowRunAttemptId: z.ZodString;
+        attempt: z.ZodNumber;
+        workspaceId: z.ZodString;
+        projectId: z.ZodString;
+        definitionId: z.ZodString;
+    }, z.core.$strip>;
+    "workflows.workflow_run.terminated": z.ZodObject<{
+        workflowRunId: z.ZodString;
+        workflowRunAttemptId: z.ZodString;
+        projectId: z.ZodString;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            succeeded: "succeeded";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>;
+    "workflows.workflow_run.cancelled": z.ZodObject<{
+        workflowRunId: z.ZodString;
+        workflowRunAttemptId: z.ZodString;
+        projectId: z.ZodString;
+    }, z.core.$strip>;
+    "workflows.job_execution.timed_out": z.ZodObject<{
+        jobId: z.ZodString;
+        jobExecutionId: z.ZodString;
+        workflowRunAttemptId: z.ZodString;
+    }, z.core.$strip>;
+    "workflows.job.activated": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        jobId: z.ZodString;
+        workflowRunId: z.ZodString;
+        workspaceId: z.ZodString;
+        mode: z.ZodLiteral<"one_shot">;
+        on: z.ZodOptional<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>;
+            filter_snapshot: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>>;
+        until: z.ZodOptional<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>;
+            filter_snapshot: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        jobId: z.ZodString;
+        workflowRunId: z.ZodString;
+        workspaceId: z.ZodString;
+        mode: z.ZodLiteral<"listening">;
+        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>;
+            filter_snapshot: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, 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>;
+            filter_snapshot: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>], "mode">;
+    "workflows.job_event.delivered": z.ZodObject<{
+        jobId: z.ZodString;
+        disposition: z.ZodEnum<{
+            fire: "fire";
+            resolve: "resolve";
+        }>;
+        eventRef: z.ZodString;
+        eventName: z.ZodString;
+    }, z.core.$strip>;
+    "workflows.job.terminated": z.ZodObject<{
+        jobId: z.ZodString;
+        workflowRunId: z.ZodString;
+        workflowRunAttemptId: z.ZodString;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            succeeded: "succeeded";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+        statusReason: 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";
+        }>>;
+    }, z.core.$strip>;
+    "workflows.job.steps_settled": z.ZodObject<{
+        jobId: z.ZodString;
+        jobExecutionId: z.ZodString;
+        workflowRunId: z.ZodString;
+        workflowRunAttemptId: z.ZodString;
+        status: z.ZodEnum<{
+            succeeded: "succeeded";
+            failed: "failed";
+        }>;
+    }, z.core.$strip>;
+    "workflows.step.restart_enqueued": z.ZodObject<{
+        jobId: z.ZodString;
+        workflowRunId: z.ZodString;
+        workflowRunAttemptId: z.ZodString;
+        failedStepId: z.ZodString;
+        failedStepAttempt: z.ZodNumber;
+        restartFromStepId: z.ZodString;
+        feedback: z.ZodString;
+    }, z.core.$strip>;
+    "workflows.step_attempt.terminated": z.ZodObject<{
+        jobId: z.ZodString;
+        workflowRunId: z.ZodString;
+        workflowRunAttemptId: z.ZodString;
+        workspaceId: z.ZodString;
+        projectId: z.ZodString;
+        stepId: z.ZodString;
+        attempt: z.ZodNumber;
+        logOutcome: z.ZodEnum<{
+            drained: "drained";
+            abandoned: "abandoned";
+        }>;
+    }, z.core.$strip>;
+};
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"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"}

package/dist/events.js

@@ -0,0 +1,144 @@
+import { z } from 'zod';
+import { jobStatusReasonSchema } from './schemas/job.js';
+import { listeningTriggerSchema } from './schemas/job-listening.js';
+import { logOutcomeSchema } from './schemas/log-outcome.js';
+const nonEmptyStringSchema = z.string().nonempty();
+export const WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED = 'workflows.workflow_run_attempt.created';
+// Terminal fact for a workflow run, written in the same transaction as the status flip.
+export const WORKFLOWS_WORKFLOW_RUN_TERMINATED = 'workflows.workflow_run.terminated';
+// Intent fact for cooperative run cancellation. Consumers use this to stop orchestration.
+export const WORKFLOWS_WORKFLOW_RUN_CANCELLED = 'workflows.workflow_run.cancelled';
+export const WORKFLOWS_JOB_EXECUTION_TIMED_OUT = 'workflows.job_execution.timed_out';
+export const WORKFLOWS_JOB_ACTIVATED = 'workflows.job.activated';
+export const WORKFLOWS_JOB_EVENT_DELIVERED = 'workflows.job_event.delivered';
+// Terminal fact for a job: the single reliable "this job is over" signal, written in
+// the same transaction as the status flip, on every terminal path.
+export const WORKFLOWS_JOB_TERMINATED = 'workflows.job.terminated';
+// Internal signal, not a terminal fact: a job's steps have all settled, so the
+// on-job-steps-settled subscriber can raise the Temporal JOB_FINISHED_SIGNAL. Fires
+// before the job row is terminal; observe WORKFLOWS_JOB_TERMINATED for the outcome.
+export const WORKFLOWS_JOB_STEPS_SETTLED = 'workflows.job.steps_settled';
+// Written in the same transaction as a durable gate restart: the failed attempt
+// plus the rewind of the projection from `restart_from`. The pull-based runner
+// re-dispatches the rewound step on its next pull, so consumers must treat this
+// at-least-once outbox event as idempotent audit data.
+export const WORKFLOWS_STEP_RESTART_ENQUEUED = 'workflows.step.restart_enqueued';
+export const WORKFLOWS_STEP_ATTEMPT_TERMINATED = 'workflows.step_attempt.terminated';
+export const workflowsWorkflowRunAttemptCreatedSchema = z.object({
+    workflowRunId: nonEmptyStringSchema,
+    workflowRunAttemptId: nonEmptyStringSchema,
+    attempt: z.number().int().positive(),
+    workspaceId: nonEmptyStringSchema,
+    projectId: nonEmptyStringSchema,
+    definitionId: nonEmptyStringSchema
+});
+// Keep outbox terminal statuses narrower than the public status schemas, which
+// also carry pending/running and job-only skipped.
+export const workflowRunTerminalStatusSchema = z.enum([
+    'succeeded',
+    'failed',
+    'cancelled'
+]);
+export const jobTerminalStatusSchema = z.enum([
+    'succeeded',
+    'failed',
+    'cancelled',
+    'skipped'
+]);
+export const terminalStatusSchema = workflowRunTerminalStatusSchema;
+export const workflowsWorkflowRunTerminatedSchema = z.object({
+    workflowRunId: nonEmptyStringSchema,
+    workflowRunAttemptId: nonEmptyStringSchema,
+    projectId: nonEmptyStringSchema,
+    status: workflowRunTerminalStatusSchema
+});
+export const workflowsWorkflowRunCancelledSchema = z.object({
+    workflowRunId: nonEmptyStringSchema,
+    workflowRunAttemptId: nonEmptyStringSchema,
+    projectId: nonEmptyStringSchema
+});
+export const workflowsJobExecutionTimedOutSchema = z.object({
+    jobId: nonEmptyStringSchema,
+    jobExecutionId: nonEmptyStringSchema,
+    workflowRunAttemptId: nonEmptyStringSchema
+});
+const workflowsJobActivatedBaseSchema = z.object({
+    jobId: nonEmptyStringSchema,
+    workflowRunId: nonEmptyStringSchema,
+    workspaceId: nonEmptyStringSchema
+});
+const resolvedListeningTriggerSchema = listeningTriggerSchema.extend({
+    filter_snapshot: z.record(z.string(), z.unknown()).optional()
+});
+export const workflowsJobActivatedSchema = z.discriminatedUnion('mode', [
+    workflowsJobActivatedBaseSchema.extend({
+        mode: z.literal('one_shot'),
+        on: z.array(resolvedListeningTriggerSchema).nullable().optional(),
+        until: z.array(resolvedListeningTriggerSchema).nullable().optional()
+    }),
+    workflowsJobActivatedBaseSchema.extend({
+        mode: z.literal('listening'),
+        on: z.array(resolvedListeningTriggerSchema).nonempty(),
+        until: z.array(resolvedListeningTriggerSchema).nullable()
+    })
+]);
+export const workflowsJobEventDeliveredSchema = z.object({
+    jobId: nonEmptyStringSchema,
+    disposition: z.enum([
+        'fire',
+        'resolve'
+    ]),
+    eventRef: nonEmptyStringSchema,
+    eventName: nonEmptyStringSchema
+});
+export const workflowsJobTerminatedSchema = z.object({
+    jobId: nonEmptyStringSchema,
+    workflowRunId: nonEmptyStringSchema,
+    workflowRunAttemptId: nonEmptyStringSchema,
+    status: jobTerminalStatusSchema,
+    statusReason: jobStatusReasonSchema.nullable()
+});
+const settledStatusSchema = z.enum([
+    'succeeded',
+    'failed'
+]);
+export const workflowsJobStepsSettledSchema = z.object({
+    jobId: nonEmptyStringSchema,
+    jobExecutionId: nonEmptyStringSchema,
+    workflowRunId: nonEmptyStringSchema,
+    workflowRunAttemptId: nonEmptyStringSchema,
+    status: settledStatusSchema
+});
+export const workflowsStepRestartEnqueuedSchema = z.object({
+    jobId: nonEmptyStringSchema,
+    workflowRunId: nonEmptyStringSchema,
+    workflowRunAttemptId: nonEmptyStringSchema,
+    failedStepId: nonEmptyStringSchema,
+    failedStepAttempt: z.number(),
+    restartFromStepId: nonEmptyStringSchema,
+    feedback: nonEmptyStringSchema
+});
+export const workflowsStepAttemptTerminatedSchema = z.object({
+    jobId: nonEmptyStringSchema,
+    workflowRunId: nonEmptyStringSchema,
+    workflowRunAttemptId: nonEmptyStringSchema,
+    workspaceId: nonEmptyStringSchema,
+    projectId: nonEmptyStringSchema,
+    stepId: nonEmptyStringSchema,
+    attempt: z.number().int().positive(),
+    logOutcome: logOutcomeSchema
+});
+export const workflowsEventSchemas = {
+    [WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED]: workflowsWorkflowRunAttemptCreatedSchema,
+    [WORKFLOWS_WORKFLOW_RUN_TERMINATED]: workflowsWorkflowRunTerminatedSchema,
+    [WORKFLOWS_WORKFLOW_RUN_CANCELLED]: workflowsWorkflowRunCancelledSchema,
+    [WORKFLOWS_JOB_EXECUTION_TIMED_OUT]: workflowsJobExecutionTimedOutSchema,
+    [WORKFLOWS_JOB_ACTIVATED]: workflowsJobActivatedSchema,
+    [WORKFLOWS_JOB_EVENT_DELIVERED]: workflowsJobEventDeliveredSchema,
+    [WORKFLOWS_JOB_TERMINATED]: workflowsJobTerminatedSchema,
+    [WORKFLOWS_JOB_STEPS_SETTLED]: workflowsJobStepsSettledSchema,
+    [WORKFLOWS_STEP_RESTART_ENQUEUED]: workflowsStepRestartEnqueuedSchema,
+    [WORKFLOWS_STEP_ATTEMPT_TERMINATED]: workflowsStepAttemptTerminatedSchema
+};
+
+//# sourceMappingURL=events.js.map

package/dist/events.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/events.ts"],"sourcesContent":["import {z} from 'zod';\nimport {jobStatusReasonSchema} from './schemas/job.js';\nimport {listeningTriggerSchema} from './schemas/job-listening.js';\nimport {logOutcomeSchema} from './schemas/log-outcome.js';\n\nconst nonEmptyStringSchema = z.string().nonempty();\n\nexport const WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED =\n  'workflows.workflow_run_attempt.created' as const;\n// Terminal fact for a workflow run, written in the same transaction as the status flip.\nexport const WORKFLOWS_WORKFLOW_RUN_TERMINATED = 'workflows.workflow_run.terminated' as const;\n// Intent fact for cooperative run cancellation. Consumers use this to stop orchestration.\nexport const WORKFLOWS_WORKFLOW_RUN_CANCELLED = 'workflows.workflow_run.cancelled' as const;\nexport const WORKFLOWS_JOB_EXECUTION_TIMED_OUT = 'workflows.job_execution.timed_out' as const;\nexport const WORKFLOWS_JOB_ACTIVATED = 'workflows.job.activated' as const;\nexport const WORKFLOWS_JOB_EVENT_DELIVERED = 'workflows.job_event.delivered' as const;\n// Terminal fact for a job: the single reliable \"this job is over\" signal, written in\n// the same transaction as the status flip, on every terminal path.\nexport const WORKFLOWS_JOB_TERMINATED = 'workflows.job.terminated' as const;\n// Internal signal, not a terminal fact: a job's steps have all settled, so the\n// on-job-steps-settled subscriber can raise the Temporal JOB_FINISHED_SIGNAL. Fires\n// before the job row is terminal; observe WORKFLOWS_JOB_TERMINATED for the outcome.\nexport const WORKFLOWS_JOB_STEPS_SETTLED = 'workflows.job.steps_settled' as const;\n// Written in the same transaction as a durable gate restart: the failed attempt\n// plus the rewind of the projection from `restart_from`. The pull-based runner\n// re-dispatches the rewound step on its next pull, so consumers must treat this\n// at-least-once outbox event as idempotent audit data.\nexport const WORKFLOWS_STEP_RESTART_ENQUEUED = 'workflows.step.restart_enqueued' as const;\nexport const WORKFLOWS_STEP_ATTEMPT_TERMINATED = 'workflows.step_attempt.terminated' as const;\n\nexport const workflowsWorkflowRunAttemptCreatedSchema = z.object({\n  workflowRunId: nonEmptyStringSchema,\n  workflowRunAttemptId: nonEmptyStringSchema,\n  attempt: z.number().int().positive(),\n  workspaceId: nonEmptyStringSchema,\n  projectId: nonEmptyStringSchema,\n  definitionId: nonEmptyStringSchema,\n});\nexport type WorkflowsWorkflowRunAttemptCreatedEventDto = z.infer<\n  typeof workflowsWorkflowRunAttemptCreatedSchema\n>;\n\n// Keep outbox terminal statuses narrower than the public status schemas, which\n// also carry pending/running and job-only skipped.\nexport const workflowRunTerminalStatusSchema = z.enum(['succeeded', 'failed', 'cancelled']);\nexport const jobTerminalStatusSchema = z.enum(['succeeded', 'failed', 'cancelled', 'skipped']);\nexport const terminalStatusSchema = workflowRunTerminalStatusSchema;\n\nexport const workflowsWorkflowRunTerminatedSchema = z.object({\n  workflowRunId: nonEmptyStringSchema,\n  workflowRunAttemptId: nonEmptyStringSchema,\n  projectId: nonEmptyStringSchema,\n  status: workflowRunTerminalStatusSchema,\n});\nexport type WorkflowsWorkflowRunTerminatedEventDto = z.infer<\n  typeof workflowsWorkflowRunTerminatedSchema\n>;\n\nexport const workflowsWorkflowRunCancelledSchema = z.object({\n  workflowRunId: nonEmptyStringSchema,\n  workflowRunAttemptId: nonEmptyStringSchema,\n  projectId: nonEmptyStringSchema,\n});\nexport type WorkflowsWorkflowRunCancelledEventDto = z.infer<\n  typeof workflowsWorkflowRunCancelledSchema\n>;\n\nexport const workflowsJobExecutionTimedOutSchema = z.object({\n  jobId: nonEmptyStringSchema,\n  jobExecutionId: nonEmptyStringSchema,\n  workflowRunAttemptId: nonEmptyStringSchema,\n});\nexport type WorkflowsJobExecutionTimedOutEventDto = z.infer<\n  typeof workflowsJobExecutionTimedOutSchema\n>;\n\nconst workflowsJobActivatedBaseSchema = z.object({\n  jobId: nonEmptyStringSchema,\n  workflowRunId: nonEmptyStringSchema,\n  workspaceId: nonEmptyStringSchema,\n});\n\nconst resolvedListeningTriggerSchema = listeningTriggerSchema.extend({\n  filter_snapshot: z.record(z.string(), z.unknown()).optional(),\n});\n\nexport const workflowsJobActivatedSchema = z.discriminatedUnion('mode', [\n  workflowsJobActivatedBaseSchema.extend({\n    mode: z.literal('one_shot'),\n    on: z.array(resolvedListeningTriggerSchema).nullable().optional(),\n    until: z.array(resolvedListeningTriggerSchema).nullable().optional(),\n  }),\n  workflowsJobActivatedBaseSchema.extend({\n    mode: z.literal('listening'),\n    on: z.array(resolvedListeningTriggerSchema).nonempty(),\n    until: z.array(resolvedListeningTriggerSchema).nullable(),\n  }),\n]);\nexport type WorkflowsJobActivatedEventDto = z.infer<typeof workflowsJobActivatedSchema>;\n\nexport const workflowsJobEventDeliveredSchema = z.object({\n  jobId: nonEmptyStringSchema,\n  disposition: z.enum(['fire', 'resolve']),\n  eventRef: nonEmptyStringSchema,\n  eventName: nonEmptyStringSchema,\n});\nexport type WorkflowsJobEventDeliveredEventDto = z.infer<typeof workflowsJobEventDeliveredSchema>;\n\nexport const workflowsJobTerminatedSchema = z.object({\n  jobId: nonEmptyStringSchema,\n  workflowRunId: nonEmptyStringSchema,\n  workflowRunAttemptId: nonEmptyStringSchema,\n  status: jobTerminalStatusSchema,\n  statusReason: jobStatusReasonSchema.nullable(),\n});\nexport type WorkflowsJobTerminatedEventDto = z.infer<typeof workflowsJobTerminatedSchema>;\n\nconst settledStatusSchema = z.enum(['succeeded', 'failed']);\n\nexport const workflowsJobStepsSettledSchema = z.object({\n  jobId: nonEmptyStringSchema,\n  jobExecutionId: nonEmptyStringSchema,\n  workflowRunId: nonEmptyStringSchema,\n  workflowRunAttemptId: nonEmptyStringSchema,\n  status: settledStatusSchema,\n});\nexport type WorkflowsJobStepsSettledEventDto = z.infer<typeof workflowsJobStepsSettledSchema>;\n\nexport const workflowsStepRestartEnqueuedSchema = z.object({\n  jobId: nonEmptyStringSchema,\n  workflowRunId: nonEmptyStringSchema,\n  workflowRunAttemptId: nonEmptyStringSchema,\n  failedStepId: nonEmptyStringSchema,\n  failedStepAttempt: z.number(),\n  restartFromStepId: nonEmptyStringSchema,\n  feedback: nonEmptyStringSchema,\n});\nexport type WorkflowsStepRestartEnqueuedEventDto = z.infer<\n  typeof workflowsStepRestartEnqueuedSchema\n>;\n\nexport const workflowsStepAttemptTerminatedSchema = z.object({\n  jobId: nonEmptyStringSchema,\n  workflowRunId: nonEmptyStringSchema,\n  workflowRunAttemptId: nonEmptyStringSchema,\n  workspaceId: nonEmptyStringSchema,\n  projectId: nonEmptyStringSchema,\n  stepId: nonEmptyStringSchema,\n  attempt: z.number().int().positive(),\n  logOutcome: logOutcomeSchema,\n});\nexport type WorkflowsStepAttemptTerminatedEventDto = z.infer<\n  typeof workflowsStepAttemptTerminatedSchema\n>;\n\nexport interface WorkflowsEventMapDto {\n  [WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED]: WorkflowsWorkflowRunAttemptCreatedEventDto;\n  [WORKFLOWS_WORKFLOW_RUN_TERMINATED]: WorkflowsWorkflowRunTerminatedEventDto;\n  [WORKFLOWS_WORKFLOW_RUN_CANCELLED]: WorkflowsWorkflowRunCancelledEventDto;\n  [WORKFLOWS_JOB_EXECUTION_TIMED_OUT]: WorkflowsJobExecutionTimedOutEventDto;\n  [WORKFLOWS_JOB_ACTIVATED]: WorkflowsJobActivatedEventDto;\n  [WORKFLOWS_JOB_EVENT_DELIVERED]: WorkflowsJobEventDeliveredEventDto;\n  [WORKFLOWS_JOB_TERMINATED]: WorkflowsJobTerminatedEventDto;\n  [WORKFLOWS_JOB_STEPS_SETTLED]: WorkflowsJobStepsSettledEventDto;\n  [WORKFLOWS_STEP_RESTART_ENQUEUED]: WorkflowsStepRestartEnqueuedEventDto;\n  [WORKFLOWS_STEP_ATTEMPT_TERMINATED]: WorkflowsStepAttemptTerminatedEventDto;\n}\n\nexport const workflowsEventSchemas = {\n  [WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED]: workflowsWorkflowRunAttemptCreatedSchema,\n  [WORKFLOWS_WORKFLOW_RUN_TERMINATED]: workflowsWorkflowRunTerminatedSchema,\n  [WORKFLOWS_WORKFLOW_RUN_CANCELLED]: workflowsWorkflowRunCancelledSchema,\n  [WORKFLOWS_JOB_EXECUTION_TIMED_OUT]: workflowsJobExecutionTimedOutSchema,\n  [WORKFLOWS_JOB_ACTIVATED]: workflowsJobActivatedSchema,\n  [WORKFLOWS_JOB_EVENT_DELIVERED]: workflowsJobEventDeliveredSchema,\n  [WORKFLOWS_JOB_TERMINATED]: workflowsJobTerminatedSchema,\n  [WORKFLOWS_JOB_STEPS_SETTLED]: workflowsJobStepsSettledSchema,\n  [WORKFLOWS_STEP_RESTART_ENQUEUED]: workflowsStepRestartEnqueuedSchema,\n  [WORKFLOWS_STEP_ATTEMPT_TERMINATED]: workflowsStepAttemptTerminatedSchema,\n} satisfies Record<keyof WorkflowsEventMapDto, z.ZodType>;\n"],"names":["z","jobStatusReasonSchema","listeningTriggerSchema","logOutcomeSchema","nonEmptyStringSchema","string","nonempty","WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED","WORKFLOWS_WORKFLOW_RUN_TERMINATED","WORKFLOWS_WORKFLOW_RUN_CANCELLED","WORKFLOWS_JOB_EXECUTION_TIMED_OUT","WORKFLOWS_JOB_ACTIVATED","WORKFLOWS_JOB_EVENT_DELIVERED","WORKFLOWS_JOB_TERMINATED","WORKFLOWS_JOB_STEPS_SETTLED","WORKFLOWS_STEP_RESTART_ENQUEUED","WORKFLOWS_STEP_ATTEMPT_TERMINATED","workflowsWorkflowRunAttemptCreatedSchema","object","workflowRunId","workflowRunAttemptId","attempt","number","int","positive","workspaceId","projectId","definitionId","workflowRunTerminalStatusSchema","enum","jobTerminalStatusSchema","terminalStatusSchema","workflowsWorkflowRunTerminatedSchema","status","workflowsWorkflowRunCancelledSchema","workflowsJobExecutionTimedOutSchema","jobId","jobExecutionId","workflowsJobActivatedBaseSchema","resolvedListeningTriggerSchema","extend","filter_snapshot","record","unknown","optional","workflowsJobActivatedSchema","discriminatedUnion","mode","literal","on","array","nullable","until","workflowsJobEventDeliveredSchema","disposition","eventRef","eventName","workflowsJobTerminatedSchema","statusReason","settledStatusSchema","workflowsJobStepsSettledSchema","workflowsStepRestartEnqueuedSchema","failedStepId","failedStepAttempt","restartFromStepId","feedback","workflowsStepAttemptTerminatedSchema","stepId","logOutcome","workflowsEventSchemas"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { type AgentConfigIssueDto, type AgentRuntimeConfigQueryDto, agentConfigIssueSchema, agentRuntimeConfigQuerySchema, type CheckoutIntentDto, type CheckoutTokenAuthDto, type CheckoutTokenResponseDto, checkoutIntentSchema, checkoutTokenAuthSchema, checkoutTokenResponseSchema, type JobDto, type JobExecutionDto, type JobListeningDto, type JobModeDto, type JobStatusDto, type JobStatusReasonDto, jobDtoSchema, jobListeningBatchSchema, jobListeningSchema, jobModeSchema, jobStatusReasonSchema, jobStatusSchema, type ListenerStatusDto, type ListeningTriggerDto, type LogOutcomeDto, listenerStatusSchema, listeningTriggerSchema, logOutcomeSchema, type NextStepResponseDto, nextStepResponseSchema, type ReportStepBodyDto, type ReportStepResponseDto, type RerunWorkflowRunBodyDto, type ResolutionReasonDto, reportStepBodySchema, reportStepResponseSchema, rerunWorkflowRunBodySchema, resolutionReasonSchema, STEP_ERROR_MESSAGE_MAX_LENGTH, STEP_RESPONSE_MAX_LENGTH, type StepAttemptDto, type StepDto, type StepErrorCategoryDto, type StepErrorDto, type StepErrorReasonDto, type StepGateResultDto, stepAttemptDtoSchema, stepDtoSchema, stepErrorCategorySchema, stepErrorDtoSchema, stepErrorReasonSchema, stepGateResultDtoSchema, type TriggerEventsBatchDto, triggerEventsBatchSchema, type WorkflowExecutionContextDto, type WorkflowExecutionEventDto, type WorkflowRunAggregatesQueryDto, type WorkflowRunAggregatesResponseDto, type WorkflowRunAttemptDto, type WorkflowRunAttemptsResponseDto, type WorkflowRunDetailResponseDto, type WorkflowRunDto, type WorkflowRunJobDetailDto, type WorkflowRunJobExecutionDetailDto, type WorkflowRunListQueryDto, type WorkflowRunListResponseDto, type WorkflowRunRerunModeDto, type WorkflowRunResponseDto, type WorkflowRunStatusDto, type WorkflowRunStepDetailDto, workflowExecutionContextSchema, workflowExecutionEventSchema, workflowRunAggregatesQuerySchema, workflowRunAggregatesResponseSchema, workflowRunAttemptDtoSchema, workflowRunAttemptsResponseSchema, workflowRunDetailResponseSchema, workflowRunDtoSchema, workflowRunJobDetailDtoSchema, workflowRunJobExecutionDetailDtoSchema, workflowRunListQuerySchema, workflowRunListResponseSchema, workflowRunRerunModeSchema, workflowRunResponseSchema, workflowRunStatusSchema, workflowRunStepDetailDtoSchema, } from '#schemas/index.js';
+export { type StepSourceLocationDto, stepSourceLocationSchema } from '#schemas/step.js';
+export { type WorkflowSourceSnapshotDto, workflowSourceSnapshotSchema, } from '#schemas/workflow-run.js';
+export { jobTerminalStatusSchema, terminalStatusSchema, WORKFLOWS_JOB_ACTIVATED, WORKFLOWS_JOB_EVENT_DELIVERED, WORKFLOWS_JOB_EXECUTION_TIMED_OUT, WORKFLOWS_JOB_STEPS_SETTLED, WORKFLOWS_JOB_TERMINATED, WORKFLOWS_STEP_ATTEMPT_TERMINATED, WORKFLOWS_STEP_RESTART_ENQUEUED, WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED, WORKFLOWS_WORKFLOW_RUN_CANCELLED, WORKFLOWS_WORKFLOW_RUN_TERMINATED, type WorkflowsEventMapDto, type WorkflowsJobActivatedEventDto, type WorkflowsJobEventDeliveredEventDto, type WorkflowsJobExecutionTimedOutEventDto, type WorkflowsJobStepsSettledEventDto, type WorkflowsJobTerminatedEventDto, type WorkflowsStepAttemptTerminatedEventDto, type WorkflowsStepRestartEnqueuedEventDto, type WorkflowsWorkflowRunAttemptCreatedEventDto, type WorkflowsWorkflowRunCancelledEventDto, type WorkflowsWorkflowRunTerminatedEventDto, workflowRunTerminalStatusSchema, workflowsEventSchemas, workflowsJobActivatedSchema, workflowsJobEventDeliveredSchema, workflowsJobExecutionTimedOutSchema, workflowsJobStepsSettledSchema, workflowsJobTerminatedSchema, workflowsStepAttemptTerminatedSchema, workflowsStepRestartEnqueuedSchema, workflowsWorkflowRunAttemptCreatedSchema, workflowsWorkflowRunCancelledSchema, workflowsWorkflowRunTerminatedSchema, } from './events.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,EAC/B,sBAAsB,EACtB,6BAA6B,EAC7B,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,oBAAoB,EACpB,uBAAuB,EACvB,2BAA2B,EAC3B,KAAK,MAAM,EACX,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,YAAY,EACZ,uBAAuB,EACvB,kBAAkB,EAClB,aAAa,EACb,qBAAqB,EACrB,eAAe,EACf,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,oBAAoB,EACpB,sBAAsB,EACtB,gBAAgB,EAChB,KAAK,mBAAmB,EACxB,sBAAsB,EACtB,KAAK,iBAAiB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,oBAAoB,EACpB,wBAAwB,EACxB,0BAA0B,EAC1B,sBAAsB,EACtB,6BAA6B,EAC7B,wBAAwB,EACxB,KAAK,cAAc,EACnB,KAAK,OAAO,EACZ,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,oBAAoB,EACpB,aAAa,EACb,uBAAuB,EACvB,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,EACvB,KAAK,qBAAqB,EAC1B,wBAAwB,EACxB,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAC9B,KAAK,6BAA6B,EAClC,KAAK,gCAAgC,EACrC,KAAK,qBAAqB,EAC1B,KAAK,8BAA8B,EACnC,KAAK,4BAA4B,EACjC,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,KAAK,gCAAgC,EACrC,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAC/B,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,8BAA8B,EAC9B,4BAA4B,EAC5B,gCAAgC,EAChC,mCAAmC,EACnC,2BAA2B,EAC3B,iCAAiC,EACjC,+BAA+B,EAC/B,oBAAoB,EACpB,6BAA6B,EAC7B,sCAAsC,EACtC,0BAA0B,EAC1B,6BAA6B,EAC7B,0BAA0B,EAC1B,yBAAyB,EACzB,uBAAuB,EACvB,8BAA8B,GAC/B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAC,KAAK,qBAAqB,EAAE,wBAAwB,EAAC,MAAM,kBAAkB,CAAC;AACtF,OAAO,EACL,KAAK,yBAAyB,EAC9B,4BAA4B,GAC7B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,uBAAuB,EACvB,6BAA6B,EAC7B,iCAAiC,EACjC,2BAA2B,EAC3B,wBAAwB,EACxB,iCAAiC,EACjC,+BAA+B,EAC/B,sCAAsC,EACtC,gCAAgC,EAChC,iCAAiC,EACjC,KAAK,oBAAoB,EACzB,KAAK,6BAA6B,EAClC,KAAK,kCAAkC,EACvC,KAAK,qCAAqC,EAC1C,KAAK,gCAAgC,EACrC,KAAK,8BAA8B,EACnC,KAAK,sCAAsC,EAC3C,KAAK,oCAAoC,EACzC,KAAK,0CAA0C,EAC/C,KAAK,qCAAqC,EAC1C,KAAK,sCAAsC,EAC3C,+BAA+B,EAC/B,qBAAqB,EACrB,2BAA2B,EAC3B,gCAAgC,EAChC,mCAAmC,EACnC,8BAA8B,EAC9B,4BAA4B,EAC5B,oCAAoC,EACpC,kCAAkC,EAClC,wCAAwC,EACxC,mCAAmC,EACnC,oCAAoC,GACrC,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export { agentConfigIssueSchema, agentRuntimeConfigQuerySchema, checkoutIntentSchema, checkoutTokenAuthSchema, checkoutTokenResponseSchema, jobDtoSchema, jobListeningBatchSchema, jobListeningSchema, jobModeSchema, jobStatusReasonSchema, jobStatusSchema, listenerStatusSchema, listeningTriggerSchema, logOutcomeSchema, nextStepResponseSchema, reportStepBodySchema, reportStepResponseSchema, rerunWorkflowRunBodySchema, resolutionReasonSchema, STEP_ERROR_MESSAGE_MAX_LENGTH, STEP_RESPONSE_MAX_LENGTH, stepAttemptDtoSchema, stepDtoSchema, stepErrorCategorySchema, stepErrorDtoSchema, stepErrorReasonSchema, stepGateResultDtoSchema, triggerEventsBatchSchema, workflowExecutionContextSchema, workflowExecutionEventSchema, workflowRunAggregatesQuerySchema, workflowRunAggregatesResponseSchema, workflowRunAttemptDtoSchema, workflowRunAttemptsResponseSchema, workflowRunDetailResponseSchema, workflowRunDtoSchema, workflowRunJobDetailDtoSchema, workflowRunJobExecutionDetailDtoSchema, workflowRunListQuerySchema, workflowRunListResponseSchema, workflowRunRerunModeSchema, workflowRunResponseSchema, workflowRunStatusSchema, workflowRunStepDetailDtoSchema } from '#schemas/index.js';
+export { stepSourceLocationSchema } from '#schemas/step.js';
+export { workflowSourceSnapshotSchema } from '#schemas/workflow-run.js';
+export { jobTerminalStatusSchema, terminalStatusSchema, WORKFLOWS_JOB_ACTIVATED, WORKFLOWS_JOB_EVENT_DELIVERED, WORKFLOWS_JOB_EXECUTION_TIMED_OUT, WORKFLOWS_JOB_STEPS_SETTLED, WORKFLOWS_JOB_TERMINATED, WORKFLOWS_STEP_ATTEMPT_TERMINATED, WORKFLOWS_STEP_RESTART_ENQUEUED, WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED, WORKFLOWS_WORKFLOW_RUN_CANCELLED, WORKFLOWS_WORKFLOW_RUN_TERMINATED, workflowRunTerminalStatusSchema, workflowsEventSchemas, workflowsJobActivatedSchema, workflowsJobEventDeliveredSchema, workflowsJobExecutionTimedOutSchema, workflowsJobStepsSettledSchema, workflowsJobTerminatedSchema, workflowsStepAttemptTerminatedSchema, workflowsStepRestartEnqueuedSchema, workflowsWorkflowRunAttemptCreatedSchema, workflowsWorkflowRunCancelledSchema, workflowsWorkflowRunTerminatedSchema } from './events.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export {\n  type AgentConfigIssueDto,\n  type AgentRuntimeConfigQueryDto,\n  agentConfigIssueSchema,\n  agentRuntimeConfigQuerySchema,\n  type CheckoutIntentDto,\n  type CheckoutTokenAuthDto,\n  type CheckoutTokenResponseDto,\n  checkoutIntentSchema,\n  checkoutTokenAuthSchema,\n  checkoutTokenResponseSchema,\n  type JobDto,\n  type JobExecutionDto,\n  type JobListeningDto,\n  type JobModeDto,\n  type JobStatusDto,\n  type JobStatusReasonDto,\n  jobDtoSchema,\n  jobListeningBatchSchema,\n  jobListeningSchema,\n  jobModeSchema,\n  jobStatusReasonSchema,\n  jobStatusSchema,\n  type ListenerStatusDto,\n  type ListeningTriggerDto,\n  type LogOutcomeDto,\n  listenerStatusSchema,\n  listeningTriggerSchema,\n  logOutcomeSchema,\n  type NextStepResponseDto,\n  nextStepResponseSchema,\n  type ReportStepBodyDto,\n  type ReportStepResponseDto,\n  type RerunWorkflowRunBodyDto,\n  type ResolutionReasonDto,\n  reportStepBodySchema,\n  reportStepResponseSchema,\n  rerunWorkflowRunBodySchema,\n  resolutionReasonSchema,\n  STEP_ERROR_MESSAGE_MAX_LENGTH,\n  STEP_RESPONSE_MAX_LENGTH,\n  type StepAttemptDto,\n  type StepDto,\n  type StepErrorCategoryDto,\n  type StepErrorDto,\n  type StepErrorReasonDto,\n  type StepGateResultDto,\n  stepAttemptDtoSchema,\n  stepDtoSchema,\n  stepErrorCategorySchema,\n  stepErrorDtoSchema,\n  stepErrorReasonSchema,\n  stepGateResultDtoSchema,\n  type TriggerEventsBatchDto,\n  triggerEventsBatchSchema,\n  type WorkflowExecutionContextDto,\n  type WorkflowExecutionEventDto,\n  type WorkflowRunAggregatesQueryDto,\n  type WorkflowRunAggregatesResponseDto,\n  type WorkflowRunAttemptDto,\n  type WorkflowRunAttemptsResponseDto,\n  type WorkflowRunDetailResponseDto,\n  type WorkflowRunDto,\n  type WorkflowRunJobDetailDto,\n  type WorkflowRunJobExecutionDetailDto,\n  type WorkflowRunListQueryDto,\n  type WorkflowRunListResponseDto,\n  type WorkflowRunRerunModeDto,\n  type WorkflowRunResponseDto,\n  type WorkflowRunStatusDto,\n  type WorkflowRunStepDetailDto,\n  workflowExecutionContextSchema,\n  workflowExecutionEventSchema,\n  workflowRunAggregatesQuerySchema,\n  workflowRunAggregatesResponseSchema,\n  workflowRunAttemptDtoSchema,\n  workflowRunAttemptsResponseSchema,\n  workflowRunDetailResponseSchema,\n  workflowRunDtoSchema,\n  workflowRunJobDetailDtoSchema,\n  workflowRunJobExecutionDetailDtoSchema,\n  workflowRunListQuerySchema,\n  workflowRunListResponseSchema,\n  workflowRunRerunModeSchema,\n  workflowRunResponseSchema,\n  workflowRunStatusSchema,\n  workflowRunStepDetailDtoSchema,\n} from '#schemas/index.js';\nexport {type StepSourceLocationDto, stepSourceLocationSchema} from '#schemas/step.js';\nexport {\n  type WorkflowSourceSnapshotDto,\n  workflowSourceSnapshotSchema,\n} from '#schemas/workflow-run.js';\nexport {\n  jobTerminalStatusSchema,\n  terminalStatusSchema,\n  WORKFLOWS_JOB_ACTIVATED,\n  WORKFLOWS_JOB_EVENT_DELIVERED,\n  WORKFLOWS_JOB_EXECUTION_TIMED_OUT,\n  WORKFLOWS_JOB_STEPS_SETTLED,\n  WORKFLOWS_JOB_TERMINATED,\n  WORKFLOWS_STEP_ATTEMPT_TERMINATED,\n  WORKFLOWS_STEP_RESTART_ENQUEUED,\n  WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED,\n  WORKFLOWS_WORKFLOW_RUN_CANCELLED,\n  WORKFLOWS_WORKFLOW_RUN_TERMINATED,\n  type WorkflowsEventMapDto,\n  type WorkflowsJobActivatedEventDto,\n  type WorkflowsJobEventDeliveredEventDto,\n  type WorkflowsJobExecutionTimedOutEventDto,\n  type WorkflowsJobStepsSettledEventDto,\n  type WorkflowsJobTerminatedEventDto,\n  type WorkflowsStepAttemptTerminatedEventDto,\n  type WorkflowsStepRestartEnqueuedEventDto,\n  type WorkflowsWorkflowRunAttemptCreatedEventDto,\n  type WorkflowsWorkflowRunCancelledEventDto,\n  type WorkflowsWorkflowRunTerminatedEventDto,\n  workflowRunTerminalStatusSchema,\n  workflowsEventSchemas,\n  workflowsJobActivatedSchema,\n  workflowsJobEventDeliveredSchema,\n  workflowsJobExecutionTimedOutSchema,\n  workflowsJobStepsSettledSchema,\n  workflowsJobTerminatedSchema,\n  workflowsStepAttemptTerminatedSchema,\n  workflowsStepRestartEnqueuedSchema,\n  workflowsWorkflowRunAttemptCreatedSchema,\n  workflowsWorkflowRunCancelledSchema,\n  workflowsWorkflowRunTerminatedSchema,\n} from './events.js';\n"],"names":["agentConfigIssueSchema","agentRuntimeConfigQuerySchema","checkoutIntentSchema","checkoutTokenAuthSchema","checkoutTokenResponseSchema","jobDtoSchema","jobListeningBatchSchema","jobListeningSchema","jobModeSchema","jobStatusReasonSchema","jobStatusSchema","listenerStatusSchema","listeningTriggerSchema","logOutcomeSchema","nextStepResponseSchema","reportStepBodySchema","reportStepResponseSchema","rerunWorkflowRunBodySchema","resolutionReasonSchema","STEP_ERROR_MESSAGE_MAX_LENGTH","STEP_RESPONSE_MAX_LENGTH","stepAttemptDtoSchema","stepDtoSchema","stepErrorCategorySchema","stepErrorDtoSchema","stepErrorReasonSchema","stepGateResultDtoSchema","triggerEventsBatchSchema","workflowExecutionContextSchema","workflowExecutionEventSchema","workflowRunAggregatesQuerySchema","workflowRunAggregatesResponseSchema","workflowRunAttemptDtoSchema","workflowRunAttemptsResponseSchema","workflowRunDetailResponseSchema","workflowRunDtoSchema","workflowRunJobDetailDtoSchema","workflowRunJobExecutionDetailDtoSchema","workflowRunListQuerySchema","workflowRunListResponseSchema","workflowRunRerunModeSchema","workflowRunResponseSchema","workflowRunStatusSchema","workflowRunStepDetailDtoSchema","stepSourceLocationSchema","workflowSourceSnapshotSchema","jobTerminalStatusSchema","terminalStatusSchema","WORKFLOWS_JOB_ACTIVATED","WORKFLOWS_JOB_EVENT_DELIVERED","WORKFLOWS_JOB_EXECUTION_TIMED_OUT","WORKFLOWS_JOB_STEPS_SETTLED","WORKFLOWS_JOB_TERMINATED","WORKFLOWS_STEP_ATTEMPT_TERMINATED","WORKFLOWS_STEP_RESTART_ENQUEUED","WORKFLOWS_WORKFLOW_RUN_ATTEMPT_CREATED","WORKFLOWS_WORKFLOW_RUN_CANCELLED","WORKFLOWS_WORKFLOW_RUN_TERMINATED","workflowRunTerminalStatusSchema","workflowsEventSchemas","workflowsJobActivatedSchema","workflowsJobEventDeliveredSchema","workflowsJobExecutionTimedOutSchema","workflowsJobStepsSettledSchema","workflowsJobTerminatedSchema","workflowsStepAttemptTerminatedSchema","workflowsStepRestartEnqueuedSchema","workflowsWorkflowRunAttemptCreatedSchema","workflowsWorkflowRunCancelledSchema","workflowsWorkflowRunTerminatedSchema"],"mappings":"AAAA,SAGEA,sBAAsB,EACtBC,6BAA6B,EAI7BC,oBAAoB,EACpBC,uBAAuB,EACvBC,2BAA2B,EAO3BC,YAAY,EACZC,uBAAuB,EACvBC,kBAAkB,EAClBC,aAAa,EACbC,qBAAqB,EACrBC,eAAe,EAIfC,oBAAoB,EACpBC,sBAAsB,EACtBC,gBAAgB,EAEhBC,sBAAsB,EAKtBC,oBAAoB,EACpBC,wBAAwB,EACxBC,0BAA0B,EAC1BC,sBAAsB,EACtBC,6BAA6B,EAC7BC,wBAAwB,EAOxBC,oBAAoB,EACpBC,aAAa,EACbC,uBAAuB,EACvBC,kBAAkB,EAClBC,qBAAqB,EACrBC,uBAAuB,EAEvBC,wBAAwB,EAiBxBC,8BAA8B,EAC9BC,4BAA4B,EAC5BC,gCAAgC,EAChCC,mCAAmC,EACnCC,2BAA2B,EAC3BC,iCAAiC,EACjCC,+BAA+B,EAC/BC,oBAAoB,EACpBC,6BAA6B,EAC7BC,sCAAsC,EACtCC,0BAA0B,EAC1BC,6BAA6B,EAC7BC,0BAA0B,EAC1BC,yBAAyB,EACzBC,uBAAuB,EACvBC,8BAA8B,QACzB,oBAAoB;AAC3B,SAAoCC,wBAAwB,QAAO,mBAAmB;AACtF,SAEEC,4BAA4B,QACvB,2BAA2B;AAClC,SACEC,uBAAuB,EACvBC,oBAAoB,EACpBC,uBAAuB,EACvBC,6BAA6B,EAC7BC,iCAAiC,EACjCC,2BAA2B,EAC3BC,wBAAwB,EACxBC,iCAAiC,EACjCC,+BAA+B,EAC/BC,sCAAsC,EACtCC,gCAAgC,EAChCC,iCAAiC,EAYjCC,+BAA+B,EAC/BC,qBAAqB,EACrBC,2BAA2B,EAC3BC,gCAAgC,EAChCC,mCAAmC,EACnCC,8BAA8B,EAC9BC,4BAA4B,EAC5BC,oCAAoC,EACpCC,kCAAkC,EAClCC,wCAAwC,EACxCC,mCAAmC,EACnCC,oCAAoC,QAC/B,cAAc"}

package/dist/schemas/agent-runtime-config.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const agentRuntimeConfigQuerySchema: z.ZodObject<{
+    step_id: z.ZodString;
+    attempt: z.ZodCoercedNumber<unknown>;
+}, z.core.$strip>;
+export type AgentRuntimeConfigQueryDto = z.infer<typeof agentRuntimeConfigQuerySchema>;
+//# sourceMappingURL=agent-runtime-config.d.ts.map