@drisp/protocol 0.6.0 → 0.6.2

package/dist/chunk-HMYWICNI.js

@@ -0,0 +1,202 @@
+// src/domain.ts
+import { z } from "zod";
+var RunStatusSchema = z.enum([
+  "running",
+  "awaiting_attention",
+  "completed",
+  "blocked",
+  "exhausted",
+  "failed",
+  "cancelled"
+]);
+var RunSchema = z.object({
+  runId: z.string(),
+  /** The durable Athena Session this Run belongs to. */
+  athenaSessionId: z.string(),
+  workflowName: z.string().optional(),
+  /** What the Run was asked to do — the `**Goal**` its Run section records. */
+  goal: z.string().optional(),
+  /** Index of the most recent Turn (0 before Turn 1). */
+  iteration: z.int().nonnegative(),
+  maxIterations: z.int().positive().optional(),
+  status: RunStatusSchema,
+  stopReason: z.string().optional(),
+  /** Vendor session id of the Run's most recent Agent Session (ADR 0014). */
+  adapterSessionId: z.string().optional(),
+  startedAt: z.number(),
+  endedAt: z.number().optional()
+});
+var TurnContinuationSchema = z.discriminatedUnion("mode", [
+  z.object({ mode: z.literal("fresh") }),
+  z.object({ mode: z.literal("resume"), handle: z.string() }),
+  z.object({ mode: z.literal("reuse-current") })
+]);
+var TurnOutcomeSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("continue") }),
+  z.object({
+    kind: z.literal("stop"),
+    status: RunStatusSchema,
+    stopReason: z.string().optional()
+  }),
+  z.object({
+    kind: z.literal("suspend"),
+    status: RunStatusSchema,
+    stopReason: z.string()
+  })
+]);
+var TurnSchema = z.object({
+  runId: z.string(),
+  /** 1-based Iteration of this Turn within its Run. */
+  iteration: z.int().positive(),
+  continuation: TurnContinuationSchema,
+  /** Vendor session id of the Agent Session this Turn ran in, once known. */
+  adapterSessionId: z.string().optional(),
+  startedAt: z.number(),
+  endedAt: z.number().optional(),
+  outcome: TurnOutcomeSchema.optional()
+});
+var HardFailureCodeSchema = z.enum([
+  "auth",
+  "billing",
+  "invalid_request",
+  "model_not_found",
+  "unclassified"
+]);
+var ExhaustedCapSchema = z.enum([
+  "retry",
+  "nudge",
+  "iterations",
+  "handover",
+  "tokens"
+]);
+var interruptionBase = {
+  /** Human-readable summary of why the Run parked. */
+  message: z.string()
+};
+var InterruptionSchema = z.discriminatedUnion("kind", [
+  z.object({
+    ...interruptionBase,
+    kind: z.literal("blocked"),
+    /** The `: reason` suffix of `NEEDS_HUMAN[: reason]`, when given. */
+    reason: z.string().optional()
+  }),
+  z.object({
+    ...interruptionBase,
+    kind: z.literal("question"),
+    /**
+     * The pending request an `answer` frame must address. Absent when the
+     * runner interrupted the Turn instead of leaving the question waiting
+     * (an unattended Workflow Run kills the Agent Session on a question,
+     * so there is no request left to answer); such a Run is woken with a
+     * `steer` carrying the human's guidance.
+     */
+    requestId: z.string().optional(),
+    question: z.string().optional()
+  }),
+  z.object({
+    ...interruptionBase,
+    kind: z.literal("hard_failure"),
+    code: HardFailureCodeSchema
+  }),
+  z.object({
+    ...interruptionBase,
+    kind: z.literal("cap_exhausted"),
+    cap: ExhaustedCapSchema,
+    limit: z.int().positive().optional(),
+    /** Structured policy decision. Older senders may supply only cap/message. */
+    resource: z.object({
+      cause: z.enum(["tokens", "iterations", "context", "restart"]),
+      limit: z.number().nonnegative(),
+      used: z.number().nonnegative(),
+      detail: z.string().optional(),
+      checkpointPath: z.string().optional(),
+      fresh: z.boolean()
+    }).optional()
+  })
+]);
+var RunSpecSchema = z.looseObject({
+  prompt: z.string().optional(),
+  athenaSessionId: z.string().optional(),
+  adapterResumeSessionId: z.string().optional(),
+  sessionId: z.string().optional(),
+  projectDir: z.string().optional(),
+  workflow: z.looseObject({
+    source: z.string().optional(),
+    ref: z.string().optional(),
+    version: z.string().optional()
+  }).optional(),
+  harness: z.string().optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  timeoutSec: z.number().optional(),
+  /** Per-run callback channel minted by the hub; both or neither. */
+  callbackWsUrl: z.string().optional(),
+  callbackToken: z.string().optional()
+});
+var RuntimeIntentSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("permission_allow") }),
+  z.object({ kind: z.literal("permission_deny"), reason: z.string() }),
+  z.object({
+    kind: z.literal("question_answer"),
+    answers: z.record(z.string(), z.string())
+  }),
+  z.object({ kind: z.literal("pre_tool_allow") }),
+  z.object({ kind: z.literal("pre_tool_deny"), reason: z.string() }),
+  z.object({ kind: z.literal("stop_block"), reason: z.string() }),
+  z.object({ kind: z.literal("compact_block"), reason: z.string() })
+]);
+var RuntimeDecisionSchema = z.object({
+  type: z.enum(["passthrough", "block", "json"]),
+  source: z.enum(["user", "timeout", "rule"]),
+  intent: RuntimeIntentSchema.optional(),
+  reason: z.string().optional(),
+  data: z.unknown().optional()
+});
+var AttachmentSchema = z.object({
+  runnerId: z.string(),
+  name: z.string().optional(),
+  slug: z.string().optional(),
+  executionTarget: z.string().optional(),
+  remoteInstanceId: z.string().optional()
+});
+var InstalledWorkflowSourceSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("builtin") }),
+  z.object({ kind: z.literal("marketplace-remote"), ref: z.string() }),
+  z.object({
+    kind: z.literal("marketplace-local"),
+    repoDir: z.string(),
+    workflowName: z.string()
+  }),
+  z.object({ kind: z.literal("filesystem"), path: z.string() }),
+  z.object({ kind: z.literal("unknown") })
+]);
+var InstalledWorkflowSchema = z.object({
+  name: z.string().min(1),
+  version: z.string().optional(),
+  source: InstalledWorkflowSourceSchema
+});
+var AssignmentRejectedReasonSchema = z.enum([
+  "local_capacity",
+  "duplicate",
+  "malformed_assignment",
+  "workspace_unresolved",
+  "workspace_invalid"
+]);
+
+export {
+  RunStatusSchema,
+  RunSchema,
+  TurnContinuationSchema,
+  TurnOutcomeSchema,
+  TurnSchema,
+  HardFailureCodeSchema,
+  ExhaustedCapSchema,
+  InterruptionSchema,
+  RunSpecSchema,
+  RuntimeIntentSchema,
+  RuntimeDecisionSchema,
+  AttachmentSchema,
+  InstalledWorkflowSourceSchema,
+  InstalledWorkflowSchema,
+  AssignmentRejectedReasonSchema
+};
+//# sourceMappingURL=chunk-HMYWICNI.js.map

