@h-rig/contracts 0.0.6-alpha.157 → 0.0.6-alpha.158

package/dist/src/providerRuntime.js

@@ -1,1633 +0,0 @@
-// @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 SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
-var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
-var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
-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
-};