@h-rig/contracts 0.0.6-alpha.0

package/dist/src/providerRuntime.js

@@ -0,0 +1,1630 @@
+// @bun
+// packages/contracts/src/providerRuntime.ts
+import { Schema as Schema4 } 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/orchestration.ts
+import { Option, Schema as Schema3, SchemaIssue, Struct } from "effect";
+
+// packages/contracts/src/model.ts
+import { Schema as Schema2 } from "effect";
+var CODEX_REASONING_EFFORT_OPTIONS = ["xhigh", "high", "medium", "low"];
+var CodexModelOptions = Schema2.Struct({
+  reasoningEffort: Schema2.optional(Schema2.Literals(CODEX_REASONING_EFFORT_OPTIONS)),
+  fastMode: Schema2.optional(Schema2.Boolean)
+});
+var ClaudeModelOptions = Schema2.Struct({});
+var ProviderModelOptions = Schema2.Struct({
+  codex: Schema2.optional(CodexModelOptions),
+  claude: Schema2.optional(ClaudeModelOptions)
+});
+
+// packages/contracts/src/orchestration.ts
+var ProviderKind = Schema3.Literals(["codex", "claude"]);
+var ProviderApprovalPolicy = Schema3.Literals([
+  "untrusted",
+  "on-failure",
+  "on-request",
+  "never"
+]);
+var ProviderSandboxMode = Schema3.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var ProviderServiceTier = Schema3.Literals(["fast", "flex"]);
+var RuntimeMode = Schema3.Literals(["approval-required", "full-access"]);
+var DEFAULT_RUNTIME_MODE = "full-access";
+var ProviderInteractionMode = Schema3.Literals(["default", "plan"]);
+var DEFAULT_PROVIDER_INTERACTION_MODE = "default";
+var ProviderRequestKind = Schema3.Literals(["command", "file-read", "file-change"]);
+var AssistantDeliveryMode = Schema3.Literals(["buffered", "streaming"]);
+var ProviderApprovalDecision = Schema3.Literals([
+  "accept",
+  "acceptForSession",
+  "decline",
+  "cancel"
+]);
+var ProviderUserInputAnswers = Schema3.Record(Schema3.String, Schema3.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(Schema3.isMaxLength(CHAT_ATTACHMENT_ID_MAX_CHARS), Schema3.isPattern(/^[a-z0-9_-]+$/i));
+var ChatImageAttachment = Schema3.Struct({
+  type: Schema3.Literal("image"),
+  id: ChatAttachmentId,
+  name: TrimmedNonEmptyString.check(Schema3.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema3.isMaxLength(100), Schema3.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema3.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES))
+});
+var UploadChatImageAttachment = Schema3.Struct({
+  type: Schema3.Literal("image"),
+  name: TrimmedNonEmptyString.check(Schema3.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema3.isMaxLength(100), Schema3.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema3.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES)),
+  dataUrl: TrimmedNonEmptyString.check(Schema3.isMaxLength(PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS))
+});
+var ChatAttachment = Schema3.Union([ChatImageAttachment]);
+var UploadChatAttachment = Schema3.Union([UploadChatImageAttachment]);
+var ProjectScriptIcon = Schema3.Literals([
+  "play",
+  "test",
+  "lint",
+  "configure",
+  "build",
+  "debug"
+]);
+var ProjectScript = Schema3.Struct({
+  id: TrimmedNonEmptyString,
+  name: TrimmedNonEmptyString,
+  command: TrimmedNonEmptyString,
+  icon: ProjectScriptIcon,
+  runOnWorktreeCreate: Schema3.Boolean
+});
+var OrchestrationProject = Schema3.Struct({
+  id: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema3.NullOr(TrimmedNonEmptyString),
+  scripts: Schema3.Array(ProjectScript),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  deletedAt: Schema3.NullOr(IsoDateTime)
+});
+var OrchestrationMessageRole = Schema3.Literals(["user", "assistant", "system"]);
+var OrchestrationMessage = Schema3.Struct({
+  id: MessageId,
+  role: OrchestrationMessageRole,
+  text: Schema3.String,
+  attachments: Schema3.optional(Schema3.Array(ChatAttachment)),
+  turnId: Schema3.NullOr(TurnId),
+  streaming: Schema3.Boolean,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var OrchestrationProposedPlanId = TrimmedNonEmptyString;
+var OrchestrationProposedPlan = Schema3.Struct({
+  id: OrchestrationProposedPlanId,
+  turnId: Schema3.NullOr(TurnId),
+  planMarkdown: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var OrchestrationSessionStatus = Schema3.Literals([
+  "idle",
+  "starting",
+  "running",
+  "ready",
+  "interrupted",
+  "stopped",
+  "error"
+]);
+var OrchestrationSession = Schema3.Struct({
+  threadId: ThreadId,
+  status: OrchestrationSessionStatus,
+  providerName: Schema3.NullOr(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  activeTurnId: Schema3.NullOr(TurnId),
+  lastError: Schema3.NullOr(TrimmedNonEmptyString),
+  updatedAt: IsoDateTime
+});
+var OrchestrationCheckpointFile = Schema3.Struct({
+  path: TrimmedNonEmptyString,
+  kind: TrimmedNonEmptyString,
+  additions: NonNegativeInt,
+  deletions: NonNegativeInt
+});
+var OrchestrationCheckpointStatus = Schema3.Literals(["ready", "missing", "error"]);
+var OrchestrationCheckpointSummary = Schema3.Struct({
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema3.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema3.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var OrchestrationThreadActivityTone = Schema3.Literals([
+  "info",
+  "tool",
+  "approval",
+  "error"
+]);
+var OrchestrationThreadActivity = Schema3.Struct({
+  id: EventId,
+  tone: OrchestrationThreadActivityTone,
+  kind: TrimmedNonEmptyString,
+  summary: TrimmedNonEmptyString,
+  payload: Schema3.Unknown,
+  turnId: Schema3.NullOr(TurnId),
+  sequence: Schema3.optional(NonNegativeInt),
+  createdAt: IsoDateTime
+});
+var OrchestrationLatestTurnState = Schema3.Literals([
+  "running",
+  "interrupted",
+  "completed",
+  "error"
+]);
+var OrchestrationLatestTurn = Schema3.Struct({
+  turnId: TurnId,
+  state: OrchestrationLatestTurnState,
+  requestedAt: IsoDateTime,
+  startedAt: Schema3.NullOr(IsoDateTime),
+  completedAt: Schema3.NullOr(IsoDateTime),
+  assistantMessageId: Schema3.NullOr(MessageId)
+});
+var OrchestrationThread = Schema3.Struct({
+  id: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema3.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema3.NullOr(TrimmedNonEmptyString),
+  latestTurn: Schema3.NullOr(OrchestrationLatestTurn),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  deletedAt: Schema3.NullOr(IsoDateTime),
+  messages: Schema3.Array(OrchestrationMessage),
+  proposedPlans: Schema3.Array(OrchestrationProposedPlan).pipe(Schema3.withDecodingDefault(() => [])),
+  activities: Schema3.Array(OrchestrationThreadActivity),
+  checkpoints: Schema3.Array(OrchestrationCheckpointSummary),
+  session: Schema3.NullOr(OrchestrationSession)
+});
+var OrchestrationReadModel = Schema3.Struct({
+  snapshotSequence: NonNegativeInt,
+  projects: Schema3.Array(OrchestrationProject),
+  threads: Schema3.Array(OrchestrationThread),
+  updatedAt: IsoDateTime
+});
+var ProjectCreateCommand = Schema3.Struct({
+  type: Schema3.Literal("project.create"),
+  commandId: CommandId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema3.optional(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var ProjectMetaUpdateCommand = Schema3.Struct({
+  type: Schema3.Literal("project.meta.update"),
+  commandId: CommandId,
+  projectId: ProjectId,
+  title: Schema3.optional(TrimmedNonEmptyString),
+  workspaceRoot: Schema3.optional(TrimmedNonEmptyString),
+  defaultModel: Schema3.optional(TrimmedNonEmptyString),
+  scripts: Schema3.optional(Schema3.Array(ProjectScript))
+});
+var ProjectDeleteCommand = Schema3.Struct({
+  type: Schema3.Literal("project.delete"),
+  commandId: CommandId,
+  projectId: ProjectId
+});
+var ThreadCreateCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.create"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema3.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema3.NullOr(TrimmedNonEmptyString),
+  createdAt: IsoDateTime
+});
+var ThreadDeleteCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.delete"),
+  commandId: CommandId,
+  threadId: ThreadId
+});
+var ThreadMetaUpdateCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.meta.update"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  title: Schema3.optional(TrimmedNonEmptyString),
+  model: Schema3.optional(TrimmedNonEmptyString),
+  branch: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  worktreePath: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString))
+});
+var ThreadRuntimeModeSetCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.runtime-mode.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  runtimeMode: RuntimeMode,
+  createdAt: IsoDateTime
+});
+var ThreadInteractionModeSetCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.interaction-mode.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  interactionMode: ProviderInteractionMode,
+  createdAt: IsoDateTime
+});
+var ThreadTurnStartCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.turn.start"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  message: Schema3.Struct({
+    messageId: MessageId,
+    role: Schema3.Literal("user"),
+    text: Schema3.String,
+    attachments: Schema3.Array(ChatAttachment)
+  }),
+  provider: Schema3.optional(ProviderKind),
+  model: Schema3.optional(TrimmedNonEmptyString),
+  serviceTier: Schema3.optional(Schema3.NullOr(ProviderServiceTier)),
+  modelOptions: Schema3.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema3.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  createdAt: IsoDateTime
+});
+var ClientThreadTurnStartCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.turn.start"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  message: Schema3.Struct({
+    messageId: MessageId,
+    role: Schema3.Literal("user"),
+    text: Schema3.String,
+    attachments: Schema3.Array(UploadChatAttachment)
+  }),
+  provider: Schema3.optional(ProviderKind),
+  model: Schema3.optional(TrimmedNonEmptyString),
+  serviceTier: Schema3.optional(Schema3.NullOr(ProviderServiceTier)),
+  modelOptions: Schema3.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema3.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  createdAt: IsoDateTime
+});
+var ThreadTurnInterruptCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.turn.interrupt"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnId: Schema3.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadApprovalRespondCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.approval.respond"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision,
+  createdAt: IsoDateTime
+});
+var ThreadUserInputRespondCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.user-input.respond"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers,
+  createdAt: IsoDateTime
+});
+var ThreadCheckpointRevertCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.checkpoint.revert"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadSessionStopCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.session.stop"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  createdAt: IsoDateTime
+});
+var DispatchableClientOrchestrationCommand = Schema3.Union([
+  ProjectCreateCommand,
+  ProjectMetaUpdateCommand,
+  ProjectDeleteCommand,
+  ThreadCreateCommand,
+  ThreadDeleteCommand,
+  ThreadMetaUpdateCommand,
+  ThreadRuntimeModeSetCommand,
+  ThreadInteractionModeSetCommand,
+  ThreadTurnStartCommand,
+  ThreadTurnInterruptCommand,
+  ThreadApprovalRespondCommand,
+  ThreadUserInputRespondCommand,
+  ThreadCheckpointRevertCommand,
+  ThreadSessionStopCommand
+]);
+var ClientOrchestrationCommand = Schema3.Union([
+  ProjectCreateCommand,
+  ProjectMetaUpdateCommand,
+  ProjectDeleteCommand,
+  ThreadCreateCommand,
+  ThreadDeleteCommand,
+  ThreadMetaUpdateCommand,
+  ThreadRuntimeModeSetCommand,
+  ThreadInteractionModeSetCommand,
+  ClientThreadTurnStartCommand,
+  ThreadTurnInterruptCommand,
+  ThreadApprovalRespondCommand,
+  ThreadUserInputRespondCommand,
+  ThreadCheckpointRevertCommand,
+  ThreadSessionStopCommand
+]);
+var ThreadSessionSetCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.session.set"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  session: OrchestrationSession,
+  createdAt: IsoDateTime
+});
+var ThreadMessageAssistantDeltaCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.message.assistant.delta"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  messageId: MessageId,
+  delta: Schema3.String,
+  turnId: Schema3.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadMessageAssistantCompleteCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.message.assistant.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  messageId: MessageId,
+  turnId: Schema3.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadProposedPlanUpsertCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.proposed-plan.upsert"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  proposedPlan: OrchestrationProposedPlan,
+  createdAt: IsoDateTime
+});
+var ThreadTurnDiffCompleteCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.turn.diff.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnId: TurnId,
+  completedAt: IsoDateTime,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema3.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema3.optional(MessageId),
+  checkpointTurnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadActivityAppendCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.activity.append"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  activity: OrchestrationThreadActivity,
+  createdAt: IsoDateTime
+});
+var ThreadRevertCompleteCommand = Schema3.Struct({
+  type: Schema3.Literal("thread.revert.complete"),
+  commandId: CommandId,
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var InternalOrchestrationCommand = Schema3.Union([
+  ThreadSessionSetCommand,
+  ThreadMessageAssistantDeltaCommand,
+  ThreadMessageAssistantCompleteCommand,
+  ThreadProposedPlanUpsertCommand,
+  ThreadTurnDiffCompleteCommand,
+  ThreadActivityAppendCommand,
+  ThreadRevertCompleteCommand
+]);
+var OrchestrationCommand = Schema3.Union([
+  DispatchableClientOrchestrationCommand,
+  InternalOrchestrationCommand
+]);
+var OrchestrationEventType = Schema3.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 = Schema3.Literals(["project", "thread"]);
+var OrchestrationActorKind = Schema3.Literals(["client", "server", "provider"]);
+var ProjectCreatedPayload = Schema3.Struct({
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  workspaceRoot: TrimmedNonEmptyString,
+  defaultModel: Schema3.NullOr(TrimmedNonEmptyString),
+  scripts: Schema3.Array(ProjectScript),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ProjectMetaUpdatedPayload = Schema3.Struct({
+  projectId: ProjectId,
+  title: Schema3.optional(TrimmedNonEmptyString),
+  workspaceRoot: Schema3.optional(TrimmedNonEmptyString),
+  defaultModel: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  scripts: Schema3.optional(Schema3.Array(ProjectScript)),
+  updatedAt: IsoDateTime
+});
+var ProjectDeletedPayload = Schema3.Struct({
+  projectId: ProjectId,
+  deletedAt: IsoDateTime
+});
+var ThreadCreatedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  projectId: ProjectId,
+  title: TrimmedNonEmptyString,
+  model: TrimmedNonEmptyString,
+  runtimeMode: RuntimeMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  branch: Schema3.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema3.NullOr(TrimmedNonEmptyString),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ThreadDeletedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  deletedAt: IsoDateTime
+});
+var ThreadMetaUpdatedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  title: Schema3.optional(TrimmedNonEmptyString),
+  model: Schema3.optional(TrimmedNonEmptyString),
+  branch: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  worktreePath: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  updatedAt: IsoDateTime
+});
+var ThreadRuntimeModeSetPayload = Schema3.Struct({
+  threadId: ThreadId,
+  runtimeMode: RuntimeMode,
+  updatedAt: IsoDateTime
+});
+var ThreadInteractionModeSetPayload = Schema3.Struct({
+  threadId: ThreadId,
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  updatedAt: IsoDateTime
+});
+var ThreadMessageSentPayload = Schema3.Struct({
+  threadId: ThreadId,
+  messageId: MessageId,
+  role: OrchestrationMessageRole,
+  text: Schema3.String,
+  attachments: Schema3.optional(Schema3.Array(ChatAttachment)),
+  turnId: Schema3.NullOr(TurnId),
+  streaming: Schema3.Boolean,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var ThreadTurnStartRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  messageId: MessageId,
+  provider: Schema3.optional(ProviderKind),
+  model: Schema3.optional(TrimmedNonEmptyString),
+  serviceTier: Schema3.optional(Schema3.NullOr(ProviderServiceTier)),
+  modelOptions: Schema3.optional(ProviderModelOptions),
+  assistantDeliveryMode: Schema3.optional(AssistantDeliveryMode),
+  runtimeMode: RuntimeMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema3.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  createdAt: IsoDateTime
+});
+var ThreadTurnInterruptRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  turnId: Schema3.optional(TurnId),
+  createdAt: IsoDateTime
+});
+var ThreadApprovalResponseRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  decision: ProviderApprovalDecision,
+  createdAt: IsoDateTime
+});
+var ThreadUserInputResponseRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  requestId: ApprovalRequestId,
+  answers: ProviderUserInputAnswers,
+  createdAt: IsoDateTime
+});
+var ThreadCheckpointRevertRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  turnCount: NonNegativeInt,
+  createdAt: IsoDateTime
+});
+var ThreadRevertedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  turnCount: NonNegativeInt
+});
+var ThreadSessionStopRequestedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  createdAt: IsoDateTime
+});
+var ThreadSessionSetPayload = Schema3.Struct({
+  threadId: ThreadId,
+  session: OrchestrationSession
+});
+var ThreadProposedPlanUpsertedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  proposedPlan: OrchestrationProposedPlan
+});
+var ThreadTurnDiffCompletedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema3.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema3.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var ThreadActivityAppendedPayload = Schema3.Struct({
+  threadId: ThreadId,
+  activity: OrchestrationThreadActivity
+});
+var OrchestrationEventMetadata = Schema3.Struct({
+  providerTurnId: Schema3.optional(TrimmedNonEmptyString),
+  providerItemId: Schema3.optional(ProviderItemId),
+  adapterKey: Schema3.optional(TrimmedNonEmptyString),
+  requestId: Schema3.optional(ApprovalRequestId),
+  ingestedAt: Schema3.optional(IsoDateTime)
+});
+var EventBaseFields = {
+  sequence: NonNegativeInt,
+  eventId: EventId,
+  aggregateKind: OrchestrationAggregateKind,
+  aggregateId: Schema3.Union([ProjectId, ThreadId]),
+  occurredAt: IsoDateTime,
+  commandId: Schema3.NullOr(CommandId),
+  causationEventId: Schema3.NullOr(EventId),
+  correlationId: Schema3.NullOr(CommandId),
+  metadata: OrchestrationEventMetadata
+};
+var PersistedEventBaseFields = {
+  sequence: NonNegativeInt,
+  eventId: EventId,
+  aggregateKind: OrchestrationAggregateKind,
+  streamId: Schema3.Union([ProjectId, ThreadId]),
+  streamVersion: NonNegativeInt,
+  occurredAt: IsoDateTime,
+  commandId: Schema3.NullOr(CommandId),
+  causationEventId: Schema3.NullOr(EventId),
+  correlationId: Schema3.NullOr(CommandId),
+  actorKind: OrchestrationActorKind,
+  metadata: OrchestrationEventMetadata
+};
+var OrchestrationEvent = Schema3.Union([
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("project.created"),
+    payload: ProjectCreatedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("project.meta-updated"),
+    payload: ProjectMetaUpdatedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("project.deleted"),
+    payload: ProjectDeletedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.created"),
+    payload: ThreadCreatedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.deleted"),
+    payload: ThreadDeletedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.meta-updated"),
+    payload: ThreadMetaUpdatedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.runtime-mode-set"),
+    payload: ThreadRuntimeModeSetPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.interaction-mode-set"),
+    payload: ThreadInteractionModeSetPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.message-sent"),
+    payload: ThreadMessageSentPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.turn-start-requested"),
+    payload: ThreadTurnStartRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.turn-interrupt-requested"),
+    payload: ThreadTurnInterruptRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.approval-response-requested"),
+    payload: ThreadApprovalResponseRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.user-input-response-requested"),
+    payload: ThreadUserInputResponseRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.checkpoint-revert-requested"),
+    payload: ThreadCheckpointRevertRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.reverted"),
+    payload: ThreadRevertedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.session-stop-requested"),
+    payload: ThreadSessionStopRequestedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.session-set"),
+    payload: ThreadSessionSetPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.proposed-plan-upserted"),
+    payload: ThreadProposedPlanUpsertedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.turn-diff-completed"),
+    payload: ThreadTurnDiffCompletedPayload
+  }),
+  Schema3.Struct({
+    ...EventBaseFields,
+    type: Schema3.Literal("thread.activity-appended"),
+    payload: ThreadActivityAppendedPayload
+  })
+]);
+var OrchestrationPersistedEvent = Schema3.Union([
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("project.created"),
+    payload: ProjectCreatedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("project.meta-updated"),
+    payload: ProjectMetaUpdatedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("project.deleted"),
+    payload: ProjectDeletedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.created"),
+    payload: ThreadCreatedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.deleted"),
+    payload: ThreadDeletedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.meta-updated"),
+    payload: ThreadMetaUpdatedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.runtime-mode-set"),
+    payload: ThreadRuntimeModeSetPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.interaction-mode-set"),
+    payload: ThreadInteractionModeSetPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.message-sent"),
+    payload: ThreadMessageSentPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.turn-start-requested"),
+    payload: ThreadTurnStartRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.turn-interrupt-requested"),
+    payload: ThreadTurnInterruptRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.approval-response-requested"),
+    payload: ThreadApprovalResponseRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.user-input-response-requested"),
+    payload: ThreadUserInputResponseRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.checkpoint-revert-requested"),
+    payload: ThreadCheckpointRevertRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.reverted"),
+    payload: ThreadRevertedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.session-stop-requested"),
+    payload: ThreadSessionStopRequestedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.session-set"),
+    payload: ThreadSessionSetPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.proposed-plan-upserted"),
+    payload: ThreadProposedPlanUpsertedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.turn-diff-completed"),
+    payload: ThreadTurnDiffCompletedPayload
+  }),
+  Schema3.Struct({
+    ...PersistedEventBaseFields,
+    eventType: Schema3.Literal("thread.activity-appended"),
+    payload: ThreadActivityAppendedPayload
+  })
+]);
+var OrchestrationCommandReceiptStatus = Schema3.Literals(["accepted", "rejected"]);
+var TurnCountRange = Schema3.Struct({
+  fromTurnCount: NonNegativeInt,
+  toTurnCount: NonNegativeInt
+}).check(Schema3.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: Schema3.String
+}), { unsafePreserveChecks: true });
+var ProviderSessionRuntimeStatus = Schema3.Literals([
+  "starting",
+  "running",
+  "stopped",
+  "error"
+]);
+var ProjectionThreadTurnStatus = Schema3.Literals([
+  "running",
+  "completed",
+  "interrupted",
+  "error"
+]);
+var ProjectionCheckpointRow = Schema3.Struct({
+  threadId: ThreadId,
+  turnId: TurnId,
+  checkpointTurnCount: NonNegativeInt,
+  checkpointRef: CheckpointRef,
+  status: OrchestrationCheckpointStatus,
+  files: Schema3.Array(OrchestrationCheckpointFile),
+  assistantMessageId: Schema3.NullOr(MessageId),
+  completedAt: IsoDateTime
+});
+var ProjectionPendingApprovalStatus = Schema3.Literals(["pending", "resolved"]);
+var ProjectionPendingApprovalDecision = Schema3.NullOr(ProviderApprovalDecision);
+var DispatchResult = Schema3.Struct({
+  sequence: NonNegativeInt
+});
+var OrchestrationGetSnapshotInput = Schema3.Struct({});
+var OrchestrationGetTurnDiffInput = TurnCountRange.mapFields(Struct.assign({ threadId: ThreadId }), { unsafePreserveChecks: true });
+var OrchestrationGetFullThreadDiffInput = Schema3.Struct({
+  threadId: ThreadId,
+  toTurnCount: NonNegativeInt
+});
+var OrchestrationReplayEventsInput = Schema3.Struct({
+  fromSequenceExclusive: NonNegativeInt
+});
+var OrchestrationReplayEventsResult = Schema3.Array(OrchestrationEvent);
+
+// packages/contracts/src/providerRuntime.ts
+var TrimmedNonEmptyStringSchema = TrimmedNonEmptyString;
+var UnknownRecordSchema = Schema4.Record(Schema4.String, Schema4.Unknown);
+var RuntimeEventRawSource = Schema4.Literals([
+  "codex.app-server.notification",
+  "codex.app-server.request",
+  "codex.eventmsg",
+  "codex.sdk.thread-event",
+  "claude.cli.stream-json"
+]);
+var RuntimeEventRaw = Schema4.Struct({
+  source: RuntimeEventRawSource,
+  method: Schema4.optional(TrimmedNonEmptyStringSchema),
+  messageType: Schema4.optional(TrimmedNonEmptyStringSchema),
+  payload: Schema4.Unknown
+});
+var ProviderRequestId = TrimmedNonEmptyStringSchema;
+var ProviderRefs = Schema4.Struct({
+  providerTurnId: Schema4.optional(TrimmedNonEmptyStringSchema),
+  providerItemId: Schema4.optional(ProviderItemId),
+  providerRequestId: Schema4.optional(ProviderRequestId)
+});
+var RuntimeSessionState = Schema4.Literals([
+  "starting",
+  "ready",
+  "running",
+  "waiting",
+  "stopped",
+  "error"
+]);
+var RuntimeThreadState = Schema4.Literals([
+  "active",
+  "idle",
+  "archived",
+  "closed",
+  "compacted",
+  "error"
+]);
+var RuntimeTurnState = Schema4.Literals([
+  "completed",
+  "failed",
+  "interrupted",
+  "cancelled"
+]);
+var RuntimePlanStepStatus = Schema4.Literals(["pending", "inProgress", "completed"]);
+var RuntimeItemStatus = Schema4.Literals(["inProgress", "completed", "failed", "declined"]);
+var RuntimeContentStreamKind = Schema4.Literals([
+  "assistant_text",
+  "reasoning_text",
+  "reasoning_summary_text",
+  "plan_text",
+  "command_output",
+  "file_change_output",
+  "unknown"
+]);
+var RuntimeSessionExitKind = Schema4.Literals(["graceful", "error"]);
+var RuntimeErrorClass = Schema4.Literals([
+  "provider_error",
+  "transport_error",
+  "permission_error",
+  "validation_error",
+  "unknown"
+]);
+var CanonicalItemType = Schema4.Literals([
+  "user_message",
+  "assistant_message",
+  "reasoning",
+  "plan",
+  "command_execution",
+  "file_change",
+  "mcp_tool_call",
+  "dynamic_tool_call",
+  "collab_agent_tool_call",
+  "web_search",
+  "image_view",
+  "review_entered",
+  "review_exited",
+  "context_compaction",
+  "error",
+  "unknown"
+]);
+var CanonicalRequestType = Schema4.Literals([
+  "command_execution_approval",
+  "file_read_approval",
+  "file_change_approval",
+  "apply_patch_approval",
+  "exec_command_approval",
+  "tool_user_input",
+  "dynamic_tool_call",
+  "auth_tokens_refresh",
+  "unknown"
+]);
+var ProviderRuntimeEventType = Schema4.Literals([
+  "session.started",
+  "session.configured",
+  "session.state.changed",
+  "session.exited",
+  "thread.started",
+  "thread.state.changed",
+  "thread.metadata.updated",
+  "thread.token-usage.updated",
+  "thread.realtime.started",
+  "thread.realtime.item-added",
+  "thread.realtime.audio.delta",
+  "thread.realtime.error",
+  "thread.realtime.closed",
+  "turn.started",
+  "turn.completed",
+  "turn.aborted",
+  "turn.plan.updated",
+  "turn.proposed.delta",
+  "turn.proposed.completed",
+  "turn.diff.updated",
+  "item.started",
+  "item.updated",
+  "item.completed",
+  "content.delta",
+  "request.opened",
+  "request.resolved",
+  "user-input.requested",
+  "user-input.resolved",
+  "task.started",
+  "task.progress",
+  "task.completed",
+  "hook.started",
+  "hook.progress",
+  "hook.completed",
+  "tool.progress",
+  "tool.summary",
+  "auth.status",
+  "account.updated",
+  "account.rate-limits.updated",
+  "mcp.status.updated",
+  "mcp.oauth.completed",
+  "model.rerouted",
+  "config.warning",
+  "deprecation.notice",
+  "files.persisted",
+  "runtime.warning",
+  "runtime.error"
+]);
+var SessionStartedType = Schema4.Literal("session.started");
+var SessionConfiguredType = Schema4.Literal("session.configured");
+var SessionStateChangedType = Schema4.Literal("session.state.changed");
+var SessionExitedType = Schema4.Literal("session.exited");
+var ThreadStartedType = Schema4.Literal("thread.started");
+var ThreadStateChangedType = Schema4.Literal("thread.state.changed");
+var ThreadMetadataUpdatedType = Schema4.Literal("thread.metadata.updated");
+var ThreadTokenUsageUpdatedType = Schema4.Literal("thread.token-usage.updated");
+var ThreadRealtimeStartedType = Schema4.Literal("thread.realtime.started");
+var ThreadRealtimeItemAddedType = Schema4.Literal("thread.realtime.item-added");
+var ThreadRealtimeAudioDeltaType = Schema4.Literal("thread.realtime.audio.delta");
+var ThreadRealtimeErrorType = Schema4.Literal("thread.realtime.error");
+var ThreadRealtimeClosedType = Schema4.Literal("thread.realtime.closed");
+var TurnStartedType = Schema4.Literal("turn.started");
+var TurnCompletedType = Schema4.Literal("turn.completed");
+var TurnAbortedType = Schema4.Literal("turn.aborted");
+var TurnPlanUpdatedType = Schema4.Literal("turn.plan.updated");
+var TurnProposedDeltaType = Schema4.Literal("turn.proposed.delta");
+var TurnProposedCompletedType = Schema4.Literal("turn.proposed.completed");
+var TurnDiffUpdatedType = Schema4.Literal("turn.diff.updated");
+var ItemStartedType = Schema4.Literal("item.started");
+var ItemUpdatedType = Schema4.Literal("item.updated");
+var ItemCompletedType = Schema4.Literal("item.completed");
+var ContentDeltaType = Schema4.Literal("content.delta");
+var RequestOpenedType = Schema4.Literal("request.opened");
+var RequestResolvedType = Schema4.Literal("request.resolved");
+var UserInputRequestedType = Schema4.Literal("user-input.requested");
+var UserInputResolvedType = Schema4.Literal("user-input.resolved");
+var TaskStartedType = Schema4.Literal("task.started");
+var TaskProgressType = Schema4.Literal("task.progress");
+var TaskCompletedType = Schema4.Literal("task.completed");
+var HookStartedType = Schema4.Literal("hook.started");
+var HookProgressType = Schema4.Literal("hook.progress");
+var HookCompletedType = Schema4.Literal("hook.completed");
+var ToolProgressType = Schema4.Literal("tool.progress");
+var ToolSummaryType = Schema4.Literal("tool.summary");
+var AuthStatusType = Schema4.Literal("auth.status");
+var AccountUpdatedType = Schema4.Literal("account.updated");
+var AccountRateLimitsUpdatedType = Schema4.Literal("account.rate-limits.updated");
+var McpStatusUpdatedType = Schema4.Literal("mcp.status.updated");
+var McpOauthCompletedType = Schema4.Literal("mcp.oauth.completed");
+var ModelReroutedType = Schema4.Literal("model.rerouted");
+var ConfigWarningType = Schema4.Literal("config.warning");
+var DeprecationNoticeType = Schema4.Literal("deprecation.notice");
+var FilesPersistedType = Schema4.Literal("files.persisted");
+var RuntimeWarningType = Schema4.Literal("runtime.warning");
+var RuntimeErrorType = Schema4.Literal("runtime.error");
+var ProviderRuntimeEventBase = Schema4.Struct({
+  eventId: EventId,
+  provider: ProviderKind,
+  threadId: ThreadId,
+  createdAt: IsoDateTime,
+  turnId: Schema4.optional(TurnId),
+  itemId: Schema4.optional(RuntimeItemId),
+  requestId: Schema4.optional(RuntimeRequestId),
+  providerRefs: Schema4.optional(ProviderRefs),
+  raw: Schema4.optional(RuntimeEventRaw)
+});
+var SessionStartedPayload = Schema4.Struct({
+  message: Schema4.optional(TrimmedNonEmptyStringSchema),
+  resume: Schema4.optional(Schema4.Unknown)
+});
+var SessionConfiguredPayload = Schema4.Struct({
+  config: UnknownRecordSchema
+});
+var SessionStateChangedPayload = Schema4.Struct({
+  state: RuntimeSessionState,
+  reason: Schema4.optional(TrimmedNonEmptyStringSchema),
+  detail: Schema4.optional(Schema4.Unknown)
+});
+var SessionExitedPayload = Schema4.Struct({
+  reason: Schema4.optional(TrimmedNonEmptyStringSchema),
+  recoverable: Schema4.optional(Schema4.Boolean),
+  exitKind: Schema4.optional(RuntimeSessionExitKind)
+});
+var ThreadStartedPayload = Schema4.Struct({
+  providerThreadId: Schema4.optional(TrimmedNonEmptyStringSchema)
+});
+var ThreadStateChangedPayload = Schema4.Struct({
+  state: RuntimeThreadState,
+  detail: Schema4.optional(Schema4.Unknown)
+});
+var ThreadMetadataUpdatedPayload = Schema4.Struct({
+  name: Schema4.optional(TrimmedNonEmptyStringSchema),
+  metadata: Schema4.optional(UnknownRecordSchema)
+});
+var ThreadTokenUsageUpdatedPayload = Schema4.Struct({
+  usage: Schema4.Unknown
+});
+var ThreadRealtimeStartedPayload = Schema4.Struct({
+  realtimeSessionId: Schema4.optional(TrimmedNonEmptyStringSchema)
+});
+var ThreadRealtimeItemAddedPayload = Schema4.Struct({
+  item: Schema4.Unknown
+});
+var ThreadRealtimeAudioDeltaPayload = Schema4.Struct({
+  audio: Schema4.Unknown
+});
+var ThreadRealtimeErrorPayload = Schema4.Struct({
+  message: TrimmedNonEmptyStringSchema
+});
+var ThreadRealtimeClosedPayload = Schema4.Struct({
+  reason: Schema4.optional(TrimmedNonEmptyStringSchema)
+});
+var TurnStartedPayload = Schema4.Struct({
+  model: Schema4.optional(TrimmedNonEmptyStringSchema),
+  effort: Schema4.optional(TrimmedNonEmptyStringSchema)
+});
+var TurnCompletedPayload = Schema4.Struct({
+  state: RuntimeTurnState,
+  stopReason: Schema4.optional(Schema4.NullOr(TrimmedNonEmptyStringSchema)),
+  usage: Schema4.optional(Schema4.Unknown),
+  modelUsage: Schema4.optional(UnknownRecordSchema),
+  totalCostUsd: Schema4.optional(Schema4.Number),
+  errorMessage: Schema4.optional(TrimmedNonEmptyStringSchema)
+});
+var TurnAbortedPayload = Schema4.Struct({
+  reason: TrimmedNonEmptyStringSchema
+});
+var RuntimePlanStep = Schema4.Struct({
+  step: TrimmedNonEmptyStringSchema,
+  status: RuntimePlanStepStatus
+});
+var TurnPlanUpdatedPayload = Schema4.Struct({
+  explanation: Schema4.optional(Schema4.NullOr(TrimmedNonEmptyStringSchema)),
+  plan: Schema4.Array(RuntimePlanStep)
+});
+var TurnProposedDeltaPayload = Schema4.Struct({
+  delta: Schema4.String
+});
+var TurnProposedCompletedPayload = Schema4.Struct({
+  planMarkdown: TrimmedNonEmptyStringSchema
+});
+var TurnDiffUpdatedPayload = Schema4.Struct({
+  unifiedDiff: Schema4.String
+});
+var ItemLifecyclePayload = Schema4.Struct({
+  itemType: CanonicalItemType,
+  status: Schema4.optional(RuntimeItemStatus),
+  title: Schema4.optional(TrimmedNonEmptyStringSchema),
+  detail: Schema4.optional(TrimmedNonEmptyStringSchema),
+  data: Schema4.optional(Schema4.Unknown)
+});
+var ContentDeltaPayload = Schema4.Struct({
+  streamKind: RuntimeContentStreamKind,
+  delta: Schema4.String,
+  contentIndex: Schema4.optional(Schema4.Int),
+  summaryIndex: Schema4.optional(Schema4.Int)
+});
+var RequestOpenedPayload = Schema4.Struct({
+  requestType: CanonicalRequestType,
+  detail: Schema4.optional(TrimmedNonEmptyStringSchema),
+  args: Schema4.optional(Schema4.Unknown)
+});
+var RequestResolvedPayload = Schema4.Struct({
+  requestType: CanonicalRequestType,
+  decision: Schema4.optional(TrimmedNonEmptyStringSchema),
+  resolution: Schema4.optional(Schema4.Unknown)
+});
+var UserInputQuestionOption = Schema4.Struct({
+  label: TrimmedNonEmptyStringSchema,
+  description: TrimmedNonEmptyStringSchema
+});
+var UserInputQuestion = Schema4.Struct({
+  id: TrimmedNonEmptyStringSchema,
+  header: TrimmedNonEmptyStringSchema,
+  question: TrimmedNonEmptyStringSchema,
+  options: Schema4.Array(UserInputQuestionOption)
+});
+var UserInputRequestedPayload = Schema4.Struct({
+  questions: Schema4.Array(UserInputQuestion)
+});
+var UserInputResolvedPayload = Schema4.Struct({
+  answers: UnknownRecordSchema
+});
+var TaskStartedPayload = Schema4.Struct({
+  taskId: RuntimeTaskId,
+  description: Schema4.optional(TrimmedNonEmptyStringSchema),
+  taskType: Schema4.optional(TrimmedNonEmptyStringSchema)
+});
+var TaskProgressPayload = Schema4.Struct({
+  taskId: RuntimeTaskId,
+  description: TrimmedNonEmptyStringSchema,
+  usage: Schema4.optional(Schema4.Unknown),
+  lastToolName: Schema4.optional(TrimmedNonEmptyStringSchema)
+});
+var TaskCompletedPayload = Schema4.Struct({
+  taskId: RuntimeTaskId,
+  status: Schema4.Literals(["completed", "failed", "stopped"]),
+  summary: Schema4.optional(TrimmedNonEmptyStringSchema),
+  usage: Schema4.optional(Schema4.Unknown)
+});
+var HookStartedPayload = Schema4.Struct({
+  hookId: TrimmedNonEmptyStringSchema,
+  hookName: TrimmedNonEmptyStringSchema,
+  hookEvent: TrimmedNonEmptyStringSchema
+});
+var HookProgressPayload = Schema4.Struct({
+  hookId: TrimmedNonEmptyStringSchema,
+  output: Schema4.optional(Schema4.String),
+  stdout: Schema4.optional(Schema4.String),
+  stderr: Schema4.optional(Schema4.String)
+});
+var HookCompletedPayload = Schema4.Struct({
+  hookId: TrimmedNonEmptyStringSchema,
+  outcome: Schema4.Literals(["success", "error", "cancelled"]),
+  output: Schema4.optional(Schema4.String),
+  stdout: Schema4.optional(Schema4.String),
+  stderr: Schema4.optional(Schema4.String),
+  exitCode: Schema4.optional(Schema4.Int)
+});
+var ToolProgressPayload = Schema4.Struct({
+  toolUseId: Schema4.optional(TrimmedNonEmptyStringSchema),
+  toolName: Schema4.optional(TrimmedNonEmptyStringSchema),
+  summary: Schema4.optional(TrimmedNonEmptyStringSchema),
+  elapsedSeconds: Schema4.optional(Schema4.Number)
+});
+var ToolSummaryPayload = Schema4.Struct({
+  summary: TrimmedNonEmptyStringSchema,
+  precedingToolUseIds: Schema4.optional(Schema4.Array(TrimmedNonEmptyStringSchema))
+});
+var AuthStatusPayload = Schema4.Struct({
+  isAuthenticating: Schema4.optional(Schema4.Boolean),
+  output: Schema4.optional(Schema4.Array(Schema4.String)),
+  error: Schema4.optional(TrimmedNonEmptyStringSchema)
+});
+var AccountUpdatedPayload = Schema4.Struct({
+  account: Schema4.Unknown
+});
+var AccountRateLimitsUpdatedPayload = Schema4.Struct({
+  rateLimits: Schema4.Unknown
+});
+var McpStatusUpdatedPayload = Schema4.Struct({
+  status: Schema4.Unknown
+});
+var McpOauthCompletedPayload = Schema4.Struct({
+  success: Schema4.Boolean,
+  name: Schema4.optional(TrimmedNonEmptyStringSchema),
+  error: Schema4.optional(TrimmedNonEmptyStringSchema)
+});
+var ModelReroutedPayload = Schema4.Struct({
+  fromModel: TrimmedNonEmptyStringSchema,
+  toModel: TrimmedNonEmptyStringSchema,
+  reason: TrimmedNonEmptyStringSchema
+});
+var ConfigWarningPayload = Schema4.Struct({
+  summary: TrimmedNonEmptyStringSchema,
+  details: Schema4.optional(TrimmedNonEmptyStringSchema),
+  path: Schema4.optional(TrimmedNonEmptyStringSchema),
+  range: Schema4.optional(Schema4.Unknown)
+});
+var DeprecationNoticePayload = Schema4.Struct({
+  summary: TrimmedNonEmptyStringSchema,
+  details: Schema4.optional(TrimmedNonEmptyStringSchema)
+});
+var FilesPersistedPayload = Schema4.Struct({
+  files: Schema4.Array(Schema4.Struct({
+    filename: TrimmedNonEmptyStringSchema,
+    fileId: TrimmedNonEmptyStringSchema
+  })),
+  failed: Schema4.optional(Schema4.Array(Schema4.Struct({
+    filename: TrimmedNonEmptyStringSchema,
+    error: TrimmedNonEmptyStringSchema
+  })))
+});
+var RuntimeWarningPayload = Schema4.Struct({
+  message: TrimmedNonEmptyStringSchema,
+  detail: Schema4.optional(Schema4.Unknown)
+});
+var RuntimeErrorPayload = Schema4.Struct({
+  message: TrimmedNonEmptyStringSchema,
+  class: Schema4.optional(RuntimeErrorClass),
+  detail: Schema4.optional(Schema4.Unknown)
+});
+var ProviderRuntimeSessionStartedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: SessionStartedType,
+  payload: SessionStartedPayload
+});
+var ProviderRuntimeSessionConfiguredEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: SessionConfiguredType,
+  payload: SessionConfiguredPayload
+});
+var ProviderRuntimeSessionStateChangedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: SessionStateChangedType,
+  payload: SessionStateChangedPayload
+});
+var ProviderRuntimeSessionExitedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: SessionExitedType,
+  payload: SessionExitedPayload
+});
+var ProviderRuntimeThreadStartedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadStartedType,
+  payload: ThreadStartedPayload
+});
+var ProviderRuntimeThreadStateChangedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadStateChangedType,
+  payload: ThreadStateChangedPayload
+});
+var ProviderRuntimeThreadMetadataUpdatedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadMetadataUpdatedType,
+  payload: ThreadMetadataUpdatedPayload
+});
+var ProviderRuntimeThreadTokenUsageUpdatedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadTokenUsageUpdatedType,
+  payload: ThreadTokenUsageUpdatedPayload
+});
+var ProviderRuntimeThreadRealtimeStartedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadRealtimeStartedType,
+  payload: ThreadRealtimeStartedPayload
+});
+var ProviderRuntimeThreadRealtimeItemAddedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadRealtimeItemAddedType,
+  payload: ThreadRealtimeItemAddedPayload
+});
+var ProviderRuntimeThreadRealtimeAudioDeltaEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadRealtimeAudioDeltaType,
+  payload: ThreadRealtimeAudioDeltaPayload
+});
+var ProviderRuntimeThreadRealtimeErrorEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadRealtimeErrorType,
+  payload: ThreadRealtimeErrorPayload
+});
+var ProviderRuntimeThreadRealtimeClosedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ThreadRealtimeClosedType,
+  payload: ThreadRealtimeClosedPayload
+});
+var ProviderRuntimeTurnStartedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TurnStartedType,
+  payload: TurnStartedPayload
+});
+var ProviderRuntimeTurnCompletedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TurnCompletedType,
+  payload: TurnCompletedPayload
+});
+var ProviderRuntimeTurnAbortedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TurnAbortedType,
+  payload: TurnAbortedPayload
+});
+var ProviderRuntimeTurnPlanUpdatedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TurnPlanUpdatedType,
+  payload: TurnPlanUpdatedPayload
+});
+var ProviderRuntimeTurnProposedDeltaEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TurnProposedDeltaType,
+  payload: TurnProposedDeltaPayload
+});
+var ProviderRuntimeTurnProposedCompletedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TurnProposedCompletedType,
+  payload: TurnProposedCompletedPayload
+});
+var ProviderRuntimeTurnDiffUpdatedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TurnDiffUpdatedType,
+  payload: TurnDiffUpdatedPayload
+});
+var ProviderRuntimeItemStartedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ItemStartedType,
+  payload: ItemLifecyclePayload
+});
+var ProviderRuntimeItemUpdatedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ItemUpdatedType,
+  payload: ItemLifecyclePayload
+});
+var ProviderRuntimeItemCompletedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ItemCompletedType,
+  payload: ItemLifecyclePayload
+});
+var ProviderRuntimeContentDeltaEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ContentDeltaType,
+  payload: ContentDeltaPayload
+});
+var ProviderRuntimeRequestOpenedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: RequestOpenedType,
+  payload: RequestOpenedPayload
+});
+var ProviderRuntimeRequestResolvedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: RequestResolvedType,
+  payload: RequestResolvedPayload
+});
+var ProviderRuntimeUserInputRequestedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: UserInputRequestedType,
+  payload: UserInputRequestedPayload
+});
+var ProviderRuntimeUserInputResolvedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: UserInputResolvedType,
+  payload: UserInputResolvedPayload
+});
+var ProviderRuntimeTaskStartedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TaskStartedType,
+  payload: TaskStartedPayload
+});
+var ProviderRuntimeTaskProgressEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TaskProgressType,
+  payload: TaskProgressPayload
+});
+var ProviderRuntimeTaskCompletedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: TaskCompletedType,
+  payload: TaskCompletedPayload
+});
+var ProviderRuntimeHookStartedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: HookStartedType,
+  payload: HookStartedPayload
+});
+var ProviderRuntimeHookProgressEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: HookProgressType,
+  payload: HookProgressPayload
+});
+var ProviderRuntimeHookCompletedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: HookCompletedType,
+  payload: HookCompletedPayload
+});
+var ProviderRuntimeToolProgressEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ToolProgressType,
+  payload: ToolProgressPayload
+});
+var ProviderRuntimeToolSummaryEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ToolSummaryType,
+  payload: ToolSummaryPayload
+});
+var ProviderRuntimeAuthStatusEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: AuthStatusType,
+  payload: AuthStatusPayload
+});
+var ProviderRuntimeAccountUpdatedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: AccountUpdatedType,
+  payload: AccountUpdatedPayload
+});
+var ProviderRuntimeAccountRateLimitsUpdatedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: AccountRateLimitsUpdatedType,
+  payload: AccountRateLimitsUpdatedPayload
+});
+var ProviderRuntimeMcpStatusUpdatedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: McpStatusUpdatedType,
+  payload: McpStatusUpdatedPayload
+});
+var ProviderRuntimeMcpOauthCompletedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: McpOauthCompletedType,
+  payload: McpOauthCompletedPayload
+});
+var ProviderRuntimeModelReroutedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ModelReroutedType,
+  payload: ModelReroutedPayload
+});
+var ProviderRuntimeConfigWarningEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: ConfigWarningType,
+  payload: ConfigWarningPayload
+});
+var ProviderRuntimeDeprecationNoticeEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: DeprecationNoticeType,
+  payload: DeprecationNoticePayload
+});
+var ProviderRuntimeFilesPersistedEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: FilesPersistedType,
+  payload: FilesPersistedPayload
+});
+var ProviderRuntimeWarningEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: RuntimeWarningType,
+  payload: RuntimeWarningPayload
+});
+var ProviderRuntimeErrorEvent = Schema4.Struct({
+  ...ProviderRuntimeEventBase.fields,
+  type: RuntimeErrorType,
+  payload: RuntimeErrorPayload
+});
+var ProviderRuntimeEventV2 = Schema4.Union([
+  ProviderRuntimeSessionStartedEvent,
+  ProviderRuntimeSessionConfiguredEvent,
+  ProviderRuntimeSessionStateChangedEvent,
+  ProviderRuntimeSessionExitedEvent,
+  ProviderRuntimeThreadStartedEvent,
+  ProviderRuntimeThreadStateChangedEvent,
+  ProviderRuntimeThreadMetadataUpdatedEvent,
+  ProviderRuntimeThreadTokenUsageUpdatedEvent,
+  ProviderRuntimeThreadRealtimeStartedEvent,
+  ProviderRuntimeThreadRealtimeItemAddedEvent,
+  ProviderRuntimeThreadRealtimeAudioDeltaEvent,
+  ProviderRuntimeThreadRealtimeErrorEvent,
+  ProviderRuntimeThreadRealtimeClosedEvent,
+  ProviderRuntimeTurnStartedEvent,
+  ProviderRuntimeTurnCompletedEvent,
+  ProviderRuntimeTurnAbortedEvent,
+  ProviderRuntimeTurnPlanUpdatedEvent,
+  ProviderRuntimeTurnProposedDeltaEvent,
+  ProviderRuntimeTurnProposedCompletedEvent,
+  ProviderRuntimeTurnDiffUpdatedEvent,
+  ProviderRuntimeItemStartedEvent,
+  ProviderRuntimeItemUpdatedEvent,
+  ProviderRuntimeItemCompletedEvent,
+  ProviderRuntimeContentDeltaEvent,
+  ProviderRuntimeRequestOpenedEvent,
+  ProviderRuntimeRequestResolvedEvent,
+  ProviderRuntimeUserInputRequestedEvent,
+  ProviderRuntimeUserInputResolvedEvent,
+  ProviderRuntimeTaskStartedEvent,
+  ProviderRuntimeTaskProgressEvent,
+  ProviderRuntimeTaskCompletedEvent,
+  ProviderRuntimeHookStartedEvent,
+  ProviderRuntimeHookProgressEvent,
+  ProviderRuntimeHookCompletedEvent,
+  ProviderRuntimeToolProgressEvent,
+  ProviderRuntimeToolSummaryEvent,
+  ProviderRuntimeAuthStatusEvent,
+  ProviderRuntimeAccountUpdatedEvent,
+  ProviderRuntimeAccountRateLimitsUpdatedEvent,
+  ProviderRuntimeMcpStatusUpdatedEvent,
+  ProviderRuntimeMcpOauthCompletedEvent,
+  ProviderRuntimeModelReroutedEvent,
+  ProviderRuntimeConfigWarningEvent,
+  ProviderRuntimeDeprecationNoticeEvent,
+  ProviderRuntimeFilesPersistedEvent,
+  ProviderRuntimeWarningEvent,
+  ProviderRuntimeErrorEvent
+]);
+var ProviderRuntimeEvent = ProviderRuntimeEventV2;
+var ProviderRuntimeToolKind = Schema4.Literals([
+  "command",
+  "file-read",
+  "file-change",
+  "other"
+]);
+var ProviderRuntimeTurnStatus = RuntimeTurnState;
+export {
+  UserInputQuestion,
+  RuntimeEventRaw,
+  ProviderRuntimeTurnStatus,
+  ProviderRuntimeEventV2,
+  ProviderRuntimeEvent,
+  ItemLifecyclePayload,
+  CanonicalRequestType,
+  CanonicalItemType
+};