package/dist/domain-B-kg2pa_.d.ts

@@ -0,0 +1,376 @@
+import { z } from 'zod';
+
+/**
+ * Workflow-execution domain shapes as the domain docs define them
+ * (UBIQUITOUS_LANGUAGE.md, ADR 0014-0016): the Workflow Run, the Turn, and the
+ * Interruption a Run parks on when it needs a human. These are the values the
+ * frames in `frames.ts` carry; nothing here knows about the wire.
+ */
+
+/**
+ * The outcome of a Workflow Run. Terminal: `completed`, `failed`, `cancelled`.
+ * Non-terminal: `running`, and `awaiting_attention` — suspended until a human
+ * replies. `blocked` and `exhausted` are no longer emitted (both route to
+ * `awaiting_attention`) but stay valid on historical rows.
+ */
+declare const RunStatusSchema: z.ZodEnum<{
+    running: "running";
+    awaiting_attention: "awaiting_attention";
+    completed: "completed";
+    blocked: "blocked";
+    exhausted: "exhausted";
+    failed: "failed";
+    cancelled: "cancelled";
+}>;
+type RunStatus = z.infer<typeof RunStatusSchema>;
+/**
+ * One execution of a whole Workflow — the loop spanning every Turn from start
+ * to a terminal Run Status. Many per Athena Session.
+ */
+declare const RunSchema: z.ZodObject<{
+    runId: z.ZodString;
+    athenaSessionId: z.ZodString;
+    workflowName: z.ZodOptional<z.ZodString>;
+    goal: z.ZodOptional<z.ZodString>;
+    iteration: z.ZodInt;
+    maxIterations: z.ZodOptional<z.ZodInt>;
+    status: z.ZodEnum<{
+        running: "running";
+        awaiting_attention: "awaiting_attention";
+        completed: "completed";
+        blocked: "blocked";
+        exhausted: "exhausted";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    stopReason: z.ZodOptional<z.ZodString>;
+    adapterSessionId: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodNumber;
+    endedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type Run = z.infer<typeof RunSchema>;
+/**
+ * How a Turn relates to the Agent Session before it: a fresh spawn, a resume
+ * of the prior Agent Session (Nudge / Retry / human reply), or reuse of the
+ * one already running.
+ */
+declare const TurnContinuationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"fresh">;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"resume">;
+    handle: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    mode: z.ZodLiteral<"reuse-current">;
+}, z.core.$strip>], "mode">;
+type TurnContinuation = z.infer<typeof TurnContinuationSchema>;
+/**
+ * The Terminal Outcome after a Turn: continue looping, stop with a terminal
+ * Run Status, or suspend in `awaiting_attention` (ADR 0004, ADR 0014 §7).
+ */
+declare const TurnOutcomeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"continue">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"stop">;
+    status: z.ZodEnum<{
+        running: "running";
+        awaiting_attention: "awaiting_attention";
+        completed: "completed";
+        blocked: "blocked";
+        exhausted: "exhausted";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    stopReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"suspend">;
+    status: z.ZodEnum<{
+        running: "running";
+        awaiting_attention: "awaiting_attention";
+        completed: "completed";
+        blocked: "blocked";
+        exhausted: "exhausted";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    stopReason: z.ZodString;
+}, z.core.$strip>], "kind">;
+type TurnOutcome = z.infer<typeof TurnOutcomeSchema>;
+/**
+ * One agent execution — a single `claude -p` invocation / one Codex
+ * `thread.run` — numbered by its Iteration within the Run.
+ */
+declare const TurnSchema: z.ZodObject<{
+    runId: z.ZodString;
+    iteration: z.ZodInt;
+    continuation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"fresh">;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"resume">;
+        handle: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        mode: z.ZodLiteral<"reuse-current">;
+    }, z.core.$strip>], "mode">;
+    adapterSessionId: z.ZodOptional<z.ZodString>;
+    startedAt: z.ZodNumber;
+    endedAt: z.ZodOptional<z.ZodNumber>;
+    outcome: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"continue">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"stop">;
+        status: z.ZodEnum<{
+            running: "running";
+            awaiting_attention: "awaiting_attention";
+            completed: "completed";
+            blocked: "blocked";
+            exhausted: "exhausted";
+            failed: "failed";
+            cancelled: "cancelled";
+        }>;
+        stopReason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"suspend">;
+        status: z.ZodEnum<{
+            running: "running";
+            awaiting_attention: "awaiting_attention";
+            completed: "completed";
+            blocked: "blocked";
+            exhausted: "exhausted";
+            failed: "failed";
+            cancelled: "cancelled";
+        }>;
+        stopReason: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+type Turn = z.infer<typeof TurnSchema>;
+/** A hard (non-transient) Turn failure class — see `failureTaxonomy.ts`. */
+declare const HardFailureCodeSchema: z.ZodEnum<{
+    auth: "auth";
+    billing: "billing";
+    invalid_request: "invalid_request";
+    model_not_found: "model_not_found";
+    unclassified: "unclassified";
+}>;
+type HardFailureCode = z.infer<typeof HardFailureCodeSchema>;
+/**
+ * A Run budget that can be exhausted (ADR 0014 §3-§4, §7; ADR 0018 §2, §10):
+ * the Retry cap, the Nudge cap, `maxIterations`, the Handover cap — a streak
+ * of unproductive Handovers — and the opt-in cumulative token budget.
+ */
+declare const ExhaustedCapSchema: z.ZodEnum<{
+    retry: "retry";
+    nudge: "nudge";
+    iterations: "iterations";
+    handover: "handover";
+    tokens: "tokens";
+}>;
+type ExhaustedCap = z.infer<typeof ExhaustedCapSchema>;
+/**
+ * Why a Run parked in `awaiting_attention` — the payload of a Needs-attention
+ * escalation. One of: a declared `NEEDS_HUMAN` marker (spelled
+ * `WORKFLOW_BLOCKED` before 0.6), an elicitation the agent raised
+ * (`AskUserQuestion`), a hard failure, or an exhausted cap/ceiling.
+ * Resolved by a human reply (`answer` for a question, `steer` otherwise),
+ * which resumes the intact Agent Session.
+ */
+declare const InterruptionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"blocked">;
+    reason: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"question">;
+    requestId: z.ZodOptional<z.ZodString>;
+    question: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"hard_failure">;
+    code: z.ZodEnum<{
+        auth: "auth";
+        billing: "billing";
+        invalid_request: "invalid_request";
+        model_not_found: "model_not_found";
+        unclassified: "unclassified";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"cap_exhausted">;
+    cap: z.ZodEnum<{
+        retry: "retry";
+        nudge: "nudge";
+        iterations: "iterations";
+        handover: "handover";
+        tokens: "tokens";
+    }>;
+    limit: z.ZodOptional<z.ZodInt>;
+    resource: z.ZodOptional<z.ZodObject<{
+        cause: z.ZodEnum<{
+            iterations: "iterations";
+            tokens: "tokens";
+            context: "context";
+            restart: "restart";
+        }>;
+        limit: z.ZodNumber;
+        used: z.ZodNumber;
+        detail: z.ZodOptional<z.ZodString>;
+        checkpointPath: z.ZodOptional<z.ZodString>;
+        fresh: z.ZodBoolean;
+    }, z.core.$strip>>;
+    message: z.ZodString;
+}, z.core.$strip>], "kind">;
+type Interruption = z.infer<typeof InterruptionSchema>;
+/**
+ * The requested shape of a Run, owned by the hub; the runner owns its
+ * realization. Every field is optional *on the wire* and unknown fields are
+ * kept (protocol §15): the runner's admission gate — not frame parsing — is
+ * where a missing `prompt` becomes a first-class `malformed_assignment`
+ * rejection, and orthogonal readers (artifact capture) read the raw spec.
+ */
+declare const RunSpecSchema: z.ZodObject<{
+    prompt: z.ZodOptional<z.ZodString>;
+    athenaSessionId: z.ZodOptional<z.ZodString>;
+    adapterResumeSessionId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    projectDir: z.ZodOptional<z.ZodString>;
+    workflow: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        ref: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    harness: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    timeoutSec: z.ZodOptional<z.ZodNumber>;
+    callbackWsUrl: z.ZodOptional<z.ZodString>;
+    callbackToken: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+type RunSpec = z.infer<typeof RunSpecSchema>;
+/** Typed semantic intent of a decision — the adapter maps it to hook output. */
+declare const RuntimeIntentSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"permission_allow">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"permission_deny">;
+    reason: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"question_answer">;
+    answers: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"pre_tool_allow">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"pre_tool_deny">;
+    reason: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"stop_block">;
+    reason: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"compact_block">;
+    reason: z.ZodString;
+}, z.core.$strip>], "kind">;
+type RuntimeIntent = z.infer<typeof RuntimeIntentSchema>;
+/**
+ * A delayed answer that resolves a prior runtime event needing user input
+ * (a permission request, a question). Correlated by `requestId` on the frame.
+ */
+declare const RuntimeDecisionSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        passthrough: "passthrough";
+        block: "block";
+        json: "json";
+    }>;
+    source: z.ZodEnum<{
+        user: "user";
+        timeout: "timeout";
+        rule: "rule";
+    }>;
+    intent: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"permission_allow">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"permission_deny">;
+        reason: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"question_answer">;
+        answers: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"pre_tool_allow">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"pre_tool_deny">;
+        reason: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"stop_block">;
+        reason: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"compact_block">;
+        reason: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    reason: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+type RuntimeDecision = z.infer<typeof RuntimeDecisionSchema>;
+/**
+ * The binding between a paired runner instance and one hub-side runner.
+ * Owned by the hub; the runner only mirrors it.
+ */
+declare const AttachmentSchema: z.ZodObject<{
+    runnerId: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    executionTarget: z.ZodOptional<z.ZodString>;
+    remoteInstanceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Attachment = z.infer<typeof AttachmentSchema>;
+/**
+ * Where an installed Workflow came from, as the runner's Workflow store
+ * records it: shipped with the CLI (`builtin`), installed from a remote
+ * marketplace (`marketplace-remote`, by ref), from a marketplace checkout on
+ * disk (`marketplace-local`), copied from a path (`filesystem`), or installed
+ * by a CLI that did not record a source (`unknown`).
+ */
+declare const InstalledWorkflowSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"builtin">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"marketplace-remote">;
+    ref: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"marketplace-local">;
+    repoDir: z.ZodString;
+    workflowName: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"filesystem">;
+    path: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"unknown">;
+}, z.core.$strip>], "kind">;
+type InstalledWorkflowSource = z.infer<typeof InstalledWorkflowSourceSchema>;
+/**
+ * One Workflow a runner can run: reported on the runner's `hello` and
+ * replaced wholesale by `workflows.changed` (protocol §17.4). `version` is
+ * absent when the Workflow declares none.
+ */
+declare const InstalledWorkflowSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"builtin">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"marketplace-remote">;
+        ref: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"marketplace-local">;
+        repoDir: z.ZodString;
+        workflowName: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"filesystem">;
+        path: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+    }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+type InstalledWorkflow = z.infer<typeof InstalledWorkflowSchema>;
+/** Why a runner declined a delivered assignment (protocol §10). */
+declare const AssignmentRejectedReasonSchema: z.ZodEnum<{
+    local_capacity: "local_capacity";
+    duplicate: "duplicate";
+    malformed_assignment: "malformed_assignment";
+    workspace_unresolved: "workspace_unresolved";
+    workspace_invalid: "workspace_invalid";
+}>;
+type AssignmentRejectedReason = z.infer<typeof AssignmentRejectedReasonSchema>;
+
+export { type AssignmentRejectedReason as A, type ExhaustedCap as E, type HardFailureCode as H, type InstalledWorkflow as I, type Run as R, type Turn as T, AssignmentRejectedReasonSchema as a, type Attachment as b, AttachmentSchema as c, ExhaustedCapSchema as d, HardFailureCodeSchema as e, InstalledWorkflowSchema as f, type InstalledWorkflowSource as g, InstalledWorkflowSourceSchema as h, type Interruption as i, InterruptionSchema as j, RunSchema as k, type RunSpec as l, RunSpecSchema as m, type RunStatus as n, RunStatusSchema as o, type RuntimeDecision as p, RuntimeDecisionSchema as q, type RuntimeIntent as r, RuntimeIntentSchema as s, type TurnContinuation as t, TurnContinuationSchema as u, type TurnOutcome as v, TurnOutcomeSchema as w, TurnSchema as x };