agent-console-server 3.4.0 → 3.5.0

package/dist/EphemeralAgentEventTypes-DGkHIIcW.js

@@ -0,0 +1,838 @@
+import { z } from "zod";
+import { SITE_NAME, createUniqueArraySchema } from "@esposter/shared";
+//#region src/models/handshake/HandshakeMessageType.ts
+let HandshakeMessageType = /* @__PURE__ */ function(HandshakeMessageType) {
+	HandshakeMessageType["Authenticate"] = "Authenticate";
+	HandshakeMessageType["Challenge"] = "Challenge";
+	HandshakeMessageType["HandOff"] = "HandOff";
+	HandshakeMessageType["Pair"] = "Pair";
+	HandshakeMessageType["Revoke"] = "Revoke";
+	return HandshakeMessageType;
+}({});
+const handshakeMessageTypeSchema = z.enum(HandshakeMessageType);
+//#endregion
+//#region src/services/constants.ts
+const DEFAULT_APP_ORIGIN = "https://esposter.com";
+const DEFAULT_HOSTNAME = "127.0.0.1";
+const DEFAULT_PORT = 7437;
+const HOST_SCHEME = `${SITE_NAME.toLowerCase()}-host`;
+const PAIRING_CODE_PARAMETER = "code";
+const PAIRING_HASH_PARAMETER = "host";
+const SHELL_OUTPUT_LENGTH = 1e5;
+const SCHEME_PAIRING_CODE_DURATION = Temporal.Duration.from({ minutes: 1 }).total("milliseconds");
+//#endregion
+//#region src/models/handshake/SignaturePurpose.ts
+let SignaturePurpose = /* @__PURE__ */ function(SignaturePurpose) {
+	SignaturePurpose["HostProof"] = "HostProof";
+	SignaturePurpose["OwnerProof"] = "OwnerProof";
+	return SignaturePurpose;
+}({});
+const signaturePurposeSchema = z.enum(SignaturePurpose);
+//#endregion
+//#region src/models/server/BaseServerMessage.ts
+const createBaseServerMessageSchema = (typeSchema) => z.object({ type: typeSchema });
+//#endregion
+//#region src/models/server/ServerMessageType.ts
+let ServerMessageType = /* @__PURE__ */ function(ServerMessageType) {
+	ServerMessageType["Authenticated"] = "Authenticated";
+	ServerMessageType["CommandError"] = "CommandError";
+	ServerMessageType["Events"] = "Events";
+	ServerMessageType["HostStopping"] = "HostStopping";
+	ServerMessageType["Paired"] = "Paired";
+	ServerMessageType["Proof"] = "Proof";
+	ServerMessageType["SessionOpened"] = "SessionOpened";
+	ServerMessageType["SessionReset"] = "SessionReset";
+	ServerMessageType["Sessions"] = "Sessions";
+	ServerMessageType["ShellClosed"] = "ShellClosed";
+	ServerMessageType["ShellOpened"] = "ShellOpened";
+	ServerMessageType["ShellOutput"] = "ShellOutput";
+	return ServerMessageType;
+}({});
+const serverMessageTypeSchema = z.enum(ServerMessageType);
+//#endregion
+//#region src/models/server/AuthenticatedMessage.ts
+const authenticatedMessageSchema = z.object({ ...createBaseServerMessageSchema(z.literal("Authenticated")).shape });
+//#endregion
+//#region src/models/server/CommandErrorMessage.ts
+const commandErrorMessageSchema = z.object({
+	...createBaseServerMessageSchema(z.literal("CommandError")).shape,
+	commandId: z.string(),
+	message: z.string().min(1)
+});
+//#endregion
+//#region src/models/event/AgentEventType.ts
+let AgentEventType = /* @__PURE__ */ function(AgentEventType) {
+	AgentEventType["AssistantMessage"] = "AssistantMessage";
+	AgentEventType["Capabilities"] = "Capabilities";
+	AgentEventType["CommandOutput"] = "CommandOutput";
+	AgentEventType["Compaction"] = "Compaction";
+	AgentEventType["ContextUsage"] = "ContextUsage";
+	AgentEventType["FileRewind"] = "FileRewind";
+	AgentEventType["Hook"] = "Hook";
+	AgentEventType["HostError"] = "HostError";
+	AgentEventType["PermissionRequest"] = "PermissionRequest";
+	AgentEventType["PermissionResolution"] = "PermissionResolution";
+	AgentEventType["RateLimit"] = "RateLimit";
+	AgentEventType["SessionInit"] = "SessionInit";
+	AgentEventType["SessionSettings"] = "SessionSettings";
+	AgentEventType["SessionState"] = "SessionState";
+	AgentEventType["StreamDelta"] = "StreamDelta";
+	AgentEventType["Subagent"] = "Subagent";
+	AgentEventType["Thinking"] = "Thinking";
+	AgentEventType["TodoUpdate"] = "TodoUpdate";
+	AgentEventType["ToolProgress"] = "ToolProgress";
+	AgentEventType["ToolResult"] = "ToolResult";
+	AgentEventType["ToolUse"] = "ToolUse";
+	AgentEventType["TurnResult"] = "TurnResult";
+	AgentEventType["TurnUsage"] = "TurnUsage";
+	AgentEventType["Unknown"] = "Unknown";
+	AgentEventType["UserMessage"] = "UserMessage";
+	return AgentEventType;
+}({});
+const agentEventTypeSchema = z.enum(AgentEventType);
+//#endregion
+//#region src/models/event/BaseAgentEvent.ts
+const createBaseAgentEventSchema = (typeSchema) => z.object({
+	createdAt: z.coerce.date(),
+	id: z.string().min(1),
+	type: typeSchema
+});
+//#endregion
+//#region src/models/event/MessageUuid.ts
+const messageUuidSchema = z.object({ messageUuid: z.string() });
+//#endregion
+//#region src/models/event/ParentToolUseId.ts
+const parentToolUseIdSchema = z.object({ parentToolUseId: z.string() });
+//#endregion
+//#region src/models/event/AssistantMessageEvent.ts
+const assistantMessageEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("AssistantMessage")).shape,
+	...messageUuidSchema.shape,
+	...parentToolUseIdSchema.shape,
+	text: z.string()
+});
+//#endregion
+//#region src/models/event/Model.ts
+const modelSchema = z.object({
+	description: z.string(),
+	displayName: z.string(),
+	value: z.string().min(1)
+});
+//#endregion
+//#region src/models/event/SlashCommand.ts
+const slashCommandSchema = z.object({
+	argumentHint: z.string(),
+	description: z.string(),
+	name: z.string().min(1)
+});
+//#endregion
+//#region src/models/event/CapabilitiesEvent.ts
+const capabilitiesEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("Capabilities")).shape,
+	commands: createUniqueArraySchema(slashCommandSchema, "name"),
+	models: createUniqueArraySchema(modelSchema, "value")
+});
+//#endregion
+//#region src/models/event/CommandOutputEvent.ts
+const commandOutputEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("CommandOutput")).shape,
+	content: z.string()
+});
+//#endregion
+//#region src/models/event/CompactionTrigger.ts
+let CompactionTrigger = /* @__PURE__ */ function(CompactionTrigger) {
+	CompactionTrigger["Auto"] = "auto";
+	CompactionTrigger["Manual"] = "manual";
+	return CompactionTrigger;
+}({});
+const compactionTriggerSchema = z.enum(CompactionTrigger);
+//#endregion
+//#region src/models/event/CompactionEvent.ts
+const compactionEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("Compaction")).shape,
+	postTokens: z.int().nonnegative(),
+	preTokens: z.int().nonnegative(),
+	trigger: compactionTriggerSchema
+});
+//#endregion
+//#region src/models/event/ContextUsageEvent.ts
+const contextUsageEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("ContextUsage")).shape,
+	autoCompactThreshold: z.int().nonnegative(),
+	isAutoCompactEnabled: z.boolean(),
+	maxTokens: z.int().positive(),
+	percentage: z.number().nonnegative(),
+	totalTokens: z.int().nonnegative()
+});
+//#endregion
+//#region src/models/event/FileRewindEvent.ts
+const fileRewindEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("FileRewind")).shape,
+	...messageUuidSchema.shape,
+	deletions: z.int().nonnegative(),
+	filePaths: z.string().array(),
+	insertions: z.int().nonnegative()
+});
+//#endregion
+//#region src/models/event/HookPhase.ts
+let HookPhase = /* @__PURE__ */ function(HookPhase) {
+	HookPhase["Progress"] = "Progress";
+	HookPhase["Response"] = "Response";
+	HookPhase["Started"] = "Started";
+	return HookPhase;
+}({});
+const hookPhaseSchema = z.enum(HookPhase);
+//#endregion
+//#region src/models/event/HookEvent.ts
+const hookEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("Hook")).shape,
+	exitCode: z.int(),
+	hookEvent: z.string().min(1),
+	hookId: z.string().min(1),
+	hookName: z.string(),
+	outcome: z.string(),
+	output: z.string(),
+	phase: hookPhaseSchema,
+	stderr: z.string(),
+	stdout: z.string()
+});
+//#endregion
+//#region src/models/event/HostErrorEvent.ts
+const hostErrorEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("HostError")).shape,
+	message: z.string().min(1)
+});
+//#endregion
+//#region src/models/event/PermissionRequestEvent.ts
+const permissionRequestEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("PermissionRequest")).shape,
+	blockedPath: z.string(),
+	decisionReason: z.string(),
+	hasSuggestions: z.boolean(),
+	input: z.record(z.string(), z.unknown()),
+	requestId: z.string().min(1),
+	title: z.string(),
+	toolName: z.string().min(1),
+	toolUseId: z.string()
+});
+//#endregion
+//#region src/models/command/PermissionBehavior.ts
+let PermissionBehavior = /* @__PURE__ */ function(PermissionBehavior) {
+	PermissionBehavior["Allow"] = "Allow";
+	PermissionBehavior["AllowAlways"] = "AllowAlways";
+	PermissionBehavior["Deny"] = "Deny";
+	return PermissionBehavior;
+}({});
+const permissionBehaviorSchema = z.enum(PermissionBehavior);
+//#endregion
+//#region src/models/event/PermissionResolutionEvent.ts
+const permissionResolutionEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("PermissionResolution")).shape,
+	behavior: permissionBehaviorSchema,
+	requestId: z.string().min(1)
+});
+//#endregion
+//#region src/models/event/RateLimitEvent.ts
+const rateLimitEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("RateLimit")).shape,
+	rateLimitType: z.string(),
+	resetsAt: z.coerce.date().optional(),
+	status: z.string().min(1),
+	utilization: z.number().min(0).max(1).optional()
+});
+//#endregion
+//#region src/models/event/McpServer.ts
+const mcpServerSchema = z.object({
+	name: z.string(),
+	status: z.string()
+});
+//#endregion
+//#region src/models/session/PermissionMode.ts
+let PermissionMode = /* @__PURE__ */ function(PermissionMode) {
+	PermissionMode["AcceptEdits"] = "acceptEdits";
+	PermissionMode["Auto"] = "auto";
+	PermissionMode["BypassPermissions"] = "bypassPermissions";
+	PermissionMode["Default"] = "default";
+	PermissionMode["DontAsk"] = "dontAsk";
+	PermissionMode["Plan"] = "plan";
+	return PermissionMode;
+}({});
+const permissionModeSchema = z.enum(PermissionMode);
+//#endregion
+//#region src/models/event/SessionInitEvent.ts
+const sessionInitEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("SessionInit")).shape,
+	agents: createUniqueArraySchema(z.string()),
+	claudeCodeVersion: z.string(),
+	cwd: z.string(),
+	mcpServers: createUniqueArraySchema(mcpServerSchema, "name"),
+	model: z.string(),
+	outputStyle: z.string(),
+	permissionMode: permissionModeSchema,
+	plugins: createUniqueArraySchema(z.string()),
+	skills: createUniqueArraySchema(z.string()),
+	slashCommands: createUniqueArraySchema(z.string()),
+	tools: createUniqueArraySchema(z.string())
+});
+//#endregion
+//#region src/models/event/SessionSettingsEvent.ts
+const sessionSettingsEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("SessionSettings")).shape,
+	model: z.string(),
+	permissionMode: permissionModeSchema
+});
+//#endregion
+//#region src/models/session/SessionState.ts
+let SessionState = /* @__PURE__ */ function(SessionState) {
+	SessionState["Closed"] = "Closed";
+	SessionState["Compacting"] = "Compacting";
+	SessionState["Idle"] = "Idle";
+	SessionState["RequiresAction"] = "RequiresAction";
+	SessionState["Running"] = "Running";
+	return SessionState;
+}({});
+const sessionStateSchema = z.enum(SessionState);
+//#endregion
+//#region src/models/event/SessionStateEvent.ts
+const sessionStateEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("SessionState")).shape,
+	state: sessionStateSchema
+});
+//#endregion
+//#region src/models/event/StreamDeltaEvent.ts
+const streamDeltaEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("StreamDelta")).shape,
+	blockId: z.string().min(1),
+	isThinking: z.boolean(),
+	text: z.string()
+});
+//#endregion
+//#region src/models/event/SubagentStatus.ts
+let SubagentStatus = /* @__PURE__ */ function(SubagentStatus) {
+	SubagentStatus["Completed"] = "Completed";
+	SubagentStatus["Failed"] = "Failed";
+	SubagentStatus["Running"] = "Running";
+	SubagentStatus["Started"] = "Started";
+	SubagentStatus["Stopped"] = "Stopped";
+	return SubagentStatus;
+}({});
+const subagentStatusSchema = z.enum(SubagentStatus);
+//#endregion
+//#region src/models/event/SubagentEvent.ts
+const subagentEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("Subagent")).shape,
+	description: z.string(),
+	durationMs: z.number().nonnegative(),
+	lastToolName: z.string(),
+	status: subagentStatusSchema,
+	subagentType: z.string(),
+	summary: z.string(),
+	taskId: z.string().min(1),
+	toolUseId: z.string(),
+	toolUses: z.int().nonnegative(),
+	totalTokens: z.int().nonnegative()
+});
+//#endregion
+//#region src/models/event/ThinkingEvent.ts
+const thinkingEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("Thinking")).shape,
+	...messageUuidSchema.shape,
+	...parentToolUseIdSchema.shape,
+	thinking: z.string()
+});
+//#endregion
+//#region src/models/event/TodoStatus.ts
+let TodoStatus = /* @__PURE__ */ function(TodoStatus) {
+	TodoStatus["Completed"] = "completed";
+	TodoStatus["InProgress"] = "in_progress";
+	TodoStatus["Pending"] = "pending";
+	return TodoStatus;
+}({});
+const todoStatusSchema = z.enum(TodoStatus);
+//#endregion
+//#region src/models/event/Todo.ts
+const todoSchema = z.object({
+	activeForm: z.string(),
+	content: z.string(),
+	id: z.string().min(1),
+	status: todoStatusSchema
+});
+//#endregion
+//#region src/models/event/TodoUpdateEvent.ts
+const todoUpdateEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("TodoUpdate")).shape,
+	todos: createUniqueArraySchema(todoSchema, "id")
+});
+//#endregion
+//#region src/models/event/ToolProgressEvent.ts
+const toolProgressEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("ToolProgress")).shape,
+	...parentToolUseIdSchema.shape,
+	elapsedSeconds: z.number().nonnegative(),
+	toolUseId: z.string().min(1)
+});
+//#endregion
+//#region src/models/event/ToolResultEvent.ts
+const toolResultEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("ToolResult")).shape,
+	...parentToolUseIdSchema.shape,
+	content: z.string(),
+	isError: z.boolean(),
+	originalText: z.string().optional(),
+	toolUseId: z.string().min(1)
+});
+//#endregion
+//#region src/models/event/ToolUseEvent.ts
+const toolUseEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("ToolUse")).shape,
+	...messageUuidSchema.shape,
+	...parentToolUseIdSchema.shape,
+	input: z.record(z.string(), z.unknown()),
+	name: z.string().min(1),
+	toolUseId: z.string().min(1)
+});
+//#endregion
+//#region src/models/event/TokenUsage.ts
+const tokenUsageSchema = z.object({
+	cacheCreationInputTokens: z.int().nonnegative(),
+	cacheReadInputTokens: z.int().nonnegative(),
+	inputTokens: z.int().nonnegative(),
+	outputTokens: z.int().nonnegative()
+});
+//#endregion
+//#region src/models/event/TurnResultEvent.ts
+const turnResultEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("TurnResult")).shape,
+	durationApiMs: z.number().nonnegative(),
+	durationMs: z.number().nonnegative(),
+	errors: z.string().array(),
+	isError: z.boolean(),
+	numTurns: z.int().nonnegative(),
+	result: z.string(),
+	subtype: z.string().min(1),
+	totalCostUsd: z.number().nonnegative(),
+	usage: tokenUsageSchema
+});
+//#endregion
+//#region src/models/event/TurnUsageEvent.ts
+const turnUsageEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("TurnUsage")).shape,
+	outputTokens: z.int().nonnegative()
+});
+//#endregion
+//#region src/models/event/UnknownEvent.ts
+const unknownEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("Unknown")).shape,
+	raw: z.string(),
+	sdkType: z.string()
+});
+//#endregion
+//#region src/models/event/UserMessageEvent.ts
+const userMessageEventSchema = z.object({
+	...createBaseAgentEventSchema(z.literal("UserMessage")).shape,
+	...messageUuidSchema.shape,
+	...parentToolUseIdSchema.shape,
+	attachmentCount: z.int().nonnegative(),
+	text: z.string()
+});
+//#endregion
+//#region src/models/event/AgentEvent.ts
+const agentEventSchema = z.discriminatedUnion("type", [
+	assistantMessageEventSchema,
+	capabilitiesEventSchema,
+	commandOutputEventSchema,
+	compactionEventSchema,
+	contextUsageEventSchema,
+	fileRewindEventSchema,
+	hookEventSchema,
+	hostErrorEventSchema,
+	permissionRequestEventSchema,
+	permissionResolutionEventSchema,
+	rateLimitEventSchema,
+	sessionInitEventSchema,
+	sessionSettingsEventSchema,
+	sessionStateEventSchema,
+	streamDeltaEventSchema,
+	subagentEventSchema,
+	thinkingEventSchema,
+	todoUpdateEventSchema,
+	toolProgressEventSchema,
+	toolResultEventSchema,
+	toolUseEventSchema,
+	turnResultEventSchema,
+	turnUsageEventSchema,
+	unknownEventSchema,
+	userMessageEventSchema
+]);
+//#endregion
+//#region src/models/server/EventsMessage.ts
+const eventsMessageSchema = z.object({
+	...createBaseServerMessageSchema(z.literal("Events")).shape,
+	events: createUniqueArraySchema(agentEventSchema, "id"),
+	sessionId: z.string().min(1)
+});
+//#endregion
+//#region src/models/server/HostStoppingMessage.ts
+const hostStoppingMessageSchema = z.object({ ...createBaseServerMessageSchema(z.literal("HostStopping")).shape });
+//#endregion
+//#region src/models/server/PairedMessage.ts
+const pairedMessageSchema = z.object({
+	...createBaseServerMessageSchema(z.literal("Paired")).shape,
+	credential: z.string().min(1),
+	deviceId: z.string().min(1),
+	publicKey: z.string().min(1)
+});
+//#endregion
+//#region src/models/server/ProofMessage.ts
+const proofMessageSchema = z.object({
+	...createBaseServerMessageSchema(z.literal("Proof")).shape,
+	nonce: z.string().min(1),
+	port: z.int(),
+	signature: z.string().min(1)
+});
+//#endregion
+//#region src/models/server/SessionOpenedMessage.ts
+const sessionOpenedMessageSchema = z.object({
+	...createBaseServerMessageSchema(z.literal("SessionOpened")).shape,
+	commandId: z.string().min(1),
+	sessionId: z.string().min(1)
+});
+//#endregion
+//#region src/models/server/SessionResetMessage.ts
+const sessionResetMessageSchema = z.object({
+	...createBaseServerMessageSchema(z.literal("SessionReset")).shape,
+	sessionId: z.string().min(1)
+});
+//#endregion
+//#region src/models/session/SessionSummary.ts
+const sessionSummarySchema = z.object({
+	cwd: z.string(),
+	id: z.string().min(1),
+	lastActivityAt: z.coerce.date(),
+	state: sessionStateSchema,
+	title: z.string()
+});
+//#endregion
+//#region src/models/server/SessionsMessage.ts
+const sessionsMessageSchema = z.object({
+	...createBaseServerMessageSchema(z.literal("Sessions")).shape,
+	sessions: createUniqueArraySchema(sessionSummarySchema, "id")
+});
+//#endregion
+//#region src/models/command/ShellId.ts
+const shellIdSchema = z.object({ shellId: z.string().min(1) });
+//#endregion
+//#region src/models/server/ShellClosedMessage.ts
+const shellClosedMessageSchema = z.object({
+	...createBaseServerMessageSchema(z.literal("ShellClosed")).shape,
+	...shellIdSchema.shape
+});
+//#endregion
+//#region src/models/server/ShellOpenedMessage.ts
+const shellOpenedMessageSchema = z.object({
+	...createBaseServerMessageSchema(z.literal("ShellOpened")).shape,
+	commandId: z.string(),
+	sessionId: z.string().min(1),
+	shellId: z.string().min(1)
+});
+//#endregion
+//#region src/models/server/ShellOutputMessage.ts
+const shellOutputMessageSchema = z.object({
+	...createBaseServerMessageSchema(z.literal("ShellOutput")).shape,
+	data: z.string(),
+	shellId: z.string().min(1)
+});
+//#endregion
+//#region src/models/server/ServerMessage.ts
+const serverMessageSchema = z.discriminatedUnion("type", [
+	authenticatedMessageSchema,
+	commandErrorMessageSchema,
+	eventsMessageSchema,
+	hostStoppingMessageSchema,
+	pairedMessageSchema,
+	proofMessageSchema,
+	sessionOpenedMessageSchema,
+	sessionResetMessageSchema,
+	sessionsMessageSchema,
+	shellClosedMessageSchema,
+	shellOpenedMessageSchema,
+	shellOutputMessageSchema
+]);
+//#endregion
+//#region src/services/handshake/getSignedText.ts
+const getSignedText = (purpose, port, nonce) => `${purpose}:${port}:${nonce}`;
+//#endregion
+//#region src/models/command/AttachmentMediaType.ts
+let AttachmentMediaType = /* @__PURE__ */ function(AttachmentMediaType) {
+	AttachmentMediaType["Gif"] = "image/gif";
+	AttachmentMediaType["Jpeg"] = "image/jpeg";
+	AttachmentMediaType["Pdf"] = "application/pdf";
+	AttachmentMediaType["Png"] = "image/png";
+	AttachmentMediaType["Text"] = "text/plain";
+	AttachmentMediaType["Webp"] = "image/webp";
+	return AttachmentMediaType;
+}({});
+const attachmentMediaTypeSchema = z.enum(AttachmentMediaType);
+//#endregion
+//#region src/models/command/CommandType.ts
+let CommandType = /* @__PURE__ */ function(CommandType) {
+	CommandType["BackgroundTasks"] = "BackgroundTasks";
+	CommandType["CloseSession"] = "CloseSession";
+	CommandType["CloseShell"] = "CloseShell";
+	CommandType["CreateSession"] = "CreateSession";
+	CommandType["Fork"] = "Fork";
+	CommandType["Interrupt"] = "Interrupt";
+	CommandType["ListSessions"] = "ListSessions";
+	CommandType["OpenShell"] = "OpenShell";
+	CommandType["PermissionVerdict"] = "PermissionVerdict";
+	CommandType["Prompt"] = "Prompt";
+	CommandType["Resume"] = "Resume";
+	CommandType["ResumeAt"] = "ResumeAt";
+	CommandType["RewindFiles"] = "RewindFiles";
+	CommandType["SetModel"] = "SetModel";
+	CommandType["SetPermissionMode"] = "SetPermissionMode";
+	CommandType["ShellInput"] = "ShellInput";
+	CommandType["ShellResize"] = "ShellResize";
+	CommandType["SlashCommand"] = "SlashCommand";
+	CommandType["StopTask"] = "StopTask";
+	return CommandType;
+}({});
+const commandTypeSchema = z.enum(CommandType);
+//#endregion
+//#region src/models/command/BaseCommand.ts
+const createBaseCommandSchema = (typeSchema) => z.object({
+	id: z.string().min(1),
+	type: typeSchema
+});
+//#endregion
+//#region src/models/command/SessionId.ts
+const sessionIdSchema = z.object({ sessionId: z.string().min(1) });
+//#endregion
+//#region src/models/command/BackgroundTasksCommand.ts
+const backgroundTasksCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("BackgroundTasks")).shape,
+	...sessionIdSchema.shape
+});
+//#endregion
+//#region src/models/command/CloseSessionCommand.ts
+const closeSessionCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("CloseSession")).shape,
+	...sessionIdSchema.shape
+});
+//#endregion
+//#region src/models/command/CreateSessionCommand.ts
+const createSessionCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("CreateSession")).shape,
+	cwd: z.string().min(1)
+});
+//#endregion
+//#region src/models/command/ForkCommand.ts
+const forkCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("Fork")).shape,
+	...sessionIdSchema.shape,
+	messageUuid: z.string()
+});
+//#endregion
+//#region src/models/command/InterruptCommand.ts
+const interruptCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("Interrupt")).shape,
+	...sessionIdSchema.shape
+});
+//#endregion
+//#region src/models/command/ListSessionsCommand.ts
+const listSessionsCommandSchema = z.object({ ...createBaseCommandSchema(z.literal("ListSessions")).shape });
+//#endregion
+//#region src/models/command/PermissionVerdictCommand.ts
+const permissionVerdictCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("PermissionVerdict")).shape,
+	...sessionIdSchema.shape,
+	behavior: permissionBehaviorSchema,
+	message: z.string(),
+	requestId: z.string().min(1)
+});
+//#endregion
+//#region src/models/command/Attachment.ts
+const attachmentSchema = z.object({
+	data: z.string(),
+	mediaType: attachmentMediaTypeSchema,
+	name: z.string()
+});
+//#endregion
+//#region src/models/command/PromptCommand.ts
+const promptCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("Prompt")).shape,
+	...sessionIdSchema.shape,
+	attachments: attachmentSchema.array(),
+	text: z.string()
+});
+//#endregion
+//#region src/models/command/ResumeAtCommand.ts
+const resumeAtCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("ResumeAt")).shape,
+	...sessionIdSchema.shape,
+	messageUuid: z.string().min(1)
+});
+//#endregion
+//#region src/models/command/ResumeCommand.ts
+const resumeCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("Resume")).shape,
+	...sessionIdSchema.shape
+});
+//#endregion
+//#region src/models/command/RewindFilesCommand.ts
+const rewindFilesCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("RewindFiles")).shape,
+	...sessionIdSchema.shape,
+	messageUuid: z.string().min(1)
+});
+//#endregion
+//#region src/models/command/SetModelCommand.ts
+const setModelCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("SetModel")).shape,
+	...sessionIdSchema.shape,
+	model: z.string().min(1)
+});
+//#endregion
+//#region src/models/command/SetPermissionModeCommand.ts
+const setPermissionModeCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("SetPermissionMode")).shape,
+	...sessionIdSchema.shape,
+	permissionMode: permissionModeSchema
+});
+//#endregion
+//#region src/models/command/SlashCommandCommand.ts
+const slashCommandCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("SlashCommand")).shape,
+	...sessionIdSchema.shape,
+	arguments: z.string(),
+	name: z.string().min(1)
+});
+//#endregion
+//#region src/models/command/StopTaskCommand.ts
+const stopTaskCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("StopTask")).shape,
+	...sessionIdSchema.shape,
+	taskId: z.string().min(1)
+});
+//#endregion
+//#region src/models/command/DriverCommand.ts
+const driverCommandSchema = z.discriminatedUnion("type", [
+	backgroundTasksCommandSchema,
+	closeSessionCommandSchema,
+	createSessionCommandSchema,
+	forkCommandSchema,
+	interruptCommandSchema,
+	listSessionsCommandSchema,
+	permissionVerdictCommandSchema,
+	promptCommandSchema,
+	resumeAtCommandSchema,
+	resumeCommandSchema,
+	rewindFilesCommandSchema,
+	setModelCommandSchema,
+	setPermissionModeCommandSchema,
+	slashCommandCommandSchema,
+	stopTaskCommandSchema
+]);
+//#endregion
+//#region src/models/command/CloseShellCommand.ts
+const closeShellCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("CloseShell")).shape,
+	...shellIdSchema.shape
+});
+//#endregion
+//#region src/models/command/TerminalSize.ts
+const terminalSizeSchema = z.object({
+	cols: z.int().positive(),
+	rows: z.int().positive()
+});
+//#endregion
+//#region src/models/command/OpenShellCommand.ts
+const openShellCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("OpenShell")).shape,
+	...sessionIdSchema.shape,
+	...terminalSizeSchema.shape,
+	cwd: z.string().min(1)
+});
+//#endregion
+//#region src/models/command/ShellInputCommand.ts
+const shellInputCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("ShellInput")).shape,
+	...shellIdSchema.shape,
+	data: z.string().min(1)
+});
+//#endregion
+//#region src/models/command/ShellResizeCommand.ts
+const shellResizeCommandSchema = z.object({
+	...createBaseCommandSchema(z.literal("ShellResize")).shape,
+	...shellIdSchema.shape,
+	...terminalSizeSchema.shape
+});
+//#endregion
+//#region src/models/command/ShellCommand.ts
+const shellCommandSchema = z.discriminatedUnion("type", [
+	closeShellCommandSchema,
+	openShellCommandSchema,
+	shellInputCommandSchema,
+	shellResizeCommandSchema
+]);
+//#endregion
+//#region src/models/command/Command.ts
+const commandSchema = z.discriminatedUnion("type", [...driverCommandSchema.options, ...shellCommandSchema.options]);
+//#endregion
+//#region src/models/handshake/BaseHandshakeMessage.ts
+const createBaseHandshakeMessageSchema = (typeSchema) => z.object({ type: typeSchema });
+//#endregion
+//#region src/models/handshake/AuthenticateMessage.ts
+const authenticateMessageSchema = z.object({
+	...createBaseHandshakeMessageSchema(z.literal("Authenticate")).shape,
+	credential: z.string().min(1)
+});
+//#endregion
+//#region src/models/handshake/ChallengeMessage.ts
+const challengeMessageSchema = z.object({
+	...createBaseHandshakeMessageSchema(z.literal("Challenge")).shape,
+	nonce: z.string().min(1)
+});
+//#endregion
+//#region src/models/handshake/HandOffMessage.ts
+const handOffMessageSchema = z.object({
+	...createBaseHandshakeMessageSchema(z.literal("HandOff")).shape,
+	code: z.string().min(1),
+	signature: z.string().min(1)
+});
+//#endregion
+//#region src/models/handshake/PairMessage.ts
+const pairMessageSchema = z.object({
+	...createBaseHandshakeMessageSchema(z.literal("Pair")).shape,
+	code: z.string().min(1)
+});
+//#endregion
+//#region src/models/handshake/RevokeMessage.ts
+const revokeMessageSchema = z.object({
+	...createBaseHandshakeMessageSchema(z.literal("Revoke")).shape,
+	deviceId: z.string().min(1),
+	signature: z.string().min(1)
+});
+//#endregion
+//#region src/models/handshake/HandshakeMessage.ts
+const handshakeMessageSchema = z.discriminatedUnion("type", [
+	authenticateMessageSchema,
+	challengeMessageSchema,
+	handOffMessageSchema,
+	pairMessageSchema,
+	revokeMessageSchema
+]);
+//#endregion
+//#region src/models/server/HostCloseCode.ts
+let HostCloseCode = /* @__PURE__ */ function(HostCloseCode) {
+	HostCloseCode[HostCloseCode["HandshakeRefused"] = 4400] = "HandshakeRefused";
+	HostCloseCode[HostCloseCode["CredentialRefused"] = 4401] = "CredentialRefused";
+	HostCloseCode[HostCloseCode["PairingRefused"] = 4403] = "PairingRefused";
+	HostCloseCode[HostCloseCode["SignatureRefused"] = 4404] = "SignatureRefused";
+	return HostCloseCode;
+}({});
+//#endregion
+//#region src/models/event/EphemeralAgentEventTypes.ts
+const EphemeralAgentEventTypes = ["StreamDelta", "TurnUsage"];
+//#endregion
+export { eventsMessageSchema as $, serverMessageTypeSchema as $t, forkCommandSchema as A, permissionRequestEventSchema as At, getSignedText as B, commandOutputEventSchema as Bt, resumeCommandSchema as C, PermissionMode as Ct, permissionVerdictCommandSchema as D, permissionResolutionEventSchema as Dt, attachmentSchema as E, rateLimitEventSchema as Et, createBaseCommandSchema as F, fileRewindEventSchema as Ft, shellIdSchema as G, parentToolUseIdSchema as Gt, shellOutputMessageSchema as H, slashCommandSchema as Ht, CommandType as I, contextUsageEventSchema as It, sessionResetMessageSchema as J, AgentEventType as Jt, sessionsMessageSchema as K, messageUuidSchema as Kt, commandTypeSchema as L, compactionEventSchema as Lt, closeSessionCommandSchema as M, hookEventSchema as Mt, backgroundTasksCommandSchema as N, HookPhase as Nt, listSessionsCommandSchema as O, PermissionBehavior as Ot, sessionIdSchema as P, hookPhaseSchema as Pt, hostStoppingMessageSchema as Q, ServerMessageType as Qt, AttachmentMediaType as R, CompactionTrigger as Rt, rewindFilesCommandSchema as S, sessionInitEventSchema as St, promptCommandSchema as T, mcpServerSchema as Tt, shellOpenedMessageSchema as U, modelSchema as Ut, serverMessageSchema as V, capabilitiesEventSchema as Vt, shellClosedMessageSchema as W, assistantMessageEventSchema as Wt, proofMessageSchema as X, commandErrorMessageSchema as Xt, sessionOpenedMessageSchema as Y, agentEventTypeSchema as Yt, pairedMessageSchema as Z, authenticatedMessageSchema as Zt, driverCommandSchema as _, streamDeltaEventSchema as _t, pairMessageSchema as a, DEFAULT_PORT as an, tokenUsageSchema as at, setPermissionModeCommandSchema as b, sessionStateSchema as bt, authenticateMessageSchema as c, PAIRING_HASH_PARAMETER as cn, toolProgressEventSchema as ct, shellCommandSchema as d, HandshakeMessageType as dn, TodoStatus as dt, createBaseServerMessageSchema as en, agentEventSchema as et, shellResizeCommandSchema as f, handshakeMessageTypeSchema as fn, todoStatusSchema as ft, closeShellCommandSchema as g, subagentStatusSchema as gt, terminalSizeSchema as h, SubagentStatus as ht, revokeMessageSchema as i, DEFAULT_HOSTNAME as in, turnResultEventSchema as it, createSessionCommandSchema as j, hostErrorEventSchema as jt, interruptCommandSchema as k, permissionBehaviorSchema as kt, createBaseHandshakeMessageSchema as l, SCHEME_PAIRING_CODE_DURATION as ln, todoUpdateEventSchema as lt, openShellCommandSchema as m, subagentEventSchema as mt, HostCloseCode as n, signaturePurposeSchema as nn, unknownEventSchema as nt, handOffMessageSchema as o, HOST_SCHEME as on, toolUseEventSchema as ot, shellInputCommandSchema as p, thinkingEventSchema as pt, sessionSummarySchema as q, createBaseAgentEventSchema as qt, handshakeMessageSchema as r, DEFAULT_APP_ORIGIN as rn, turnUsageEventSchema as rt, challengeMessageSchema as s, PAIRING_CODE_PARAMETER as sn, toolResultEventSchema as st, EphemeralAgentEventTypes as t, SignaturePurpose as tn, userMessageEventSchema as tt, commandSchema as u, SHELL_OUTPUT_LENGTH as un, todoSchema as ut, stopTaskCommandSchema as v, sessionStateEventSchema as vt, resumeAtCommandSchema as w, permissionModeSchema as wt, setModelCommandSchema as x, sessionSettingsEventSchema as xt, slashCommandCommandSchema as y, SessionState as yt, attachmentMediaTypeSchema as z, compactionTriggerSchema as zt };