@drisp/protocol 0.6.0 → 0.6.2

package/dist/index.js

@@ -1,386 +1,220 @@
+import {
+  AssignmentRejectedReasonSchema,
+  AttachmentSchema,
+  ExhaustedCapSchema,
+  HardFailureCodeSchema,
+  InstalledWorkflowSchema,
+  InstalledWorkflowSourceSchema,
+  InterruptionSchema,
+  RunSchema,
+  RunSpecSchema,
+  RunStatusSchema,
+  RuntimeDecisionSchema,
+  RuntimeIntentSchema,
+  TurnContinuationSchema,
+  TurnOutcomeSchema,
+  TurnSchema
+} from "./chunk-HMYWICNI.js";
+
 // src/version.ts
 var PROTOCOL_VERSION = 1;
 
-// src/domain.ts
+// src/events.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({
+var RunStreamEventSchema = 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"
-]);
-
-// src/events.ts
-import { z as z2 } from "zod";
-var RunStreamEventSchema = z2.object({
-  runId: z2.string(),
   /** Runner-local order within the Run. */
-  seq: z2.int().nonnegative(),
-  ts: z2.number(),
-  kind: z2.string(),
-  payload: z2.unknown().optional()
-});
-var FeedEventLevelSchema = z2.enum(["debug", "info", "warn", "error"]);
-var FeedEventCauseSchema = z2.object({
-  parent_event_id: z2.string().optional(),
-  hook_request_id: z2.string().optional(),
-  tool_use_id: z2.string().optional(),
-  transcript_path: z2.string().optional()
-});
-var FeedEventSchema = z2.looseObject({
-  event_id: z2.string(),
-  seq: z2.int().nonnegative(),
-  ts: z2.number(),
-  session_id: z2.string(),
+  seq: z.int().nonnegative(),
+  ts: z.number(),
+  kind: z.string(),
+  payload: z.unknown().optional()
+});
+var FeedEventLevelSchema = z.enum(["debug", "info", "warn", "error"]);
+var FeedEventCauseSchema = z.object({
+  parent_event_id: z.string().optional(),
+  hook_request_id: z.string().optional(),
+  tool_use_id: z.string().optional(),
+  transcript_path: z.string().optional()
+});
+var FeedEventSchema = z.looseObject({
+  event_id: z.string(),
+  seq: z.int().nonnegative(),
+  ts: z.number(),
+  session_id: z.string(),
   /** A Feed Run id (`{session_id}:R{n}`) — unrelated to a Workflow Run id. */
-  run_id: z2.string(),
-  prompt_id: z2.string().optional(),
-  effort_level: z2.string().optional(),
-  kind: z2.string(),
+  run_id: z.string(),
+  prompt_id: z.string().optional(),
+  effort_level: z.string().optional(),
+  kind: z.string(),
   level: FeedEventLevelSchema,
-  actor_id: z2.string(),
+  actor_id: z.string(),
   cause: FeedEventCauseSchema.optional(),
-  title: z2.string(),
-  body: z2.string().optional(),
-  ui: z2.object({
-    collapsed_default: z2.boolean().optional(),
-    pin: z2.boolean().optional(),
-    badge: z2.string().optional()
+  title: z.string(),
+  body: z.string().optional(),
+  ui: z.object({
+    collapsed_default: z.boolean().optional(),
+    pin: z.boolean().optional(),
+    badge: z.string().optional()
   }).optional(),
-  display: z2.object({ title: z2.string().optional() }).optional(),
-  data: z2.unknown(),
-  raw: z2.unknown().optional()
+  display: z.object({ title: z.string().optional() }).optional(),
+  data: z.unknown(),
+  raw: z.unknown().optional()
 });
 var PHASE_FEED_EVENT_KIND = "phase";
-var PhaseEventSchema = z2.object({
+var PhaseEventSchema = z.object({
   /** The Workflow Run id (not a Feed Run id). */
-  runId: z2.string(),
+  runId: z.string(),
   /** 1-based Iteration of the Turn whose Journal named this step. */
-  turn: z2.int().positive(),
-  step: z2.string().min(1),
-  stepIndex: z2.int().positive().optional(),
-  stepTotal: z2.int().positive().optional()
+  turn: z.int().positive(),
+  step: z.string().min(1),
+  stepIndex: z.int().positive().optional(),
+  stepTotal: z.int().positive().optional()
 });
 var PhaseFeedEventSchema = FeedEventSchema.extend({
-  kind: z2.literal(PHASE_FEED_EVENT_KIND),
+  kind: z.literal(PHASE_FEED_EVENT_KIND),
   data: PhaseEventSchema
 });
-var FeedOriginSchema = z2.enum(["local", "dashboard"]);
-var FeedEnvelopeSchema = z2.object({
-  instanceId: z2.string(),
-  athenaSessionId: z2.string(),
-  runId: z2.string(),
+var FeedOriginSchema = z.enum(["local", "dashboard"]);
+var FeedEnvelopeSchema = z.object({
+  instanceId: z.string(),
+  athenaSessionId: z.string(),
+  runId: z.string(),
   origin: FeedOriginSchema,
-  eventId: z2.string(),
-  feedSeq: z2.int().nonnegative(),
-  emittedAt: z2.number(),
+  eventId: z.string(),
+  feedSeq: z.int().nonnegative(),
+  emittedAt: z.number(),
   feedEvent: FeedEventSchema
 });
 
 // src/frames.ts
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 var runStartBody = {
-  runId: z3.string(),
+  runId: z2.string(),
   runSpec: RunSpecSchema.optional(),
   /**
    * The runner this assignment is bound to — top-level so the CLI can route
    * to the right Attachment without inspecting `runSpec`. Absent from hubs
    * that use single-runtime semantics.
    */
-  runnerId: z3.string().optional()
+  runnerId: z2.string().optional()
 };
 var answerBody = {
-  athenaSessionId: z3.string(),
-  requestId: z3.string(),
+  athenaSessionId: z2.string(),
+  requestId: z2.string(),
   decision: RuntimeDecisionSchema
 };
 var stopBody = {
-  runId: z3.string(),
-  runnerId: z3.string().optional()
+  runId: z2.string(),
+  runnerId: z2.string().optional()
 };
-var PingFrameSchema = z3.object({
-  type: z3.literal("ping"),
-  ts: z3.number()
+var PingFrameSchema = z2.object({
+  type: z2.literal("ping"),
+  ts: z2.number()
 });
-var PongFrameSchema = z3.object({
-  type: z3.literal("pong"),
-  ts: z3.number()
+var PongFrameSchema = z2.object({
+  type: z2.literal("pong"),
+  ts: z2.number()
 });
-var AssignmentAcceptedFrameSchema = z3.object({
-  type: z3.literal("assignment_accepted"),
-  runId: z3.string()
+var AssignmentAcceptedFrameSchema = z2.object({
+  type: z2.literal("assignment_accepted"),
+  runId: z2.string()
 });
-var AssignmentRejectedFrameSchema = z3.object({
-  type: z3.literal("assignment_rejected"),
-  runId: z3.string(),
+var AssignmentRejectedFrameSchema = z2.object({
+  type: z2.literal("assignment_rejected"),
+  runId: z2.string(),
   reason: AssignmentRejectedReasonSchema,
-  message: z3.string().optional()
+  message: z2.string().optional()
 });
-var DecisionAckFrameSchema = z3.object({
-  type: z3.literal("decision_ack"),
-  athenaSessionId: z3.string(),
-  requestId: z3.string()
+var DecisionAckFrameSchema = z2.object({
+  type: z2.literal("decision_ack"),
+  athenaSessionId: z2.string(),
+  requestId: z2.string()
 });
-var FeedAckFrameSchema = z3.object({
-  type: z3.literal("feed_ack"),
-  deliverySeq: z3.int().nonnegative().optional(),
-  eventId: z3.string().optional()
+var FeedAckFrameSchema = z2.object({
+  type: z2.literal("feed_ack"),
+  deliverySeq: z2.int().nonnegative().optional(),
+  eventId: z2.string().optional()
 });
-var AttachmentsChangedFrameSchema = z3.object({
-  type: z3.literal("attachments.changed"),
-  attachments: z3.array(AttachmentSchema)
+var AttachmentsChangedFrameSchema = z2.object({
+  type: z2.literal("attachments.changed"),
+  attachments: z2.array(AttachmentSchema)
 });
-var ErrorFrameSchema = z3.object({
-  type: z3.literal("error"),
-  code: z3.string(),
-  message: z3.string().optional()
+var ErrorFrameSchema = z2.object({
+  type: z2.literal("error"),
+  code: z2.string(),
+  message: z2.string().optional()
 });
-var JobAssignmentFrameSchema = z3.object({
-  type: z3.literal("job_assignment"),
+var JobAssignmentFrameSchema = z2.object({
+  type: z2.literal("job_assignment"),
   ...runStartBody
 });
-var DashboardDecisionFrameSchema = z3.object({
-  type: z3.literal("dashboard_decision"),
+var DashboardDecisionFrameSchema = z2.object({
+  type: z2.literal("dashboard_decision"),
   ...answerBody
 });
-var CancelFrameSchema = z3.object({
-  type: z3.literal("cancel"),
+var CancelFrameSchema = z2.object({
+  type: z2.literal("cancel"),
   ...stopBody
 });
-var RunEventFrameSchema = z3.object({
-  type: z3.literal("run_event"),
+var RunEventFrameSchema = z2.object({
+  type: z2.literal("run_event"),
   ...RunStreamEventSchema.shape
 });
-var FeedEventFrameSchema = z3.object({
-  type: z3.literal("feed_event"),
+var FeedEventFrameSchema = z2.object({
+  type: z2.literal("feed_event"),
   /** Runner-local outbox order, used only for delivery retry. */
-  deliverySeq: z3.int().nonnegative(),
+  deliverySeq: z2.int().nonnegative(),
   envelope: FeedEnvelopeSchema
 });
-var HelloFrameSchema = z3.object({
-  type: z3.literal("hello"),
-  protocolVersion: z3.int().positive(),
-  role: z3.enum(["runner", "hub"]).optional(),
-  instanceId: z3.string().optional(),
-  agent: z3.object({ name: z3.string(), version: z3.string().optional() }).optional(),
-  capabilities: z3.array(z3.string()).optional(),
-  workflows: z3.array(InstalledWorkflowSchema).optional()
-});
-var WorkflowsChangedFrameSchema = z3.object({
-  type: z3.literal("workflows.changed"),
-  workflows: z3.array(InstalledWorkflowSchema)
-});
-var RunStartFrameSchema = z3.object({
-  type: z3.literal("run.start"),
+var HelloFrameSchema = z2.object({
+  type: z2.literal("hello"),
+  protocolVersion: z2.int().positive(),
+  role: z2.enum(["runner", "hub"]).optional(),
+  instanceId: z2.string().optional(),
+  agent: z2.object({ name: z2.string(), version: z2.string().optional() }).optional(),
+  capabilities: z2.array(z2.string()).optional(),
+  workflows: z2.array(InstalledWorkflowSchema).optional()
+});
+var WorkflowsChangedFrameSchema = z2.object({
+  type: z2.literal("workflows.changed"),
+  workflows: z2.array(InstalledWorkflowSchema)
+});
+var RunStartFrameSchema = z2.object({
+  type: z2.literal("run.start"),
   ...runStartBody
 });
-var AnswerFrameSchema = z3.object({
-  type: z3.literal("answer"),
+var AnswerFrameSchema = z2.object({
+  type: z2.literal("answer"),
   ...answerBody
 });
-var StopFrameSchema = z3.object({
-  type: z3.literal("stop"),
+var StopFrameSchema = z2.object({
+  type: z2.literal("stop"),
   ...stopBody
 });
-var SteerFrameSchema = z3.object({
-  type: z3.literal("steer"),
-  runId: z3.string(),
-  athenaSessionId: z3.string().optional(),
-  text: z3.string().min(1)
+var SteerFrameSchema = z2.object({
+  type: z2.literal("steer"),
+  runId: z2.string(),
+  athenaSessionId: z2.string().optional(),
+  text: z2.string().min(1)
 });
-var NeedsHumanFrameSchema = z3.object({
-  type: z3.literal("needs_human"),
-  runId: z3.string(),
-  athenaSessionId: z3.string().optional(),
+var NeedsHumanFrameSchema = z2.object({
+  type: z2.literal("needs_human"),
+  runId: z2.string(),
+  athenaSessionId: z2.string().optional(),
   interruption: InterruptionSchema
 });
-var RunStreamEventFrameSchema = z3.object({
-  type: z3.literal("event"),
-  stream: z3.literal("run"),
+var RunStreamEventFrameSchema = z2.object({
+  type: z2.literal("event"),
+  stream: z2.literal("run"),
   ...RunStreamEventSchema.shape
 });
-var FeedStreamEventFrameSchema = z3.object({
-  type: z3.literal("event"),
-  stream: z3.literal("feed"),
-  deliverySeq: z3.int().nonnegative(),
+var FeedStreamEventFrameSchema = z2.object({
+  type: z2.literal("event"),
+  stream: z2.literal("feed"),
+  deliverySeq: z2.int().nonnegative(),
   envelope: FeedEnvelopeSchema
 });
-var EventFrameSchema = z3.discriminatedUnion("stream", [
+var EventFrameSchema = z2.discriminatedUnion("stream", [
   RunStreamEventFrameSchema,
   FeedStreamEventFrameSchema
 ]);
@@ -394,7 +228,7 @@ var unchangedFrames = [
   AttachmentsChangedFrameSchema,
   ErrorFrameSchema
 ];
-var LegacyFrameSchema = z3.discriminatedUnion("type", [
+var LegacyFrameSchema = z2.discriminatedUnion("type", [
   JobAssignmentFrameSchema,
   DashboardDecisionFrameSchema,
   CancelFrameSchema,
@@ -402,7 +236,7 @@ var LegacyFrameSchema = z3.discriminatedUnion("type", [
   FeedEventFrameSchema,
   ...unchangedFrames
 ]);
-var CanonicalFrameSchema = z3.discriminatedUnion("type", [
+var CanonicalFrameSchema = z2.discriminatedUnion("type", [
   HelloFrameSchema,
   RunStartFrameSchema,
   AnswerFrameSchema,
@@ -413,7 +247,7 @@ var CanonicalFrameSchema = z3.discriminatedUnion("type", [
   EventFrameSchema,
   ...unchangedFrames
 ]);
-var FrameSchema = z3.discriminatedUnion("type", [
+var FrameSchema = z2.discriminatedUnion("type", [
   JobAssignmentFrameSchema,
   DashboardDecisionFrameSchema,
   CancelFrameSchema,
@@ -511,7 +345,7 @@ function toLegacyFrame(frame) {
 }
 
 // src/jsonSchema.ts
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 var JSON_SCHEMA_SOURCES = {
   frame: FrameSchema,
   "canonical-frame": CanonicalFrameSchema,
@@ -535,7 +369,7 @@ function jsonSchemaId(name) {
 function buildJsonSchemas() {
   const out = {};
   for (const name of Object.keys(JSON_SCHEMA_SOURCES)) {
-    const generated = z4.toJSONSchema(JSON_SCHEMA_SOURCES[name], {
+    const generated = z3.toJSONSchema(JSON_SCHEMA_SOURCES[name], {
       target: "draft-2020-12",
       unrepresentable: "any"
     });