@h-rig/contracts 0.0.6-alpha.0

package/dist/src/server.js

@@ -0,0 +1,1053 @@
+// @bun
+// packages/contracts/src/server.ts
+import { Schema as Schema6 } from "effect";
+
+// packages/contracts/src/baseSchemas.ts
+import { Schema } from "effect";
+var TrimmedString = Schema.Trim;
+var TrimmedNonEmptyString = TrimmedString.check(Schema.isNonEmpty());
+var NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+var PositiveInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1));
+var IsoDateTime = Schema.String;
+var makeEntityId = (brand) => TrimmedNonEmptyString.pipe(Schema.brand(brand));
+var ThreadId = makeEntityId("ThreadId");
+var ProjectId = makeEntityId("ProjectId");
+var WorkspaceId = makeEntityId("WorkspaceId");
+var GraphId = makeEntityId("GraphId");
+var TaskId = makeEntityId("TaskId");
+var RunId = makeEntityId("RunId");
+var EngineRuntimeId = makeEntityId("EngineRuntimeId");
+var ConversationId = makeEntityId("ConversationId");
+var ActionId = makeEntityId("ActionId");
+var ArtifactId = makeEntityId("ArtifactId");
+var WorktreeId = makeEntityId("WorktreeId");
+var ValidationResultId = makeEntityId("ValidationResultId");
+var ReviewResultId = makeEntityId("ReviewResultId");
+var CommandId = makeEntityId("CommandId");
+var EventId = makeEntityId("EventId");
+var MessageId = makeEntityId("MessageId");
+var TurnId = makeEntityId("TurnId");
+var ProviderItemId = makeEntityId("ProviderItemId");
+var RuntimeSessionId = makeEntityId("RuntimeSessionId");
+var RuntimeItemId = makeEntityId("RuntimeItemId");
+var RuntimeRequestId = makeEntityId("RuntimeRequestId");
+var RuntimeTaskId = makeEntityId("RuntimeTaskId");
+var ApprovalRequestId = makeEntityId("ApprovalRequestId");
+var CheckpointRef = makeEntityId("CheckpointRef");
+var RemoteEndpointId = makeEntityId("RemoteEndpointId");
+
+// packages/contracts/src/keybindings.ts
+import { Schema as Schema2 } from "effect";
+var MAX_KEYBINDING_VALUE_LENGTH = 64;
+var MAX_KEYBINDING_WHEN_LENGTH = 256;
+var MAX_SCRIPT_ID_LENGTH = 24;
+var MAX_KEYBINDINGS_COUNT = 256;
+var STATIC_KEYBINDING_COMMANDS = [
+  "terminal.toggle",
+  "terminal.split",
+  "terminal.new",
+  "terminal.close",
+  "diff.toggle",
+  "chat.new",
+  "chat.newLocal",
+  "editor.openFavorite"
+];
+var SCRIPT_RUN_COMMAND_PATTERN = Schema2.TemplateLiteral([
+  Schema2.Literal("script."),
+  Schema2.NonEmptyString.check(Schema2.isMaxLength(MAX_SCRIPT_ID_LENGTH), Schema2.isPattern(/^[a-z0-9][a-z0-9-]*$/)),
+  Schema2.Literal(".run")
+]);
+var KeybindingCommand = Schema2.Union([
+  Schema2.Literals(STATIC_KEYBINDING_COMMANDS),
+  SCRIPT_RUN_COMMAND_PATTERN
+]);
+var KeybindingValue = TrimmedString.check(Schema2.isMinLength(1), Schema2.isMaxLength(MAX_KEYBINDING_VALUE_LENGTH));
+var KeybindingWhen = TrimmedString.check(Schema2.isMinLength(1), Schema2.isMaxLength(MAX_KEYBINDING_WHEN_LENGTH));
+var KeybindingRule = Schema2.Struct({
+  key: KeybindingValue,
+  command: KeybindingCommand,
+  when: Schema2.optional(KeybindingWhen)
+});
+var KeybindingsConfig = Schema2.Array(KeybindingRule).check(Schema2.isMaxLength(MAX_KEYBINDINGS_COUNT));
+var KeybindingShortcut = Schema2.Struct({
+  key: KeybindingValue,
+  metaKey: Schema2.Boolean,
+  ctrlKey: Schema2.Boolean,
+  shiftKey: Schema2.Boolean,
+  altKey: Schema2.Boolean,
+  modKey: Schema2.Boolean
+});
+var KeybindingWhenNode = Schema2.Union([
+  Schema2.Struct({
+    type: Schema2.Literal("identifier"),
+    name: Schema2.NonEmptyString
+  }),
+  Schema2.Struct({
+    type: Schema2.Literal("not"),
+    node: Schema2.suspend(() => KeybindingWhenNode)
+  }),
+  Schema2.Struct({
+    type: Schema2.Literal("and"),
+    left: Schema2.suspend(() => KeybindingWhenNode),
+    right: Schema2.suspend(() => KeybindingWhenNode)
+  }),
+  Schema2.Struct({
+    type: Schema2.Literal("or"),
+    left: Schema2.suspend(() => KeybindingWhenNode),
+    right: Schema2.suspend(() => KeybindingWhenNode)
+  })
+]);
+var ResolvedKeybindingRule = Schema2.Struct({
+  command: KeybindingCommand,
+  shortcut: KeybindingShortcut,
+  whenAst: Schema2.optional(KeybindingWhenNode)
+}).annotate({ parseOptions: { onExcessProperty: "ignore" } });
+var ResolvedKeybindingsConfig = Schema2.Array(ResolvedKeybindingRule).check(Schema2.isMaxLength(MAX_KEYBINDINGS_COUNT));
+
+// packages/contracts/src/editor.ts
+import { Schema as Schema3 } from "effect";
+var EDITORS = [
+  { id: "cursor", label: "Cursor", command: "cursor" },
+  { id: "vscode", label: "VS Code", command: "code" },
+  { id: "zed", label: "Zed", command: "zed" },
+  { id: "file-manager", label: "File Manager", command: null }
+];
+var EditorId = Schema3.Literals(EDITORS.map((e) => e.id));
+var OpenInEditorInput = Schema3.Struct({
+  cwd: TrimmedNonEmptyString,
+  editor: EditorId
+});
+
+// packages/contracts/src/orchestration.ts
+import { Option, Schema as Schema5, SchemaIssue, Struct } from "effect";
+
+// packages/contracts/src/model.ts
+import { Schema as Schema4 } from "effect";
+var CODEX_REASONING_EFFORT_OPTIONS = ["xhigh", "high", "medium", "low"];
+var CodexModelOptions = Schema4.Struct({
+  reasoningEffort: Schema4.optional(Schema4.Literals(CODEX_REASONING_EFFORT_OPTIONS)),
+  fastMode: Schema4.optional(Schema4.Boolean)
+});
+var ClaudeModelOptions = Schema4.Struct({});
+var ProviderModelOptions = Schema4.Struct({
+  codex: Schema4.optional(CodexModelOptions),
+  claude: Schema4.optional(ClaudeModelOptions)
+});
+
+// packages/contracts/src/orchestration.ts
+var ProviderKind = Schema5.Literals(["codex", "claude"]);
+var ProviderApprovalPolicy = Schema5.Literals([
+  "untrusted",
+  "on-failure",
+  "on-request",
+  "never"
+]);
+var ProviderSandboxMode = Schema5.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var ProviderServiceTier = Schema5.Literals(["fast", "flex"]);
+var RuntimeMode = Schema5.Literals(["approval-required", "full-access"]);
+var DEFAULT_RUNTIME_MODE = "full-access";
+var ProviderInteractionMode = Schema5.Literals(["default", "plan"]);
+var DEFAULT_PROVIDER_INTERACTION_MODE = "default";
+var ProviderRequestKind = Schema5.Literals(["command", "file-read", "file-change"]);
+var AssistantDeliveryMode = Schema5.Literals(["buffered", "streaming"]);
+var ProviderApprovalDecision = Schema5.Literals([
+  "accept",
+  "acceptForSession",
+  "decline",
+  "cancel"
+]);
+var ProviderUserInputAnswers = Schema5.Record(Schema5.String, Schema5.Unknown);
+var PROVIDER_SEND_TURN_MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS = 14000000;
+var CHAT_ATTACHMENT_ID_MAX_CHARS = 128;
+var ChatAttachmentId = TrimmedNonEmptyString.check(Schema5.isMaxLength(CHAT_ATTACHMENT_ID_MAX_CHARS), Schema5.isPattern(/^[a-z0-9_-]+$/i));
+var ChatImageAttachment = Schema5.Struct({
+  type: Schema5.Literal("image"),
+  id: ChatAttachmentId,
+  name: TrimmedNonEmptyString.check(Schema5.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema5.isMaxLength(100), Schema5.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema5.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES))
+});
+var UploadChatImageAttachment = Schema5.Struct({
+  type: Schema5.Literal("image"),
+  name: TrimmedNonEmptyString.check(Schema5.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema5.isMaxLength(100), Schema5.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema5.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES)),
+  dataUrl: TrimmedNonEmptyString.check(Schema5.isMaxLength(PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS))
+});
+var ChatAttachment = Schema5.Union([ChatImageAttachment]);
+var UploadChatAttachment = Schema5.Union([UploadChatImageAttachment]);
+var ProjectScriptIcon = Schema5.Literals([
+  "play",
+  "test",
+  "lint",
+  "configure",
+  "build",
+  "debug"
+]);
+var ProjectScript = Schema5.Struct({
+  id: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  command: TrimmedNonEmptyString,
+  icon: ProjectScriptIcon,
+  runOnWorktreeCreate: Schema5.Boolean
+});
+var OrchestrationProject = Schema5.Struct({
+  id: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema5.NullOr(TrimmedNonEmptyString),
+  scripts: Schema5.Array(ProjectScript),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  deletedAt: Schema5.NullOr(IsoDateTime)
+});
+var OrchestrationMessageRole = Schema5.Literals(["user", "assistant", "system"]);
+var OrchestrationMessage = Schema5.Struct({
+  id: MessageId,
+  role: OrchestrationMessageRole,
+  text: Schema5.String,
+  attachments: Schema5.optional(Schema5.Array(ChatAttachment)),
+  turnId: Schema5.NullOr(TurnId),
+  streaming: Schema5.Boolean,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var OrchestrationProposedPlanId = TrimmedNonEmptyString;
+var OrchestrationProposedPlan = Schema5.Struct({
+  id: OrchestrationProposedPlanId,
+  turnId: Schema5.NullOr(TurnId),
+  planMarkdown: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var OrchestrationSessionStatus = Schema5.Literals([
+  "idle",
+  "starting",
+  "running",
+  "ready",
+  "interrupted",
+  "stopped",
+  "error"
+]);
+var OrchestrationSession = Schema5.Struct({
+  threadId: ThreadId,
+  status: OrchestrationSessionStatus,
+  providerName: Schema5.NullOr(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode.pipe(Schema5.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  activeTurnId: Schema5.NullOr(TurnId),
+  lastError: Schema5.NullOr(TrimmedNonEmptyString),
+  updatedAt: IsoDateTime
+});
+var OrchestrationCheckpointFile = Schema5.Struct({
+  path: TrimmedNonEmptyString,
+  kind: TrimmedNonEmptyString,
+  additions: NonNegativeInt,
+  deletions: NonNegativeInt
+});
+var OrchestrationCheckpointStatus = Schema5.Literals(["ready", "missing", "error"]);
+var OrchestrationCheckpointSummary = Schema5.Struct({
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema5.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema5.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var OrchestrationThreadActivityTone = Schema5.Literals([
+  "info",
+  "tool",
+  "approval",
+  "error"
+]);
+var OrchestrationThreadActivity = Schema5.Struct({
+  id: EventId,
+  tone: OrchestrationThreadActivityTone,
+  kind: TrimmedNonEmptyString,
+  summary: TrimmedNonEmptyString,
+  payload: Schema5.Unknown,
+  turnId: Schema5.NullOr(TurnId),
+  sequence: Schema5.optional(NonNegativeInt),
+  createdAt: IsoDateTime
+});
+var OrchestrationLatestTurnState = Schema5.Literals([
+  "running",
+  "interrupted",
+  "completed",
+  "error"
+]);
+var OrchestrationLatestTurn = Schema5.Struct({
+  turnId: TurnId,
+  state: OrchestrationLatestTurnState,
+  requestedAt: IsoDateTime,
+  startedAt: Schema5.NullOr(IsoDateTime),
+  completedAt: Schema5.NullOr(IsoDateTime),
+  assistantMessageId: Schema5.NullOr(MessageId)
+});
+var OrchestrationThread = Schema5.Struct({
+  id: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode.pipe(Schema5.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema5.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema5.NullOr(TrimmedNonEmptyString),
+  latestTurn: Schema5.NullOr(OrchestrationLatestTurn),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  deletedAt: Schema5.NullOr(IsoDateTime),
+  messages: Schema5.Array(OrchestrationMessage),
+  proposedPlans: Schema5.Array(OrchestrationProposedPlan).pipe(Schema5.withDecodingDefault(() => [])),
+  activities: Schema5.Array(OrchestrationThreadActivity),
+  checkpoints: Schema5.Array(OrchestrationCheckpointSummary),
+  session: Schema5.NullOr(OrchestrationSession)
+});
+var OrchestrationReadModel = Schema5.Struct({
+  snapshotSequence: NonNegativeInt,
+  projects: Schema5.Array(OrchestrationProject),
+  threads: Schema5.Array(OrchestrationThread),
+  updatedAt: IsoDateTime
+});
+var ProjectCreateCommand = Schema5.Struct({
+  type: Schema5.Literal("project.create"),
+  commandId: CommandId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema5.optional(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var ProjectMetaUpdateCommand = Schema5.Struct({
+  type: Schema5.Literal("project.meta.update"),
+  commandId: CommandId,
+  projectId: ProjectId,
+  title: Schema5.optional(TrimmedNonEmptyString),
+  workspaceRoot: Schema5.optional(TrimmedNonEmptyString),
+  defaultModel: Schema5.optional(TrimmedNonEmptyString),
+  scripts: Schema5.optional(Schema5.Array(ProjectScript))
+});
+var ProjectDeleteCommand = Schema5.Struct({
+  type: Schema5.Literal("project.delete"),
+  commandId: CommandId,
+  projectId: ProjectId
+});
+var ThreadCreateCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.create"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode.pipe(Schema5.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema5.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema5.NullOr(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var ThreadDeleteCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.delete"),
+  commandId: CommandId,
+  threadId: ThreadId
+});
+var ThreadMetaUpdateCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.meta.update"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  title: Schema5.optional(TrimmedNonEmptyString),
+  model: Schema5.optional(TrimmedNonEmptyString),
+  branch: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  worktreePath: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString))
+});
+var ThreadRuntimeModeSetCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.runtime-mode.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  runtimeMode: RuntimeMode,
+  createdAt: IsoDateTime
+});
+var ThreadInteractionModeSetCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.interaction-mode.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  interactionMode: ProviderInteractionMode,
+  createdAt: IsoDateTime
+});
+var ThreadTurnStartCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.turn.start"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  message: Schema5.Struct({
+    messageId: MessageId,
+    role: Schema5.Literal("user"),
+    text: Schema5.String,
+    attachments: Schema5.Array(ChatAttachment)
+  }),
+  provider: Schema5.optional(ProviderKind),
+  model: Schema5.optional(TrimmedNonEmptyString),
+  serviceTier: Schema5.optional(Schema5.NullOr(ProviderServiceTier)),
+  modelOptions: Schema5.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema5.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode.pipe(Schema5.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema5.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  createdAt: IsoDateTime
+});
+var ClientThreadTurnStartCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.turn.start"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  message: Schema5.Struct({
+    messageId: MessageId,
+    role: Schema5.Literal("user"),
+    text: Schema5.String,
+    attachments: Schema5.Array(UploadChatAttachment)
+  }),
+  provider: Schema5.optional(ProviderKind),
+  model: Schema5.optional(TrimmedNonEmptyString),
+  serviceTier: Schema5.optional(Schema5.NullOr(ProviderServiceTier)),
+  modelOptions: Schema5.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema5.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  createdAt: IsoDateTime
+});
+var ThreadTurnInterruptCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.turn.interrupt"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnId: Schema5.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadApprovalRespondCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.approval.respond"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision,
+  createdAt: IsoDateTime
+});
+var ThreadUserInputRespondCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.user-input.respond"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers,
+  createdAt: IsoDateTime
+});
+var ThreadCheckpointRevertCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.checkpoint.revert"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadSessionStopCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.session.stop"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  createdAt: IsoDateTime
+});
+var DispatchableClientOrchestrationCommand = Schema5.Union([
+  ProjectCreateCommand,
+  ProjectMetaUpdateCommand,
+  ProjectDeleteCommand,
+  ThreadCreateCommand,
+  ThreadDeleteCommand,
+  ThreadMetaUpdateCommand,
+  ThreadRuntimeModeSetCommand,
+  ThreadInteractionModeSetCommand,
+  ThreadTurnStartCommand,
+  ThreadTurnInterruptCommand,
+  ThreadApprovalRespondCommand,
+  ThreadUserInputRespondCommand,
+  ThreadCheckpointRevertCommand,
+  ThreadSessionStopCommand
+]);
+var ClientOrchestrationCommand = Schema5.Union([
+  ProjectCreateCommand,
+  ProjectMetaUpdateCommand,
+  ProjectDeleteCommand,
+  ThreadCreateCommand,
+  ThreadDeleteCommand,
+  ThreadMetaUpdateCommand,
+  ThreadRuntimeModeSetCommand,
+  ThreadInteractionModeSetCommand,
+  ClientThreadTurnStartCommand,
+  ThreadTurnInterruptCommand,
+  ThreadApprovalRespondCommand,
+  ThreadUserInputRespondCommand,
+  ThreadCheckpointRevertCommand,
+  ThreadSessionStopCommand
+]);
+var ThreadSessionSetCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.session.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  session: OrchestrationSession,
+  createdAt: IsoDateTime
+});
+var ThreadMessageAssistantDeltaCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.message.assistant.delta"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  messageId: MessageId,
+  delta: Schema5.String,
+  turnId: Schema5.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadMessageAssistantCompleteCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.message.assistant.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  messageId: MessageId,
+  turnId: Schema5.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadProposedPlanUpsertCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.proposed-plan.upsert"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  proposedPlan: OrchestrationProposedPlan,
+  createdAt: IsoDateTime
+});
+var ThreadTurnDiffCompleteCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.turn.diff.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnId: TurnId,
+  completedAt: IsoDateTime,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema5.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema5.optional(MessageId),
+  checkpointTurnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadActivityAppendCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.activity.append"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  activity: OrchestrationThreadActivity,
+  createdAt: IsoDateTime
+});
+var ThreadRevertCompleteCommand = Schema5.Struct({
+  type: Schema5.Literal("thread.revert.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var InternalOrchestrationCommand = Schema5.Union([
+  ThreadSessionSetCommand,
+  ThreadMessageAssistantDeltaCommand,
+  ThreadMessageAssistantCompleteCommand,
+  ThreadProposedPlanUpsertCommand,
+  ThreadTurnDiffCompleteCommand,
+  ThreadActivityAppendCommand,
+  ThreadRevertCompleteCommand
+]);
+var OrchestrationCommand = Schema5.Union([
+  DispatchableClientOrchestrationCommand,
+  InternalOrchestrationCommand
+]);
+var OrchestrationEventType = Schema5.Literals([
+  "project.created",
+  "project.meta-updated",
+  "project.deleted",
+  "thread.created",
+  "thread.deleted",
+  "thread.meta-updated",
+  "thread.runtime-mode-set",
+  "thread.interaction-mode-set",
+  "thread.message-sent",
+  "thread.turn-start-requested",
+  "thread.turn-interrupt-requested",
+  "thread.approval-response-requested",
+  "thread.user-input-response-requested",
+  "thread.checkpoint-revert-requested",
+  "thread.reverted",
+  "thread.session-stop-requested",
+  "thread.session-set",
+  "thread.proposed-plan-upserted",
+  "thread.turn-diff-completed",
+  "thread.activity-appended"
+]);
+var OrchestrationAggregateKind = Schema5.Literals(["project", "thread"]);
+var OrchestrationActorKind = Schema5.Literals(["client", "server", "provider"]);
+var ProjectCreatedPayload = Schema5.Struct({
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema5.NullOr(TrimmedNonEmptyString),
+  scripts: Schema5.Array(ProjectScript),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ProjectMetaUpdatedPayload = Schema5.Struct({
+  projectId: ProjectId,
+  title: Schema5.optional(TrimmedNonEmptyString),
+  workspaceRoot: Schema5.optional(TrimmedNonEmptyString),
+  defaultModel: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  scripts: Schema5.optional(Schema5.Array(ProjectScript)),
+  updatedAt: IsoDateTime
+});
+var ProjectDeletedPayload = Schema5.Struct({
+  projectId: ProjectId,
+  deletedAt: IsoDateTime
+});
+var ThreadCreatedPayload = Schema5.Struct({
+  threadId: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode.pipe(Schema5.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema5.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema5.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema5.NullOr(TrimmedNonEmptyString),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ThreadDeletedPayload = Schema5.Struct({
+  threadId: ThreadId,
+  deletedAt: IsoDateTime
+});
+var ThreadMetaUpdatedPayload = Schema5.Struct({
+  threadId: ThreadId,
+  title: Schema5.optional(TrimmedNonEmptyString),
+  model: Schema5.optional(TrimmedNonEmptyString),
+  branch: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  worktreePath: Schema5.optional(Schema5.NullOr(TrimmedNonEmptyString)),
+  updatedAt: IsoDateTime
+});
+var ThreadRuntimeModeSetPayload = Schema5.Struct({
+  threadId: ThreadId,
+  runtimeMode: RuntimeMode,
+  updatedAt: IsoDateTime
+});
+var ThreadInteractionModeSetPayload = Schema5.Struct({
+  threadId: ThreadId,
+  interactionMode: ProviderInteractionMode.pipe(Schema5.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  updatedAt: IsoDateTime
+});
+var ThreadMessageSentPayload = Schema5.Struct({
+  threadId: ThreadId,
+  messageId: MessageId,
+  role: OrchestrationMessageRole,
+  text: Schema5.String,
+  attachments: Schema5.optional(Schema5.Array(ChatAttachment)),
+  turnId: Schema5.NullOr(TurnId),
+  streaming: Schema5.Boolean,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ThreadTurnStartRequestedPayload = Schema5.Struct({
+  threadId: ThreadId,
+  messageId: MessageId,
+  provider: Schema5.optional(ProviderKind),
+  model: Schema5.optional(TrimmedNonEmptyString),
+  serviceTier: Schema5.optional(Schema5.NullOr(ProviderServiceTier)),
+  modelOptions: Schema5.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema5.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode.pipe(Schema5.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema5.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  createdAt: IsoDateTime
+});
+var ThreadTurnInterruptRequestedPayload = Schema5.Struct({
+  threadId: ThreadId,
+  turnId: Schema5.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadApprovalResponseRequestedPayload = Schema5.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision,
+  createdAt: IsoDateTime
+});
+var ThreadUserInputResponseRequestedPayload = Schema5.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers,
+  createdAt: IsoDateTime
+});
+var ThreadCheckpointRevertRequestedPayload = Schema5.Struct({
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadRevertedPayload = Schema5.Struct({
+  threadId: ThreadId,
+  turnCount: NonNegativeInt
+});
+var ThreadSessionStopRequestedPayload = Schema5.Struct({
+  threadId: ThreadId,
+  createdAt: IsoDateTime
+});
+var ThreadSessionSetPayload = Schema5.Struct({
+  threadId: ThreadId,
+  session: OrchestrationSession
+});
+var ThreadProposedPlanUpsertedPayload = Schema5.Struct({
+  threadId: ThreadId,
+  proposedPlan: OrchestrationProposedPlan
+});
+var ThreadTurnDiffCompletedPayload = Schema5.Struct({
+  threadId: ThreadId,
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema5.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema5.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var ThreadActivityAppendedPayload = Schema5.Struct({
+  threadId: ThreadId,
+  activity: OrchestrationThreadActivity
+});
+var OrchestrationEventMetadata = Schema5.Struct({
+  providerTurnId: Schema5.optional(TrimmedNonEmptyString),
+  providerItemId: Schema5.optional(ProviderItemId),
+  adapterKey: Schema5.optional(TrimmedNonEmptyString),
+  requestId: Schema5.optional(ApprovalRequestId),
+  ingestedAt: Schema5.optional(IsoDateTime)
+});
+var EventBaseFields = {
+  sequence: NonNegativeInt,
+  eventId: EventId,
+  aggregateKind: OrchestrationAggregateKind,
+  aggregateId: Schema5.Union([ProjectId, ThreadId]),
+  occurredAt: IsoDateTime,
+  commandId: Schema5.NullOr(CommandId),
+  causationEventId: Schema5.NullOr(EventId),
+  correlationId: Schema5.NullOr(CommandId),
+  metadata: OrchestrationEventMetadata
+};
+var PersistedEventBaseFields = {
+  sequence: NonNegativeInt,
+  eventId: EventId,
+  aggregateKind: OrchestrationAggregateKind,
+  streamId: Schema5.Union([ProjectId, ThreadId]),
+  streamVersion: NonNegativeInt,
+  occurredAt: IsoDateTime,
+  commandId: Schema5.NullOr(CommandId),
+  causationEventId: Schema5.NullOr(EventId),
+  correlationId: Schema5.NullOr(CommandId),
+  actorKind: OrchestrationActorKind,
+  metadata: OrchestrationEventMetadata
+};
+var OrchestrationEvent = Schema5.Union([
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("project.created"),
+    payload: ProjectCreatedPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("project.meta-updated"),
+    payload: ProjectMetaUpdatedPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("project.deleted"),
+    payload: ProjectDeletedPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.created"),
+    payload: ThreadCreatedPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.deleted"),
+    payload: ThreadDeletedPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.meta-updated"),
+    payload: ThreadMetaUpdatedPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.runtime-mode-set"),
+    payload: ThreadRuntimeModeSetPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.interaction-mode-set"),
+    payload: ThreadInteractionModeSetPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.message-sent"),
+    payload: ThreadMessageSentPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.turn-start-requested"),
+    payload: ThreadTurnStartRequestedPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.turn-interrupt-requested"),
+    payload: ThreadTurnInterruptRequestedPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.approval-response-requested"),
+    payload: ThreadApprovalResponseRequestedPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.user-input-response-requested"),
+    payload: ThreadUserInputResponseRequestedPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.checkpoint-revert-requested"),
+    payload: ThreadCheckpointRevertRequestedPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.reverted"),
+    payload: ThreadRevertedPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.session-stop-requested"),
+    payload: ThreadSessionStopRequestedPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.session-set"),
+    payload: ThreadSessionSetPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.proposed-plan-upserted"),
+    payload: ThreadProposedPlanUpsertedPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.turn-diff-completed"),
+    payload: ThreadTurnDiffCompletedPayload
+  }),
+  Schema5.Struct({
+    ...EventBaseFields,
+    type: Schema5.Literal("thread.activity-appended"),
+    payload: ThreadActivityAppendedPayload
+  })
+]);
+var OrchestrationPersistedEvent = Schema5.Union([
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("project.created"),
+    payload: ProjectCreatedPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("project.meta-updated"),
+    payload: ProjectMetaUpdatedPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("project.deleted"),
+    payload: ProjectDeletedPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.created"),
+    payload: ThreadCreatedPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.deleted"),
+    payload: ThreadDeletedPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.meta-updated"),
+    payload: ThreadMetaUpdatedPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.runtime-mode-set"),
+    payload: ThreadRuntimeModeSetPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.interaction-mode-set"),
+    payload: ThreadInteractionModeSetPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.message-sent"),
+    payload: ThreadMessageSentPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.turn-start-requested"),
+    payload: ThreadTurnStartRequestedPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.turn-interrupt-requested"),
+    payload: ThreadTurnInterruptRequestedPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.approval-response-requested"),
+    payload: ThreadApprovalResponseRequestedPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.user-input-response-requested"),
+    payload: ThreadUserInputResponseRequestedPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.checkpoint-revert-requested"),
+    payload: ThreadCheckpointRevertRequestedPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.reverted"),
+    payload: ThreadRevertedPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.session-stop-requested"),
+    payload: ThreadSessionStopRequestedPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.session-set"),
+    payload: ThreadSessionSetPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.proposed-plan-upserted"),
+    payload: ThreadProposedPlanUpsertedPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.turn-diff-completed"),
+    payload: ThreadTurnDiffCompletedPayload
+  }),
+  Schema5.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema5.Literal("thread.activity-appended"),
+    payload: ThreadActivityAppendedPayload
+  })
+]);
+var OrchestrationCommandReceiptStatus = Schema5.Literals(["accepted", "rejected"]);
+var TurnCountRange = Schema5.Struct({
+  fromTurnCount: NonNegativeInt,
+  toTurnCount: NonNegativeInt
+}).check(Schema5.makeFilter((input) => input.fromTurnCount <= input.toTurnCount || new SchemaIssue.InvalidValue(Option.some(input.fromTurnCount), {
+  message: "fromTurnCount must be less than or equal to toTurnCount"
+}), { identifier: "OrchestrationTurnDiffRange" }));
+var ThreadTurnDiff = TurnCountRange.mapFields(Struct.assign({
+  threadId: ThreadId,
+  diff: Schema5.String
+}), { unsafePreserveChecks: true });
+var ProviderSessionRuntimeStatus = Schema5.Literals([
+  "starting",
+  "running",
+  "stopped",
+  "error"
+]);
+var ProjectionThreadTurnStatus = Schema5.Literals([
+  "running",
+  "completed",
+  "interrupted",
+  "error"
+]);
+var ProjectionCheckpointRow = Schema5.Struct({
+  threadId: ThreadId,
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema5.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema5.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var ProjectionPendingApprovalStatus = Schema5.Literals(["pending", "resolved"]);
+var ProjectionPendingApprovalDecision = Schema5.NullOr(ProviderApprovalDecision);
+var DispatchResult = Schema5.Struct({
+  sequence: NonNegativeInt
+});
+var OrchestrationGetSnapshotInput = Schema5.Struct({});
+var OrchestrationGetTurnDiffInput = TurnCountRange.mapFields(Struct.assign({ threadId: ThreadId }), { unsafePreserveChecks: true });
+var OrchestrationGetFullThreadDiffInput = Schema5.Struct({
+  threadId: ThreadId,
+  toTurnCount: NonNegativeInt
+});
+var OrchestrationReplayEventsInput = Schema5.Struct({
+  fromSequenceExclusive: NonNegativeInt
+});
+var OrchestrationReplayEventsResult = Schema5.Array(OrchestrationEvent);
+
+// packages/contracts/src/server.ts
+var KeybindingsMalformedConfigIssue = Schema6.Struct({
+  kind: Schema6.Literal("keybindings.malformed-config"),
+  message: TrimmedNonEmptyString
+});
+var KeybindingsInvalidEntryIssue = Schema6.Struct({
+  kind: Schema6.Literal("keybindings.invalid-entry"),
+  message: TrimmedNonEmptyString,
+  index: Schema6.Number
+});
+var ServerConfigIssue = Schema6.Union([
+  KeybindingsMalformedConfigIssue,
+  KeybindingsInvalidEntryIssue
+]);
+var ServerConfigIssues = Schema6.Array(ServerConfigIssue);
+var ServerProviderStatusState = Schema6.Literals(["ready", "warning", "error"]);
+var ServerProviderAuthStatus = Schema6.Literals([
+  "authenticated",
+  "unauthenticated",
+  "unknown"
+]);
+var ServerProviderStatus = Schema6.Struct({
+  provider: ProviderKind,
+  status: ServerProviderStatusState,
+  available: Schema6.Boolean,
+  authStatus: ServerProviderAuthStatus,
+  checkedAt: IsoDateTime,
+  message: Schema6.optional(TrimmedNonEmptyString)
+});
+var ServerProviderStatuses = Schema6.Array(ServerProviderStatus);
+var ServerConfig = Schema6.Struct({
+  cwd: TrimmedNonEmptyString,
+  rigRoot: Schema6.NullOr(TrimmedNonEmptyString),
+  keybindingsConfigPath: TrimmedNonEmptyString,
+  keybindings: ResolvedKeybindingsConfig,
+  issues: ServerConfigIssues,
+  providers: ServerProviderStatuses,
+  availableEditors: Schema6.Array(EditorId)
+});
+var ServerUpsertKeybindingInput = KeybindingRule;
+var ServerUpsertKeybindingResult = Schema6.Struct({
+  keybindings: ResolvedKeybindingsConfig,
+  issues: ServerConfigIssues
+});
+var ServerConfigUpdatedPayload = Schema6.Struct({
+  issues: ServerConfigIssues,
+  providers: ServerProviderStatuses
+});
+export {
+  ServerUpsertKeybindingResult,
+  ServerUpsertKeybindingInput,
+  ServerProviderStatusState,
+  ServerProviderStatus,
+  ServerProviderAuthStatus,
+  ServerConfigUpdatedPayload,
+  ServerConfigIssue,
+  ServerConfig
+};