@agentknight/sdk 0.9.35

package/dist/chunks/chunk-ZKAN2FO7.js

@@ -0,0 +1,2654 @@
+// ../protocol/dist/sessions/sessions.js
+import { z as z3 } from "zod";
+
+// ../protocol/dist/common/primitives.js
+import { z } from "zod";
+var IdSchema = z.string().trim().min(1).max(256);
+var IsoDateSchema = z.iso.datetime({ offset: true });
+var Base64UrlKeyIdSchema = z.string().regex(/^[A-Za-z0-9_-]{22}$/u, "Expected a 16-byte base64url key ID");
+var UsernameSchema = z.string().trim().min(1).max(120);
+
+// ../protocol/dist/common/errors.js
+import { z as z2 } from "zod";
+var ProtocolFailureSchema = z2.object({
+  code: IdSchema,
+  message: z2.string().min(1).max(1024)
+});
+var OperationAckSchema = z2.discriminatedUnion("ok", [
+  z2.object({ ok: z2.literal(true), capabilities: z2.array(IdSchema).max(64).optional() }),
+  z2.object({
+    ok: z2.literal(false),
+    code: IdSchema,
+    message: z2.string().min(1).max(1024)
+  })
+]);
+var ProtocolErrorSchema = z2.object({
+  event: z2.string().min(1).max(128),
+  code: IdSchema,
+  message: z2.string().min(1).max(1024)
+});
+
+// ../protocol/dist/sessions/sessions.js
+var SESSION_DELETE_CAPABILITY = "session-delete";
+var SESSION_LIST_UPDATES_CAPABILITY = "session-list-updates";
+var SESSION_WORKTREE_CREATION_CAPABILITY = "session-worktree-creation";
+var MANAGED_SESSION_SELECTION_CAPABILITY = "coding-agent:managed";
+var AGENT_CONTROLS_CAPABILITY = "coding-agent-controls-v1";
+var GroupChatParticipantSchema = z3.object({
+  sessionId: IdSchema,
+  title: z3.string().trim().min(1).max(260)
+}).strict();
+var GroupChatInfoSchema = z3.object({
+  participants: z3.array(GroupChatParticipantSchema).length(2).refine((participants) => new Set(participants.map((participant) => participant.sessionId)).size === 2, "A group requires two different sessions"),
+  state: z3.enum(["ready", "running", "paused", "blocked"])
+}).strict();
+var SessionSummarySchema = z3.object({
+  userId: IdSchema,
+  sessionId: IdSchema,
+  machineId: IdSchema,
+  summary: z3.string().max(4096).optional(),
+  renameSupported: z3.boolean().optional(),
+  workingDirectory: z3.string().max(32768).optional(),
+  gitRoot: z3.string().max(32768).optional(),
+  repository: z3.string().max(1024).optional(),
+  gitRemoteUrl: z3.string().max(32768).optional(),
+  branch: z3.string().max(1024).optional(),
+  isRemote: z3.boolean(),
+  createdAt: IsoDateSchema,
+  modifiedAt: IsoDateSchema,
+  groupChat: GroupChatInfoSchema.optional()
+});
+var SessionsSnapshotSchema = z3.object({
+  userId: IdSchema,
+  machineId: IdSchema,
+  machineName: z3.string().trim().min(1).max(120),
+  platform: z3.string().trim().min(1).max(64),
+  agentRunId: IdSchema,
+  sequence: z3.number().int().positive(),
+  generatedAt: IsoDateSchema,
+  complete: z3.boolean(),
+  totalCount: z3.number().int().nonnegative(),
+  nextCursor: z3.string().min(1).max(1024).optional(),
+  sessions: z3.array(SessionSummarySchema)
+}).superRefine((snapshot, context) => {
+  if (snapshot.totalCount < snapshot.sessions.length) {
+    context.addIssue({
+      code: "custom",
+      message: "Snapshot totalCount cannot be smaller than its session page",
+      path: ["totalCount"]
+    });
+  }
+  if (snapshot.complete === (snapshot.nextCursor !== void 0)) {
+    context.addIssue({
+      code: "custom",
+      message: "Incomplete snapshots require a nextCursor",
+      path: ["nextCursor"]
+    });
+  }
+  const sessionIds = /* @__PURE__ */ new Set();
+  for (const [index, session] of snapshot.sessions.entries()) {
+    if (session.machineId !== snapshot.machineId) {
+      context.addIssue({
+        code: "custom",
+        message: "Session machineId must match snapshot machineId",
+        path: ["sessions", index, "machineId"]
+      });
+    }
+    if (session.userId !== snapshot.userId) {
+      context.addIssue({
+        code: "custom",
+        message: "Session userId must match snapshot userId",
+        path: ["sessions", index, "userId"]
+      });
+    }
+    if (sessionIds.has(session.sessionId)) {
+      context.addIssue({
+        code: "custom",
+        message: "Session IDs must be unique within a snapshot",
+        path: ["sessions", index, "sessionId"]
+      });
+    }
+    sessionIds.add(session.sessionId);
+  }
+});
+var SessionListRequestSchema = z3.object({
+  requestId: IdSchema,
+  machineId: IdSchema,
+  cursor: z3.string().min(1).max(1024).optional()
+});
+var SessionListResultSchema = z3.discriminatedUnion("ok", [
+  z3.object({
+    ok: z3.literal(true),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    snapshot: SessionsSnapshotSchema
+  }),
+  z3.object({
+    ok: z3.literal(false),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    error: ProtocolFailureSchema
+  })
+]);
+var SessionAgentModeSchema = z3.enum([
+  "interactive",
+  "plan",
+  "autopilot"
+]);
+var AgentConfigurationOptionSchema = z3.object({
+  id: IdSchema,
+  name: z3.string().trim().min(1).max(260),
+  value: z3.string().min(1).max(256),
+  options: z3.array(z3.object({
+    value: z3.string().min(1).max(256),
+    name: z3.string().trim().min(1).max(260)
+  }).strict()).min(1).max(100)
+}).strict();
+var AgentConfigurationChangeSchema = z3.object({
+  id: IdSchema,
+  value: z3.string().min(1).max(256)
+}).strict();
+var WorkspaceOptionSchema = z3.object({
+  id: IdSchema,
+  name: z3.string().trim().min(1).max(260),
+  path: z3.string().trim().min(1).max(32768)
+});
+var REASONING_EFFORTS = [
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var ReasoningEffortSchema = z3.enum(REASONING_EFFORTS);
+var CopilotModelOptionSchema = z3.object({
+  id: IdSchema,
+  name: z3.string().trim().min(1).max(260),
+  isDefault: z3.boolean(),
+  supportedReasoningEfforts: z3.array(ReasoningEffortSchema).optional(),
+  defaultReasoningEffort: ReasoningEffortSchema.optional(),
+  creation: z3.object({
+    agentId: IdSchema,
+    agentName: z3.string().trim().min(1).max(260),
+    modelName: z3.string().trim().min(1).max(260),
+    agentModes: z3.array(SessionAgentModeSchema).min(1),
+    reasoningEffortConfigurationSupported: z3.boolean(),
+    isDefault: z3.boolean()
+  }).strict().optional()
+});
+var SessionReasoningEffortSchema = z3.enum([
+  "default",
+  ...REASONING_EFFORTS
+]);
+var CurrentReasoningEffortSchema = z3.string().trim().min(1).max(64);
+var SessionToolInfoSchema = z3.object({
+  name: z3.string().trim().min(1).max(260),
+  description: z3.string().trim().min(1).max(4096).optional(),
+  deferred: z3.boolean().optional()
+});
+var SessionSlashCommandInfoSchema = z3.object({
+  name: z3.string().trim().min(1).max(260),
+  description: z3.string().trim().min(1).max(4096).optional(),
+  kind: z3.enum(["builtin", "skill", "client"])
+});
+var SessionSkillInfoSchema = z3.object({
+  name: z3.string().trim().min(1).max(260),
+  description: z3.string().trim().min(1).max(4096).optional(),
+  source: z3.string().trim().min(1).max(260),
+  enabled: z3.boolean(),
+  userInvocable: z3.boolean(),
+  commandName: z3.string().trim().min(1).max(260).optional()
+});
+var SessionEnvironmentInfoSchema = z3.object({
+  tools: z3.array(SessionToolInfoSchema).max(512),
+  slashCommands: z3.array(SessionSlashCommandInfoSchema).max(512),
+  skills: z3.array(SessionSkillInfoSchema).max(512)
+});
+var SessionOptionsRequestSchema = z3.object({
+  requestId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema.optional(),
+  workspaceId: IdSchema.optional(),
+  capabilities: z3.array(IdSchema).max(64).optional()
+});
+var SessionOptionsResultSchema = z3.discriminatedUnion("ok", [
+  z3.object({
+    ok: z3.literal(true),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema.optional(),
+    workspaces: z3.array(WorkspaceOptionSchema),
+    models: z3.array(CopilotModelOptionSchema).min(1),
+    modelRefreshError: z3.string().min(1).max(4096).optional(),
+    agentModes: z3.array(SessionAgentModeSchema).min(1),
+    reasoningEffortConfigurationSupported: z3.literal(true).optional(),
+    fileAttachmentsSupported: z3.boolean().optional(),
+    worktreeCreationSupported: z3.literal(true).optional(),
+    worktreeBranches: z3.array(z3.string().min(1).max(1024)).optional(),
+    worktreeCurrentBranch: z3.string().min(1).max(1024).optional(),
+    currentModelId: IdSchema.optional(),
+    currentAgentMode: SessionAgentModeSchema.optional(),
+    currentReasoningEffort: CurrentReasoningEffortSchema.optional(),
+    environment: SessionEnvironmentInfoSchema.optional(),
+    agentName: z3.string().trim().min(1).max(260).optional(),
+    configOptions: z3.array(AgentConfigurationOptionSchema).max(32).optional()
+  }),
+  z3.object({
+    ok: z3.literal(false),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema.optional(),
+    error: ProtocolFailureSchema
+  })
+]);
+var SessionCreateRequestSchema = z3.object({
+  requestId: IdSchema,
+  machineId: IdSchema,
+  workspaceId: IdSchema,
+  modelId: IdSchema,
+  agentMode: SessionAgentModeSchema,
+  reasoningEffort: SessionReasoningEffortSchema.optional(),
+  worktree: z3.object({
+    branchName: z3.string().trim().min(1).max(120).optional(),
+    baseBranch: z3.string().trim().min(1).max(1024).optional()
+  }).strict().optional()
+});
+var SessionCreateResultSchema = z3.discriminatedUnion("ok", [
+  z3.object({
+    ok: z3.literal(true),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    session: SessionSummarySchema,
+    modelId: IdSchema,
+    agentMode: SessionAgentModeSchema,
+    reasoningEffort: SessionReasoningEffortSchema.optional()
+  }),
+  z3.object({
+    ok: z3.literal(false),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    error: ProtocolFailureSchema
+  })
+]);
+var SessionDeleteRequestSchema = z3.object({
+  requestId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema
+}).strict();
+var SessionDeleteResultSchema = z3.discriminatedUnion("ok", [
+  z3.object({
+    ok: z3.literal(true),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema
+  }).strict(),
+  z3.object({
+    ok: z3.literal(false),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema,
+    error: ProtocolFailureSchema
+  }).strict()
+]);
+var SessionConfigureRequestSchema = z3.object({
+  requestId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema,
+  modelId: IdSchema.optional(),
+  agentMode: SessionAgentModeSchema.optional(),
+  reasoningEffort: SessionReasoningEffortSchema.optional(),
+  configOption: AgentConfigurationChangeSchema.optional()
+}).refine((request) => request.modelId !== void 0 || request.agentMode !== void 0 || request.reasoningEffort !== void 0 || request.configOption !== void 0, { message: "A modelId, agentMode, reasoningEffort, or configOption change is required" });
+var SessionConfigureResultSchema = z3.discriminatedUnion("ok", [
+  z3.object({
+    ok: z3.literal(true),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema,
+    modelId: IdSchema.optional(),
+    agentMode: SessionAgentModeSchema,
+    reasoningEffort: CurrentReasoningEffortSchema.optional(),
+    configOptions: z3.array(AgentConfigurationOptionSchema).max(32).optional()
+  }),
+  z3.object({
+    ok: z3.literal(false),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema,
+    error: ProtocolFailureSchema
+  })
+]);
+var SessionRemoteActionSchema = z3.enum([
+  "status",
+  "enable",
+  "disable"
+]);
+var SessionRemoteStateSchema = z3.enum([
+  "off",
+  "connecting",
+  "active",
+  "error"
+]);
+var SessionRemoteRequestSchema = z3.object({
+  requestId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema,
+  action: SessionRemoteActionSchema
+});
+var SessionRemoteStatusSchema = z3.object({
+  state: SessionRemoteStateSchema,
+  attachedSessionId: IdSchema.optional(),
+  url: z3.url().max(32768).optional(),
+  steerable: z3.boolean(),
+  error: ProtocolFailureSchema.optional()
+});
+var SessionRemoteResultSchema = z3.discriminatedUnion("ok", [
+  z3.object({
+    ok: z3.literal(true),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema,
+    status: SessionRemoteStatusSchema
+  }),
+  z3.object({
+    ok: z3.literal(false),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema,
+    error: ProtocolFailureSchema
+  })
+]);
+
+// ../protocol/dist/conversation/attachments.js
+import { z as z4 } from "zod";
+var MAX_INLINE_IMAGE_BYTES = 3 * 1024 * 1024;
+var MAX_INLINE_HTML_BYTES = 512 * 1024;
+var MAX_PROMPT_FILE_BYTES = 1024 * 1024;
+var InlineImageMimeTypeSchema = z4.enum([
+  "image/gif",
+  "image/jpeg",
+  "image/png",
+  "image/webp"
+]);
+var Base64DataSchema = z4.string().min(4).max(Math.ceil(MAX_INLINE_IMAGE_BYTES / 3) * 4).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/, "Expected canonical base64 data");
+var Sha256Schema = z4.string().regex(/^[a-f0-9]{64}$/);
+function decodedBase64ByteLength(value) {
+  const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+  return value.length / 4 * 3 - padding;
+}
+var PromptImageAttachmentSchema = z4.object({
+  name: z4.string().trim().min(1).max(255),
+  mimeType: z4.enum(["image/jpeg", "image/png", "image/webp"]),
+  data: Base64DataSchema,
+  byteLength: z4.number().int().positive().max(MAX_INLINE_IMAGE_BYTES),
+  sha256: Sha256Schema
+}).strict().superRefine((attachment, context) => {
+  if (decodedBase64ByteLength(attachment.data) !== attachment.byteLength) {
+    context.addIssue({
+      code: "custom",
+      path: ["byteLength"],
+      message: "byteLength does not match the base64 payload"
+    });
+  }
+});
+var PromptFileAttachmentSchema = z4.object({
+  name: z4.string().trim().min(1).max(255).regex(/^[^\\/\x00-\x1f\x7f]+$/).refine((name) => name !== "." && name !== "..", "Expected a filename"),
+  mimeType: z4.string().max(256).regex(/^[a-zA-Z0-9!#$&^_.+-]+\/[a-zA-Z0-9!#$&^_.+-]+$/),
+  data: Base64DataSchema.max(Math.ceil(MAX_PROMPT_FILE_BYTES / 3) * 4),
+  byteLength: z4.number().int().positive().max(MAX_PROMPT_FILE_BYTES),
+  sha256: Sha256Schema
+}).strict().superRefine((attachment, context) => {
+  if (decodedBase64ByteLength(attachment.data) !== attachment.byteLength) {
+    context.addIssue({
+      code: "custom",
+      path: ["byteLength"],
+      message: "byteLength does not match the base64 payload"
+    });
+  }
+});
+var ConversationAttachmentSchema = z4.object({
+  kind: z4.enum([
+    "file",
+    "image",
+    "html",
+    "selection",
+    "github-reference",
+    "unknown"
+  ]),
+  name: z4.string().trim().min(1).max(1024),
+  mimeType: z4.string().trim().min(1).max(256).optional(),
+  uri: z4.string().trim().min(1).max(32768).optional(),
+  data: Base64DataSchema.optional(),
+  byteLength: z4.number().int().positive().max(MAX_INLINE_IMAGE_BYTES).optional(),
+  sha256: Sha256Schema.optional(),
+  imageRef: z4.literal("sha256").optional()
+}).strict().superRefine((attachment, context) => {
+  if (attachment.imageRef !== void 0) {
+    if (attachment.kind !== "image" || attachment.data !== void 0 || attachment.sha256 === void 0 || attachment.byteLength === void 0 || !InlineImageMimeTypeSchema.safeParse(attachment.mimeType).success) {
+      context.addIssue({
+        code: "custom",
+        message: "Image references require image metadata and must not carry inline data"
+      });
+    }
+    return;
+  }
+  const contentFields = [
+    attachment.data,
+    attachment.byteLength,
+    attachment.sha256
+  ];
+  const contentFieldCount = contentFields.filter((field) => field !== void 0).length;
+  if (contentFieldCount !== 0 && contentFieldCount !== contentFields.length) {
+    context.addIssue({
+      code: "custom",
+      message: "Inline attachment content requires data, byteLength, and sha256"
+    });
+    return;
+  }
+  if (attachment.data === void 0 || attachment.byteLength === void 0) {
+    return;
+  }
+  if (attachment.kind !== "image" && attachment.kind !== "html") {
+    context.addIssue({
+      code: "custom",
+      path: ["data"],
+      message: "Only image and html attachments may carry inline content"
+    });
+  }
+  if (attachment.kind === "image" && !InlineImageMimeTypeSchema.safeParse(attachment.mimeType).success) {
+    context.addIssue({
+      code: "custom",
+      path: ["mimeType"],
+      message: "Inline images must be GIF, JPEG, PNG, or WebP"
+    });
+  }
+  if (attachment.kind === "html" && (attachment.mimeType !== "text/html" || attachment.byteLength > MAX_INLINE_HTML_BYTES)) {
+    context.addIssue({
+      code: "custom",
+      path: ["mimeType"],
+      message: "HTML content must be text/html and at most 512 KiB"
+    });
+  }
+  if (decodedBase64ByteLength(attachment.data) !== attachment.byteLength) {
+    context.addIssue({
+      code: "custom",
+      path: ["byteLength"],
+      message: "byteLength does not match the base64 payload"
+    });
+  }
+});
+
+// ../protocol/dist/conversation/conversation.js
+import { z as z5 } from "zod";
+var CONVERSATION_ACTIVITY_STEP_LIMIT = 1e3;
+var CONVERSATION_SOURCE_ID_LIMIT = 1e3;
+var ConversationItemBaseShape = {
+  id: IdSchema,
+  revision: z5.number().int().positive(),
+  turnId: IdSchema,
+  timestamp: IsoDateSchema,
+  sourceEventIds: z5.array(IdSchema).min(1).max(CONVERSATION_SOURCE_ID_LIMIT),
+  sourceMessageIds: z5.array(IdSchema).min(1).max(CONVERSATION_SOURCE_ID_LIMIT).optional(),
+  sourceInteractionIds: z5.array(IdSchema).min(1).max(CONVERSATION_SOURCE_ID_LIMIT).optional()
+};
+var MAX_INLINE_IMAGE_MESSAGE_BYTES = 3 * 1024 * 1024;
+var MAX_INLINE_IMAGES_PER_MESSAGE = 4;
+var ActivityStepTimeShape = {
+  // First observed event time; completion updates must not move an existing call.
+  timestamp: IsoDateSchema.optional()
+};
+var ConversationToolStepSchema = z5.object({
+  id: IdSchema,
+  kind: z5.literal("tool"),
+  name: z5.string().trim().min(1).max(256),
+  status: z5.enum(["running", "completed", "failed"]),
+  ...ActivityStepTimeShape
+}).strict();
+var ConversationSkillStepSchema = z5.object({
+  id: IdSchema,
+  kind: z5.literal("skill"),
+  name: z5.string().trim().min(1).max(256),
+  status: z5.literal("completed"),
+  description: z5.string().trim().min(1).max(2048).optional(),
+  source: z5.string().trim().min(1).max(256).optional(),
+  ...ActivityStepTimeShape
+}).strict();
+var ConversationSubagentStepSchema = z5.object({
+  id: IdSchema,
+  kind: z5.literal("subagent"),
+  name: z5.string().trim().min(1).max(256),
+  status: z5.enum(["running", "completed", "failed"]),
+  description: z5.string().trim().min(1).max(2048).optional(),
+  model: z5.string().trim().min(1).max(256).optional(),
+  durationMs: z5.number().int().nonnegative().optional(),
+  resultSummary: z5.string().max(4096).optional(),
+  error: z5.string().max(4096).optional(),
+  ...ActivityStepTimeShape
+}).strict();
+var ConversationPermissionStepSchema = z5.object({
+  id: IdSchema,
+  kind: z5.literal("permission"),
+  name: z5.string().trim().min(1).max(256),
+  status: z5.enum(["running", "completed", "failed"]),
+  description: z5.string().trim().min(1).max(2048).optional(),
+  resultSummary: z5.string().max(4096).optional(),
+  error: z5.string().max(4096).optional(),
+  ...ActivityStepTimeShape
+}).strict();
+var ConversationActivityStepSchema = z5.discriminatedUnion("kind", [
+  ConversationToolStepSchema,
+  ConversationSkillStepSchema,
+  ConversationSubagentStepSchema,
+  ConversationPermissionStepSchema
+]);
+var ConversationHumanMessageSchema = z5.object({
+  ...ConversationItemBaseShape,
+  kind: z5.literal("human-message"),
+  actor: z5.literal("human"),
+  content: z5.string().max(1e5),
+  attachments: z5.array(ConversationAttachmentSchema).max(100),
+  operationId: IdSchema.optional()
+}).strict();
+var ConversationAssistantMessageSchema = z5.object({
+  ...ConversationItemBaseShape,
+  kind: z5.literal("assistant-message"),
+  actor: z5.enum(["assistant", "subagent"]),
+  content: z5.string().max(5e5),
+  attachments: z5.array(ConversationAttachmentSchema).max(100).optional(),
+  model: z5.string().trim().min(1).max(256).optional(),
+  agentId: IdSchema.optional(),
+  final: z5.boolean()
+}).strict().superRefine((message, context) => {
+  const inlineImages = message.attachments?.filter((attachment) => attachment.kind === "image" && attachment.data !== void 0) ?? [];
+  if (inlineImages.length > MAX_INLINE_IMAGES_PER_MESSAGE) {
+    context.addIssue({
+      code: "custom",
+      path: ["attachments"],
+      message: "Assistant messages may contain at most 4 inline images"
+    });
+  }
+  const inlineImageBytes = inlineImages.reduce((total, attachment) => total + (attachment.byteLength ?? 0), 0);
+  if (inlineImageBytes > MAX_INLINE_IMAGE_MESSAGE_BYTES) {
+    context.addIssue({
+      code: "custom",
+      path: ["attachments"],
+      message: "Assistant message images exceed the 3 MiB total limit"
+    });
+  }
+});
+var ConversationActivityGroupSchema = z5.object({
+  ...ConversationItemBaseShape,
+  kind: z5.literal("activity-group"),
+  actor: z5.enum(["assistant", "subagent"]),
+  status: z5.enum(["running", "completed", "failed"]),
+  steps: z5.array(ConversationActivityStepSchema).max(CONVERSATION_ACTIVITY_STEP_LIMIT)
+}).strict();
+var ConversationNoticeSchema = z5.object({
+  ...ConversationItemBaseShape,
+  kind: z5.literal("notice"),
+  actor: z5.enum(["system", "assistant", "subagent"]),
+  severity: z5.enum(["info", "success", "warning", "error"]),
+  title: z5.string().trim().min(1).max(256),
+  content: z5.string().max(4096),
+  presentation: z5.literal("compact").optional()
+}).strict();
+var ConversationPlanTodoSchema = z5.object({
+  id: IdSchema,
+  title: z5.string().trim().min(1).max(1024),
+  description: z5.string().max(4096).optional(),
+  status: z5.string().trim().min(1).max(64),
+  dependsOn: z5.array(IdSchema).max(100)
+}).strict();
+var ConversationPlanUpdateSchema = z5.object({
+  ...ConversationItemBaseShape,
+  kind: z5.literal("plan-update"),
+  actor: z5.enum(["assistant", "subagent"]),
+  operation: z5.enum(["created", "updated", "deleted"]),
+  content: z5.string().max(1e5),
+  todos: z5.array(ConversationPlanTodoSchema).max(1e3)
+}).strict();
+var ConversationItemSchema = z5.discriminatedUnion("kind", [
+  ConversationHumanMessageSchema,
+  ConversationAssistantMessageSchema,
+  ConversationActivityGroupSchema,
+  ConversationNoticeSchema,
+  ConversationPlanUpdateSchema
+]);
+var ConversationItemUpsertSchema = z5.object({
+  userId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema,
+  item: ConversationItemSchema
+});
+var ConversationActivityStepUpsertSchema = z5.object({
+  userId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema,
+  activityId: IdSchema,
+  revision: z5.number().int().positive(),
+  turnId: IdSchema,
+  timestamp: IsoDateSchema,
+  actor: z5.enum(["assistant", "subagent"]),
+  status: z5.enum(["running", "completed", "failed"]),
+  sourceEventId: IdSchema,
+  step: ConversationActivityStepSchema
+}).strict();
+
+// ../protocol/dist/conversation/timeline.js
+import { z as z6 } from "zod";
+var SESSION_ASSISTANT_PREVIEW_CAPABILITY = "session-assistant-preview-v1";
+var SessionUserPreviewSchema = z6.object({
+  id: IdSchema,
+  revision: z6.number().int().positive(),
+  timestamp: IsoDateSchema,
+  text: z6.string().max(4096)
+});
+var SessionAssistantPreviewSchema = z6.object({
+  id: IdSchema,
+  revision: z6.number().int().positive(),
+  timestamp: IsoDateSchema,
+  sourceEventIds: z6.array(IdSchema).min(1).max(1e3),
+  text: z6.string().max(4096),
+  final: z6.boolean(),
+  attachments: z6.array(ConversationAttachmentSchema.refine((attachment) => attachment.kind === "image" && attachment.imageRef === "sha256", "Assistant previews contain image references only")).max(4)
+});
+var SESSION_TIMELINE_PAGE_SIZE = 100;
+var SessionTimelinePageRequestSchema = z6.object({
+  requestId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema,
+  cursor: z6.string().max(32768).optional(),
+  metadataOnly: z6.boolean().optional(),
+  acceptContentEncodings: z6.array(z6.string().min(1).max(32)).max(8).optional(),
+  imageReferences: z6.boolean().optional(),
+  pageSize: z6.number().int().min(1).max(SESSION_TIMELINE_PAGE_SIZE).default(SESSION_TIMELINE_PAGE_SIZE),
+  assistantPreview: z6.boolean().optional()
+});
+var SessionWatchRequestSchema = z6.object({
+  requestId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema,
+  watching: z6.boolean()
+}).strict();
+var SessionWatchResultSchema = z6.discriminatedUnion("ok", [
+  z6.object({
+    ok: z6.literal(true),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema,
+    watching: z6.boolean()
+  }).strict(),
+  z6.object({
+    ok: z6.literal(false),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema,
+    watching: z6.boolean(),
+    error: ProtocolFailureSchema
+  }).strict()
+]);
+var SessionTimelinePageSchema = z6.object({
+  items: z6.array(ConversationItemSchema).max(SESSION_TIMELINE_PAGE_SIZE),
+  cursor: z6.string().max(32768),
+  hasMore: z6.boolean(),
+  cursorStatus: z6.enum(["ok", "expired"]),
+  assistantPreview: SessionAssistantPreviewSchema.optional(),
+  userPreview: SessionUserPreviewSchema.optional(),
+  previewsComplete: z6.boolean().optional()
+});
+var SessionTimelinePageResultSchema = z6.discriminatedUnion("ok", [
+  z6.object({
+    ok: z6.literal(true),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema,
+    page: SessionTimelinePageSchema
+  }),
+  z6.object({
+    ok: z6.literal(false),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema,
+    error: ProtocolFailureSchema
+  })
+]);
+var SessionTimelineInvalidatedSchema = z6.object({
+  userId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema,
+  reason: z6.enum(["clear", "rewind"]),
+  sourceEventId: IdSchema,
+  timestamp: IsoDateSchema
+}).strict();
+
+// ../protocol/dist/sessions/interactions.js
+import { z as z7 } from "zod";
+var MOBILE_INTERACTION_PERSISTENCE_CAPABILITY = "interaction-persistence";
+var INTERACTION_DISMISS_RESPONSE_CAPABILITY = "interaction-dismiss-response";
+var INTERACTION_SUPERSEDED_ERROR_CODE = "INTERACTION_SUPERSEDED";
+var InteractionFormFieldSchema = z7.object({
+  id: IdSchema,
+  label: z7.string().trim().min(1).max(1024),
+  description: z7.string().max(2048).optional(),
+  inputType: z7.enum([
+    "text",
+    "number",
+    "integer",
+    "boolean",
+    "select",
+    "multi-select"
+  ]),
+  required: z7.boolean(),
+  options: z7.array(z7.string().max(1024)).max(100),
+  defaultValue: z7.union([
+    z7.string().max(4096),
+    z7.number().finite(),
+    z7.boolean(),
+    z7.array(z7.string().max(1024)).max(100)
+  ]).optional(),
+  minimum: z7.number().finite().optional(),
+  maximum: z7.number().finite().optional(),
+  minLength: z7.number().int().nonnegative().max(1e6).optional(),
+  maxLength: z7.number().int().nonnegative().max(1e6).optional(),
+  minItems: z7.number().int().nonnegative().max(100).optional(),
+  maxItems: z7.number().int().nonnegative().max(100).optional(),
+  format: z7.enum(["email", "uri", "date", "date-time"]).optional()
+}).strict();
+var InteractionPermissionRequestSchema = z7.object({
+  kind: z7.literal("permission"),
+  permissionKind: IdSchema,
+  title: z7.string().trim().min(1).max(256),
+  description: z7.string().max(4096),
+  canApproveSession: z7.boolean(),
+  canApproveAlways: z7.boolean().optional(),
+  approvalScope: z7.string().trim().min(1).max(4096).optional()
+}).strict();
+var InteractionUserInputRequestSchema = z7.object({
+  kind: z7.literal("user_input"),
+  question: z7.string().trim().min(1).max(4096),
+  choices: z7.array(z7.string().max(1024)).max(100),
+  allowFreeform: z7.boolean()
+}).strict();
+var InteractionElicitationRequestSchema = z7.object({
+  kind: z7.literal("elicitation"),
+  message: z7.string().trim().min(1).max(4096),
+  mode: z7.enum(["form", "url"]),
+  source: z7.string().trim().min(1).max(256).optional(),
+  url: z7.url().max(32768).optional(),
+  fields: z7.array(InteractionFormFieldSchema).max(100)
+}).strict();
+var InteractionMcpOauthRequestSchema = z7.object({
+  kind: z7.literal("mcp_oauth"),
+  serverName: z7.string().trim().min(1).max(256),
+  serverUrl: z7.url().max(32768),
+  reason: z7.enum(["initial", "refresh", "reauth", "upscope"]),
+  responseMode: z7.literal("cancel-only")
+}).strict();
+var InteractionMcpHeadersRequestSchema = z7.object({
+  kind: z7.literal("mcp_headers"),
+  serverName: z7.string().trim().min(1).max(256),
+  serverUrl: z7.url().max(32768),
+  reason: z7.string().trim().min(1).max(256),
+  responseMode: z7.literal("none-only")
+}).strict();
+var InteractionAutoModeSwitchRequestSchema = z7.object({
+  kind: z7.literal("auto_mode_switch"),
+  errorCode: IdSchema.optional(),
+  retryAfterSeconds: z7.number().int().nonnegative().optional()
+}).strict();
+var InteractionSessionLimitsRequestSchema = z7.object({
+  kind: z7.literal("session_limits"),
+  maxAiCredits: z7.number().finite().nonnegative(),
+  usedAiCredits: z7.number().finite().nonnegative()
+}).strict();
+var InteractionExitPlanRequestSchema = z7.object({
+  kind: z7.literal("exit_plan"),
+  summary: z7.string().max(4096),
+  planContent: z7.string().max(1e5).optional(),
+  actions: z7.array(IdSchema).min(1).max(20),
+  recommendedAction: IdSchema
+}).strict();
+var InteractionRequestSchema = z7.discriminatedUnion("kind", [
+  InteractionPermissionRequestSchema,
+  InteractionUserInputRequestSchema,
+  InteractionElicitationRequestSchema,
+  InteractionMcpOauthRequestSchema,
+  InteractionMcpHeadersRequestSchema,
+  InteractionAutoModeSwitchRequestSchema,
+  InteractionSessionLimitsRequestSchema,
+  InteractionExitPlanRequestSchema
+]);
+var InteractionPermissionResponseSchema = z7.object({
+  kind: z7.literal("permission"),
+  decision: z7.enum(["approve-once", "approve-for-session", "approve-always", "reject"]),
+  feedback: z7.string().trim().min(1).max(2048).optional()
+}).strict();
+var InteractionUserInputResponseSchema = z7.object({
+  kind: z7.literal("user_input"),
+  answer: z7.string().max(1e5),
+  wasFreeform: z7.boolean()
+}).strict();
+var InteractionFieldValueSchema = z7.union([
+  z7.string().max(4096),
+  z7.number(),
+  z7.boolean(),
+  z7.array(z7.string().max(1024)).max(100)
+]);
+var InteractionElicitationResponseSchema = z7.object({
+  kind: z7.literal("elicitation"),
+  action: z7.enum(["accept", "decline", "cancel"]),
+  values: z7.record(z7.string().max(256), InteractionFieldValueSchema)
+}).strict();
+var InteractionMcpOauthResponseSchema = z7.object({
+  kind: z7.literal("mcp_oauth"),
+  action: z7.literal("cancel")
+}).strict();
+var InteractionMcpHeadersResponseSchema = z7.object({
+  kind: z7.literal("mcp_headers"),
+  action: z7.literal("none")
+}).strict();
+var InteractionAutoModeSwitchResponseSchema = z7.object({
+  kind: z7.literal("auto_mode_switch"),
+  action: z7.enum(["yes", "yes_always", "no"])
+}).strict();
+var InteractionSessionLimitsResponseSchema = z7.object({
+  kind: z7.literal("session_limits"),
+  action: z7.enum(["add", "set", "unset", "cancel"]),
+  additionalAiCredits: z7.number().positive().optional(),
+  maxAiCredits: z7.number().positive().optional()
+}).strict().superRefine((response, context) => {
+  if (response.action === "add" && response.additionalAiCredits === void 0) {
+    context.addIssue({
+      code: z7.ZodIssueCode.custom,
+      path: ["additionalAiCredits"],
+      message: "additionalAiCredits is required for add"
+    });
+  }
+  if (response.action === "set" && response.maxAiCredits === void 0) {
+    context.addIssue({
+      code: z7.ZodIssueCode.custom,
+      path: ["maxAiCredits"],
+      message: "maxAiCredits is required for set"
+    });
+  }
+  if (response.action !== "add" && response.additionalAiCredits !== void 0) {
+    context.addIssue({
+      code: z7.ZodIssueCode.custom,
+      path: ["additionalAiCredits"],
+      message: "additionalAiCredits is only valid for add"
+    });
+  }
+  if (response.action !== "set" && response.maxAiCredits !== void 0) {
+    context.addIssue({
+      code: z7.ZodIssueCode.custom,
+      path: ["maxAiCredits"],
+      message: "maxAiCredits is only valid for set"
+    });
+  }
+});
+var InteractionExitPlanResponseSchema = z7.object({
+  kind: z7.literal("exit_plan"),
+  approved: z7.boolean(),
+  selectedAction: IdSchema.optional(),
+  feedback: z7.string().trim().min(1).max(4096).optional()
+}).strict();
+var InteractionResponseSchema = z7.discriminatedUnion("kind", [
+  InteractionPermissionResponseSchema,
+  InteractionUserInputResponseSchema,
+  InteractionElicitationResponseSchema,
+  InteractionMcpOauthResponseSchema,
+  InteractionMcpHeadersResponseSchema,
+  InteractionAutoModeSwitchResponseSchema,
+  InteractionSessionLimitsResponseSchema,
+  InteractionExitPlanResponseSchema
+]);
+var InteractionRequestPayloadSchema = z7.object({
+  interactionRequestId: IdSchema,
+  userId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema,
+  request: InteractionRequestSchema
+}).strict();
+var InteractionRespondRequestSchema = z7.object({
+  requestId: IdSchema,
+  interactionRequestId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema,
+  response: InteractionResponseSchema
+}).strict();
+var InteractionRespondResultSchema = z7.discriminatedUnion("ok", [
+  z7.object({
+    ok: z7.literal(true),
+    requestId: IdSchema,
+    interactionRequestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema
+  }).strict(),
+  z7.object({
+    ok: z7.literal(false),
+    requestId: IdSchema,
+    interactionRequestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema,
+    error: ProtocolFailureSchema
+  }).strict()
+]);
+var PermissionRequestPayloadSchema = z7.object({
+  permissionRequestId: IdSchema,
+  userId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema,
+  request: z7.record(z7.string(), z7.unknown())
+});
+var PermissionRespondRequestSchema = z7.object({
+  requestId: IdSchema,
+  permissionRequestId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema,
+  decision: z7.enum(["approve-once", "reject"]),
+  feedback: z7.string().trim().min(1).max(2048).optional()
+});
+var PermissionRespondResultSchema = z7.discriminatedUnion("ok", [
+  z7.object({
+    ok: z7.literal(true),
+    requestId: IdSchema,
+    permissionRequestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema
+  }),
+  z7.object({
+    ok: z7.literal(false),
+    requestId: IdSchema,
+    permissionRequestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema,
+    error: ProtocolFailureSchema
+  })
+]);
+
+// ../protocol/dist/common/version.js
+import { z as z8 } from "zod";
+var LEGACY_PROTOCOL_VERSION = 10;
+var PROTOCOL_VERSION = 11;
+var OLDEST_SUPPORTED_PROTOCOL_VERSION = 9;
+var SupportedProtocolVersionSchema = z8.union([
+  z8.literal(OLDEST_SUPPORTED_PROTOCOL_VERSION),
+  z8.literal(LEGACY_PROTOCOL_VERSION),
+  z8.literal(PROTOCOL_VERSION)
+]);
+var TRANSPORT_V2 = 2;
+var SECURE_SOCKET_IO_NAMESPACE = "/v2";
+
+// ../protocol/dist/auth/authentication.js
+import { z as z9 } from "zod";
+var UserRoleSchema = z9.enum(["admin", "user"]);
+var PasswordSchema = z9.string().min(1).max(4096);
+var PcTokenLabelSchema = z9.string().trim().min(1).max(120);
+var AuthUserSchema = z9.object({
+  userId: IdSchema,
+  username: UsernameSchema,
+  role: UserRoleSchema
+}).strict();
+var LoginRequestSchema = z9.object({
+  username: UsernameSchema,
+  password: PasswordSchema
+});
+var LoginResultSchema = z9.discriminatedUnion("ok", [
+  z9.object({
+    ok: z9.literal(true),
+    accessToken: z9.string().min(32),
+    expiresAt: z9.number().int().positive(),
+    user: AuthUserSchema
+  }),
+  z9.object({
+    ok: z9.literal(false),
+    error: ProtocolFailureSchema
+  })
+]);
+var MobileLoginRequestSchema = z9.object({
+  mobileCredential: z9.string().min(64).max(4096),
+  clientId: IdSchema
+});
+var PcAccountRequestSchema = z9.object({
+  userId: IdSchema,
+  machineId: IdSchema
+}).strict();
+var PcAccountResultSchema = z9.discriminatedUnion("ok", [
+  z9.object({
+    ok: z9.literal(true),
+    user: AuthUserSchema,
+    method: z9.enum(["microsoft", "token"])
+  }).strict(),
+  z9.object({
+    ok: z9.literal(false),
+    error: ProtocolFailureSchema
+  }).strict()
+]);
+var AdminUserSummarySchema = z9.object({
+  userId: IdSchema,
+  username: UsernameSchema,
+  role: UserRoleSchema,
+  createdAt: z9.number().int().nonnegative(),
+  updatedAt: z9.number().int().nonnegative(),
+  disabledAt: z9.number().int().nonnegative().nullable()
+}).strict();
+var AdminFailureResultSchema = z9.object({
+  ok: z9.literal(false),
+  error: ProtocolFailureSchema
+}).strict();
+var AdminUserListResultSchema = z9.discriminatedUnion("ok", [
+  z9.object({
+    ok: z9.literal(true),
+    users: z9.array(AdminUserSummarySchema)
+  }).strict(),
+  AdminFailureResultSchema
+]);
+var AdminUserCreateRequestSchema = z9.object({
+  username: UsernameSchema,
+  password: PasswordSchema
+}).strict();
+var AdminUserCreateResultSchema = z9.discriminatedUnion("ok", [
+  z9.object({
+    ok: z9.literal(true),
+    user: AdminUserSummarySchema
+  }).strict(),
+  AdminFailureResultSchema
+]);
+var AdminUserStatusRequestSchema = z9.object({
+  userId: IdSchema,
+  disabled: z9.boolean()
+}).strict();
+var AdminUserStatusResultSchema = z9.discriminatedUnion("ok", [
+  z9.object({
+    ok: z9.literal(true),
+    user: AdminUserSummarySchema
+  }).strict(),
+  AdminFailureResultSchema
+]);
+var AdminUserPasswordRequestSchema = z9.object({
+  userId: IdSchema,
+  password: PasswordSchema
+}).strict();
+var AdminUserPasswordResultSchema = z9.discriminatedUnion("ok", [
+  z9.object({
+    ok: z9.literal(true),
+    user: AdminUserSummarySchema
+  }).strict(),
+  AdminFailureResultSchema
+]);
+var PcServiceTokenSummarySchema = z9.object({
+  tokenId: IdSchema,
+  userId: IdSchema,
+  label: PcTokenLabelSchema,
+  createdAt: z9.number().int().nonnegative(),
+  lastUsedAt: z9.number().int().nonnegative().nullable(),
+  revokedAt: z9.number().int().nonnegative().nullable()
+}).strict();
+var AdminPcTokenListRequestSchema = z9.object({
+  userId: IdSchema
+}).strict();
+var AdminPcTokenListResultSchema = z9.discriminatedUnion("ok", [
+  z9.object({
+    ok: z9.literal(true),
+    tokens: z9.array(PcServiceTokenSummarySchema)
+  }).strict(),
+  AdminFailureResultSchema
+]);
+var AdminPcTokenIssueRequestSchema = z9.object({
+  userId: IdSchema,
+  label: PcTokenLabelSchema
+}).strict();
+var AdminPcTokenIssueResultSchema = z9.discriminatedUnion("ok", [
+  z9.object({
+    ok: z9.literal(true),
+    token: z9.string().min(32).max(256),
+    pcToken: PcServiceTokenSummarySchema
+  }).strict(),
+  AdminFailureResultSchema
+]);
+var AdminPcTokenRevokeRequestSchema = z9.object({
+  tokenId: IdSchema
+}).strict();
+var AdminPcTokenRevokeResultSchema = z9.discriminatedUnion("ok", [
+  z9.object({
+    ok: z9.literal(true),
+    pcToken: PcServiceTokenSummarySchema
+  }).strict(),
+  AdminFailureResultSchema
+]);
+
+// ../protocol/dist/auth/pairing.js
+import { z as z10 } from "zod";
+var PAIRING_URI_SCHEME = "agentknight";
+var PAIRING_URI_HOST = "pair";
+var MOBILE_TRANSFER_MAX_PARTS = 64;
+var MOBILE_TRANSFER_PART_DATA_MAX_LENGTH = 2600;
+var MOBILE_TRANSFER_RELAY_TTL_MS = 10 * 60 * 1e3;
+var MOBILE_TRANSFER_RELAY_MAX_CIPHERTEXT_LENGTH = 128 * 1024;
+var PairingCreateRequestSchema = z10.object({
+  userId: IdSchema,
+  machineId: IdSchema,
+  stableDeviceId: IdSchema.optional(),
+  machineName: z10.string().trim().min(1).max(120),
+  keyId: Base64UrlKeyIdSchema.optional()
+});
+var PairingCreateResultSchema = z10.discriminatedUnion("ok", [
+  z10.object({
+    ok: z10.literal(true),
+    code: z10.string().min(32).max(256),
+    expiresAt: z10.number().int().positive()
+  }),
+  z10.object({
+    ok: z10.literal(false),
+    error: ProtocolFailureSchema
+  })
+]);
+var PairingExchangeRequestSchema = z10.object({
+  code: z10.string().min(32).max(256),
+  clientId: IdSchema
+});
+var PairingExchangeResultSchema = z10.discriminatedUnion("ok", [
+  z10.object({
+    ok: z10.literal(true),
+    accessToken: z10.string().min(32),
+    expiresAt: z10.number().int().positive(),
+    mobileCredential: z10.string().min(64).max(4096),
+    mobileCredentialExpiresAt: z10.number().int().positive(),
+    stableDeviceId: IdSchema.optional(),
+    user: AuthUserSchema
+  }),
+  z10.object({
+    ok: z10.literal(false),
+    error: ProtocolFailureSchema
+  })
+]);
+var MobileTransferMachineSchema = z10.object({
+  machineId: IdSchema,
+  mobileCredential: z10.string().min(64).max(4096),
+  contentKey: z10.string().regex(/^[A-Za-z0-9_-]{43}$/u, "Expected a 32-byte base64url key"),
+  relayUrl: z10.url().max(2048).optional(),
+  relayUsername: UsernameSchema.optional(),
+  stableDeviceId: IdSchema.optional(),
+  pairedAt: z10.number().int().nonnegative().optional(),
+  lastSeenAt: z10.number().int().nonnegative().optional(),
+  sleeping: z10.boolean().optional(),
+  selected: z10.boolean().optional()
+}).strict();
+var MobileTransferPayloadSchema = z10.object({
+  relayUrl: z10.url().max(2048),
+  username: UsernameSchema,
+  machines: z10.array(MobileTransferMachineSchema).min(1).max(32)
+}).strict().superRefine((payload, context) => {
+  const normalizeEndpoint = (value) => value.trim().replace(/\/+$/u, "").replace(/^(https?):\/\/(\[[^\]]+\]|[^:/?#]+)(?::([0-9]+))?(?=\/|$)/iu, (_match, scheme, host, rawPort) => {
+    const protocol = scheme.toLowerCase();
+    const port = rawPort === void 0 ? void 0 : Number(rawPort);
+    const isDefaultPort = protocol === "http" && port === 80 || protocol === "https" && port === 443;
+    const authorityPort = port === void 0 || isDefaultPort ? "" : `:${port}`;
+    return `${protocol}://${host.toLowerCase()}${authorityPort}`;
+  });
+  const defaultEndpoint = normalizeEndpoint(payload.relayUrl);
+  const identities = /* @__PURE__ */ new Set();
+  const devices = /* @__PURE__ */ new Map();
+  payload.machines.forEach((machine, index) => {
+    const endpoint = normalizeEndpoint(machine.relayUrl ?? payload.relayUrl);
+    const account = machine.relayUsername ?? (endpoint === defaultEndpoint ? payload.username : null);
+    const identity2 = JSON.stringify([machine.machineId, endpoint, account]);
+    if (identities.has(identity2)) {
+      context.addIssue({
+        code: "custom",
+        message: "Transfer contains duplicate PC authorizations",
+        path: ["machines", index]
+      });
+    }
+    identities.add(identity2);
+    const deviceId = machine.stableDeviceId ?? machine.machineId;
+    const connections = devices.get(deviceId) ?? [];
+    connections.push(machine);
+    devices.set(deviceId, connections);
+  });
+  for (const connections of devices.values()) {
+    if (connections.some((machine) => machine.selected !== void 0) && connections.filter((machine) => machine.selected !== false).length > 1) {
+      context.addIssue({
+        code: "custom",
+        message: "Transfer selects multiple connections for one PC",
+        path: ["machines"]
+      });
+    }
+  }
+});
+var MobileTransferPartSchema = z10.object({
+  transferId: z10.string().regex(/^[A-Za-z0-9_-]{43}$/u, "Expected a SHA-256 base64url digest"),
+  part: z10.number().int().min(1).max(MOBILE_TRANSFER_MAX_PARTS),
+  total: z10.number().int().min(2).max(MOBILE_TRANSFER_MAX_PARTS),
+  data: z10.string().min(1).max(MOBILE_TRANSFER_PART_DATA_MAX_LENGTH).regex(/^[A-Za-z0-9_-]+$/u, "Expected base64url data")
+}).strict().refine(({ part, total }) => part <= total, {
+  message: "Part number must not exceed total parts",
+  path: ["part"]
+});
+var MobileTransferUploadRequestSchema = z10.object({
+  ciphertext: z10.string().min(1).max(MOBILE_TRANSFER_RELAY_MAX_CIPHERTEXT_LENGTH).regex(/^[A-Za-z0-9_-]+$/u, "Expected base64url ciphertext")
+}).strict();
+var MobileTransferUploadResultSchema = z10.object({
+  token: z10.string().regex(/^[A-Za-z0-9_-]{43}$/u, "Expected a 32-byte base64url token"),
+  expiresAt: z10.number().int().positive()
+}).strict();
+var MobileTransferDownloadResultSchema = z10.object({
+  ciphertext: z10.string().min(1).max(MOBILE_TRANSFER_RELAY_MAX_CIPHERTEXT_LENGTH).regex(/^[A-Za-z0-9_-]+$/u, "Expected base64url ciphertext")
+}).strict();
+
+// ../protocol/dist/auth/microsoft-enrollment.js
+import { z as z11 } from "zod";
+var MicrosoftIdentityReferenceSchema = z11.object({
+  issuer: z11.literal("https://login.microsoftonline.com/9188040d-6c67-4c5b-b112-36a304b66dad/v2.0"),
+  clientId: z11.uuid(),
+  subject: z11.string().min(1).max(255).regex(/^[\x21-\x7e]+$/)
+}).strict();
+var PcEnrollmentIdSchema = z11.uuid();
+var PcEnrollmentStateSchema = z11.enum([
+  "pending",
+  "approved",
+  "issued",
+  "confirmed",
+  "cancelled",
+  "expired"
+]);
+var PcEnrollmentStartRequestSchema = z11.object({
+  machineId: z11.string().min(1).max(128).regex(/^[A-Za-z0-9._:-]+$/),
+  deviceName: z11.string().trim().min(1).max(120).regex(/^[^\x00-\x1f\x7f]+$/),
+  codeChallenge: z11.string().regex(/^[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/)
+}).strict();
+var PcEnrollmentVerifierRequestSchema = z11.object({
+  verifier: z11.string().regex(/^[A-Za-z0-9._~-]{43,128}$/)
+}).strict();
+var MicrosoftCsrfRequestSchema = z11.object({
+  csrfToken: z11.string().min(1).max(256)
+}).strict();
+var PcEnrollmentApproveRequestSchema = MicrosoftCsrfRequestSchema.extend({
+  confirmationCode: z11.string().regex(/^[A-F0-9]{8}$/),
+  localCredentials: z11.object({
+    username: z11.string().trim().min(1).max(120),
+    password: z11.string().min(1).max(4096)
+  }).strict().optional()
+}).strict();
+var MicrosoftEnrollmentFailureSchema = z11.object({
+  ok: z11.literal(false),
+  error: z11.object({
+    code: z11.string().min(1).max(128),
+    message: z11.string().min(1).max(1024)
+  }).strict()
+}).strict();
+var MicrosoftMutationResultSchema = z11.discriminatedUnion("ok", [
+  z11.object({ ok: z11.literal(true) }).strict(),
+  MicrosoftEnrollmentFailureSchema
+]);
+var PcEnrollmentStartResultSchema = z11.discriminatedUnion("ok", [
+  z11.object({
+    ok: z11.literal(true),
+    enrollmentId: PcEnrollmentIdSchema,
+    confirmationCode: z11.string().regex(/^[A-F0-9]{8}$/),
+    verificationUri: z11.url(),
+    expiresAt: z11.number().int().positive(),
+    intervalSeconds: z11.number().int().positive()
+  }).strict(),
+  MicrosoftEnrollmentFailureSchema
+]);
+var PcEnrollmentStatusResultSchema = z11.discriminatedUnion("ok", [
+  z11.object({
+    ok: z11.literal(true),
+    state: PcEnrollmentStateSchema,
+    expiresAt: z11.number().int().positive()
+  }).strict(),
+  MicrosoftEnrollmentFailureSchema
+]);
+var PcEnrollmentExchangeResultSchema = z11.discriminatedUnion("ok", [
+  z11.object({
+    ok: z11.literal(true),
+    token: z11.string().min(32).max(4096),
+    tokenId: z11.string().min(1).max(256),
+    grantId: z11.uuid(),
+    machineId: PcEnrollmentStartRequestSchema.shape.machineId,
+    user: AuthUserSchema,
+    confirmBy: z11.number().int().positive()
+  }).strict(),
+  MicrosoftEnrollmentFailureSchema
+]);
+var PcBrowserRedirectUriSchema = z11.string().regex(/^http:\/\/127\.0\.0\.1:(?:[1-9]\d{0,3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5])\/relay-login\/callback$/);
+var PcBrowserStateSchema = PcEnrollmentStartRequestSchema.shape.codeChallenge;
+var PcBrowserAuthorizationCodeSchema = PcEnrollmentStartRequestSchema.shape.codeChallenge;
+var PcBrowserAuthorizationStartRequestSchema = PcEnrollmentStartRequestSchema.extend({
+  redirectUri: PcBrowserRedirectUriSchema,
+  state: PcBrowserStateSchema
+}).strict();
+var PcBrowserAuthorizationStartResultSchema = z11.discriminatedUnion("ok", [
+  z11.object({
+    ok: z11.literal(true),
+    enrollmentId: PcEnrollmentIdSchema,
+    verificationUri: z11.url(),
+    expiresAt: z11.number().int().positive()
+  }).strict(),
+  MicrosoftEnrollmentFailureSchema
+]);
+var PcBrowserAuthorizationExchangeRequestSchema = PcEnrollmentVerifierRequestSchema.extend({
+  code: PcBrowserAuthorizationCodeSchema,
+  redirectUri: PcBrowserRedirectUriSchema
+}).strict();
+var PcBrowserAuthorizationCallbackSchema = z11.union([
+  z11.object({ state: PcBrowserStateSchema, code: PcBrowserAuthorizationCodeSchema }).strict(),
+  z11.object({
+    state: PcBrowserStateSchema,
+    error: z11.enum(["access_denied", "expired", "cancelled"])
+  }).strict()
+]);
+var MicrosoftDeviceSchema = z11.object({
+  grantId: z11.uuid(),
+  tokenId: z11.string().min(1).max(256),
+  machineId: PcEnrollmentStartRequestSchema.shape.machineId,
+  deviceName: PcEnrollmentStartRequestSchema.shape.deviceName,
+  createdAt: z11.number().int().nonnegative(),
+  revokedAt: z11.number().int().nonnegative().nullable()
+}).strict();
+var MicrosoftDevicesResultSchema = z11.discriminatedUnion("ok", [
+  z11.object({
+    ok: z11.literal(true),
+    identity: MicrosoftIdentityReferenceSchema,
+    devices: z11.array(MicrosoftDeviceSchema)
+  }).strict(),
+  MicrosoftEnrollmentFailureSchema
+]);
+var MicrosoftIdentitySummarySchema = MicrosoftIdentityReferenceSchema.extend({
+  identityId: z11.uuid(),
+  userId: z11.string().min(1).max(256).nullable(),
+  allowed: z11.boolean(),
+  decidedBy: z11.string().min(1).max(256),
+  decidedAt: z11.number().int().nonnegative(),
+  createdAt: z11.number().int().nonnegative(),
+  lastLoginAt: z11.number().int().nonnegative().nullable()
+}).strict();
+var MicrosoftIdentityAllowRequestSchema = z11.object({
+  identity: MicrosoftIdentityReferenceSchema,
+  allowed: z11.boolean()
+}).strict();
+var MicrosoftIdentityAllowResultSchema = z11.discriminatedUnion("ok", [
+  z11.object({ ok: z11.literal(true), identity: MicrosoftIdentitySummarySchema }).strict(),
+  MicrosoftEnrollmentFailureSchema
+]);
+var MicrosoftIdentitiesResultSchema = z11.discriminatedUnion("ok", [
+  z11.object({ ok: z11.literal(true), identities: z11.array(MicrosoftIdentitySummarySchema) }).strict(),
+  MicrosoftEnrollmentFailureSchema
+]);
+var MicrosoftInvitationEmailSchema = z11.email().max(254).regex(/^[\x21-\x7e]+$/);
+var MicrosoftInvitationCodeSchema = z11.string().length(24).regex(/^[A-F0-9]{24}$/);
+var MicrosoftInvitationCreateRequestSchema = z11.object({
+  email: MicrosoftInvitationEmailSchema
+}).strict();
+var MicrosoftInvitationCreateResultSchema = z11.discriminatedUnion("ok", [
+  z11.object({
+    ok: z11.literal(true),
+    invitationId: z11.uuid(),
+    email: MicrosoftInvitationEmailSchema,
+    code: MicrosoftInvitationCodeSchema,
+    expiresAt: z11.number().int().nonnegative(),
+    invitationUri: z11.url()
+  }).strict(),
+  MicrosoftEnrollmentFailureSchema
+]);
+var MicrosoftInvitationAcceptRequestSchema = MicrosoftCsrfRequestSchema.extend({
+  code: MicrosoftInvitationCodeSchema
+}).strict();
+
+// ../protocol/dist/transport/event-names.js
+import { z as z12 } from "zod";
+var PcSecureEventNameSchema = z12.enum([
+  "session.communication",
+  "session.list.result",
+  "session.options.result",
+  "session.create.result",
+  "session.delete.result",
+  "session.configure.result",
+  "session.remote.result",
+  "session.timeline.page.result",
+  "session.watch.result",
+  "session.prompt.result",
+  "session.activity",
+  "session.abort.result",
+  "conversation.item.upsert",
+  "conversation.activity.step.upsert",
+  "session.timeline.invalidated",
+  "interaction.request",
+  "interaction.respond.result",
+  "permission.request",
+  "permission.respond.result",
+  "sessions.snapshot"
+]);
+var MobileSecureEventNameSchema = z12.enum([
+  "session.communication",
+  "session.list",
+  "session.options",
+  "session.create",
+  "session.delete",
+  "session.configure",
+  "session.remote",
+  "session.timeline.page",
+  "session.watch",
+  "session.prompt",
+  "session.abort",
+  "interaction.respond",
+  "permission.respond"
+]);
+var SecureEventNameSchema = z12.enum([
+  "session.communication",
+  "session.list.result",
+  "session.options.result",
+  "session.create.result",
+  "session.delete.result",
+  "session.configure.result",
+  "session.remote.result",
+  "session.timeline.page.result",
+  "session.watch.result",
+  "session.prompt.result",
+  "session.activity",
+  "session.abort.result",
+  "conversation.item.upsert",
+  "conversation.activity.step.upsert",
+  "session.timeline.invalidated",
+  "interaction.request",
+  "interaction.respond.result",
+  "permission.request",
+  "permission.respond.result",
+  "sessions.snapshot",
+  "session.list",
+  "session.options",
+  "session.create",
+  "session.delete",
+  "session.configure",
+  "session.remote",
+  "session.timeline.page",
+  "session.watch",
+  "session.prompt",
+  "session.abort",
+  "interaction.respond",
+  "permission.respond"
+]);
+
+// ../protocol/dist/transport/transport.js
+import { z as z13 } from "zod";
+var RoleSchema = z13.enum(["pc", "mobile"]);
+var V2SocketAuthBaseShape = {
+  transportVersion: z13.coerce.number().pipe(z13.literal(TRANSPORT_V2)),
+  protocolVersion: z13.coerce.number().pipe(SupportedProtocolVersionSchema),
+  token: z13.string().min(1),
+  clientId: IdSchema,
+  machineId: IdSchema,
+  keyId: Base64UrlKeyIdSchema
+};
+var V2PcSocketAuthSchema = z13.object({
+  ...V2SocketAuthBaseShape,
+  role: z13.literal("pc"),
+  userId: IdSchema
+}).strict();
+var V2MobileSocketAuthSchema = z13.object({
+  ...V2SocketAuthBaseShape,
+  role: z13.literal("mobile"),
+  mobileCredential: z13.string().min(64).max(4096)
+}).strict();
+var V2SocketAuthSchema = z13.discriminatedUnion("role", [
+  V2PcSocketAuthSchema,
+  V2MobileSocketAuthSchema
+]);
+var SECURE_MESSAGE_MAX_CIPHERTEXT_LENGTH = 16e6;
+var SecureMessageBaseShape = {
+  version: z13.literal(1),
+  algorithm: z13.literal("A256GCM"),
+  messageId: IdSchema,
+  machineId: IdSchema,
+  clientId: IdSchema,
+  recipientClientId: IdSchema.optional(),
+  keyId: Base64UrlKeyIdSchema,
+  sentAt: z13.number().int().nonnegative(),
+  nonce: z13.string().regex(/^[A-Za-z0-9_-]{16}$/u, "Expected a 12-byte base64url nonce"),
+  ciphertext: z13.string().min(22).max(SECURE_MESSAGE_MAX_CIPHERTEXT_LENGTH).regex(/^[A-Za-z0-9_-]+$/u, "Expected base64url ciphertext")
+};
+var SecureMessageSchema = z13.discriminatedUnion("sender", [
+  z13.object({
+    ...SecureMessageBaseShape,
+    sender: z13.literal("pc"),
+    event: PcSecureEventNameSchema
+  }).strict(),
+  z13.object({
+    ...SecureMessageBaseShape,
+    sender: z13.literal("mobile"),
+    event: MobileSecureEventNameSchema
+  }).strict()
+]);
+var SecureDeliveryErrorSchema = z13.object({
+  messageId: IdSchema,
+  event: SecureEventNameSchema,
+  machineId: IdSchema,
+  code: z13.enum([
+    "MACHINE_OFFLINE",
+    "IDENTITY_MISMATCH",
+    "KEY_ID_MISMATCH",
+    "INVALID_PAYLOAD",
+    "SESSION_DELETE_UNSUPPORTED",
+    "SESSION_COMMUNICATION_UNSUPPORTED"
+  ]),
+  message: z13.string().min(1).max(1024)
+}).strict();
+
+// ../protocol/dist/transport/machines.js
+import { z as z14 } from "zod";
+var MOBILE_CONNECTED_REPLAY_CAPABILITY = "mobile-connected-replay";
+var MACHINE_HELLO_SDK_COMPAT_VERSION = "1.0.9";
+var MachineHelloBaseShape = {
+  userId: IdSchema,
+  machineId: IdSchema,
+  machineName: z14.string().trim().min(1).max(120),
+  platform: z14.string().trim().min(1).max(64),
+  agentRunId: IdSchema,
+  sdkVersion: z14.literal(MACHINE_HELLO_SDK_COMPAT_VERSION),
+  clientVersion: z14.string().trim().min(1).max(64).optional(),
+  capabilities: z14.array(IdSchema).max(64).optional()
+};
+var OldestSupportedMachineHelloSchema = z14.object({
+  ...MachineHelloBaseShape,
+  protocolVersion: z14.literal(OLDEST_SUPPORTED_PROTOCOL_VERSION)
+});
+var LegacyMachineHelloSchema = z14.object({
+  ...MachineHelloBaseShape,
+  protocolVersion: z14.literal(LEGACY_PROTOCOL_VERSION)
+});
+var MachineHelloSchema = z14.object({
+  ...MachineHelloBaseShape,
+  protocolVersion: z14.literal(PROTOCOL_VERSION)
+});
+var CompatibleMachineHelloSchema = z14.union([
+  OldestSupportedMachineHelloSchema,
+  LegacyMachineHelloSchema,
+  MachineHelloSchema
+]);
+var V2MachineHelloSchema = z14.union([
+  OldestSupportedMachineHelloSchema.strict(),
+  LegacyMachineHelloSchema.strict(),
+  MachineHelloSchema.strict()
+]);
+var MachineHeartbeatSchema = z14.object({
+  userId: IdSchema,
+  machineId: IdSchema,
+  agentRunId: IdSchema,
+  sentAt: z14.number().int().nonnegative()
+});
+var MachinePresenceStateShape = {
+  online: z14.literal(true),
+  connectedAt: z14.number().int().nonnegative(),
+  lastSeen: z14.number().int().nonnegative()
+};
+var MachinePresenceSchema = z14.union([
+  OldestSupportedMachineHelloSchema.extend(MachinePresenceStateShape),
+  LegacyMachineHelloSchema.extend(MachinePresenceStateShape),
+  MachineHelloSchema.extend(MachinePresenceStateShape)
+]);
+var MachineOfflineSchema = z14.object({
+  userId: IdSchema,
+  machineId: IdSchema,
+  agentRunId: IdSchema,
+  disconnectedAt: z14.number().int().nonnegative()
+});
+var MobileDisconnectedSchema = z14.object({
+  clientId: IdSchema,
+  machineId: IdSchema,
+  disconnectedAt: z14.number().int().nonnegative()
+});
+var MobileConnectedSchema = z14.object({
+  clientId: IdSchema,
+  machineId: IdSchema,
+  connectedAt: z14.number().int().nonnegative(),
+  capabilities: z14.array(IdSchema).max(64).optional()
+});
+var MachineListRequestSchema = z14.object({
+  requestId: IdSchema
+});
+var MachineListResultSchema = z14.object({
+  requestId: IdSchema,
+  machines: z14.array(MachinePresenceSchema),
+  // Absent on older relays; PC presence capabilities alone do not negotiate routing.
+  relayCapabilities: z14.array(IdSchema).max(64).optional()
+});
+
+// ../protocol/dist/transport/peer-message.js
+import { z as z15 } from "zod";
+var PC_PEER_CHAT_CAPABILITY = "pc-peer-chat-v1";
+var PeerTextSchema = z15.string().max(16e3).refine((value) => value.trim().length > 0);
+var PeerMessageBaseShape = {
+  version: z15.literal(1),
+  messageId: IdSchema,
+  sourceSessionId: IdSchema,
+  targetMachineId: IdSchema,
+  targetSessionId: IdSchema
+};
+var PeerMessageSchema = z15.discriminatedUnion("kind", [
+  z15.object({
+    ...PeerMessageBaseShape,
+    kind: z15.literal("request"),
+    content: PeerTextSchema,
+    timeoutMs: z15.number().int().min(1e3).max(12e4)
+  }).strict(),
+  z15.object({
+    ...PeerMessageBaseShape,
+    kind: z15.literal("response"),
+    requestId: IdSchema,
+    content: PeerTextSchema
+  }).strict(),
+  z15.object({
+    ...PeerMessageBaseShape,
+    kind: z15.literal("error"),
+    requestId: IdSchema,
+    code: z15.string().trim().min(1).max(80),
+    message: z15.string().trim().min(1).max(1024)
+  }).strict(),
+  z15.object({
+    ...PeerMessageBaseShape,
+    kind: z15.literal("cancel"),
+    requestId: IdSchema
+  }).strict()
+]);
+var PeerDeliverySchema = z15.object({
+  sourceMachineId: IdSchema,
+  message: PeerMessageSchema
+}).strict();
+
+// ../protocol/dist/transport/a2a.js
+import { z as z16 } from "zod";
+var PC_A2A_CAPABILITY = "pc-a2a-v1";
+var A2A_BODY_MAX_LENGTH = 65536;
+var A2aRelayRequestSchema = z16.object({
+  userId: IdSchema,
+  sourceMachineId: IdSchema,
+  targetSessionId: IdSchema,
+  endpointUrl: z16.url().max(2048),
+  kind: z16.enum(["card", "rpc"]),
+  body: z16.string().max(A2A_BODY_MAX_LENGTH),
+  protocolVersion: z16.string().max(32).optional()
+}).strict().refine((request) => request.kind !== "card" || request.body === "", {
+  path: ["body"],
+  message: "Agent card requests must have an empty body"
+});
+var A2aRelayResponseSchema = z16.object({
+  status: z16.number().int().min(200).max(599),
+  body: z16.string().max(A2A_BODY_MAX_LENGTH)
+}).strict();
+
+// ../protocol/dist/sessions/session-communication.js
+import { z as z17 } from "zod";
+var SESSION_COMMUNICATION_CAPABILITY = "session.communication.v1";
+var SessionCommunicationIdSchema = z17.string().min(1).max(256).refine((value) => value === value.trim(), "Expected an unpadded identity");
+var SessionCommunicationIdentityShape = {
+  requestId: SessionCommunicationIdSchema,
+  machineId: SessionCommunicationIdSchema,
+  sessionId: SessionCommunicationIdSchema,
+  operation: z17.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/u),
+  version: z17.number().int().positive().max(2147483647)
+};
+var SessionCommunicationDataSchema = z17.record(z17.string(), z17.json());
+var SessionCommunicationRequestSchema = z17.object({
+  ...SessionCommunicationIdentityShape,
+  kind: z17.literal("request"),
+  data: SessionCommunicationDataSchema
+}).strict();
+var SessionCommunicationResponseSchema = z17.object({
+  ...SessionCommunicationIdentityShape,
+  kind: z17.literal("response"),
+  data: SessionCommunicationDataSchema
+}).strict();
+var SessionCommunicationErrorSchema = z17.object({
+  ...SessionCommunicationIdentityShape,
+  kind: z17.literal("error"),
+  error: ProtocolFailureSchema
+}).strict();
+var SessionCommunicationSchema = z17.discriminatedUnion("kind", [
+  SessionCommunicationRequestSchema,
+  SessionCommunicationResponseSchema,
+  SessionCommunicationErrorSchema
+]);
+function sessionCommunicationOperationCapability(operation, version) {
+  return `${operation}.v${version}`;
+}
+function sessionCommunicationError(request, error) {
+  const { data: _data, ...identity2 } = request;
+  return { ...identity2, kind: "error", error };
+}
+
+// ../protocol/dist/sessions/session-workspace.js
+import { z as z18 } from "zod";
+var SESSION_PROJECT_IDENTITY_OPERATION = "session.project.identity";
+var SESSION_PROJECT_IDENTITY_VERSION = 1;
+var SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH = 32768;
+var SESSION_PROJECT_IDENTITY_MAX_RESPONSE_BYTES = 640 * 1024;
+var SESSION_DIRECTORY_LIST_OPERATION = "session.directory.list";
+var SESSION_DIRECTORY_LIST_VERSION = 1;
+var SESSION_DIRECTORY_MAX_PATH_LENGTH = 1024;
+var SESSION_DIRECTORY_MAX_DEPTH = 32;
+var SESSION_DIRECTORY_MAX_ENTRIES = 500;
+var SESSION_DIRECTORY_MAX_RESPONSE_BYTES = 128 * 1024;
+var SESSION_FILE_READ_OPERATION = "session.file.read";
+var SESSION_FILE_READ_VERSION = 1;
+var SESSION_FILE_MAX_ORIGINAL_BYTES = 500 * 1024;
+var SESSION_FILE_GZIP_THRESHOLD_BYTES = 20 * 1024;
+var SESSION_FILE_MAX_IMAGE_BYTES = 100 * 1024;
+var SESSION_FILE_MAX_IMAGE_EDGE = 1280;
+var SESSION_FILE_MAX_IMAGE_PIXELS = 16 * 1024 * 1024;
+var SESSION_FILE_MAX_TRANSFER_BYTES = SESSION_FILE_MAX_ORIGINAL_BYTES + 1024;
+var SESSION_FILE_MAX_BASE64_LENGTH = Math.ceil(SESSION_FILE_MAX_TRANSFER_BYTES / 3) * 4;
+var SESSION_FILE_MAX_RESPONSE_BYTES = SESSION_FILE_MAX_BASE64_LENGTH + 8192;
+var SESSION_FILE_MEDIA_TYPES = [
+  "text/plain",
+  "text/html",
+  "text/markdown",
+  "text/css",
+  "text/javascript",
+  "application/json",
+  "application/xml",
+  "text/xml",
+  "application/yaml",
+  "image/webp"
+];
+function isSafeSessionDirectoryPath(path) {
+  if (path === "")
+    return true;
+  if (path.length > SESSION_DIRECTORY_MAX_PATH_LENGTH)
+    return false;
+  const segments = path.split("/");
+  return segments.length <= SESSION_DIRECTORY_MAX_DEPTH && segments.every((segment) => segment.length > 0 && segment.length <= 255 && segment !== "." && segment !== ".." && !/[\\:<>"|?*\u0000-\u001f\u007f]/u.test(segment) && !/[. ]$/u.test(segment) && !/~[0-9]/u.test(segment) && !/^(?:con|prn|aux|nul|com[0-9¹²³]|lpt[0-9¹²³])(?:[ .]|$)/iu.test(segment) && !/^(?:conin\$|conout\$)$/iu.test(segment));
+}
+var SessionDirectoryListRequestSchema = z18.object({
+  requestId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema,
+  path: z18.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH)
+}).strict();
+var SessionDirectoryEntrySchema = z18.object({
+  name: z18.string().min(1).max(255),
+  kind: z18.enum(["directory", "file", "blocked"])
+}).strict();
+var SessionDirectoryListDataSchema = SessionDirectoryListRequestSchema.pick({ path: true });
+var SessionDirectoryListResultDataSchema = z18.object({
+  path: z18.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH),
+  rootRevision: z18.string().min(1).max(128),
+  entries: z18.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES)
+}).strict();
+var SessionDirectoryListResponseSchema = SessionDirectoryListRequestSchema.extend({
+  rootRevision: z18.string().min(1).max(128).optional(),
+  entries: z18.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES).optional(),
+  error: ProtocolFailureSchema.optional()
+}).superRefine((response, context) => {
+  if (response.error === void 0 ? response.entries === void 0 || response.rootRevision === void 0 : response.entries !== void 0 || response.rootRevision !== void 0) {
+    context.addIssue({ code: "custom", message: "Expected directory success or failure" });
+  }
+});
+var SessionFileReadDataSchema = z18.object({
+  path: z18.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
+  rootRevision: z18.string().regex(/^[A-Za-z0-9_-]{43}$/u)
+}).strict();
+var SessionFileReadResultDataSchema = z18.object({
+  path: SessionFileReadDataSchema.shape.path,
+  rootRevision: SessionFileReadDataSchema.shape.rootRevision,
+  mediaType: z18.enum(SESSION_FILE_MEDIA_TYPES),
+  originalByteLength: z18.number().int().min(0).max(SESSION_FILE_MAX_ORIGINAL_BYTES),
+  // Canonical length after decompression, not the length of the transport bytes.
+  byteLength: z18.number().int().min(0).max(SESSION_FILE_MAX_ORIGINAL_BYTES),
+  encoding: z18.enum(["identity", "gzip"]),
+  data: z18.string().max(SESSION_FILE_MAX_BASE64_LENGTH)
+}).strict().superRefine((result, context) => {
+  const invalid = () => context.addIssue({ code: "custom", message: "Invalid file content" });
+  if (result.encoding === "gzip" !== result.originalByteLength >= SESSION_FILE_GZIP_THRESHOLD_BYTES)
+    invalid();
+  if (result.mediaType === "image/webp" ? result.byteLength === 0 || result.byteLength > SESSION_FILE_MAX_IMAGE_BYTES || result.originalByteLength === 0 : result.byteLength !== result.originalByteLength)
+    invalid();
+  const base64 = result.data;
+  const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+  const length = base64.length / 4 * 3 - padding;
+  if (base64.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(base64) || length > SESSION_FILE_MAX_TRANSFER_BYTES || padding === 2 && !/[AQgw]==$/u.test(base64) || padding === 1 && !/[AEIMQUYcgkosw048]=$/u.test(base64) || (result.encoding === "identity" ? length !== result.byteLength : length < 20))
+    invalid();
+});
+var SessionGitProjectSchema = z18.object({
+  localRepositoryKey: z18.string().length(43).regex(/^[A-Za-z0-9_-]{43}$/),
+  worktreeRoot: z18.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH),
+  mainWorktreeRoot: z18.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional(),
+  gitRemoteUrl: z18.string().max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional()
+}).strict();
+var SessionProjectIdentityRequestDataSchema = z18.object({}).strict();
+var SessionProjectIdentityResultDataSchema = z18.object({
+  project: SessionGitProjectSchema.optional()
+}).strict();
+
+// ../protocol/dist/sessions/session-resource.js
+import { z as z19 } from "zod";
+var SESSION_RESOURCE_READ_OPERATION = "session.resource.read";
+var SESSION_RESOURCE_READ_VERSION = 1;
+var SESSION_RESOURCE_MAX_ORIGINAL_BYTES = 499999;
+var SESSION_RESOURCE_GZIP_THRESHOLD_BYTES = 20 * 1024;
+var SESSION_RESOURCE_MAX_IMAGE_PIXELS = 16 * 1024 * 1024;
+var SESSION_RESOURCE_MAX_TRANSFER_BYTES = SESSION_RESOURCE_MAX_ORIGINAL_BYTES + 1024;
+var SESSION_RESOURCE_MAX_BASE64_LENGTH = Math.ceil(SESSION_RESOURCE_MAX_TRANSFER_BYTES / 3) * 4;
+var SESSION_RESOURCE_MAX_RESPONSE_BYTES = SESSION_RESOURCE_MAX_BASE64_LENGTH + 8192;
+var SESSION_RESOURCE_MEDIA_TYPES = [
+  "image/jpeg",
+  "image/png",
+  "image/webp",
+  "text/css",
+  "text/javascript"
+];
+var SessionResourceReadDataSchema = z19.object({
+  path: z19.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
+  rootRevision: z19.string().regex(/^[A-Za-z0-9_-]{43}$/u)
+}).strict();
+var SessionResourceReadResultDataSchema = z19.object({
+  path: SessionResourceReadDataSchema.shape.path,
+  rootRevision: SessionResourceReadDataSchema.shape.rootRevision,
+  mediaType: z19.enum(SESSION_RESOURCE_MEDIA_TYPES),
+  originalByteLength: z19.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
+  byteLength: z19.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
+  encoding: z19.enum(["identity", "gzip"]),
+  data: z19.string().max(SESSION_RESOURCE_MAX_BASE64_LENGTH)
+}).strict().superRefine((result, context) => {
+  const invalid = () => context.addIssue({ code: "custom", message: "Invalid resource content" });
+  if (result.encoding === "gzip" !== result.originalByteLength >= SESSION_RESOURCE_GZIP_THRESHOLD_BYTES || result.byteLength !== result.originalByteLength || result.mediaType.startsWith("image/") && result.byteLength === 0)
+    invalid();
+  const base64 = result.data;
+  const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+  const length = base64.length / 4 * 3 - padding;
+  if (base64.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(base64) || length > SESSION_RESOURCE_MAX_TRANSFER_BYTES || padding === 2 && !/[AQgw]==$/u.test(base64) || padding === 1 && !/[AEIMQUYcgkosw048]=$/u.test(base64) || (result.encoding === "identity" ? length !== result.byteLength : length < 20))
+    invalid();
+});
+
+// ../protocol/dist/sessions/session-rename.js
+import { z as z20 } from "zod";
+var SESSION_RENAME_OPERATION = "session.rename";
+var SESSION_RENAME_VERSION = 1;
+var SESSION_RENAME_CAPABILITY = sessionCommunicationOperationCapability(SESSION_RENAME_OPERATION, SESSION_RENAME_VERSION);
+var SESSION_NAME_MAX_LENGTH = 100;
+var SessionNameSchema = z20.string().regex(/^[^\u0000-\u001f\u007f]*$/u).trim().min(1).max(SESSION_NAME_MAX_LENGTH);
+var SessionRenameDataSchema = z20.object({ name: SessionNameSchema }).strict();
+var SessionRenameResultDataSchema = z20.object({ name: SessionNameSchema }).strict();
+
+// ../protocol/dist/sessions/group-chat.js
+import { z as z21 } from "zod";
+var GROUP_CHAT_CREATE_OPERATION = "group-chat.create";
+var GROUP_CHAT_CREATE_VERSION = 1;
+var GROUP_CHAT_CREATE_CAPABILITY = sessionCommunicationOperationCapability(GROUP_CHAT_CREATE_OPERATION, GROUP_CHAT_CREATE_VERSION);
+var GroupChatCreateDataSchema = z21.object({
+  peerSessionId: IdSchema
+}).strict();
+var GroupChatCreateResultDataSchema = z21.object({
+  session: SessionSummarySchema.refine((session) => session.groupChat !== void 0, "Group creation must return a virtual group session")
+}).strict();
+
+// ../protocol/dist/sessions/prompts.js
+import { z as z22 } from "zod";
+var SESSION_FILE_ATTACHMENTS_CAPABILITY = "session-file-attachments";
+var SESSION_PROMPT_SUBMISSION_TIME_CAPABILITY = "session-prompt-submission-time";
+var MAX_PROMPT_IMAGE_BYTES = 3 * 1024 * 1024;
+var SessionPromptRequestSchema = z22.object({
+  requestId: IdSchema,
+  operationId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema,
+  prompt: z22.string().trim().max(1e5),
+  attachments: z22.array(PromptImageAttachmentSchema).max(4).optional(),
+  fileAttachments: z22.array(PromptFileAttachmentSchema).max(4).optional(),
+  mode: z22.enum(["enqueue", "immediate"]).default("enqueue")
+}).strict().superRefine((request, context) => {
+  if (request.prompt.length === 0 && (request.attachments?.length ?? 0) === 0 && (request.fileAttachments?.length ?? 0) === 0) {
+    context.addIssue({
+      code: "custom",
+      path: ["prompt"],
+      message: "A prompt or attachment is required"
+    });
+  }
+  const attachments = [...request.attachments ?? [], ...request.fileAttachments ?? []];
+  if (attachments.length > 4) {
+    context.addIssue({
+      code: "custom",
+      path: ["fileAttachments"],
+      message: "A prompt supports at most 4 attachments"
+    });
+  }
+  const attachmentBytes = attachments.reduce((total, attachment) => total + attachment.byteLength, 0) ?? 0;
+  if (attachmentBytes > MAX_PROMPT_IMAGE_BYTES) {
+    context.addIssue({
+      code: "custom",
+      path: ["attachments"],
+      message: "Prompt attachments exceed the 3 MiB total limit"
+    });
+  }
+});
+var SessionPromptResultSchema = z22.discriminatedUnion("ok", [
+  z22.object({
+    ok: z22.literal(true),
+    requestId: IdSchema,
+    operationId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema,
+    messageId: IdSchema,
+    mode: z22.enum(["enqueue", "immediate"]),
+    deliveryState: z22.enum(["queued", "processing"]),
+    // Negotiated lower bound from the native event clock. Exact text and history
+    // ownership checks still apply; this is not an identity or proof of persistence.
+    submittedAt: IsoDateSchema.optional()
+  }),
+  z22.object({
+    ok: z22.literal(false),
+    requestId: IdSchema,
+    operationId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema,
+    error: ProtocolFailureSchema
+  })
+]);
+var SessionActivityUpdateSchema = z22.object({
+  userId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema,
+  state: z22.enum(["working", "idle"]),
+  occurredAt: IsoDateSchema,
+  assistantPreview: SessionAssistantPreviewSchema.optional(),
+  userPreview: SessionUserPreviewSchema.optional()
+});
+var SessionAbortRequestSchema = z22.object({
+  requestId: IdSchema,
+  machineId: IdSchema,
+  sessionId: IdSchema
+});
+var SessionAbortResultSchema = z22.discriminatedUnion("ok", [
+  z22.object({
+    ok: z22.literal(true),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema
+  }),
+  z22.object({
+    ok: z22.literal(false),
+    requestId: IdSchema,
+    machineId: IdSchema,
+    sessionId: IdSchema,
+    error: ProtocolFailureSchema
+  })
+]);
+
+// ../protocol/dist/conversation/timeline-sync.js
+import { z as z23 } from "zod";
+var TIMELINE_SYNC_OPERATION = "session.timeline.sync";
+var TIMELINE_IMAGE_OPERATION = "session.image.read";
+var TIMELINE_SYNC_VERSION = 1;
+var TIMELINE_SYNC_MAX_EVENTS = 128;
+var TIMELINE_SYNC_MAX_BYTES = 6 * 1024 * 1024;
+var TIMELINE_IMAGE_CHUNK_BYTES = 48 * 1024;
+var TIMELINE_IMAGE_MAX_BYTES = 3 * 1024 * 1024;
+var identity = z23.string().min(1).max(256);
+var sequence = z23.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+var hash = z23.string().regex(/^[a-f0-9]{64}$/u);
+var TimelineWatermarkSchema = z23.object({
+  epoch: identity,
+  sequence
+}).strict();
+var TimelineSyncRequestSchema = z23.object({
+  watermark: TimelineWatermarkSchema.optional(),
+  waitMs: z23.number().int().min(0).max(2e4).optional(),
+  resume: z23.boolean().optional()
+}).strict();
+var TimelineTextAppendSchema = z23.object({
+  itemId: identity,
+  baseRevision: z23.number().int().positive(),
+  revision: z23.number().int().positive(),
+  appendText: z23.string().min(1).max(5e5),
+  sourceEventIds: z23.array(identity).min(1).max(1e3).optional(),
+  sourceMessageIds: z23.array(identity).min(1).max(1e3).optional(),
+  sourceInteractionIds: z23.array(identity).min(1).max(1e3).optional()
+}).strict();
+var TimelineSyncEventSchema = z23.discriminatedUnion("kind", [
+  z23.object({ kind: z23.literal("upsert"), sequence, item: ConversationItemSchema }).strict(),
+  z23.object({ kind: z23.literal("append"), sequence, append: TimelineTextAppendSchema }).strict(),
+  z23.object({
+    kind: z23.literal("step"),
+    sequence,
+    upsert: ConversationActivityStepUpsertSchema
+  }).strict()
+]);
+var TimelineResyncReasonSchema = z23.enum([
+  "initial",
+  "epoch-changed",
+  "evicted",
+  "gap",
+  "clear",
+  "rewind",
+  "oversized"
+]);
+var TimelineSyncResponseSchema = z23.discriminatedUnion("status", [
+  z23.object({
+    status: z23.literal("snapshot"),
+    watermark: TimelineWatermarkSchema,
+    page: SessionTimelinePageSchema
+  }).strict(),
+  z23.object({
+    status: z23.literal("replay"),
+    watermark: TimelineWatermarkSchema,
+    afterSequence: sequence,
+    events: z23.array(TimelineSyncEventSchema).max(TIMELINE_SYNC_MAX_EVENTS),
+    hasMore: z23.boolean()
+  }).strict(),
+  z23.object({
+    status: z23.literal("resync"),
+    epoch: identity,
+    reason: TimelineResyncReasonSchema
+  }).strict()
+]);
+var TimelineImageRequestSchema = z23.object({
+  sha256: hash,
+  offset: z23.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1)
+}).strict();
+var TimelineImageChunkSchema = z23.object({
+  sha256: hash,
+  offset: z23.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1),
+  totalBytes: z23.number().int().positive().max(TIMELINE_IMAGE_MAX_BYTES),
+  mimeType: z23.enum(["image/gif", "image/jpeg", "image/png", "image/webp"]),
+  data: z23.string().min(4).max(Math.ceil(TIMELINE_IMAGE_CHUNK_BYTES / 3) * 4).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u),
+  eof: z23.boolean()
+}).strict().superRefine((chunk, context) => {
+  const padding = chunk.data.endsWith("==") ? 2 : chunk.data.endsWith("=") ? 1 : 0;
+  const length = chunk.data.length / 4 * 3 - padding;
+  const end = chunk.offset + length;
+  if (end > chunk.totalBytes || chunk.eof !== (end === chunk.totalBytes) || !chunk.eof && length !== TIMELINE_IMAGE_CHUNK_BYTES) {
+    context.addIssue({ code: "custom", message: "Image chunk length or completion does not match its total" });
+  }
+});
+
+// ../protocol/dist/workbench.js
+import { z as z25 } from "zod";
+
+// ../protocol/dist/schedules.js
+import { z as z24 } from "zod";
+var SCHEDULES_CAPABILITY = "session-schedules-v1";
+var SCHEDULE_OPERATIONS = [
+  "schedule.snapshot",
+  "schedule.create",
+  "schedule.delete",
+  "schedule.draft.dismiss",
+  "schedule.resume"
+];
+var Id = z24.string().min(1).max(256);
+var NativeId = z24.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+var Time = z24.iso.datetime({ offset: true });
+var WorkbenchScheduleRuleSchema = z24.discriminatedUnion("kind", [
+  z24.object({ kind: z24.literal("once"), at: Time }).strict(),
+  z24.object({
+    kind: z24.literal("interval"),
+    seconds: z24.number().int().min(10).max(86400),
+    recurring: z24.boolean().optional()
+  }).strict(),
+  z24.object({
+    kind: z24.literal("cron"),
+    expression: z24.string().trim().min(9).max(256).regex(/^\S+(?: +\S+){4}$/),
+    timezone: z24.string().min(1).max(128).regex(/^[A-Za-z0-9_+./-]+$/)
+  }).strict()
+]);
+var Content = {
+  rule: WorkbenchScheduleRuleSchema,
+  prompt: z24.string().max(16e3).describe("The execution prompt, or ONLY the user's exact arguments when skill is set. Do not include the skill name, slash prefix, scheduling instructions, or extra explanation in skill arguments."),
+  skill: z24.string().min(1).max(256).regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/).optional().describe("A genuine callable skill name from this session, without the leading slash. Set this field when the user requests a skill; put only its exact arguments in prompt.")
+};
+var WorkbenchScheduleProposalSchema = z24.object(Content).strict().refine((value) => value.prompt.trim().length > 0 || value.skill !== void 0, { message: "A prompt or skill is required" });
+var WorkbenchScheduleDraftSchema = z24.object({
+  id: z24.uuid(),
+  createdAt: Time,
+  ...Content
+}).strict();
+var WorkbenchScheduleEntrySchema = z24.object({
+  id: NativeId,
+  prompt: z24.string().max(1e5),
+  displayPrompt: z24.string().max(1e5).optional(),
+  recurring: z24.boolean(),
+  nextRunAt: Time,
+  intervalMs: z24.number().int().positive().optional(),
+  cron: z24.string().max(256).optional(),
+  timezone: z24.string().max(128).optional(),
+  at: Time.optional()
+}).strict();
+var WorkbenchScheduleResultSchema = z24.object({
+  id: Id,
+  scheduleId: NativeId,
+  triggerEventId: Id,
+  time: Time,
+  prompt: z24.string().max(16e3),
+  status: z24.enum(["reply", "error", "merged", "pending", "unknown"]),
+  reply: z24.string().max(16e3).optional(),
+  replyEventId: Id.optional(),
+  error: z24.string().max(1024).optional()
+}).strict();
+var WorkbenchScheduleSnapshotSchema = z24.object({
+  state: z24.enum(["active", "needs-resume"]),
+  workingDirectory: z24.string().max(32768).optional(),
+  timezone: z24.string().max(128).optional(),
+  entries: z24.array(WorkbenchScheduleEntrySchema).max(256),
+  drafts: z24.array(WorkbenchScheduleDraftSchema).max(100),
+  results: z24.array(WorkbenchScheduleResultSchema).max(100),
+  historyTruncated: z24.boolean(),
+  sampledAt: Time
+}).strict();
+var Submission = {
+  operationId: z24.uuid(),
+  operationCreatedAt: z24.iso.datetime(),
+  expectedAgentRunId: Id
+};
+var WorkbenchScheduleCreateRequestSchema = z24.object({
+  ...Submission,
+  ...Content,
+  draftId: z24.uuid().optional()
+}).strict().refine((value) => value.prompt.trim().length > 0 || value.skill !== void 0, { message: "A prompt or skill is required" });
+var WorkbenchScheduleCreateResultSchema = z24.object({
+  snapshot: WorkbenchScheduleSnapshotSchema,
+  verified: z24.boolean()
+}).strict();
+var WorkbenchScheduleDeleteRequestSchema = z24.object({
+  ...Submission,
+  id: NativeId
+}).strict();
+var WorkbenchScheduleDeleteResultSchema = z24.object({
+  snapshot: WorkbenchScheduleSnapshotSchema,
+  removed: z24.boolean()
+}).strict();
+var WorkbenchScheduleDraftDismissRequestSchema = z24.object({
+  ...Submission,
+  draftId: z24.uuid()
+}).strict();
+var ScheduleAndroidSchemas = {
+  WorkbenchScheduleRule: WorkbenchScheduleRuleSchema,
+  WorkbenchScheduleProposal: WorkbenchScheduleProposalSchema,
+  WorkbenchScheduleDraft: WorkbenchScheduleDraftSchema,
+  WorkbenchScheduleEntry: WorkbenchScheduleEntrySchema,
+  WorkbenchScheduleResult: WorkbenchScheduleResultSchema,
+  WorkbenchScheduleSnapshot: WorkbenchScheduleSnapshotSchema,
+  WorkbenchScheduleCreateRequest: WorkbenchScheduleCreateRequestSchema,
+  WorkbenchScheduleCreateResult: WorkbenchScheduleCreateResultSchema,
+  WorkbenchScheduleDeleteRequest: WorkbenchScheduleDeleteRequestSchema,
+  WorkbenchScheduleDeleteResult: WorkbenchScheduleDeleteResultSchema,
+  WorkbenchScheduleDraftDismissRequest: WorkbenchScheduleDraftDismissRequestSchema
+};
+
+// ../protocol/dist/workbench.js
+var Id2 = z25.string().trim().min(1).max(256);
+var Text = z25.string().max(1e5);
+var Count = z25.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var Failure = z25.object({ code: Id2, message: z25.string().min(1).max(1024) }).strict();
+var WORKBENCH_VERSION = 1;
+var RESEARCH_CHAT_CAPABILITY = "research-chat-v1";
+var WORKBENCH_OPERATIONS = [
+  "operation.get",
+  "question.ask",
+  "research.create",
+  "research.list",
+  "research.timeline",
+  "research.send",
+  "research.abort",
+  "research.delete",
+  "command.list",
+  "command.invoke",
+  "queue.snapshot",
+  "queue.mutate",
+  "insights.read",
+  "context.compact",
+  ...SCHEDULE_OPERATIONS
+];
+var workbenchCapability = (operation) => `${operation}.v${WORKBENCH_VERSION}`;
+var Submission2 = {
+  operationId: z25.uuid(),
+  operationCreatedAt: z25.iso.datetime(),
+  expectedAgentRunId: Id2
+};
+var WorkbenchOperationGetSchema = z25.object({ operationId: z25.uuid() }).strict();
+var WorkbenchOperationStatusSchema = z25.object({
+  operationId: z25.uuid(),
+  operation: z25.enum(WORKBENCH_OPERATIONS),
+  agentRunId: Id2,
+  state: z25.enum(["running", "succeeded", "failed", "uncertain", "result-expired"]),
+  result: z25.record(z25.string(), z25.json()).optional(),
+  error: Failure.optional()
+}).strict().superRefine((value, context) => {
+  if (value.state === "succeeded" !== (value.result !== void 0) || (value.state === "failed" || value.state === "uncertain") !== (value.error !== void 0)) {
+    context.addIssue({ code: "custom", message: "Invalid operation state payload" });
+  }
+});
+var WorkbenchAskRequestSchema = z25.object({
+  ...Submission2,
+  question: z25.string().trim().min(1).max(16e3)
+}).strict();
+var WorkbenchAskResultSchema = z25.object({ answer: Text }).strict();
+var WorkbenchEmptyRequestSchema = z25.object({}).strict();
+var WorkbenchSubmitRequestSchema = z25.object(Submission2).strict();
+var WorkbenchResearchCreateRequestSchema = z25.object({
+  ...Submission2,
+  title: z25.string().trim().min(1).max(120),
+  question: z25.string().trim().min(1).max(16e3),
+  sourceItemId: Id2.optional(),
+  deferInitialPrompt: z25.literal(true).optional()
+}).strict();
+var WorkbenchResearchThreadSchema = z25.object({
+  sessionId: Id2,
+  parentSessionId: Id2,
+  title: z25.string().min(1).max(120),
+  createdAt: z25.iso.datetime(),
+  contextAnchor: Id2.optional(),
+  contextTruncated: z25.boolean(),
+  detached: z25.boolean(),
+  state: z25.enum(["creating", "ready", "failed"])
+}).strict();
+var WorkbenchResearchCreateResultSchema = z25.object({
+  thread: WorkbenchResearchThreadSchema
+}).strict();
+var WorkbenchResearchListResultSchema = z25.object({
+  threads: z25.array(WorkbenchResearchThreadSchema).max(100)
+}).strict();
+var WorkbenchResearchTimelineRequestSchema = z25.object({
+  cursor: Id2.optional()
+}).strict();
+var WorkbenchResearchSendRequestSchema = z25.object({
+  ...Submission2,
+  prompt: z25.string().trim().min(1).max(16e3)
+}).strict();
+var WorkbenchResearchSendResultSchema = z25.object({ messageId: Id2 }).strict();
+var WorkbenchCompletedResultSchema = z25.object({ completed: z25.boolean() }).strict();
+var WorkbenchCommandSchema = z25.object({
+  name: z25.string().min(1).max(260),
+  description: z25.string().max(4096),
+  argumentHint: z25.string().max(1024).optional(),
+  kind: z25.enum(["builtin", "skill", "client"]),
+  allowDuringExecution: z25.boolean(),
+  supported: z25.boolean(),
+  reason: z25.string().max(1024).optional()
+}).strict();
+var WorkbenchCommandListResultSchema = z25.object({
+  commands: z25.array(WorkbenchCommandSchema).max(512)
+}).strict();
+var WorkbenchCommandInvokeRequestSchema = z25.object({
+  ...Submission2,
+  name: z25.string().trim().min(1).max(260),
+  input: z25.string().max(16e3)
+}).strict();
+var WorkbenchCommandChoiceSchema = z25.object({
+  name: z25.string().min(1).max(260),
+  label: z25.string().min(1).max(1024),
+  input: z25.string().max(16e3)
+}).strict();
+var WorkbenchCommandResultSchema = z25.discriminatedUnion("kind", [
+  z25.object({ kind: z25.literal("text"), text: Text }).strict(),
+  z25.object({ kind: z25.literal("completed") }).strict(),
+  z25.object({ kind: z25.literal("sent"), messageId: Id2 }).strict(),
+  z25.object({
+    kind: z25.literal("select-subcommand"),
+    choices: z25.array(WorkbenchCommandChoiceSchema).min(1).max(100)
+  }).strict()
+]);
+var WorkbenchQueueItemSchema = z25.object({
+  id: Id2,
+  kind: z25.string().min(1).max(64),
+  texts: z25.array(z25.string().max(1e5)).min(1).max(100),
+  actions: z25.array(z25.enum(["edit", "remove", "move", "send-now"])).max(4)
+}).strict();
+var WorkbenchQueueSnapshotSchema = z25.object({
+  generation: Id2,
+  revision: Id2,
+  items: z25.array(WorkbenchQueueItemSchema).max(512),
+  steeringMessages: z25.array(z25.string().max(1e5)).max(512)
+}).strict();
+var QueueMutation = {
+  ...Submission2,
+  generation: Id2,
+  revision: Id2,
+  id: Id2
+};
+var WorkbenchQueueMutationRequestSchema = z25.discriminatedUnion("action", [
+  z25.object({ ...QueueMutation, action: z25.literal("edit"), prompt: z25.string().trim().min(1).max(1e5) }).strict(),
+  z25.object({ ...QueueMutation, action: z25.literal("remove") }).strict(),
+  z25.object({ ...QueueMutation, action: z25.literal("move"), toPosition: z25.number().int().min(0).max(511) }).strict(),
+  z25.object({ ...QueueMutation, action: z25.literal("send-now") }).strict()
+]);
+var WorkbenchQueueMutationResultSchema = z25.object({
+  changed: z25.boolean(),
+  snapshot: WorkbenchQueueSnapshotSchema
+}).strict();
+var WorkbenchTokenMetricSchema = z25.object({
+  kind: z25.string().min(1).max(128),
+  count: Count
+}).strict();
+var WorkbenchModelUsageSchema = z25.object({
+  model: Id2,
+  requests: Count,
+  premiumRequestCost: z25.number().finite().nonnegative(),
+  tokens: z25.array(WorkbenchTokenMetricSchema).max(32)
+}).strict();
+var WorkbenchContextSchema = z25.object({
+  currentTokens: Count,
+  tokenLimit: Count,
+  systemTokens: Count.optional(),
+  conversationTokens: Count.optional(),
+  toolTokens: Count.optional()
+}).strict();
+var WorkbenchInsightsSchema = z25.object({
+  sampledAt: z25.iso.datetime(),
+  generation: Id2,
+  model: Id2.optional(),
+  totalUserRequests: Count,
+  premiumRequestCost: z25.number().finite().nonnegative(),
+  nanoAiu: z25.string().regex(/^\d+$/).max(40).optional(),
+  tokens: z25.array(WorkbenchTokenMetricSchema).max(32),
+  models: z25.array(WorkbenchModelUsageSchema).max(100),
+  context: WorkbenchContextSchema.optional(),
+  canCompact: z25.boolean(),
+  compactUnavailableReason: z25.string().max(1024).optional()
+}).strict();
+var WorkbenchCompactResultSchema = z25.object({
+  success: z25.boolean(),
+  tokensRemoved: Count,
+  messagesRemoved: Count
+}).strict();
+var WorkbenchAndroidSchemas = {
+  WorkbenchOperationGet: WorkbenchOperationGetSchema,
+  WorkbenchOperationStatus: WorkbenchOperationStatusSchema,
+  WorkbenchAskRequest: WorkbenchAskRequestSchema,
+  WorkbenchAskResult: WorkbenchAskResultSchema,
+  WorkbenchSubmitRequest: WorkbenchSubmitRequestSchema,
+  WorkbenchResearchCreateRequest: WorkbenchResearchCreateRequestSchema,
+  WorkbenchResearchThread: WorkbenchResearchThreadSchema,
+  WorkbenchResearchCreateResult: WorkbenchResearchCreateResultSchema,
+  WorkbenchResearchListResult: WorkbenchResearchListResultSchema,
+  WorkbenchResearchTimelineRequest: WorkbenchResearchTimelineRequestSchema,
+  WorkbenchResearchSendRequest: WorkbenchResearchSendRequestSchema,
+  WorkbenchResearchSendResult: WorkbenchResearchSendResultSchema,
+  WorkbenchCompletedResult: WorkbenchCompletedResultSchema,
+  WorkbenchCommand: WorkbenchCommandSchema,
+  WorkbenchCommandListResult: WorkbenchCommandListResultSchema,
+  WorkbenchCommandInvokeRequest: WorkbenchCommandInvokeRequestSchema,
+  WorkbenchCommandChoice: WorkbenchCommandChoiceSchema,
+  WorkbenchCommandResult: WorkbenchCommandResultSchema,
+  WorkbenchQueueItem: WorkbenchQueueItemSchema,
+  WorkbenchQueueSnapshot: WorkbenchQueueSnapshotSchema,
+  WorkbenchQueueMutationRequest: WorkbenchQueueMutationRequestSchema,
+  WorkbenchQueueMutationResult: WorkbenchQueueMutationResultSchema,
+  WorkbenchTokenMetric: WorkbenchTokenMetricSchema,
+  WorkbenchModelUsage: WorkbenchModelUsageSchema,
+  WorkbenchContext: WorkbenchContextSchema,
+  WorkbenchInsights: WorkbenchInsightsSchema,
+  WorkbenchCompactResult: WorkbenchCompactResultSchema
+};
+
+// ../protocol/dist/codegen/android-schemas.js
+var AndroidProtocolSchemas = {
+  ...WorkbenchAndroidSchemas,
+  ...ScheduleAndroidSchemas,
+  SessionCommunication: SessionCommunicationSchema,
+  SessionRenameData: SessionRenameDataSchema,
+  SessionRenameResultData: SessionRenameResultDataSchema,
+  SessionDirectoryListData: SessionDirectoryListDataSchema,
+  SessionDirectoryListResultData: SessionDirectoryListResultDataSchema,
+  SessionFileReadData: SessionFileReadDataSchema,
+  SessionFileReadResultData: SessionFileReadResultDataSchema,
+  SessionResourceReadData: SessionResourceReadDataSchema,
+  SessionResourceReadResultData: SessionResourceReadResultDataSchema,
+  SessionDirectoryListRequest: SessionDirectoryListRequestSchema,
+  SessionDirectoryEntry: SessionDirectoryEntrySchema,
+  SessionDirectoryListResponse: SessionDirectoryListResponseSchema,
+  SessionGitProject: SessionGitProjectSchema,
+  SessionProjectIdentityResultData: SessionProjectIdentityResultDataSchema,
+  V2SocketAuth: V2SocketAuthSchema,
+  SecureMessage: SecureMessageSchema,
+  SecureDeliveryError: SecureDeliveryErrorSchema,
+  AuthUser: AuthUserSchema,
+  LoginRequest: LoginRequestSchema,
+  LoginResult: LoginResultSchema,
+  PcAccountRequest: PcAccountRequestSchema,
+  PcAccountResult: PcAccountResultSchema,
+  PairingExchangeRequest: PairingExchangeRequestSchema,
+  PairingExchangeResult: PairingExchangeResultSchema,
+  MobileTransferMachine: MobileTransferMachineSchema,
+  MobileTransferPayload: MobileTransferPayloadSchema,
+  MobileTransferPart: MobileTransferPartSchema,
+  MobileTransferUploadRequest: MobileTransferUploadRequestSchema,
+  MobileTransferUploadResult: MobileTransferUploadResultSchema,
+  MobileTransferDownloadResult: MobileTransferDownloadResultSchema,
+  MobileLoginRequest: MobileLoginRequestSchema,
+  MachinePresence: MachinePresenceSchema,
+  MachineOffline: MachineOfflineSchema,
+  MachineListRequest: MachineListRequestSchema,
+  MachineListResult: MachineListResultSchema,
+  SessionSummary: SessionSummarySchema,
+  GroupChatParticipant: GroupChatParticipantSchema,
+  GroupChatInfo: GroupChatInfoSchema,
+  GroupChatCreateData: GroupChatCreateDataSchema,
+  GroupChatCreateResultData: GroupChatCreateResultDataSchema,
+  SessionsSnapshot: SessionsSnapshotSchema,
+  SessionListRequest: SessionListRequestSchema,
+  SessionListResult: SessionListResultSchema,
+  WorkspaceOption: WorkspaceOptionSchema,
+  CopilotModelOption: CopilotModelOptionSchema,
+  SessionOptionsRequest: SessionOptionsRequestSchema,
+  SessionOptionsResult: SessionOptionsResultSchema,
+  SessionCreateRequest: SessionCreateRequestSchema,
+  SessionCreateResult: SessionCreateResultSchema,
+  SessionDeleteRequest: SessionDeleteRequestSchema,
+  SessionDeleteResult: SessionDeleteResultSchema,
+  SessionConfigureRequest: SessionConfigureRequestSchema,
+  SessionConfigureResult: SessionConfigureResultSchema,
+  SessionRemoteRequest: SessionRemoteRequestSchema,
+  SessionRemoteStatus: SessionRemoteStatusSchema,
+  SessionRemoteResult: SessionRemoteResultSchema,
+  ConversationAttachment: ConversationAttachmentSchema,
+  PromptImageAttachment: PromptImageAttachmentSchema,
+  ConversationActivityStep: ConversationActivityStepSchema,
+  ConversationPlanTodo: ConversationPlanTodoSchema,
+  ConversationItem: ConversationItemSchema,
+  SessionAssistantPreview: SessionAssistantPreviewSchema,
+  SessionUserPreview: SessionUserPreviewSchema,
+  SessionTimelinePageRequest: SessionTimelinePageRequestSchema,
+  SessionWatchRequest: SessionWatchRequestSchema,
+  SessionWatchResult: SessionWatchResultSchema,
+  SessionTimelinePage: SessionTimelinePageSchema,
+  SessionTimelinePageResult: SessionTimelinePageResultSchema,
+  TimelineWatermark: TimelineWatermarkSchema,
+  TimelineSyncRequest: TimelineSyncRequestSchema,
+  TimelineTextAppend: TimelineTextAppendSchema,
+  TimelineSyncEvent: TimelineSyncEventSchema,
+  TimelineSyncResponse: TimelineSyncResponseSchema,
+  TimelineImageRequest: TimelineImageRequestSchema,
+  TimelineImageChunk: TimelineImageChunkSchema,
+  SessionPromptRequest: SessionPromptRequestSchema,
+  SessionPromptResult: SessionPromptResultSchema,
+  SessionActivityUpdate: SessionActivityUpdateSchema,
+  SessionAbortRequest: SessionAbortRequestSchema,
+  SessionAbortResult: SessionAbortResultSchema,
+  ConversationItemUpsert: ConversationItemUpsertSchema,
+  ConversationActivityStepUpsert: ConversationActivityStepUpsertSchema,
+  SessionTimelineInvalidated: SessionTimelineInvalidatedSchema,
+  InteractionFormField: InteractionFormFieldSchema,
+  InteractionRequest: InteractionRequestSchema,
+  InteractionResponse: InteractionResponseSchema,
+  InteractionRequestPayload: InteractionRequestPayloadSchema,
+  InteractionRespondRequest: InteractionRespondRequestSchema,
+  InteractionRespondResult: InteractionRespondResultSchema,
+  PermissionRequestPayload: PermissionRequestPayloadSchema,
+  PermissionRespondRequest: PermissionRespondRequestSchema,
+  PermissionRespondResult: PermissionRespondResultSchema,
+  ProtocolError: ProtocolErrorSchema
+};
+
+export {
+  PROTOCOL_VERSION,
+  TRANSPORT_V2,
+  SECURE_SOCKET_IO_NAMESPACE,
+  IdSchema,
+  OperationAckSchema,
+  PAIRING_URI_SCHEME,
+  PAIRING_URI_HOST,
+  PairingCreateResultSchema,
+  SECURE_MESSAGE_MAX_CIPHERTEXT_LENGTH,
+  SecureMessageSchema,
+  MOBILE_CONNECTED_REPLAY_CAPABILITY,
+  MACHINE_HELLO_SDK_COMPAT_VERSION,
+  MachineHelloSchema,
+  MobileDisconnectedSchema,
+  MobileConnectedSchema,
+  PC_PEER_CHAT_CAPABILITY,
+  PeerMessageSchema,
+  PeerDeliverySchema,
+  PC_A2A_CAPABILITY,
+  A2aRelayRequestSchema,
+  A2aRelayResponseSchema,
+  SESSION_COMMUNICATION_CAPABILITY,
+  SessionCommunicationDataSchema,
+  SessionCommunicationRequestSchema,
+  SessionCommunicationSchema,
+  sessionCommunicationOperationCapability,
+  sessionCommunicationError,
+  SESSION_PROJECT_IDENTITY_OPERATION,
+  SESSION_PROJECT_IDENTITY_VERSION,
+  SESSION_DIRECTORY_LIST_OPERATION,
+  SESSION_DIRECTORY_LIST_VERSION,
+  SESSION_DIRECTORY_MAX_ENTRIES,
+  SESSION_DIRECTORY_MAX_RESPONSE_BYTES,
+  SESSION_FILE_READ_OPERATION,
+  SESSION_FILE_READ_VERSION,
+  SESSION_FILE_MAX_ORIGINAL_BYTES,
+  SESSION_FILE_GZIP_THRESHOLD_BYTES,
+  SESSION_FILE_MAX_IMAGE_BYTES,
+  SESSION_FILE_MAX_IMAGE_EDGE,
+  SESSION_FILE_MAX_IMAGE_PIXELS,
+  isSafeSessionDirectoryPath,
+  SessionDirectoryListDataSchema,
+  SessionDirectoryListResultDataSchema,
+  SessionFileReadDataSchema,
+  SessionFileReadResultDataSchema,
+  SessionGitProjectSchema,
+  SessionProjectIdentityRequestDataSchema,
+  SessionProjectIdentityResultDataSchema,
+  SESSION_RESOURCE_READ_OPERATION,
+  SESSION_RESOURCE_READ_VERSION,
+  SESSION_RESOURCE_MAX_ORIGINAL_BYTES,
+  SESSION_RESOURCE_GZIP_THRESHOLD_BYTES,
+  SESSION_RESOURCE_MAX_IMAGE_PIXELS,
+  SessionResourceReadDataSchema,
+  SessionResourceReadResultDataSchema,
+  SESSION_RENAME_OPERATION,
+  SESSION_RENAME_VERSION,
+  SESSION_NAME_MAX_LENGTH,
+  SessionNameSchema,
+  SessionRenameDataSchema,
+  SessionRenameResultDataSchema,
+  SESSION_DELETE_CAPABILITY,
+  SESSION_LIST_UPDATES_CAPABILITY,
+  SESSION_WORKTREE_CREATION_CAPABILITY,
+  MANAGED_SESSION_SELECTION_CAPABILITY,
+  AGENT_CONTROLS_CAPABILITY,
+  GroupChatParticipantSchema,
+  GroupChatInfoSchema,
+  SessionSummarySchema,
+  SessionsSnapshotSchema,
+  SessionListRequestSchema,
+  SessionListResultSchema,
+  REASONING_EFFORTS,
+  ReasoningEffortSchema,
+  CopilotModelOptionSchema,
+  SessionReasoningEffortSchema,
+  CurrentReasoningEffortSchema,
+  SessionToolInfoSchema,
+  SessionSlashCommandInfoSchema,
+  SessionSkillInfoSchema,
+  SessionOptionsRequestSchema,
+  SessionOptionsResultSchema,
+  SessionCreateRequestSchema,
+  SessionDeleteRequestSchema,
+  SessionConfigureRequestSchema,
+  SessionConfigureResultSchema,
+  SessionRemoteRequestSchema,
+  SessionRemoteStatusSchema,
+  GROUP_CHAT_CREATE_OPERATION,
+  GROUP_CHAT_CREATE_VERSION,
+  GROUP_CHAT_CREATE_CAPABILITY,
+  GroupChatCreateDataSchema,
+  GroupChatCreateResultDataSchema,
+  PromptImageAttachmentSchema,
+  PromptFileAttachmentSchema,
+  ConversationAttachmentSchema,
+  CONVERSATION_ACTIVITY_STEP_LIMIT,
+  CONVERSATION_SOURCE_ID_LIMIT,
+  ConversationItemSchema,
+  ConversationItemUpsertSchema,
+  ConversationActivityStepUpsertSchema,
+  SESSION_ASSISTANT_PREVIEW_CAPABILITY,
+  SessionUserPreviewSchema,
+  SessionAssistantPreviewSchema,
+  SESSION_TIMELINE_PAGE_SIZE,
+  SessionTimelinePageRequestSchema,
+  SessionWatchRequestSchema,
+  SessionTimelinePageSchema,
+  SessionTimelineInvalidatedSchema,
+  SESSION_FILE_ATTACHMENTS_CAPABILITY,
+  SESSION_PROMPT_SUBMISSION_TIME_CAPABILITY,
+  SessionPromptRequestSchema,
+  SessionActivityUpdateSchema,
+  SessionAbortRequestSchema,
+  MOBILE_INTERACTION_PERSISTENCE_CAPABILITY,
+  INTERACTION_DISMISS_RESPONSE_CAPABILITY,
+  INTERACTION_SUPERSEDED_ERROR_CODE,
+  InteractionRequestSchema,
+  InteractionResponseSchema,
+  InteractionRequestPayloadSchema,
+  InteractionRespondRequestSchema,
+  InteractionRespondResultSchema,
+  PermissionRequestPayloadSchema,
+  PermissionRespondRequestSchema,
+  TIMELINE_SYNC_OPERATION,
+  TIMELINE_IMAGE_OPERATION,
+  TIMELINE_SYNC_VERSION,
+  TIMELINE_SYNC_MAX_EVENTS,
+  TIMELINE_SYNC_MAX_BYTES,
+  TIMELINE_IMAGE_CHUNK_BYTES,
+  TIMELINE_IMAGE_MAX_BYTES,
+  TimelineSyncRequestSchema,
+  TimelineSyncResponseSchema,
+  TimelineImageRequestSchema,
+  TimelineImageChunkSchema,
+  SCHEDULES_CAPABILITY,
+  SCHEDULE_OPERATIONS,
+  WorkbenchScheduleProposalSchema,
+  WorkbenchScheduleDraftSchema,
+  WorkbenchScheduleEntrySchema,
+  WorkbenchScheduleSnapshotSchema,
+  WorkbenchScheduleCreateRequestSchema,
+  WorkbenchScheduleCreateResultSchema,
+  WorkbenchScheduleDeleteRequestSchema,
+  WorkbenchScheduleDeleteResultSchema,
+  WorkbenchScheduleDraftDismissRequestSchema,
+  WORKBENCH_VERSION,
+  RESEARCH_CHAT_CAPABILITY,
+  WORKBENCH_OPERATIONS,
+  workbenchCapability,
+  WorkbenchOperationGetSchema,
+  WorkbenchOperationStatusSchema,
+  WorkbenchAskRequestSchema,
+  WorkbenchAskResultSchema,
+  WorkbenchEmptyRequestSchema,
+  WorkbenchSubmitRequestSchema,
+  WorkbenchResearchCreateRequestSchema,
+  WorkbenchResearchCreateResultSchema,
+  WorkbenchResearchListResultSchema,
+  WorkbenchResearchTimelineRequestSchema,
+  WorkbenchResearchSendRequestSchema,
+  WorkbenchResearchSendResultSchema,
+  WorkbenchCompletedResultSchema,
+  WorkbenchCommandSchema,
+  WorkbenchCommandListResultSchema,
+  WorkbenchCommandInvokeRequestSchema,
+  WorkbenchCommandResultSchema,
+  WorkbenchQueueSnapshotSchema,
+  WorkbenchQueueMutationRequestSchema,
+  WorkbenchQueueMutationResultSchema,
+  WorkbenchInsightsSchema,
+  WorkbenchCompactResultSchema
+};