@drisp/protocol 0.6.0 → 0.6.2

package/dist/v2.js

@@ -0,0 +1,613 @@
+import {
+  InstalledWorkflowSchema
+} from "./chunk-HMYWICNI.js";
+
+// src/v2.ts
+import { z } from "zod";
+
+// src/history.ts
+function readableHistory(records) {
+  const pending = /* @__PURE__ */ new Map();
+  const result = [];
+  for (const record of records) {
+    if (record.kind !== "history.fragment") {
+      result.push(record);
+      continue;
+    }
+    const value = record.data;
+    if (!value || value.version !== 1 || typeof value.eventId !== "string" || typeof value.kind !== "string" || typeof value.text !== "string" || !Number.isSafeInteger(value.index) || !Number.isSafeInteger(value.total))
+      continue;
+    const index = value.index, total = value.total;
+    if (total < 1 || total > 1024 || index < 0 || index >= total) continue;
+    if (index === 0) pending.set(value.eventId, { kind: value.kind, next: 0, total, text: "" });
+    const item = pending.get(value.eventId);
+    if (!item || item.next !== index || item.total !== total || item.kind !== value.kind) {
+      pending.delete(value.eventId);
+      continue;
+    }
+    item.text += value.text;
+    item.next++;
+    if (item.text.length > 16 * 1024 * 1024) {
+      pending.delete(value.eventId);
+      continue;
+    }
+    if (item.next === total) {
+      pending.delete(value.eventId);
+      try {
+        result.push({
+          ...record,
+          eventId: value.eventId,
+          kind: item.kind,
+          data: JSON.parse(item.text)
+        });
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+
+// src/v2.ts
+var protocolVersion = { major: 2, minor: 1 };
+var conversationContinuationCapability = "conversation_continuation";
+var abandonedConversationContinuationCapability = "abandoned_conversation_continuation";
+var repositoryAccessCapability = "repository_checkout_v1";
+var workflowInstallCapability = "workflow_install_v1";
+var secretEnvironmentSchema = z.record(
+  z.string().regex(/^(?:OPENAI_API_KEY|ANTHROPIC_API_KEY|CLAUDE_CODE_OAUTH_TOKEN|NPM_TOKEN|NODE_AUTH_TOKEN|PIP_INDEX_URL|PIP_EXTRA_INDEX_URL|UV_INDEX_URL|DRISP_TEST_[A-Z0-9_]+)$/),
+  z.string().regex(/^projects\/[a-zA-Z0-9-]+\/secrets\/[a-zA-Z0-9_-]+\/versions\/(?:latest|[0-9]+)$/)
+);
+var permissionAnswerSchema = z.strictObject({
+  kind: z.literal("permission"),
+  decision: z.enum(["allow", "deny"]),
+  reason: z.string().max(4096).optional()
+});
+var id = z.string().min(1).max(160);
+var sequence = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var positive = sequence.refine((n) => n > 0);
+var timestamp = z.iso.datetime();
+var scopeSchema = z.discriminatedUnion("visibility", [
+  z.strictObject({ visibility: z.literal("organization") }),
+  z.strictObject({ visibility: z.literal("private"), ownerUserId: id })
+]);
+var installedWorkflowsSchema = z.array(InstalledWorkflowSchema).max(256);
+var harnessSchema = z.enum(["claude-code", "codex"]);
+var harnessReadinessSchema = z.strictObject({ installed: z.boolean(), signedIn: z.boolean() });
+var runnerReadinessSchema = z.strictObject({
+  "claude-code": harnessReadinessSchema.optional(),
+  codex: harnessReadinessSchema.optional()
+});
+var harnessInstallCommands = {
+  "claude-code": "npm i -g @anthropic-ai/claude-code",
+  codex: "npm i -g @openai/codex"
+};
+var harnessSignInCommands = { "claude-code": "claude auth login", codex: "codex login" };
+function readinessFixCommand(harness, readiness) {
+  if (!readiness.installed) return harnessInstallCommands[harness];
+  if (!readiness.signedIn) return harnessSignInCommands[harness];
+  return void 0;
+}
+var runnerUpdateCommand = "npm i -g @drisp/cli";
+var interruptionSchema = z.strictObject({
+  interruptionId: id,
+  revision: positive,
+  kind: z.enum(["permission", "question", "guidance", "recovery"]),
+  message: z.string().max(16384),
+  requestId: id.optional()
+});
+var workflowIdentitySchema = z.strictObject({
+  name: z.string().min(1).max(128),
+  version: z.string().min(1).max(128).optional()
+});
+var factIdentity = {
+  runId: id,
+  attemptId: id,
+  executionRevision: positive,
+  emittedAt: timestamp
+};
+var controlRecordSchema = z.discriminatedUnion("kind", [
+  /** Instance-scoped, not tied to a Run: the full replacement inventory of installed Workflows. */
+  z.strictObject({ kind: z.literal("workflows.changed"), workflows: installedWorkflowsSchema }),
+  /** Instance-scoped, not tied to a Run: the Runner's full Readiness, sent when it changes after hello. */
+  z.strictObject({ kind: z.literal("readiness.changed"), readiness: runnerReadinessSchema }),
+  z.strictObject({ kind: z.literal("assignment.accepted"), runId: id, attemptId: id }),
+  z.strictObject({
+    kind: z.literal("assignment.rejected"),
+    runId: id,
+    attemptId: id,
+    reason: z.string().max(1024)
+  }),
+  z.strictObject({
+    kind: z.literal("run.started"),
+    ...factIdentity,
+    /** Absent from runners that predate Workflow reporting. */
+    workflow: workflowIdentitySchema.optional()
+  }),
+  z.strictObject({ kind: z.literal("run.resumed"), ...factIdentity }),
+  z.strictObject({
+    kind: z.literal("run.attention"),
+    ...factIdentity,
+    interruption: interruptionSchema,
+    occupancy: z.enum(["held", "released"]),
+    historyThrough: sequence,
+    continuation: z.discriminatedUnion("kind", [
+      z.strictObject({ kind: z.literal("live_request") }),
+      z.strictObject({ kind: z.literal("local_checkpoint"), checkpointId: id }),
+      z.strictObject({ kind: z.literal("portable_checkpoint"), checkpointId: id }),
+      z.strictObject({ kind: z.literal("repair_required"), detail: z.string().max(4096) })
+    ])
+  }),
+  z.strictObject({
+    kind: z.literal("run.finished"),
+    ...factIdentity,
+    status: z.enum(["completed", "failed", "cancelled"]),
+    historyThrough: sequence,
+    /** No setup/harness executed and no workspace was produced; safe to retire without export. */
+    workspaceUnavailable: z.literal(true).optional()
+  }),
+  z.strictObject({ kind: z.literal("command.applied"), runId: id, attemptId: id, commandId: id }),
+  z.strictObject({
+    kind: z.literal("command.rejected"),
+    runId: id,
+    attemptId: id,
+    commandId: id,
+    reason: z.string().max(1024)
+  }),
+  z.strictObject({ kind: z.literal("revoked_not_started"), runId: id, attemptId: id })
+]);
+var repositoryRefSchema = z.string().min(1).max(512).regex(
+  /^(?![-/])(?!.*\.\.)(?!.*@\{)(?!.*(?:^|\/)\.)(?!.*\.lock(?:\/|$))(?!.*\/\/)[^\x00-\x20\x7f~^:?*\[\\]+(?<![/.])$/
+);
+var repositoryWorkingDirectorySchema = z.string().min(1).max(1024).regex(
+  /^(?:\.|(?!\/)(?!.*(?:^|\/)\.\.?(?:\/|$))(?!.*(?:^|\/)\.git(?:\/|$))[^\x00-\x1f\x7f\\:]+(?<!\/))$/
+);
+var repositoryIdentity = {
+  repositoryId: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  installationId: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  owner: z.string().min(1).max(100).regex(/^[a-zA-Z0-9][a-zA-Z0-9-]*$/),
+  name: z.string().min(1).max(100).regex(/^(?!\.{1,2}$)[a-zA-Z0-9_.-]+$/)
+};
+var repositoryBindingSchema = z.strictObject({
+  id,
+  label: z.string().min(1).max(160),
+  ...repositoryIdentity,
+  defaultRef: repositoryRefSchema,
+  workingDirectory: repositoryWorkingDirectorySchema,
+  setupCommands: z.array(z.string().min(1).max(8192)).max(16),
+  revision: positive,
+  enabled: z.boolean()
+});
+var repositorySourceSchema = z.strictObject({
+  bindingId: id,
+  ...repositoryIdentity,
+  ref: repositoryRefSchema,
+  commitSha: z.string().regex(/^[0-9a-f]{40}$/),
+  branch: repositoryRefSchema,
+  workingDirectory: repositoryWorkingDirectorySchema,
+  setupCommands: z.array(z.string().min(1).max(8192)).max(16),
+  configRevision: positive
+});
+var workflowSourceSchema = z.string().max(201).regex(/^[A-Za-z0-9][A-Za-z0-9_.-]*\/[A-Za-z0-9][A-Za-z0-9_.-]*$/);
+var workflowReferenceSchema = z.union([
+  z.string().max(512),
+  z.strictObject({
+    name: z.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9_-]*$/),
+    source: workflowSourceSchema.optional(),
+    ref: z.string().min(1).max(512).optional(),
+    version: z.string().min(1).max(128).regex(/^\d[A-Za-z0-9_.+-]*$/).optional()
+  })
+]);
+var workflowName = (workflow) => typeof workflow === "object" ? workflow.name : workflow;
+var installReference = (workflow) => typeof workflow === "object" && workflow.source !== void 0 ? workflow : void 0;
+var sameWorkflow = (a, b) => canonicalJson(a ?? null) === canonicalJson(b ?? null);
+var runSpecSchema = z.strictObject({
+  prompt: z.string().min(1).max(131072),
+  projectDir: z.string().min(1).max(4096),
+  harness: harnessSchema,
+  workflow: workflowReferenceSchema.optional(),
+  repository: repositorySourceSchema.optional()
+});
+var commandSchema = z.strictObject({
+  commandId: id,
+  hubEpoch: id,
+  runId: id,
+  expectedRecordRevision: sequence.optional(),
+  intent: z.discriminatedUnion("kind", [
+    z.strictObject({
+      kind: z.literal("start"),
+      sessionId: id,
+      /**
+       * Absent: the Hub resolves the Runner member-first (root ADR-0005): the Session's conversation Runner, else
+       * the starting member's own ready Personal Runner, else the Team default, else the start is refused.
+       */
+      runnerId: id.optional(),
+      computeProfileId: id.optional(),
+      scope: scopeSchema,
+      spec: runSpecSchema
+    }),
+    z.strictObject({ kind: z.literal("cancel") }),
+    z.strictObject({ kind: z.literal("abandon") }),
+    z.strictObject({ kind: z.literal("steer"), text: z.string().min(1).max(131072) }),
+    z.strictObject({
+      kind: z.literal("answer"),
+      interruptionId: id,
+      expectedInterruptionRevision: positive,
+      requestId: id.optional(),
+      answer: z.json()
+    }),
+    z.strictObject({
+      kind: z.literal("resume"),
+      interruptionId: id,
+      guidance: z.string().max(131072).optional()
+    })
+  ])
+});
+var grantSchema = z.strictObject({
+  commandId: id,
+  hubEpoch: id,
+  runId: id,
+  sessionId: id,
+  runnerId: id,
+  installationId: id,
+  attemptId: id,
+  generation: positive,
+  baseExecutionRevision: sequence,
+  baseHistorySeq: sequence,
+  cloudHistoryThrough: sequence,
+  purpose: z.enum(["start", "resume"]),
+  spec: runSpecSchema,
+  continuation: z.json().optional(),
+  /** A new Run in a durable conversation; never resumes the predecessor's lifecycle. */
+  previousRun: z.strictObject({
+    runId: id,
+    executionRevision: sequence,
+    historyProduced: sequence,
+    /** Hub-confirmed administrative closure; allows an exact parked predecessor snapshot. */
+    closeReason: z.literal("abandoned").optional(),
+    checkpoint: z.strictObject({ checkpointId: id, checksum: z.string().regex(/^[a-f0-9]{64}$/) }).optional()
+  }).optional(),
+  checkpoint: z.strictObject({ checkpointId: id, checksum: z.string().regex(/^[a-f0-9]{64}$/) }).optional()
+});
+var historyRecordSchema = z.strictObject({
+  eventId: id,
+  attemptId: id,
+  emittedAt: timestamp,
+  kind: z.string().min(1).max(128),
+  data: z.json()
+});
+var runnerFrameSchema = z.discriminatedUnion("type", [
+  z.strictObject({
+    type: z.literal("hello"),
+    role: z.literal("runner"),
+    protocol: z.strictObject({ major: z.literal(2), minor: sequence }),
+    runnerId: id,
+    installationId: id,
+    softwareVersion: z.string().max(128),
+    capabilities: z.array(z.string().max(128)).max(64),
+    /** Absent from older runners: the Hub treats the inventory as unknown, never as empty. */
+    workflows: installedWorkflowsSchema.optional(),
+    /** Absent from older runners, and from a runner that has not finished its first check: unknown, not "not ready". */
+    readiness: runnerReadinessSchema.optional(),
+    control: z.strictObject({ firstRetainedSeq: positive, lastProducedSeq: sequence })
+  }),
+  z.strictObject({
+    type: z.literal("control.batch"),
+    firstSeq: positive,
+    records: z.array(controlRecordSchema).min(1).max(128)
+  }),
+  z.strictObject({
+    type: z.literal("history.batch"),
+    runId: id,
+    firstSeq: positive,
+    records: z.array(historyRecordSchema).min(1).max(128)
+  }),
+  z.strictObject({ type: z.literal("ping"), nonce: id }),
+  z.strictObject({
+    type: z.literal("reconcile.page"),
+    inventoryId: id.default("single-page"),
+    page: sequence.default(0),
+    complete: z.boolean(),
+    runs: z.array(
+      z.strictObject({
+        runId: id,
+        attemptId: id,
+        executionRevision: sequence,
+        phase: z.enum(["admitted", "prepared", "executing", "parked", "terminal", "recovery"])
+      })
+    ).max(128)
+  })
+]);
+var runViewSchema = z.object({
+  runId: id,
+  sessionId: id,
+  runnerId: id,
+  computeProfileId: id.optional(),
+  scope: scopeSchema,
+  recordRevision: positive,
+  label: z.string().max(160).optional(),
+  /** Resolved by the runner at start; absent until the Run starts and for runners that predate reporting. */
+  workflow: workflowIdentitySchema.optional(),
+  execution: z.object({
+    status: z.enum(["running", "awaiting_attention", "completed", "failed", "cancelled"]),
+    revision: positive,
+    attemptId: id,
+    occupancy: z.enum(["held", "released"]),
+    startedAt: timestamp.optional(),
+    endedAt: timestamp.optional(),
+    interruption: interruptionSchema.optional()
+  }).nullable(),
+  scheduling: z.enum(["queued", "dispatching", "admitted", "idle"]),
+  closed: z.boolean(),
+  closeReason: z.string().optional(),
+  cancellation: id.optional(),
+  pendingResume: commandSchema.shape.intent.optional(),
+  /** Derived per viewer; absent on older Hubs. Never grants execution authority. */
+  runnerStopped: z.boolean().optional(),
+  canAbandon: z.boolean().optional(),
+  historyThrough: sequence,
+  expectedHistoryThrough: sequence.optional(),
+  createdAt: sequence,
+  checkpoint: z.object({ id, state: z.enum(["pending", "ready"]), checksum: z.string().optional() }).optional()
+});
+var clientFrameSchema = z.discriminatedUnion("type", [
+  z.strictObject({ type: z.literal("watch"), hubEpoch: id, runIds: z.array(id).max(100) }),
+  z.strictObject({ type: z.literal("watch.ack"), subscriptionId: id, through: sequence }),
+  z.strictObject({ type: z.literal("command.submit"), command: commandSchema }),
+  z.strictObject({ type: z.literal("ping"), nonce: id })
+]);
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object") {
+    const encoded = JSON.stringify(value);
+    if (encoded === void 0) throw new Error("Non-JSON value");
+    return encoded;
+  }
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
+}
+var checkpointPathSchema = z.string().min(1).max(4096).refine(
+  (path) => !path.startsWith("/") && !path.includes("\\") && path.split("/").every((part) => part !== "" && part !== "." && part !== ".." && part !== ".git")
+);
+var checkpointSchema = z.strictObject({
+  version: z.literal(1),
+  checkpointId: z.string().min(1),
+  orgId: z.string().min(1),
+  phase: z.enum(["parked", "terminal"]),
+  runId: z.string().min(1),
+  sessionId: z.string().min(1),
+  sourceAttemptId: z.string().min(1),
+  executionRevision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  historyProduced: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  historyAck: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  grant: grantSchema,
+  gitHead: z.string().regex(/^[0-9a-f]{40,64}$/),
+  gitBase: z.string().regex(/^[0-9a-f]{40,64}$/).optional(),
+  gitBundle: z.string(),
+  indexPatch: z.string(),
+  files: z.array(
+    z.strictObject({ path: checkpointPathSchema, content: z.string(), executable: z.boolean() })
+  ).max(1e5),
+  deleted: z.array(checkpointPathSchema).max(1e5),
+  sessionRows: z.array(z.strictObject({ kind: z.string(), id: z.string(), payload: z.string() })),
+  history: z.array(
+    z.strictObject({ seq: z.number().int().positive(), record: historyRecordSchema })
+  )
+});
+var connectCodeAlphabet = "ABCDEFGHJKMNPQRSTUVWXYZ23456789";
+var connectCodeSchema = z.string().regex(/^[A-HJKMNP-Z2-9]{8}$/);
+var connectCodeRequestSchema = z.strictObject({ hubEpoch: z.string() });
+var connectCodeResponseSchema = z.strictObject({
+  code: connectCodeSchema,
+  expiresAt: sequence
+});
+var connectRedeemRequestSchema = z.strictObject({
+  code: z.string().min(8).max(16),
+  installationId: id,
+  hostname: z.string().min(1).max(255),
+  os: z.string().min(1).max(64),
+  softwareVersion: z.string().min(1).max(128)
+});
+var connectRedeemResponseSchema = z.strictObject({
+  orgId: id,
+  hubEpoch: z.string(),
+  runnerId: id,
+  installationId: id,
+  name: z.string(),
+  token: z.string().min(32),
+  credentialId: id,
+  expiresAt: sequence
+});
+var connectAlreadyConnectedSchema = z.strictObject({
+  error: z.literal("runner_already_connected"),
+  orgId: id,
+  runnerId: id,
+  name: z.string()
+});
+var audienceSchema = z.enum(["personal", "team"]);
+var runnerListEntrySchema = z.object({
+  id,
+  online: z.number(),
+  capacity: z.number(),
+  managed: z.number(),
+  draining: z.number(),
+  stopped: z.number(),
+  name: z.string().nullable(),
+  connectedBy: z.string().nullable(),
+  audience: audienceSchema.nullable(),
+  softwareVersion: z.string().nullable(),
+  /** Milliseconds since the epoch of the last hello or disconnect; null before the first connection. */
+  lastSeen: sequence.nullable(),
+  /** Absent when the runner has not reported an inventory: unknown, not none. */
+  workflows: installedWorkflowsSchema.optional(),
+  /**
+   * True when the viewer may not rename it, change its capacity or change its Audience: a teammate's Personal
+   * Runner seen by an admin (who may still Disconnect it), or a Runner a member did not connect. Absent from Hubs
+   * older than Audience, like the list's `viewer`, `teamDefault` and `runsGoTo`.
+   */
+  readOnly: z.boolean().optional(),
+  /** What the Runner last reported; absent when it never has (an older runner, or one not yet connected). */
+  readiness: runnerReadinessSchema.optional(),
+  /**
+   * True when the Runner reported a version below the Hub's minimum: it is listed as "Update required" and takes no
+   * Runs until it is updated (`runnerUpdateCommand`). Absent from Hubs older than Readiness.
+   */
+  updateRequired: z.boolean().optional(),
+  /**
+   * True while it is paused as "Needs an owner": the member who connected this Team Runner left the Team, so it
+   * takes no Runs until an admin adopts it (`/runners/{id}/adopt`) or Disconnects it. Absent from older Hubs.
+   */
+  needsOwner: z.boolean().optional()
+});
+var teamDefaultSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("runner"), runnerId: id }),
+  z.strictObject({ kind: z.literal("profile"), profileId: id })
+]);
+var teamDefaultRequestSchema = z.strictObject({
+  hubEpoch: z.string(),
+  teamDefault: teamDefaultSchema.nullable()
+});
+var runnerUpdateRequestSchema = z.strictObject({
+  hubEpoch: z.string(),
+  name: z.string().max(100).optional(),
+  capacity: z.number().int().min(1).max(64).optional(),
+  audience: audienceSchema.optional()
+}).refine(
+  (update) => update.name !== void 0 || update.capacity !== void 0 || update.audience !== void 0,
+  { message: "nothing to update" }
+);
+var runsGoToSchema = z.union([
+  /** The viewer's own Runner: Personal, or one they connected that was widened to Team (DRI-42). */
+  z.strictObject({ via: z.literal("personal"), runnerId: id }),
+  z.strictObject({ via: z.literal("team_default"), runnerId: id }),
+  z.strictObject({ via: z.literal("team_default"), profileId: id }),
+  /** `runner_needs_owner`: the Team default is a Runner paused because the member who connected it left. */
+  z.strictObject({ via: z.literal("none"), reason: z.enum(["no_runner_available", "runner_needs_owner"]) })
+]);
+var runnerListSchema = z.object({
+  capabilities: z.record(z.string(), z.boolean()).optional(),
+  historyRetentionDays: z.number().int().positive().nullable().optional(),
+  /** Who the list was filtered for: a member sees their own and Team Runners, an admin every Runner. */
+  viewer: z.object({ userId: z.string(), admin: z.boolean() }).optional(),
+  teamDefault: teamDefaultSchema.nullable().optional(),
+  runsGoTo: runsGoToSchema.optional(),
+  /** The lowest Runner version this Hub sends Runs to. Absent from Hubs older than Readiness. */
+  minimumRunnerVersion: z.string().optional(),
+  runners: z.array(runnerListEntrySchema),
+  profiles: z.array(z.object({
+    id: z.string(),
+    label: z.string(),
+    projectDir: z.string(),
+    repositoryRequired: z.boolean().optional(),
+    /** Marketplace refs baked into the profile's image; absent when the profile declares none. */
+    workflows: z.array(z.string()).optional(),
+    workflowSources: z.array(z.string()).optional()
+  }))
+});
+var runnerDisconnectRequestSchema = z.strictObject({ hubEpoch: z.string() });
+var hubEpochRequestSchema = runnerDisconnectRequestSchema;
+var runnerDisconnectPreviewSchema = z.object({
+  runnerId: id,
+  name: z.string().nullable(),
+  runs: z.array(z.object({
+    runId: id,
+    label: z.string().optional(),
+    /** Working: executing now. Parked: waiting for a person, Runner released. Queued: not started yet. */
+    state: z.enum(["working", "parked", "queued"])
+  })),
+  hiddenRuns: z.number().int().nonnegative()
+});
+var runnerDisconnectResponseSchema = z.object({
+  disconnected: z.literal(true),
+  /** How many Runs were Stopped with the reason `runner_disconnected`. */
+  stoppedRuns: z.number().int().nonnegative()
+});
+var runnerAdoptRequestSchema = hubEpochRequestSchema;
+var connectStartRequestSchema = connectRedeemRequestSchema.omit({ code: true });
+var connectStartResponseSchema = z.strictObject({
+  /** The machine's secret for polling; never shown. */
+  deviceCode: z.string().min(32).max(160),
+  code: connectCodeSchema,
+  expiresAt: sequence,
+  intervalSec: z.number().int().positive(),
+  /** The web console page that approves `code`. */
+  verificationUrl: z.string().url()
+});
+var connectPollRequestSchema = z.strictObject({ deviceCode: z.string().min(32).max(160) });
+var connectPendingResponseSchema = z.strictObject({
+  hostname: z.string(),
+  os: z.string(),
+  softwareVersion: z.string(),
+  requestedAt: sequence,
+  expiresAt: sequence
+});
+var connectApproveRequestSchema = z.strictObject({
+  code: z.string().min(8).max(16),
+  audience: audienceSchema,
+  hubEpoch: z.string().optional()
+});
+var connectDenyRequestSchema = z.strictObject({ code: z.string().min(8).max(16) });
+export {
+  abandonedConversationContinuationCapability,
+  audienceSchema,
+  canonicalJson,
+  checkpointPathSchema,
+  checkpointSchema,
+  clientFrameSchema,
+  commandSchema,
+  connectAlreadyConnectedSchema,
+  connectApproveRequestSchema,
+  connectCodeAlphabet,
+  connectCodeRequestSchema,
+  connectCodeResponseSchema,
+  connectCodeSchema,
+  connectDenyRequestSchema,
+  connectPendingResponseSchema,
+  connectPollRequestSchema,
+  connectRedeemRequestSchema,
+  connectRedeemResponseSchema,
+  connectStartRequestSchema,
+  connectStartResponseSchema,
+  controlRecordSchema,
+  conversationContinuationCapability,
+  grantSchema,
+  harnessReadinessSchema,
+  harnessSchema,
+  historyRecordSchema,
+  hubEpochRequestSchema,
+  installReference,
+  installedWorkflowsSchema,
+  interruptionSchema,
+  permissionAnswerSchema,
+  protocolVersion,
+  readableHistory,
+  readinessFixCommand,
+  repositoryAccessCapability,
+  repositoryBindingSchema,
+  repositoryRefSchema,
+  repositorySourceSchema,
+  repositoryWorkingDirectorySchema,
+  runSpecSchema,
+  runViewSchema,
+  runnerAdoptRequestSchema,
+  runnerDisconnectPreviewSchema,
+  runnerDisconnectRequestSchema,
+  runnerDisconnectResponseSchema,
+  runnerFrameSchema,
+  runnerListEntrySchema,
+  runnerListSchema,
+  runnerReadinessSchema,
+  runnerUpdateCommand,
+  runnerUpdateRequestSchema,
+  runsGoToSchema,
+  sameWorkflow,
+  scopeSchema,
+  secretEnvironmentSchema,
+  sequence,
+  teamDefaultRequestSchema,
+  teamDefaultSchema,
+  workflowIdentitySchema,
+  workflowInstallCapability,
+  workflowName,
+  workflowReferenceSchema,
+  workflowSourceSchema
+};
+//# sourceMappingURL=v2.js.map