@workclaw/openclaw-workclaw 1.0.338 → 1.0.339

package/dist/node_modules/.pnpm/openclaw@2026.5.22/node_modules/openclaw/dist/protocol-DiXjp30g.js

@@ -0,0 +1,3080 @@
+import { n as ENV_SECRET_REF_ID_RE } from "./types.secrets-DwPik3M8.js";
+import { r as SECRET_PROVIDER_ALIAS_PATTERN, i as SINGLE_VALUE_FILE_REF_ID, n as FILE_SECRET_REF_ID_INVALID_ESCAPE_JSON_SCHEMA_PATTERN, t as EXEC_SECRET_REF_ID_JSON_SCHEMA_PATTERN } from "./ref-contract-D_h_G00C.js";
+import { r as GATEWAY_CLIENT_MODES, n as GATEWAY_CLIENT_IDS } from "./client-info-BVWE_ra1.js";
+import { t as INPUT_PROVENANCE_KIND_VALUES } from "./input-provenance-CmqYxlZ2.js";
+import { r as MAX_PLUGIN_APPROVAL_TIMEOUT_MS } from "./plugin-approvals-BAd_Vwt-.js";
+import Ajv from "../../../../ajv@8.20.0/node_modules/ajv/dist/ajv.js";
+import { Optional } from "../../../../typebox@1.1.38/node_modules/typebox/build/type/types/_optional.js";
+import { Array as _Array_ } from "../../../../typebox@1.1.38/node_modules/typebox/build/type/types/array.js";
+import { Any } from "../../../../typebox@1.1.38/node_modules/typebox/build/type/types/any.js";
+import { Object as _Object_ } from "../../../../typebox@1.1.38/node_modules/typebox/build/type/types/object.js";
+import { Union } from "../../../../typebox@1.1.38/node_modules/typebox/build/type/types/union.js";
+import { Unknown } from "../../../../typebox@1.1.38/node_modules/typebox/build/type/types/unknown.js";
+import { Unsafe } from "../../../../typebox@1.1.38/node_modules/typebox/build/type/types/unsafe.js";
+import { Enum } from "../../../../typebox@1.1.38/node_modules/typebox/build/type/types/enum.js";
+import "../../../../typebox@1.1.38/node_modules/typebox/build/system/hashing/hash.js";
+import { Boolean } from "../../../../typebox@1.1.38/node_modules/typebox/build/type/types/boolean.js";
+import { Integer } from "../../../../typebox@1.1.38/node_modules/typebox/build/type/types/integer.js";
+import { Literal } from "../../../../typebox@1.1.38/node_modules/typebox/build/type/types/literal.js";
+import { Null } from "../../../../typebox@1.1.38/node_modules/typebox/build/type/types/null.js";
+import { Number } from "../../../../typebox@1.1.38/node_modules/typebox/build/type/types/number.js";
+import { Record } from "../../../../typebox@1.1.38/node_modules/typebox/build/type/types/record.js";
+import { String } from "../../../../typebox@1.1.38/node_modules/typebox/build/type/types/string.js";
+import "../../../../typebox@1.1.38/node_modules/typebox/build/type/script/token/internal/char.js";
+import "../../../../typebox@1.1.38/node_modules/typebox/build/type/script/token/ident.js";
+const AGENT_INTERNAL_EVENT_TYPE_TASK_COMPLETION = "task_completion";
+const AGENT_INTERNAL_EVENT_SOURCES = [
+  "subagent",
+  "cron",
+  "image_generation",
+  "video_generation",
+  "music_generation"
+];
+const AGENT_INTERNAL_EVENT_STATUSES = [
+  "ok",
+  "timeout",
+  "error",
+  "unknown"
+];
+const NonEmptyString = String({ minLength: 1 });
+const ChatSendSessionKeyString = String({
+  minLength: 1,
+  maxLength: 512
+});
+const SessionLabelString = String({
+  minLength: 1,
+  maxLength: 512
+});
+const InputProvenanceSchema = _Object_({
+  kind: String({ enum: [...INPUT_PROVENANCE_KIND_VALUES] }),
+  originSessionId: Optional(String()),
+  sourceSessionKey: Optional(String()),
+  sourceChannel: Optional(String()),
+  sourceTool: Optional(String())
+}, { additionalProperties: false });
+const GatewayClientIdSchema = Enum(GATEWAY_CLIENT_IDS);
+const GatewayClientModeSchema = Enum(GATEWAY_CLIENT_MODES);
+Union([
+  Literal("env"),
+  Literal("file"),
+  Literal("exec")
+]);
+const SecretProviderAliasString = String({ pattern: SECRET_PROVIDER_ALIAS_PATTERN.source });
+const EnvSecretRefSchema = _Object_({
+  source: Literal("env"),
+  provider: SecretProviderAliasString,
+  id: String({ pattern: ENV_SECRET_REF_ID_RE.source })
+}, { additionalProperties: false });
+const FileSecretRefIdSchema = Unsafe({
+  type: "string",
+  anyOf: [{ const: SINGLE_VALUE_FILE_REF_ID }, { allOf: [{ pattern: "^/" }, { not: { pattern: FILE_SECRET_REF_ID_INVALID_ESCAPE_JSON_SCHEMA_PATTERN } }] }]
+});
+const FileSecretRefSchema = _Object_({
+  source: Literal("file"),
+  provider: SecretProviderAliasString,
+  id: FileSecretRefIdSchema
+}, { additionalProperties: false });
+const ExecSecretRefSchema = _Object_({
+  source: Literal("exec"),
+  provider: SecretProviderAliasString,
+  id: String({ pattern: EXEC_SECRET_REF_ID_JSON_SCHEMA_PATTERN })
+}, { additionalProperties: false });
+const SecretRefSchema = Union([
+  EnvSecretRefSchema,
+  FileSecretRefSchema,
+  ExecSecretRefSchema
+]);
+const SecretInputSchema = Union([String(), SecretRefSchema]);
+const AgentGeneratedAttachmentSchema = _Object_({
+  type: Optional(String({ enum: [
+    "image",
+    "audio",
+    "video",
+    "file"
+  ] })),
+  path: Optional(String()),
+  url: Optional(String()),
+  mediaUrl: Optional(String()),
+  filePath: Optional(String()),
+  mimeType: Optional(String()),
+  name: Optional(String())
+}, { additionalProperties: false });
+const AgentInternalEventSchema = _Object_({
+  type: Literal(AGENT_INTERNAL_EVENT_TYPE_TASK_COMPLETION),
+  source: String({ enum: [...AGENT_INTERNAL_EVENT_SOURCES] }),
+  childSessionKey: String(),
+  childSessionId: Optional(String()),
+  announceType: String(),
+  taskLabel: String(),
+  status: String({ enum: [...AGENT_INTERNAL_EVENT_STATUSES] }),
+  statusLabel: String(),
+  result: String(),
+  attachments: Optional(_Array_(AgentGeneratedAttachmentSchema)),
+  mediaUrls: Optional(_Array_(String())),
+  statsLine: Optional(String()),
+  replyInstruction: String()
+}, { additionalProperties: false });
+_Object_({
+  runId: NonEmptyString,
+  seq: Integer({ minimum: 0 }),
+  stream: NonEmptyString,
+  ts: Integer({ minimum: 0 }),
+  spawnedBy: Optional(NonEmptyString),
+  isHeartbeat: Optional(Boolean()),
+  data: Record(String(), Unknown())
+}, { additionalProperties: false });
+const MessageActionToolContextSchema = _Object_({
+  currentChannelId: Optional(String()),
+  currentGraphChannelId: Optional(String()),
+  currentChannelProvider: Optional(String()),
+  currentThreadTs: Optional(String()),
+  currentMessageId: Optional(Union([String(), Number()])),
+  replyToMode: Optional(Union([
+    Literal("off"),
+    Literal("first"),
+    Literal("all"),
+    Literal("batched")
+  ])),
+  hasRepliedRef: Optional(_Object_({ value: Boolean() }, { additionalProperties: false })),
+  skipCrossContextDecoration: Optional(Boolean())
+}, { additionalProperties: false });
+const MessageActionParamsSchema = _Object_({
+  channel: NonEmptyString,
+  action: NonEmptyString,
+  params: Record(String(), Unknown()),
+  accountId: Optional(String()),
+  requesterSenderId: Optional(String()),
+  senderIsOwner: Optional(Boolean()),
+  sessionKey: Optional(String()),
+  sessionId: Optional(String()),
+  inboundTurnKind: Optional(String({ enum: ["user_request", "room_event"] })),
+  agentId: Optional(String()),
+  toolContext: Optional(MessageActionToolContextSchema),
+  idempotencyKey: NonEmptyString
+}, { additionalProperties: false });
+const SendParamsSchema = _Object_({
+  to: NonEmptyString,
+  message: Optional(String()),
+  mediaUrl: Optional(String()),
+  mediaUrls: Optional(_Array_(String())),
+  asVoice: Optional(Boolean()),
+  gifPlayback: Optional(Boolean()),
+  channel: Optional(String()),
+  accountId: Optional(String()),
+  /** Optional agent id for per-agent media root resolution on gateway sends. */
+  agentId: Optional(String()),
+  /** Reply target message id for native quoted/threaded sends where supported. */
+  replyToId: Optional(String()),
+  /** Thread id (channel-specific meaning, e.g. Telegram forum topic id). */
+  threadId: Optional(String()),
+  /** Force document-style media sends where supported. */
+  forceDocument: Optional(Boolean()),
+  /** Send silently (no notification) where supported. */
+  silent: Optional(Boolean()),
+  /** Channel-specific parse mode for formatted text. */
+  parseMode: Optional(Literal("HTML")),
+  /** Optional session key for mirroring delivered output back into the transcript. */
+  sessionKey: Optional(String()),
+  idempotencyKey: NonEmptyString
+}, { additionalProperties: false });
+const PollParamsSchema = _Object_({
+  to: NonEmptyString,
+  question: NonEmptyString,
+  options: _Array_(NonEmptyString, {
+    minItems: 2,
+    maxItems: 12
+  }),
+  maxSelections: Optional(Integer({
+    minimum: 1,
+    maximum: 12
+  })),
+  /** Poll duration in seconds (channel-specific limits may apply). */
+  durationSeconds: Optional(Integer({
+    minimum: 1,
+    maximum: 604800
+  })),
+  durationHours: Optional(Integer({ minimum: 1 })),
+  /** Send silently (no notification) where supported. */
+  silent: Optional(Boolean()),
+  /** Poll anonymity where supported (e.g. Telegram polls default to anonymous). */
+  isAnonymous: Optional(Boolean()),
+  /** Thread id (channel-specific meaning, e.g. Telegram forum topic id). */
+  threadId: Optional(String()),
+  channel: Optional(String()),
+  accountId: Optional(String()),
+  idempotencyKey: NonEmptyString
+}, { additionalProperties: false });
+const AgentParamsSchema = _Object_({
+  message: NonEmptyString,
+  agentId: Optional(NonEmptyString),
+  provider: Optional(String()),
+  model: Optional(String()),
+  to: Optional(String()),
+  replyTo: Optional(String()),
+  sessionId: Optional(String()),
+  sessionKey: Optional(String()),
+  thinking: Optional(String()),
+  deliver: Optional(Boolean()),
+  attachments: Optional(_Array_(Unknown())),
+  channel: Optional(String()),
+  replyChannel: Optional(String()),
+  accountId: Optional(String()),
+  replyAccountId: Optional(String()),
+  threadId: Optional(String()),
+  groupId: Optional(String()),
+  groupChannel: Optional(String()),
+  groupSpace: Optional(String()),
+  timeout: Optional(Integer({ minimum: 0 })),
+  bestEffortDeliver: Optional(Boolean()),
+  lane: Optional(String()),
+  cleanupBundleMcpOnRunEnd: Optional(Boolean()),
+  modelRun: Optional(Boolean()),
+  promptMode: Optional(Union([
+    Literal("full"),
+    Literal("minimal"),
+    Literal("none")
+  ])),
+  extraSystemPrompt: Optional(String()),
+  bootstrapContextMode: Optional(Union([Literal("full"), Literal("lightweight")])),
+  bootstrapContextRunKind: Optional(Union([
+    Literal("default"),
+    Literal("heartbeat"),
+    Literal("cron")
+  ])),
+  acpTurnSource: Optional(Literal("manual_spawn")),
+  internalRuntimeHandoffId: Optional(NonEmptyString),
+  internalEvents: Optional(_Array_(AgentInternalEventSchema)),
+  inputProvenance: Optional(InputProvenanceSchema),
+  sourceReplyDeliveryMode: Optional(Union([Literal("automatic"), Literal("message_tool_only")])),
+  voiceWakeTrigger: Optional(String()),
+  idempotencyKey: NonEmptyString,
+  label: Optional(SessionLabelString)
+}, { additionalProperties: false });
+const AgentIdentityParamsSchema = _Object_({
+  agentId: Optional(NonEmptyString),
+  sessionKey: Optional(String())
+}, { additionalProperties: false });
+_Object_({
+  agentId: NonEmptyString,
+  name: Optional(NonEmptyString),
+  avatar: Optional(NonEmptyString),
+  avatarSource: Optional(NonEmptyString),
+  avatarStatus: Optional(String({ enum: [
+    "none",
+    "local",
+    "remote",
+    "data"
+  ] })),
+  avatarReason: Optional(NonEmptyString),
+  emoji: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const AgentWaitParamsSchema = _Object_({
+  runId: NonEmptyString,
+  timeoutMs: Optional(Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+const WakeParamsSchema = _Object_({
+  mode: Union([Literal("now"), Literal("next-heartbeat")]),
+  text: NonEmptyString,
+  sessionKey: Optional(NonEmptyString)
+}, { additionalProperties: true });
+const ModelChoiceSchema = _Object_({
+  id: NonEmptyString,
+  name: NonEmptyString,
+  provider: NonEmptyString,
+  alias: Optional(NonEmptyString),
+  contextWindow: Optional(Integer({ minimum: 1 })),
+  reasoning: Optional(Boolean())
+}, { additionalProperties: false });
+const AgentSummarySchema = _Object_({
+  id: NonEmptyString,
+  name: Optional(NonEmptyString),
+  identity: Optional(_Object_({
+    name: Optional(NonEmptyString),
+    theme: Optional(NonEmptyString),
+    emoji: Optional(NonEmptyString),
+    avatar: Optional(NonEmptyString),
+    avatarUrl: Optional(NonEmptyString)
+  }, { additionalProperties: false })),
+  workspace: Optional(NonEmptyString),
+  model: Optional(_Object_({
+    primary: Optional(NonEmptyString),
+    fallbacks: Optional(_Array_(NonEmptyString))
+  }, { additionalProperties: false })),
+  agentRuntime: Optional(_Object_({
+    id: NonEmptyString,
+    fallback: Optional(Union([Literal("pi"), Literal("none")])),
+    source: Union([
+      Literal("env"),
+      Literal("agent"),
+      Literal("defaults"),
+      Literal("model"),
+      Literal("provider"),
+      Literal("implicit")
+    ])
+  }, { additionalProperties: false }))
+}, { additionalProperties: false });
+const AgentsListParamsSchema = _Object_({}, { additionalProperties: false });
+_Object_({
+  defaultId: NonEmptyString,
+  mainKey: NonEmptyString,
+  scope: Union([Literal("per-sender"), Literal("global")]),
+  agents: _Array_(AgentSummarySchema)
+}, { additionalProperties: false });
+const AgentsCreateParamsSchema = _Object_({
+  name: NonEmptyString,
+  workspace: NonEmptyString,
+  model: Optional(NonEmptyString),
+  emoji: Optional(String()),
+  avatar: Optional(String())
+}, { additionalProperties: false });
+_Object_({
+  ok: Literal(true),
+  agentId: NonEmptyString,
+  name: NonEmptyString,
+  workspace: NonEmptyString,
+  model: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const AgentsUpdateParamsSchema = _Object_({
+  agentId: NonEmptyString,
+  name: Optional(NonEmptyString),
+  workspace: Optional(NonEmptyString),
+  model: Optional(NonEmptyString),
+  emoji: Optional(String()),
+  avatar: Optional(String())
+}, { additionalProperties: false });
+_Object_({
+  ok: Literal(true),
+  agentId: NonEmptyString
+}, { additionalProperties: false });
+const AgentsDeleteParamsSchema = _Object_({
+  agentId: NonEmptyString,
+  deleteFiles: Optional(Boolean())
+}, { additionalProperties: false });
+_Object_({
+  ok: Literal(true),
+  agentId: NonEmptyString,
+  removedBindings: Integer({ minimum: 0 })
+}, { additionalProperties: false });
+const AgentsFileEntrySchema = _Object_({
+  name: NonEmptyString,
+  path: NonEmptyString,
+  missing: Boolean(),
+  size: Optional(Integer({ minimum: 0 })),
+  updatedAtMs: Optional(Integer({ minimum: 0 })),
+  content: Optional(String())
+}, { additionalProperties: false });
+const AgentsFilesListParamsSchema = _Object_({ agentId: NonEmptyString }, { additionalProperties: false });
+_Object_({
+  agentId: NonEmptyString,
+  workspace: NonEmptyString,
+  files: _Array_(AgentsFileEntrySchema)
+}, { additionalProperties: false });
+const AgentsFilesGetParamsSchema = _Object_({
+  agentId: NonEmptyString,
+  name: NonEmptyString
+}, { additionalProperties: false });
+_Object_({
+  agentId: NonEmptyString,
+  workspace: NonEmptyString,
+  file: AgentsFileEntrySchema
+}, { additionalProperties: false });
+const AgentsFilesSetParamsSchema = _Object_({
+  agentId: NonEmptyString,
+  name: NonEmptyString,
+  content: String()
+}, { additionalProperties: false });
+_Object_({
+  ok: Literal(true),
+  agentId: NonEmptyString,
+  workspace: NonEmptyString,
+  file: AgentsFileEntrySchema
+}, { additionalProperties: false });
+const ModelsListParamsSchema = _Object_({ view: Optional(Union([
+  Literal("default"),
+  Literal("configured"),
+  Literal("all")
+])) }, { additionalProperties: false });
+_Object_({ models: _Array_(ModelChoiceSchema) }, { additionalProperties: false });
+const SkillsStatusParamsSchema = _Object_({ agentId: Optional(NonEmptyString) }, { additionalProperties: false });
+const SkillsBinsParamsSchema = _Object_({}, { additionalProperties: false });
+_Object_({ bins: _Array_(NonEmptyString) }, { additionalProperties: false });
+const Sha256String = String({
+  minLength: 64,
+  maxLength: 64,
+  pattern: "^[a-fA-F0-9]{64}$"
+});
+const SkillUploadIdempotencyKeyString = String({
+  minLength: 1,
+  maxLength: 2048
+});
+const SkillUploadDataBase64String = String({
+  minLength: 1,
+  maxLength: 5592408
+});
+const SkillsUploadBeginParamsSchema = _Object_({
+  kind: Literal("skill-archive"),
+  slug: NonEmptyString,
+  sizeBytes: Integer({ minimum: 1 }),
+  sha256: Optional(Sha256String),
+  force: Optional(Boolean()),
+  idempotencyKey: Optional(SkillUploadIdempotencyKeyString)
+}, { additionalProperties: false });
+const SkillsUploadChunkParamsSchema = _Object_({
+  uploadId: NonEmptyString,
+  offset: Integer({ minimum: 0 }),
+  dataBase64: SkillUploadDataBase64String
+}, { additionalProperties: false });
+const SkillsUploadCommitParamsSchema = _Object_({
+  uploadId: NonEmptyString,
+  sha256: Optional(Sha256String)
+}, { additionalProperties: false });
+const SkillsInstallParamsSchema = Union([
+  _Object_({
+    name: NonEmptyString,
+    installId: NonEmptyString,
+    dangerouslyForceUnsafeInstall: Optional(Boolean()),
+    timeoutMs: Optional(Integer({ minimum: 1e3 }))
+  }, { additionalProperties: false }),
+  _Object_({
+    source: Literal("clawhub"),
+    slug: NonEmptyString,
+    version: Optional(NonEmptyString),
+    force: Optional(Boolean()),
+    timeoutMs: Optional(Integer({ minimum: 1e3 }))
+  }, { additionalProperties: false }),
+  _Object_({
+    source: Literal("upload"),
+    uploadId: NonEmptyString,
+    slug: NonEmptyString,
+    force: Optional(Boolean()),
+    sha256: Optional(Sha256String),
+    timeoutMs: Optional(Integer({ minimum: 1e3 }))
+  }, { additionalProperties: false })
+]);
+const SkillsUpdateParamsSchema = Union([_Object_({
+  skillKey: NonEmptyString,
+  enabled: Optional(Boolean()),
+  apiKey: Optional(String()),
+  env: Optional(Record(NonEmptyString, String()))
+}, { additionalProperties: false }), _Object_({
+  source: Literal("clawhub"),
+  slug: Optional(NonEmptyString),
+  all: Optional(Boolean())
+}, { additionalProperties: false })]);
+const SkillsSearchParamsSchema = _Object_({
+  query: Optional(NonEmptyString),
+  limit: Optional(Integer({
+    minimum: 1,
+    maximum: 100
+  }))
+}, { additionalProperties: false });
+_Object_({ results: _Array_(_Object_({
+  score: Number(),
+  slug: NonEmptyString,
+  displayName: NonEmptyString,
+  summary: Optional(String()),
+  version: Optional(NonEmptyString),
+  updatedAt: Optional(Integer())
+}, { additionalProperties: false })) }, { additionalProperties: false });
+const SkillsDetailParamsSchema = _Object_({ slug: NonEmptyString }, { additionalProperties: false });
+_Object_({
+  skill: Union([_Object_({
+    slug: NonEmptyString,
+    displayName: NonEmptyString,
+    summary: Optional(String()),
+    tags: Optional(Record(NonEmptyString, String())),
+    createdAt: Integer(),
+    updatedAt: Integer()
+  }, { additionalProperties: false }), Null()]),
+  latestVersion: Optional(Union([_Object_({
+    version: NonEmptyString,
+    createdAt: Integer(),
+    changelog: Optional(String())
+  }, { additionalProperties: false }), Null()])),
+  metadata: Optional(Union([_Object_({
+    os: Optional(Union([_Array_(String()), Null()])),
+    systems: Optional(Union([_Array_(String()), Null()]))
+  }, { additionalProperties: false }), Null()])),
+  owner: Optional(Union([_Object_({
+    handle: Optional(Union([NonEmptyString, Null()])),
+    displayName: Optional(Union([NonEmptyString, Null()])),
+    image: Optional(Union([String(), Null()]))
+  }, { additionalProperties: false }), Null()]))
+}, { additionalProperties: false });
+const ToolsCatalogParamsSchema = _Object_({
+  agentId: Optional(NonEmptyString),
+  includePlugins: Optional(Boolean())
+}, { additionalProperties: false });
+const ToolsEffectiveParamsSchema = _Object_({
+  agentId: Optional(NonEmptyString),
+  sessionKey: NonEmptyString
+}, { additionalProperties: false });
+const ToolsInvokeParamsSchema = _Object_({
+  name: NonEmptyString,
+  args: Optional(Record(String(), Unknown())),
+  sessionKey: Optional(NonEmptyString),
+  agentId: Optional(NonEmptyString),
+  confirm: Optional(Boolean()),
+  idempotencyKey: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const ToolCatalogProfileSchema = _Object_({
+  id: Union([
+    Literal("minimal"),
+    Literal("coding"),
+    Literal("messaging"),
+    Literal("full")
+  ]),
+  label: NonEmptyString
+}, { additionalProperties: false });
+const ToolCatalogEntrySchema = _Object_({
+  id: NonEmptyString,
+  label: NonEmptyString,
+  description: String(),
+  source: Union([Literal("core"), Literal("plugin")]),
+  pluginId: Optional(NonEmptyString),
+  optional: Optional(Boolean()),
+  risk: Optional(Union([
+    Literal("low"),
+    Literal("medium"),
+    Literal("high")
+  ])),
+  tags: Optional(_Array_(NonEmptyString)),
+  defaultProfiles: _Array_(Union([
+    Literal("minimal"),
+    Literal("coding"),
+    Literal("messaging"),
+    Literal("full")
+  ]))
+}, { additionalProperties: false });
+const ToolCatalogGroupSchema = _Object_({
+  id: NonEmptyString,
+  label: NonEmptyString,
+  source: Union([Literal("core"), Literal("plugin")]),
+  pluginId: Optional(NonEmptyString),
+  tools: _Array_(ToolCatalogEntrySchema)
+}, { additionalProperties: false });
+_Object_({
+  agentId: NonEmptyString,
+  profiles: _Array_(ToolCatalogProfileSchema),
+  groups: _Array_(ToolCatalogGroupSchema)
+}, { additionalProperties: false });
+const ToolsEffectiveEntrySchema = _Object_({
+  id: NonEmptyString,
+  label: NonEmptyString,
+  description: String(),
+  rawDescription: String(),
+  source: Union([
+    Literal("core"),
+    Literal("plugin"),
+    Literal("channel")
+  ]),
+  pluginId: Optional(NonEmptyString),
+  channelId: Optional(NonEmptyString),
+  risk: Optional(Union([
+    Literal("low"),
+    Literal("medium"),
+    Literal("high")
+  ])),
+  tags: Optional(_Array_(NonEmptyString))
+}, { additionalProperties: false });
+const ToolsEffectiveGroupSchema = _Object_({
+  id: Union([
+    Literal("core"),
+    Literal("plugin"),
+    Literal("channel")
+  ]),
+  label: NonEmptyString,
+  source: Union([
+    Literal("core"),
+    Literal("plugin"),
+    Literal("channel")
+  ]),
+  tools: _Array_(ToolsEffectiveEntrySchema)
+}, { additionalProperties: false });
+_Object_({
+  agentId: NonEmptyString,
+  profile: NonEmptyString,
+  groups: _Array_(ToolsEffectiveGroupSchema)
+}, { additionalProperties: false });
+const ToolsInvokeErrorSchema = _Object_({
+  code: NonEmptyString,
+  message: NonEmptyString,
+  details: Optional(Unknown())
+}, { additionalProperties: false });
+_Object_({
+  ok: Boolean(),
+  toolName: NonEmptyString,
+  output: Optional(Unknown()),
+  requiresApproval: Optional(Boolean()),
+  approvalId: Optional(NonEmptyString),
+  source: Optional(Union([
+    Literal("core"),
+    Literal("plugin"),
+    Literal("mcp"),
+    Literal("channel"),
+    String()
+  ])),
+  error: Optional(ToolsInvokeErrorSchema)
+}, { additionalProperties: false });
+const ArtifactQueryParamsProperties = {
+  sessionKey: Optional(NonEmptyString),
+  runId: Optional(NonEmptyString),
+  taskId: Optional(NonEmptyString),
+  agentId: Optional(NonEmptyString)
+};
+const ArtifactQueryParamsSchema = _Object_(ArtifactQueryParamsProperties, { additionalProperties: false });
+const ArtifactGetParamsSchema = _Object_({
+  ...ArtifactQueryParamsProperties,
+  artifactId: NonEmptyString
+}, { additionalProperties: false });
+const ArtifactSummarySchema = _Object_({
+  id: NonEmptyString,
+  type: NonEmptyString,
+  title: NonEmptyString,
+  mimeType: Optional(NonEmptyString),
+  sizeBytes: Optional(Integer({ minimum: 0 })),
+  sessionKey: Optional(NonEmptyString),
+  runId: Optional(NonEmptyString),
+  taskId: Optional(NonEmptyString),
+  messageSeq: Optional(Integer({ minimum: 1 })),
+  source: Optional(NonEmptyString),
+  download: _Object_({ mode: Union([
+    Literal("bytes"),
+    Literal("url"),
+    Literal("unsupported")
+  ]) }, { additionalProperties: false })
+}, { additionalProperties: false });
+const ArtifactsListParamsSchema = ArtifactQueryParamsSchema;
+_Object_({ artifacts: _Array_(ArtifactSummarySchema) }, { additionalProperties: false });
+const ArtifactsGetParamsSchema = ArtifactGetParamsSchema;
+_Object_({ artifact: ArtifactSummarySchema }, { additionalProperties: false });
+const ArtifactsDownloadParamsSchema = ArtifactGetParamsSchema;
+_Object_({
+  artifact: ArtifactSummarySchema,
+  encoding: Optional(Literal("base64")),
+  data: Optional(String()),
+  url: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const TalkModeParamsSchema = _Object_({
+  enabled: Boolean(),
+  phase: Optional(String())
+}, { additionalProperties: false });
+const TalkConfigParamsSchema = _Object_({ includeSecrets: Optional(Boolean()) }, { additionalProperties: false });
+const TalkSpeakParamsSchema = _Object_({
+  text: NonEmptyString,
+  voiceId: Optional(String()),
+  modelId: Optional(String()),
+  outputFormat: Optional(String()),
+  speed: Optional(Number()),
+  rateWpm: Optional(Integer({ minimum: 1 })),
+  stability: Optional(Number()),
+  similarity: Optional(Number()),
+  style: Optional(Number()),
+  speakerBoost: Optional(Boolean()),
+  seed: Optional(Integer({ minimum: 0 })),
+  normalize: Optional(String()),
+  language: Optional(String()),
+  latencyTier: Optional(Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+const TalkModeSchema = Union([
+  Literal("realtime"),
+  Literal("stt-tts"),
+  Literal("transcription")
+]);
+const TalkTransportSchema = Union([
+  Literal("webrtc"),
+  Literal("provider-websocket"),
+  Literal("gateway-relay"),
+  Literal("managed-room")
+]);
+const TalkBrainSchema = Union([
+  Literal("agent-consult"),
+  Literal("direct-tools"),
+  Literal("none")
+]);
+const TalkEventTypeSchema = Union([
+  Literal("session.started"),
+  Literal("session.ready"),
+  Literal("session.closed"),
+  Literal("session.error"),
+  Literal("session.replaced"),
+  Literal("turn.started"),
+  Literal("turn.ended"),
+  Literal("turn.cancelled"),
+  Literal("capture.started"),
+  Literal("capture.stopped"),
+  Literal("capture.cancelled"),
+  Literal("capture.once"),
+  Literal("input.audio.delta"),
+  Literal("input.audio.committed"),
+  Literal("transcript.delta"),
+  Literal("transcript.done"),
+  Literal("output.text.delta"),
+  Literal("output.text.done"),
+  Literal("output.audio.started"),
+  Literal("output.audio.delta"),
+  Literal("output.audio.done"),
+  Literal("tool.call"),
+  Literal("tool.progress"),
+  Literal("tool.result"),
+  Literal("tool.error"),
+  Literal("usage.metrics"),
+  Literal("latency.metrics"),
+  Literal("health.changed")
+]);
+const TURN_SCOPED_TALK_EVENT_TYPES = [
+  "turn.started",
+  "turn.ended",
+  "turn.cancelled",
+  "input.audio.delta",
+  "input.audio.committed",
+  "transcript.delta",
+  "transcript.done",
+  "output.text.delta",
+  "output.text.done",
+  "output.audio.started",
+  "output.audio.delta",
+  "output.audio.done",
+  "tool.call",
+  "tool.progress",
+  "tool.result",
+  "tool.error"
+];
+const CAPTURE_SCOPED_TALK_EVENT_TYPES = [
+  "capture.started",
+  "capture.stopped",
+  "capture.cancelled",
+  "capture.once"
+];
+function requireJsonSchemaProperties(properties) {
+  const conditionalRequirementKey = ["th", "en"].join("");
+  return Object.fromEntries([[conditionalRequirementKey, { required: properties }]]);
+}
+const TalkEventSchema = _Object_({
+  id: NonEmptyString,
+  type: TalkEventTypeSchema,
+  sessionId: NonEmptyString,
+  turnId: Optional(String()),
+  captureId: Optional(String()),
+  seq: Integer({ minimum: 1 }),
+  timestamp: NonEmptyString,
+  mode: TalkModeSchema,
+  transport: TalkTransportSchema,
+  brain: TalkBrainSchema,
+  provider: Optional(String()),
+  final: Optional(Boolean()),
+  callId: Optional(String()),
+  itemId: Optional(String()),
+  parentId: Optional(String()),
+  payload: Unknown()
+}, {
+  additionalProperties: false,
+  allOf: [{
+    if: {
+      properties: { type: { enum: TURN_SCOPED_TALK_EVENT_TYPES } },
+      required: ["type"]
+    },
+    ...requireJsonSchemaProperties(["turnId"])
+  }, {
+    if: {
+      properties: { type: { enum: CAPTURE_SCOPED_TALK_EVENT_TYPES } },
+      required: ["type"]
+    },
+    ...requireJsonSchemaProperties(["captureId"])
+  }]
+});
+const TalkClientCreateParamsSchema = _Object_({
+  sessionKey: Optional(String()),
+  provider: Optional(String()),
+  model: Optional(String()),
+  voice: Optional(String()),
+  vadThreshold: Optional(Number()),
+  silenceDurationMs: Optional(Integer({ minimum: 1 })),
+  prefixPaddingMs: Optional(Integer({ minimum: 0 })),
+  reasoningEffort: Optional(String()),
+  mode: Optional(TalkModeSchema),
+  transport: Optional(TalkTransportSchema),
+  brain: Optional(TalkBrainSchema)
+}, { additionalProperties: false });
+const TalkClientToolCallParamsSchema = _Object_({
+  sessionKey: NonEmptyString,
+  callId: NonEmptyString,
+  name: NonEmptyString,
+  args: Optional(Unknown()),
+  relaySessionId: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const TalkClientToolCallResultSchema = _Object_({
+  runId: NonEmptyString,
+  idempotencyKey: NonEmptyString
+}, { additionalProperties: false });
+const TalkSessionJoinParamsSchema = _Object_({
+  sessionId: NonEmptyString,
+  token: NonEmptyString
+}, { additionalProperties: false });
+const TalkSessionCreateParamsSchema = _Object_({
+  sessionKey: Optional(String()),
+  spawnedBy: Optional(NonEmptyString),
+  provider: Optional(String()),
+  model: Optional(String()),
+  voice: Optional(String()),
+  vadThreshold: Optional(Number()),
+  silenceDurationMs: Optional(Integer({ minimum: 1 })),
+  prefixPaddingMs: Optional(Integer({ minimum: 0 })),
+  reasoningEffort: Optional(String()),
+  mode: Optional(TalkModeSchema),
+  transport: Optional(TalkTransportSchema),
+  brain: Optional(TalkBrainSchema),
+  ttlMs: Optional(Integer({
+    minimum: 1e3,
+    maximum: 36e5
+  }))
+}, { additionalProperties: false });
+const TalkSessionAppendAudioParamsSchema = _Object_({
+  sessionId: NonEmptyString,
+  audioBase64: NonEmptyString,
+  timestamp: Optional(Number())
+}, { additionalProperties: false });
+const TalkSessionTurnParamsSchema = _Object_({
+  sessionId: NonEmptyString,
+  turnId: Optional(String())
+}, { additionalProperties: false });
+const TalkSessionCancelTurnParamsSchema = _Object_({
+  sessionId: NonEmptyString,
+  turnId: Optional(String()),
+  reason: Optional(String())
+}, { additionalProperties: false });
+const TalkSessionCancelOutputParamsSchema = _Object_({
+  sessionId: NonEmptyString,
+  turnId: Optional(String()),
+  reason: Optional(String())
+}, { additionalProperties: false });
+const TalkSessionSubmitToolResultParamsSchema = _Object_({
+  sessionId: NonEmptyString,
+  callId: NonEmptyString,
+  result: Unknown(),
+  options: Optional(_Object_({
+    suppressResponse: Optional(Boolean()),
+    willContinue: Optional(Boolean())
+  }, { additionalProperties: false }))
+}, { additionalProperties: false });
+const TalkSessionCloseParamsSchema = _Object_({ sessionId: NonEmptyString }, { additionalProperties: false });
+const TalkSessionManagedRoomStateSchema = _Object_({
+  activeClientId: Optional(String()),
+  activeTurnId: Optional(String()),
+  recentTalkEvents: _Array_(TalkEventSchema)
+}, { additionalProperties: false });
+const TalkSessionManagedRoomRecordSchema = _Object_({
+  id: NonEmptyString,
+  roomId: NonEmptyString,
+  roomUrl: NonEmptyString,
+  sessionKey: NonEmptyString,
+  sessionId: Optional(String()),
+  channel: Optional(String()),
+  target: Optional(String()),
+  provider: Optional(String()),
+  model: Optional(String()),
+  voice: Optional(String()),
+  mode: TalkModeSchema,
+  transport: TalkTransportSchema,
+  brain: TalkBrainSchema,
+  createdAt: Number(),
+  expiresAt: Number(),
+  room: TalkSessionManagedRoomStateSchema
+}, { additionalProperties: false });
+const TalkCatalogParamsSchema = _Object_({}, { additionalProperties: false });
+const TalkCatalogProviderSchema = _Object_({
+  id: NonEmptyString,
+  label: NonEmptyString,
+  configured: Boolean(),
+  models: Optional(_Array_(String())),
+  voices: Optional(_Array_(String())),
+  defaultModel: Optional(String()),
+  modes: Optional(_Array_(TalkModeSchema)),
+  transports: Optional(_Array_(TalkTransportSchema)),
+  brains: Optional(_Array_(TalkBrainSchema)),
+  inputAudioFormats: Optional(_Array_(_Object_({
+    encoding: Union([Literal("pcm16"), Literal("g711_ulaw")]),
+    sampleRateHz: Integer({ minimum: 1 }),
+    channels: Integer({ minimum: 1 })
+  }, { additionalProperties: false }))),
+  outputAudioFormats: Optional(_Array_(_Object_({
+    encoding: Union([Literal("pcm16"), Literal("g711_ulaw")]),
+    sampleRateHz: Integer({ minimum: 1 }),
+    channels: Integer({ minimum: 1 })
+  }, { additionalProperties: false }))),
+  supportsBrowserSession: Optional(Boolean()),
+  supportsBargeIn: Optional(Boolean()),
+  supportsToolCalls: Optional(Boolean()),
+  supportsVideoFrames: Optional(Boolean()),
+  supportsSessionResumption: Optional(Boolean())
+}, { additionalProperties: false });
+const TalkCatalogProviderGroupSchema = _Object_({
+  activeProvider: Optional(String()),
+  providers: _Array_(TalkCatalogProviderSchema)
+}, { additionalProperties: false });
+const TalkCatalogResultSchema = _Object_({
+  modes: _Array_(TalkModeSchema),
+  transports: _Array_(TalkTransportSchema),
+  brains: _Array_(TalkBrainSchema),
+  speech: TalkCatalogProviderGroupSchema,
+  transcription: TalkCatalogProviderGroupSchema,
+  realtime: TalkCatalogProviderGroupSchema
+}, { additionalProperties: false });
+const BrowserRealtimeAudioContractSchema = _Object_({
+  inputEncoding: Union([Literal("pcm16"), Literal("g711_ulaw")]),
+  inputSampleRateHz: Integer({ minimum: 1 }),
+  outputEncoding: Union([Literal("pcm16"), Literal("g711_ulaw")]),
+  outputSampleRateHz: Integer({ minimum: 1 })
+}, { additionalProperties: false });
+const TalkSessionCreateResultSchema = _Object_({
+  sessionId: NonEmptyString,
+  provider: Optional(String()),
+  mode: TalkModeSchema,
+  transport: TalkTransportSchema,
+  brain: TalkBrainSchema,
+  relaySessionId: Optional(NonEmptyString),
+  transcriptionSessionId: Optional(NonEmptyString),
+  handoffId: Optional(NonEmptyString),
+  roomId: Optional(NonEmptyString),
+  roomUrl: Optional(NonEmptyString),
+  token: Optional(NonEmptyString),
+  audio: Optional(Unknown()),
+  model: Optional(String()),
+  voice: Optional(String()),
+  expiresAt: Optional(Number())
+}, { additionalProperties: false });
+const TalkSessionTurnResultSchema = _Object_({
+  ok: Boolean(),
+  turnId: Optional(String()),
+  events: Optional(_Array_(TalkEventSchema))
+}, { additionalProperties: false });
+const TalkSessionJoinResultSchema = TalkSessionManagedRoomRecordSchema;
+const TalkSessionOkResultSchema = _Object_({ ok: Boolean() }, { additionalProperties: false });
+const BrowserRealtimeWebRtcSdpSessionSchema = _Object_({
+  provider: NonEmptyString,
+  transport: Literal("webrtc"),
+  clientSecret: NonEmptyString,
+  offerUrl: Optional(String()),
+  offerHeaders: Optional(Record(String(), String())),
+  model: Optional(String()),
+  voice: Optional(String()),
+  expiresAt: Optional(Number())
+}, { additionalProperties: false });
+const BrowserRealtimeJsonPcmWebSocketSessionSchema = _Object_({
+  provider: NonEmptyString,
+  transport: Literal("provider-websocket"),
+  protocol: NonEmptyString,
+  clientSecret: NonEmptyString,
+  websocketUrl: NonEmptyString,
+  audio: BrowserRealtimeAudioContractSchema,
+  initialMessage: Optional(Unknown()),
+  model: Optional(String()),
+  voice: Optional(String()),
+  expiresAt: Optional(Number())
+}, { additionalProperties: false });
+const BrowserRealtimeGatewayRelaySessionSchema = _Object_({
+  provider: NonEmptyString,
+  transport: Literal("gateway-relay"),
+  relaySessionId: NonEmptyString,
+  audio: BrowserRealtimeAudioContractSchema,
+  model: Optional(String()),
+  voice: Optional(String()),
+  expiresAt: Optional(Number())
+}, { additionalProperties: false });
+const BrowserRealtimeManagedRoomSessionSchema = _Object_({
+  provider: NonEmptyString,
+  transport: Literal("managed-room"),
+  roomUrl: NonEmptyString,
+  token: Optional(String()),
+  model: Optional(String()),
+  voice: Optional(String()),
+  expiresAt: Optional(Number())
+}, { additionalProperties: false });
+const TalkClientCreateResultSchema = Union([
+  BrowserRealtimeWebRtcSdpSessionSchema,
+  BrowserRealtimeJsonPcmWebSocketSessionSchema,
+  BrowserRealtimeGatewayRelaySessionSchema,
+  BrowserRealtimeManagedRoomSessionSchema
+]);
+const talkProviderFieldSchemas = { apiKey: Optional(SecretInputSchema) };
+const TalkProviderConfigSchema = _Object_(talkProviderFieldSchemas, { additionalProperties: true });
+const TalkRealtimeConfigSchema = _Object_({
+  provider: Optional(String()),
+  providers: Optional(Record(String(), TalkProviderConfigSchema)),
+  model: Optional(String()),
+  voice: Optional(String()),
+  instructions: Optional(String()),
+  mode: Optional(TalkModeSchema),
+  transport: Optional(TalkTransportSchema),
+  brain: Optional(TalkBrainSchema)
+}, { additionalProperties: false });
+const ResolvedTalkConfigSchema = _Object_({
+  provider: String(),
+  config: TalkProviderConfigSchema
+}, { additionalProperties: false });
+const TalkConfigSchema = _Object_({
+  provider: Optional(String()),
+  providers: Optional(Record(String(), TalkProviderConfigSchema)),
+  realtime: Optional(TalkRealtimeConfigSchema),
+  resolved: Optional(ResolvedTalkConfigSchema),
+  consultThinkingLevel: Optional(String()),
+  consultFastMode: Optional(Boolean()),
+  speechLocale: Optional(String()),
+  interruptOnSpeech: Optional(Boolean()),
+  silenceTimeoutMs: Optional(Integer({ minimum: 1 }))
+}, { additionalProperties: false });
+const TalkConfigResultSchema = _Object_({ config: _Object_({
+  talk: Optional(TalkConfigSchema),
+  session: Optional(_Object_({ mainKey: Optional(String()) }, { additionalProperties: false })),
+  ui: Optional(_Object_({ seamColor: Optional(String()) }, { additionalProperties: false }))
+}, { additionalProperties: false }) }, { additionalProperties: false });
+const TalkSpeakResultSchema = _Object_({
+  audioBase64: NonEmptyString,
+  provider: NonEmptyString,
+  outputFormat: Optional(String()),
+  voiceCompatible: Optional(Boolean()),
+  mimeType: Optional(String()),
+  fileExtension: Optional(String())
+}, { additionalProperties: false });
+const ChannelsStatusParamsSchema = _Object_({
+  probe: Optional(Boolean()),
+  timeoutMs: Optional(Integer({ minimum: 0 })),
+  channel: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const ChannelAccountSnapshotSchema = _Object_({
+  accountId: NonEmptyString,
+  name: Optional(String()),
+  enabled: Optional(Boolean()),
+  configured: Optional(Boolean()),
+  linked: Optional(Boolean()),
+  running: Optional(Boolean()),
+  connected: Optional(Boolean()),
+  reconnectAttempts: Optional(Integer({ minimum: 0 })),
+  lastConnectedAt: Optional(Integer({ minimum: 0 })),
+  lastError: Optional(String()),
+  healthState: Optional(String()),
+  lastStartAt: Optional(Integer({ minimum: 0 })),
+  lastStopAt: Optional(Integer({ minimum: 0 })),
+  lastInboundAt: Optional(Integer({ minimum: 0 })),
+  lastOutboundAt: Optional(Integer({ minimum: 0 })),
+  lastTransportActivityAt: Optional(Integer({ minimum: 0 })),
+  busy: Optional(Boolean()),
+  activeRuns: Optional(Integer({ minimum: 0 })),
+  lastRunActivityAt: Optional(Integer({ minimum: 0 })),
+  lastProbeAt: Optional(Integer({ minimum: 0 })),
+  mode: Optional(String()),
+  dmPolicy: Optional(String()),
+  allowFrom: Optional(_Array_(String())),
+  tokenSource: Optional(String()),
+  botTokenSource: Optional(String()),
+  appTokenSource: Optional(String()),
+  baseUrl: Optional(String()),
+  allowUnmentionedGroups: Optional(Boolean()),
+  cliPath: Optional(Union([String(), Null()])),
+  dbPath: Optional(Union([String(), Null()])),
+  port: Optional(Union([Integer({ minimum: 0 }), Null()])),
+  probe: Optional(Unknown()),
+  audit: Optional(Unknown()),
+  application: Optional(Unknown())
+}, { additionalProperties: true });
+const ChannelUiMetaSchema = _Object_({
+  id: NonEmptyString,
+  label: NonEmptyString,
+  detailLabel: NonEmptyString,
+  systemImage: Optional(String())
+}, { additionalProperties: false });
+const ChannelEventLoopHealthSchema = _Object_({
+  degraded: Boolean(),
+  reasons: _Array_(Union([
+    Literal("event_loop_delay"),
+    Literal("event_loop_utilization"),
+    Literal("cpu")
+  ])),
+  intervalMs: Integer({ minimum: 0 }),
+  delayP99Ms: Number({ minimum: 0 }),
+  delayMaxMs: Number({ minimum: 0 }),
+  utilization: Number({ minimum: 0 }),
+  cpuCoreRatio: Number({ minimum: 0 })
+}, { additionalProperties: false });
+_Object_({
+  ts: Integer({ minimum: 0 }),
+  channelOrder: _Array_(NonEmptyString),
+  channelLabels: Record(NonEmptyString, NonEmptyString),
+  channelDetailLabels: Optional(Record(NonEmptyString, NonEmptyString)),
+  channelSystemImages: Optional(Record(NonEmptyString, NonEmptyString)),
+  channelMeta: Optional(_Array_(ChannelUiMetaSchema)),
+  channels: Record(NonEmptyString, Unknown()),
+  channelAccounts: Record(NonEmptyString, _Array_(ChannelAccountSnapshotSchema)),
+  channelDefaultAccountId: Record(NonEmptyString, NonEmptyString),
+  eventLoop: Optional(ChannelEventLoopHealthSchema),
+  partial: Optional(Boolean()),
+  warnings: Optional(_Array_(String()))
+}, { additionalProperties: false });
+const ChannelsLogoutParamsSchema = _Object_({
+  channel: NonEmptyString,
+  accountId: Optional(String())
+}, { additionalProperties: false });
+const ChannelsStopParamsSchema = _Object_({
+  channel: NonEmptyString,
+  accountId: Optional(String())
+}, { additionalProperties: false });
+const ChannelsStartParamsSchema = _Object_({
+  channel: NonEmptyString,
+  accountId: Optional(String())
+}, { additionalProperties: false });
+const WebLoginStartParamsSchema = _Object_({
+  force: Optional(Boolean()),
+  timeoutMs: Optional(Integer({ minimum: 0 })),
+  verbose: Optional(Boolean()),
+  accountId: Optional(String())
+}, { additionalProperties: false });
+const QrDataUrlSchema = String({
+  maxLength: 16384,
+  pattern: "^data:image/png;base64,"
+});
+const WebLoginWaitParamsSchema = _Object_({
+  timeoutMs: Optional(Integer({ minimum: 0 })),
+  accountId: Optional(String()),
+  currentQrDataUrl: Optional(QrDataUrlSchema)
+}, { additionalProperties: false });
+const COMMAND_DESCRIPTION_MAX_LENGTH = 2e3;
+const BoundedNonEmptyString = (maxLength) => String({
+  minLength: 1,
+  maxLength
+});
+const CommandSourceSchema = Union([
+  Literal("native"),
+  Literal("skill"),
+  Literal("plugin")
+]);
+const CommandScopeSchema = Union([
+  Literal("text"),
+  Literal("native"),
+  Literal("both")
+]);
+const CommandCategorySchema = Union([
+  Literal("session"),
+  Literal("options"),
+  Literal("status"),
+  Literal("management"),
+  Literal("media"),
+  Literal("tools"),
+  Literal("docks")
+]);
+const CommandArgChoiceSchema = _Object_({
+  value: String({ maxLength: 200 }),
+  label: String({ maxLength: 200 })
+}, { additionalProperties: false });
+const CommandArgSchema = _Object_({
+  name: BoundedNonEmptyString(200),
+  description: String({ maxLength: 500 }),
+  type: Union([
+    Literal("string"),
+    Literal("number"),
+    Literal("boolean")
+  ]),
+  required: Optional(Boolean()),
+  choices: Optional(_Array_(CommandArgChoiceSchema, { maxItems: 50 })),
+  dynamic: Optional(Boolean())
+}, { additionalProperties: false });
+const CommandEntrySchema = _Object_({
+  name: BoundedNonEmptyString(200),
+  nativeName: Optional(BoundedNonEmptyString(200)),
+  textAliases: Optional(_Array_(BoundedNonEmptyString(200), { maxItems: 20 })),
+  description: String({ maxLength: COMMAND_DESCRIPTION_MAX_LENGTH }),
+  category: Optional(CommandCategorySchema),
+  source: CommandSourceSchema,
+  scope: CommandScopeSchema,
+  acceptsArgs: Boolean(),
+  args: Optional(_Array_(CommandArgSchema, { maxItems: 20 }))
+}, { additionalProperties: false });
+const CommandsListParamsSchema = _Object_({
+  agentId: Optional(NonEmptyString),
+  provider: Optional(NonEmptyString),
+  scope: Optional(CommandScopeSchema),
+  includeArgs: Optional(Boolean())
+}, { additionalProperties: false });
+_Object_({ commands: _Array_(CommandEntrySchema, { maxItems: 500 }) }, { additionalProperties: false });
+const ConfigSchemaLookupPathString = String({
+  minLength: 1,
+  maxLength: 1024,
+  pattern: "^[A-Za-z0-9_./\\[\\]\\-*]+$"
+});
+const ConfigDeliveryContextSchema = _Object_({
+  channel: Optional(String()),
+  to: Optional(String()),
+  accountId: Optional(String()),
+  threadId: Optional(Union([String(), Number()]))
+}, { additionalProperties: false });
+const ConfigGetParamsSchema = _Object_({}, { additionalProperties: false });
+const ConfigSetParamsSchema = _Object_({
+  raw: NonEmptyString,
+  baseHash: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const ConfigApplyLikeParamsSchema = _Object_({
+  raw: NonEmptyString,
+  baseHash: Optional(NonEmptyString),
+  sessionKey: Optional(String()),
+  deliveryContext: Optional(ConfigDeliveryContextSchema),
+  note: Optional(String()),
+  restartDelayMs: Optional(Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+const ConfigApplyParamsSchema = ConfigApplyLikeParamsSchema;
+const ConfigPatchParamsSchema = ConfigApplyLikeParamsSchema;
+const ConfigSchemaParamsSchema = _Object_({}, { additionalProperties: false });
+const ConfigSchemaLookupParamsSchema = _Object_({ path: ConfigSchemaLookupPathString }, { additionalProperties: false });
+const UpdateStatusParamsSchema = _Object_({}, { additionalProperties: false });
+const UpdateRunParamsSchema = _Object_({
+  sessionKey: Optional(String()),
+  deliveryContext: Optional(ConfigDeliveryContextSchema),
+  note: Optional(String()),
+  continuationMessage: Optional(String()),
+  restartDelayMs: Optional(Integer({ minimum: 0 })),
+  timeoutMs: Optional(Integer({ minimum: 1 }))
+}, { additionalProperties: false });
+const ConfigUiHintSchema = _Object_({
+  label: Optional(String()),
+  help: Optional(String()),
+  tags: Optional(_Array_(String())),
+  group: Optional(String()),
+  order: Optional(Integer()),
+  advanced: Optional(Boolean()),
+  sensitive: Optional(Boolean()),
+  placeholder: Optional(String()),
+  itemTemplate: Optional(Unknown())
+}, { additionalProperties: false });
+_Object_({
+  schema: Unknown(),
+  uiHints: Record(String(), ConfigUiHintSchema),
+  version: NonEmptyString,
+  generatedAt: NonEmptyString
+}, { additionalProperties: false });
+const ConfigSchemaLookupChildSchema = _Object_({
+  key: NonEmptyString,
+  path: NonEmptyString,
+  type: Optional(Union([String(), _Array_(String())])),
+  required: Boolean(),
+  hasChildren: Boolean(),
+  reloadKind: Optional(Union([
+    Literal("restart"),
+    Literal("hot"),
+    Literal("none")
+  ])),
+  hint: Optional(ConfigUiHintSchema),
+  hintPath: Optional(String())
+}, { additionalProperties: false });
+const ConfigSchemaLookupResultSchema = _Object_({
+  path: NonEmptyString,
+  schema: Unknown(),
+  reloadKind: Optional(Union([
+    Literal("restart"),
+    Literal("hot"),
+    Literal("none")
+  ])),
+  hint: Optional(ConfigUiHintSchema),
+  hintPath: Optional(String()),
+  children: _Array_(ConfigSchemaLookupChildSchema)
+}, { additionalProperties: false });
+function cronAgentTurnPayloadSchema(params) {
+  return _Object_({
+    kind: Literal("agentTurn"),
+    message: params.message,
+    model: Optional(String()),
+    fallbacks: Optional(_Array_(String())),
+    thinking: Optional(String()),
+    timeoutSeconds: Optional(Number({ minimum: 0 })),
+    allowUnsafeExternalContent: Optional(Boolean()),
+    lightContext: Optional(Boolean()),
+    toolsAllow: Optional(params.toolsAllow)
+  }, { additionalProperties: false });
+}
+const CronSessionTargetSchema = Union([
+  Literal("main"),
+  Literal("isolated"),
+  Literal("current"),
+  String({ pattern: "^session:.+" })
+]);
+const CronWakeModeSchema = Union([Literal("next-heartbeat"), Literal("now")]);
+function cronRunStatusSchema(options = {}) {
+  return Union([
+    Literal("ok"),
+    Literal("error"),
+    Literal("skipped")
+  ], options);
+}
+const CronRunStatusSchema = cronRunStatusSchema();
+const DeprecatedCronRunStatusSchema = cronRunStatusSchema({
+  deprecated: true,
+  description: "Deprecated alias for lastRunStatus."
+});
+const CronSortDirSchema = Union([Literal("asc"), Literal("desc")]);
+const CronJobsEnabledFilterSchema = Union([
+  Literal("all"),
+  Literal("enabled"),
+  Literal("disabled")
+]);
+const CronJobsSortBySchema = Union([
+  Literal("nextRunAtMs"),
+  Literal("updatedAtMs"),
+  Literal("name")
+]);
+const CronRunsStatusFilterSchema = Union([
+  Literal("all"),
+  Literal("ok"),
+  Literal("error"),
+  Literal("skipped")
+]);
+const CronRunsStatusValueSchema = Union([
+  Literal("ok"),
+  Literal("error"),
+  Literal("skipped")
+]);
+const CronDeliveryStatusSchema = Union([
+  Literal("delivered"),
+  Literal("not-delivered"),
+  Literal("unknown"),
+  Literal("not-requested")
+]);
+const CronFailoverReasonSchema = Union([
+  Literal("auth"),
+  Literal("format"),
+  Literal("rate_limit"),
+  Literal("billing"),
+  Literal("server_error"),
+  Literal("timeout"),
+  Literal("model_not_found"),
+  Literal("empty_response"),
+  Literal("no_error_details"),
+  Literal("unclassified"),
+  Literal("unknown")
+]);
+const CronRunDiagnosticSeveritySchema = Union([
+  Literal("info"),
+  Literal("warn"),
+  Literal("error")
+]);
+const CronRunDiagnosticSourceSchema = Union([
+  Literal("cron-preflight"),
+  Literal("cron-setup"),
+  Literal("model-preflight"),
+  Literal("agent-run"),
+  Literal("tool"),
+  Literal("exec"),
+  Literal("delivery")
+]);
+const CronRunDiagnosticSchema = _Object_({
+  ts: Integer({ minimum: 0 }),
+  source: CronRunDiagnosticSourceSchema,
+  severity: CronRunDiagnosticSeveritySchema,
+  message: String(),
+  toolName: Optional(String()),
+  exitCode: Optional(Union([Number(), Null()])),
+  truncated: Optional(Boolean())
+}, { additionalProperties: false });
+const CronRunDiagnosticsSchema = _Object_({
+  summary: Optional(String()),
+  entries: _Array_(CronRunDiagnosticSchema)
+}, { additionalProperties: false });
+const CronCommonOptionalFields = {
+  agentId: Optional(Union([NonEmptyString, Null()])),
+  sessionKey: Optional(Union([NonEmptyString, Null()])),
+  description: Optional(String()),
+  enabled: Optional(Boolean()),
+  deleteAfterRun: Optional(Boolean())
+};
+function cronIdOrJobIdParams(extraFields) {
+  return Union([_Object_({
+    id: NonEmptyString,
+    ...extraFields
+  }, { additionalProperties: false }), _Object_({
+    jobId: NonEmptyString,
+    ...extraFields
+  }, { additionalProperties: false })]);
+}
+const CronRunLogJobIdSchema = String({
+  minLength: 1,
+  pattern: "^[^/\\\\]+$"
+});
+const CronScheduleSchema = Union([
+  _Object_({
+    kind: Literal("at"),
+    at: NonEmptyString
+  }, { additionalProperties: false }),
+  _Object_({
+    kind: Literal("every"),
+    everyMs: Integer({ minimum: 1 }),
+    anchorMs: Optional(Integer({ minimum: 0 }))
+  }, { additionalProperties: false }),
+  _Object_({
+    kind: Literal("cron"),
+    expr: NonEmptyString,
+    tz: Optional(String()),
+    staggerMs: Optional(Integer({ minimum: 0 }))
+  }, { additionalProperties: false })
+]);
+const CronPayloadSchema = Union([_Object_({
+  kind: Literal("systemEvent"),
+  text: NonEmptyString
+}, { additionalProperties: false }), cronAgentTurnPayloadSchema({
+  message: NonEmptyString,
+  toolsAllow: _Array_(String())
+})]);
+const CronPayloadPatchSchema = Union([_Object_({
+  kind: Literal("systemEvent"),
+  text: Optional(NonEmptyString)
+}, { additionalProperties: false }), cronAgentTurnPayloadSchema({
+  message: Optional(NonEmptyString),
+  toolsAllow: Union([_Array_(String()), Null()])
+})]);
+const CronFailureAlertSchema = _Object_({
+  after: Optional(Integer({ minimum: 1 })),
+  channel: Optional(Union([Literal("last"), NonEmptyString])),
+  to: Optional(String()),
+  cooldownMs: Optional(Integer({ minimum: 0 })),
+  includeSkipped: Optional(Boolean()),
+  mode: Optional(Union([Literal("announce"), Literal("webhook")])),
+  accountId: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const CronFailureDestinationSchema = _Object_({
+  channel: Optional(Union([Literal("last"), NonEmptyString])),
+  to: Optional(String()),
+  accountId: Optional(NonEmptyString),
+  mode: Optional(Union([Literal("announce"), Literal("webhook")]))
+}, { additionalProperties: false });
+const CronDeliverySharedProperties = {
+  channel: Optional(Union([Literal("last"), NonEmptyString])),
+  threadId: Optional(Union([String(), Number()])),
+  accountId: Optional(NonEmptyString),
+  bestEffort: Optional(Boolean()),
+  failureDestination: Optional(CronFailureDestinationSchema)
+};
+const CronDeliveryNoopSchema = _Object_({
+  mode: Literal("none"),
+  ...CronDeliverySharedProperties,
+  to: Optional(String())
+}, { additionalProperties: false });
+const CronDeliveryAnnounceSchema = _Object_({
+  mode: Literal("announce"),
+  ...CronDeliverySharedProperties,
+  to: Optional(String())
+}, { additionalProperties: false });
+const CronDeliveryWebhookSchema = _Object_({
+  mode: Literal("webhook"),
+  ...CronDeliverySharedProperties,
+  to: NonEmptyString
+}, { additionalProperties: false });
+const CronDeliverySchema = Union([
+  CronDeliveryNoopSchema,
+  CronDeliveryAnnounceSchema,
+  CronDeliveryWebhookSchema
+]);
+const CronDeliveryPatchSchema = _Object_({
+  mode: Optional(Union([
+    Literal("none"),
+    Literal("announce"),
+    Literal("webhook")
+  ])),
+  ...CronDeliverySharedProperties,
+  to: Optional(String())
+}, { additionalProperties: false });
+const CronFailureNotificationDeliverySchema = _Object_({
+  delivered: Optional(Boolean()),
+  status: CronDeliveryStatusSchema,
+  error: Optional(String())
+}, { additionalProperties: false });
+const CronJobStateSchema = _Object_({
+  nextRunAtMs: Optional(Integer({ minimum: 0 })),
+  runningAtMs: Optional(Integer({ minimum: 0 })),
+  lastRunAtMs: Optional(Integer({ minimum: 0 })),
+  lastRunStatus: Optional(CronRunStatusSchema),
+  lastStatus: Optional(DeprecatedCronRunStatusSchema),
+  lastError: Optional(String()),
+  lastDiagnostics: Optional(CronRunDiagnosticsSchema),
+  lastDiagnosticSummary: Optional(String()),
+  lastErrorReason: Optional(CronFailoverReasonSchema),
+  lastDurationMs: Optional(Integer({ minimum: 0 })),
+  consecutiveErrors: Optional(Integer({ minimum: 0 })),
+  consecutiveSkipped: Optional(Integer({ minimum: 0 })),
+  lastDelivered: Optional(Boolean()),
+  lastDeliveryStatus: Optional(CronDeliveryStatusSchema),
+  lastDeliveryError: Optional(String()),
+  lastFailureNotificationDelivered: Optional(Boolean()),
+  lastFailureNotificationDeliveryStatus: Optional(CronDeliveryStatusSchema),
+  lastFailureNotificationDeliveryError: Optional(String()),
+  lastFailureAlertAtMs: Optional(Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+const CronJobStatePatchSchema = _Object_({
+  nextRunAtMs: Optional(Integer({ minimum: 0 })),
+  runningAtMs: Optional(Integer({ minimum: 0 })),
+  lastRunAtMs: Optional(Integer({ minimum: 0 })),
+  lastRunStatus: Optional(CronRunStatusSchema),
+  lastStatus: Optional(DeprecatedCronRunStatusSchema),
+  lastError: Optional(String()),
+  lastErrorReason: Optional(CronFailoverReasonSchema),
+  lastDurationMs: Optional(Integer({ minimum: 0 })),
+  consecutiveErrors: Optional(Integer({ minimum: 0 })),
+  consecutiveSkipped: Optional(Integer({ minimum: 0 })),
+  lastDelivered: Optional(Boolean()),
+  lastDeliveryStatus: Optional(CronDeliveryStatusSchema),
+  lastDeliveryError: Optional(String()),
+  lastFailureNotificationDelivered: Optional(Boolean()),
+  lastFailureNotificationDeliveryStatus: Optional(CronDeliveryStatusSchema),
+  lastFailureNotificationDeliveryError: Optional(String()),
+  lastFailureAlertAtMs: Optional(Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+_Object_({
+  id: NonEmptyString,
+  agentId: Optional(NonEmptyString),
+  sessionKey: Optional(NonEmptyString),
+  name: NonEmptyString,
+  description: Optional(String()),
+  enabled: Boolean(),
+  deleteAfterRun: Optional(Boolean()),
+  createdAtMs: Integer({ minimum: 0 }),
+  updatedAtMs: Integer({ minimum: 0 }),
+  schedule: CronScheduleSchema,
+  sessionTarget: CronSessionTargetSchema,
+  wakeMode: CronWakeModeSchema,
+  payload: CronPayloadSchema,
+  delivery: Optional(CronDeliverySchema),
+  failureAlert: Optional(Union([Literal(false), CronFailureAlertSchema])),
+  state: CronJobStateSchema
+}, { additionalProperties: false });
+const CronListParamsSchema = _Object_({
+  includeDisabled: Optional(Boolean()),
+  limit: Optional(Integer({
+    minimum: 1,
+    maximum: 200
+  })),
+  offset: Optional(Integer({ minimum: 0 })),
+  query: Optional(String()),
+  enabled: Optional(CronJobsEnabledFilterSchema),
+  sortBy: Optional(CronJobsSortBySchema),
+  sortDir: Optional(CronSortDirSchema),
+  agentId: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const CronStatusParamsSchema = _Object_({}, { additionalProperties: false });
+const CronGetParamsSchema = cronIdOrJobIdParams({});
+const CronAddParamsSchema = _Object_({
+  name: NonEmptyString,
+  ...CronCommonOptionalFields,
+  schedule: CronScheduleSchema,
+  sessionTarget: CronSessionTargetSchema,
+  wakeMode: CronWakeModeSchema,
+  payload: CronPayloadSchema,
+  delivery: Optional(CronDeliverySchema),
+  failureAlert: Optional(Union([Literal(false), CronFailureAlertSchema]))
+}, { additionalProperties: false });
+const CronUpdateParamsSchema = cronIdOrJobIdParams({ patch: _Object_({
+  name: Optional(NonEmptyString),
+  ...CronCommonOptionalFields,
+  schedule: Optional(CronScheduleSchema),
+  sessionTarget: Optional(CronSessionTargetSchema),
+  wakeMode: Optional(CronWakeModeSchema),
+  payload: Optional(CronPayloadPatchSchema),
+  delivery: Optional(CronDeliveryPatchSchema),
+  failureAlert: Optional(Union([Literal(false), CronFailureAlertSchema])),
+  state: Optional(CronJobStatePatchSchema)
+}, { additionalProperties: false }) });
+const CronRemoveParamsSchema = cronIdOrJobIdParams({});
+const CronRunParamsSchema = cronIdOrJobIdParams({ mode: Optional(Union([Literal("due"), Literal("force")])) });
+const CronRunsParamsSchema = _Object_({
+  scope: Optional(Union([Literal("job"), Literal("all")])),
+  id: Optional(CronRunLogJobIdSchema),
+  jobId: Optional(CronRunLogJobIdSchema),
+  runId: Optional(NonEmptyString),
+  limit: Optional(Integer({
+    minimum: 1,
+    maximum: 200
+  })),
+  offset: Optional(Integer({ minimum: 0 })),
+  statuses: Optional(_Array_(CronRunsStatusValueSchema, {
+    minItems: 1,
+    maxItems: 3
+  })),
+  status: Optional(CronRunsStatusFilterSchema),
+  deliveryStatuses: Optional(_Array_(CronDeliveryStatusSchema, {
+    minItems: 1,
+    maxItems: 4
+  })),
+  deliveryStatus: Optional(CronDeliveryStatusSchema),
+  query: Optional(String()),
+  sortDir: Optional(CronSortDirSchema)
+}, { additionalProperties: false });
+_Object_({
+  ts: Integer({ minimum: 0 }),
+  jobId: NonEmptyString,
+  action: Literal("finished"),
+  status: Optional(CronRunStatusSchema),
+  error: Optional(String()),
+  summary: Optional(String()),
+  diagnostics: Optional(CronRunDiagnosticsSchema),
+  delivered: Optional(Boolean()),
+  deliveryStatus: Optional(CronDeliveryStatusSchema),
+  deliveryError: Optional(String()),
+  failureNotificationDelivery: Optional(CronFailureNotificationDeliverySchema),
+  sessionId: Optional(NonEmptyString),
+  sessionKey: Optional(NonEmptyString),
+  runId: Optional(NonEmptyString),
+  runAtMs: Optional(Integer({ minimum: 0 })),
+  durationMs: Optional(Integer({ minimum: 0 })),
+  nextRunAtMs: Optional(Integer({ minimum: 0 })),
+  model: Optional(String()),
+  provider: Optional(String()),
+  usage: Optional(_Object_({
+    input_tokens: Optional(Number()),
+    output_tokens: Optional(Number()),
+    total_tokens: Optional(Number()),
+    cache_read_tokens: Optional(Number()),
+    cache_write_tokens: Optional(Number())
+  }, { additionalProperties: false })),
+  jobName: Optional(String())
+}, { additionalProperties: false });
+const EnvironmentStatusSchema = String({ enum: [
+  "available",
+  "unavailable",
+  "starting",
+  "stopping",
+  "error"
+] });
+function createEnvironmentSummarySchema() {
+  return _Object_({
+    id: NonEmptyString,
+    type: NonEmptyString,
+    label: Optional(NonEmptyString),
+    status: EnvironmentStatusSchema,
+    capabilities: Optional(_Array_(NonEmptyString))
+  }, { additionalProperties: false });
+}
+const EnvironmentSummarySchema = createEnvironmentSummarySchema();
+const EnvironmentsListParamsSchema = _Object_({}, { additionalProperties: false });
+_Object_({ environments: _Array_(EnvironmentSummarySchema) }, { additionalProperties: false });
+const EnvironmentsStatusParamsSchema = _Object_({ environmentId: NonEmptyString }, { additionalProperties: false });
+createEnvironmentSummarySchema();
+const ExecApprovalsAllowlistEntrySchema = _Object_({
+  id: Optional(NonEmptyString),
+  pattern: String(),
+  source: Optional(Literal("allow-always")),
+  commandText: Optional(String()),
+  argPattern: Optional(String()),
+  lastUsedAt: Optional(Integer({ minimum: 0 })),
+  lastUsedCommand: Optional(String()),
+  lastResolvedPath: Optional(String())
+}, { additionalProperties: false });
+const ExecApprovalsPolicyFields = {
+  security: Optional(String()),
+  ask: Optional(String()),
+  askFallback: Optional(String()),
+  autoAllowSkills: Optional(Boolean())
+};
+const ExecApprovalsDefaultsSchema = _Object_(ExecApprovalsPolicyFields, { additionalProperties: false });
+const ExecApprovalsAgentSchema = _Object_({
+  ...ExecApprovalsPolicyFields,
+  allowlist: Optional(_Array_(ExecApprovalsAllowlistEntrySchema))
+}, { additionalProperties: false });
+const ExecApprovalsFileSchema = _Object_({
+  version: Literal(1),
+  socket: Optional(_Object_({
+    path: Optional(String()),
+    token: Optional(String())
+  }, { additionalProperties: false })),
+  defaults: Optional(ExecApprovalsDefaultsSchema),
+  agents: Optional(Record(String(), ExecApprovalsAgentSchema))
+}, { additionalProperties: false });
+_Object_({
+  path: NonEmptyString,
+  exists: Boolean(),
+  hash: NonEmptyString,
+  file: ExecApprovalsFileSchema
+}, { additionalProperties: false });
+const ExecApprovalsGetParamsSchema = _Object_({}, { additionalProperties: false });
+const ExecApprovalsSetParamsSchema = _Object_({
+  file: ExecApprovalsFileSchema,
+  baseHash: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const ExecApprovalsNodeGetParamsSchema = _Object_({ nodeId: NonEmptyString }, { additionalProperties: false });
+const ExecApprovalsNodeSetParamsSchema = _Object_({
+  nodeId: NonEmptyString,
+  file: ExecApprovalsFileSchema,
+  baseHash: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const ExecApprovalGetParamsSchema = _Object_({ id: NonEmptyString }, { additionalProperties: false });
+const ExecApprovalRequestParamsSchema = _Object_({
+  id: Optional(NonEmptyString),
+  command: Optional(NonEmptyString),
+  commandArgv: Optional(_Array_(String())),
+  systemRunPlan: Optional(_Object_({
+    argv: _Array_(String()),
+    cwd: Union([String(), Null()]),
+    commandText: String(),
+    commandPreview: Optional(Union([String(), Null()])),
+    agentId: Union([String(), Null()]),
+    sessionKey: Union([String(), Null()]),
+    mutableFileOperand: Optional(Union([_Object_({
+      argvIndex: Integer({ minimum: 0 }),
+      path: String(),
+      sha256: String()
+    }, { additionalProperties: false }), Null()]))
+  }, { additionalProperties: false })),
+  env: Optional(Record(NonEmptyString, String())),
+  cwd: Optional(Union([String(), Null()])),
+  nodeId: Optional(Union([NonEmptyString, Null()])),
+  host: Optional(Union([String(), Null()])),
+  security: Optional(Union([String(), Null()])),
+  ask: Optional(Union([String(), Null()])),
+  warningText: Optional(Union([String(), Null()])),
+  commandSpans: Optional(_Array_(_Object_({
+    startIndex: Integer({
+      minimum: 0,
+      description: "Inclusive UTF-16 code unit offset into command."
+    }),
+    endIndex: Integer({
+      minimum: 1,
+      description: "Exclusive UTF-16 code unit offset into command; must be greater than startIndex and no greater than command.length."
+    })
+  }, { additionalProperties: false }))),
+  agentId: Optional(Union([String(), Null()])),
+  resolvedPath: Optional(Union([String(), Null()])),
+  sessionKey: Optional(Union([String(), Null()])),
+  turnSourceChannel: Optional(Union([String(), Null()])),
+  turnSourceTo: Optional(Union([String(), Null()])),
+  turnSourceAccountId: Optional(Union([String(), Null()])),
+  turnSourceThreadId: Optional(Union([
+    String(),
+    Number(),
+    Null()
+  ])),
+  timeoutMs: Optional(Integer({ minimum: 1 })),
+  twoPhase: Optional(Boolean())
+}, { additionalProperties: false });
+const ExecApprovalResolveParamsSchema = _Object_({
+  id: NonEmptyString,
+  decision: NonEmptyString
+}, { additionalProperties: false });
+const DevicePairListParamsSchema = _Object_({}, { additionalProperties: false });
+const DevicePairApproveParamsSchema = _Object_({ requestId: NonEmptyString }, { additionalProperties: false });
+const DevicePairRejectParamsSchema = _Object_({ requestId: NonEmptyString }, { additionalProperties: false });
+const DevicePairRemoveParamsSchema = _Object_({ deviceId: NonEmptyString }, { additionalProperties: false });
+const DeviceTokenRotateParamsSchema = _Object_({
+  deviceId: NonEmptyString,
+  role: NonEmptyString,
+  scopes: Optional(_Array_(NonEmptyString))
+}, { additionalProperties: false });
+const DeviceTokenRevokeParamsSchema = _Object_({
+  deviceId: NonEmptyString,
+  role: NonEmptyString
+}, { additionalProperties: false });
+_Object_({
+  requestId: NonEmptyString,
+  deviceId: NonEmptyString,
+  publicKey: NonEmptyString,
+  displayName: Optional(NonEmptyString),
+  platform: Optional(NonEmptyString),
+  deviceFamily: Optional(NonEmptyString),
+  clientId: Optional(NonEmptyString),
+  clientMode: Optional(NonEmptyString),
+  role: Optional(NonEmptyString),
+  roles: Optional(_Array_(NonEmptyString)),
+  scopes: Optional(_Array_(NonEmptyString)),
+  remoteIp: Optional(NonEmptyString),
+  silent: Optional(Boolean()),
+  isRepair: Optional(Boolean()),
+  ts: Integer({ minimum: 0 })
+}, { additionalProperties: false });
+_Object_({
+  requestId: NonEmptyString,
+  deviceId: NonEmptyString,
+  decision: NonEmptyString,
+  ts: Integer({ minimum: 0 })
+}, { additionalProperties: false });
+const PresenceEntrySchema = _Object_({
+  host: Optional(NonEmptyString),
+  ip: Optional(NonEmptyString),
+  version: Optional(NonEmptyString),
+  platform: Optional(NonEmptyString),
+  deviceFamily: Optional(NonEmptyString),
+  modelIdentifier: Optional(NonEmptyString),
+  mode: Optional(NonEmptyString),
+  lastInputSeconds: Optional(Integer({ minimum: 0 })),
+  reason: Optional(NonEmptyString),
+  tags: Optional(_Array_(NonEmptyString)),
+  text: Optional(String()),
+  ts: Integer({ minimum: 0 }),
+  deviceId: Optional(NonEmptyString),
+  roles: Optional(_Array_(NonEmptyString)),
+  scopes: Optional(_Array_(NonEmptyString)),
+  instanceId: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const HealthSnapshotSchema = Any();
+const SessionDefaultsSchema = _Object_({
+  defaultAgentId: NonEmptyString,
+  mainKey: NonEmptyString,
+  mainSessionKey: NonEmptyString,
+  scope: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const StateVersionSchema = _Object_({
+  presence: Integer({ minimum: 0 }),
+  health: Integer({ minimum: 0 })
+}, { additionalProperties: false });
+const SnapshotSchema = _Object_({
+  presence: _Array_(PresenceEntrySchema),
+  health: HealthSnapshotSchema,
+  stateVersion: StateVersionSchema,
+  uptimeMs: Integer({ minimum: 0 }),
+  configPath: Optional(NonEmptyString),
+  stateDir: Optional(NonEmptyString),
+  sessionDefaults: Optional(SessionDefaultsSchema),
+  authMode: Optional(Union([
+    Literal("none"),
+    Literal("token"),
+    Literal("password"),
+    Literal("trusted-proxy")
+  ])),
+  updateAvailable: Optional(_Object_({
+    currentVersion: NonEmptyString,
+    latestVersion: NonEmptyString,
+    channel: NonEmptyString
+  }))
+}, { additionalProperties: false });
+_Object_({ ts: Integer({ minimum: 0 }) }, { additionalProperties: false });
+_Object_({
+  reason: NonEmptyString,
+  restartExpectedMs: Optional(Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+const ConnectParamsSchema = _Object_({
+  minProtocol: Integer({ minimum: 1 }),
+  maxProtocol: Integer({ minimum: 1 }),
+  client: _Object_({
+    id: GatewayClientIdSchema,
+    displayName: Optional(NonEmptyString),
+    version: NonEmptyString,
+    platform: NonEmptyString,
+    deviceFamily: Optional(NonEmptyString),
+    modelIdentifier: Optional(NonEmptyString),
+    mode: GatewayClientModeSchema,
+    instanceId: Optional(NonEmptyString)
+  }, { additionalProperties: false }),
+  caps: Optional(_Array_(NonEmptyString, { default: [] })),
+  commands: Optional(_Array_(NonEmptyString)),
+  permissions: Optional(Record(NonEmptyString, Boolean())),
+  pathEnv: Optional(String()),
+  role: Optional(NonEmptyString),
+  scopes: Optional(_Array_(NonEmptyString)),
+  device: Optional(_Object_({
+    id: NonEmptyString,
+    publicKey: NonEmptyString,
+    signature: NonEmptyString,
+    signedAt: Integer({ minimum: 0 }),
+    nonce: NonEmptyString
+  }, { additionalProperties: false })),
+  auth: Optional(_Object_({
+    token: Optional(String()),
+    bootstrapToken: Optional(String()),
+    deviceToken: Optional(String()),
+    password: Optional(String()),
+    approvalRuntimeToken: Optional(String())
+  }, { additionalProperties: false })),
+  locale: Optional(String()),
+  userAgent: Optional(String())
+}, { additionalProperties: false });
+_Object_({
+  type: Literal("hello-ok"),
+  protocol: Integer({ minimum: 1 }),
+  server: _Object_({
+    version: NonEmptyString,
+    connId: NonEmptyString
+  }, { additionalProperties: false }),
+  features: _Object_({
+    methods: _Array_(NonEmptyString),
+    events: _Array_(NonEmptyString)
+  }, { additionalProperties: false }),
+  snapshot: SnapshotSchema,
+  pluginSurfaceUrls: Optional(Record(NonEmptyString, NonEmptyString)),
+  auth: _Object_({
+    deviceToken: Optional(NonEmptyString),
+    role: NonEmptyString,
+    scopes: _Array_(NonEmptyString),
+    issuedAtMs: Optional(Integer({ minimum: 0 })),
+    deviceTokens: Optional(_Array_(_Object_({
+      deviceToken: NonEmptyString,
+      role: NonEmptyString,
+      scopes: _Array_(NonEmptyString),
+      issuedAtMs: Integer({ minimum: 0 })
+    }, { additionalProperties: false })))
+  }, { additionalProperties: false }),
+  policy: _Object_({
+    maxPayload: Integer({ minimum: 1 }),
+    maxBufferedBytes: Integer({ minimum: 1 }),
+    tickIntervalMs: Integer({ minimum: 1 })
+  }, { additionalProperties: false })
+}, { additionalProperties: false });
+const ErrorShapeSchema = _Object_({
+  code: NonEmptyString,
+  message: NonEmptyString,
+  details: Optional(Unknown()),
+  retryable: Optional(Boolean()),
+  retryAfterMs: Optional(Integer({ minimum: 0 }))
+}, { additionalProperties: false });
+const RequestFrameSchema = _Object_({
+  type: Literal("req"),
+  id: NonEmptyString,
+  method: NonEmptyString,
+  params: Optional(Unknown())
+}, { additionalProperties: false });
+const ResponseFrameSchema = _Object_({
+  type: Literal("res"),
+  id: NonEmptyString,
+  ok: Boolean(),
+  payload: Optional(Unknown()),
+  error: Optional(ErrorShapeSchema)
+}, { additionalProperties: false });
+const EventFrameSchema = _Object_({
+  type: Literal("event"),
+  event: NonEmptyString,
+  payload: Optional(Unknown()),
+  seq: Optional(Integer({ minimum: 0 })),
+  stateVersion: Optional(StateVersionSchema)
+}, { additionalProperties: false });
+Union([
+  RequestFrameSchema,
+  ResponseFrameSchema,
+  EventFrameSchema
+], { discriminator: "type" });
+const LogsTailParamsSchema = _Object_({
+  cursor: Optional(Integer({ minimum: 0 })),
+  limit: Optional(Integer({
+    minimum: 1,
+    maximum: 5e3
+  })),
+  maxBytes: Optional(Integer({
+    minimum: 1,
+    maximum: 1e6
+  }))
+}, { additionalProperties: false });
+_Object_({
+  file: NonEmptyString,
+  cursor: Integer({ minimum: 0 }),
+  size: Integer({ minimum: 0 }),
+  lines: _Array_(String()),
+  truncated: Optional(Boolean()),
+  reset: Optional(Boolean())
+}, { additionalProperties: false });
+const ChatHistoryParamsSchema = _Object_({
+  sessionKey: NonEmptyString,
+  limit: Optional(Integer({
+    minimum: 1,
+    maximum: 1e3
+  })),
+  maxChars: Optional(Integer({
+    minimum: 1,
+    maximum: 5e5
+  }))
+}, { additionalProperties: false });
+const ChatSendParamsSchema = _Object_({
+  sessionKey: ChatSendSessionKeyString,
+  sessionId: Optional(NonEmptyString),
+  message: String(),
+  thinking: Optional(String()),
+  fastMode: Optional(Boolean()),
+  deliver: Optional(Boolean()),
+  originatingChannel: Optional(String()),
+  originatingTo: Optional(String()),
+  originatingAccountId: Optional(String()),
+  originatingThreadId: Optional(String()),
+  attachments: Optional(_Array_(Unknown())),
+  timeoutMs: Optional(Integer({ minimum: 0 })),
+  systemInputProvenance: Optional(InputProvenanceSchema),
+  systemProvenanceReceipt: Optional(String()),
+  idempotencyKey: NonEmptyString
+}, { additionalProperties: false });
+const ChatAbortParamsSchema = _Object_({
+  sessionKey: NonEmptyString,
+  runId: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const ChatInjectParamsSchema = _Object_({
+  sessionKey: NonEmptyString,
+  message: NonEmptyString,
+  label: Optional(String({ maxLength: 100 }))
+}, { additionalProperties: false });
+const ChatEventBaseSchema = {
+  runId: NonEmptyString,
+  sessionKey: NonEmptyString,
+  spawnedBy: Optional(NonEmptyString),
+  seq: Integer({ minimum: 0 })
+};
+const ChatEventErrorKindSchema = Union([
+  Literal("refusal"),
+  Literal("timeout"),
+  Literal("rate_limit"),
+  Literal("context_length"),
+  Literal("unknown")
+]);
+const ChatDeltaEventSchema = _Object_({
+  ...ChatEventBaseSchema,
+  state: Literal("delta"),
+  message: Optional(Unknown()),
+  deltaText: String(),
+  replace: Optional(Boolean()),
+  usage: Optional(Unknown())
+}, { additionalProperties: false });
+const ChatFinalEventSchema = _Object_({
+  ...ChatEventBaseSchema,
+  state: Literal("final"),
+  message: Optional(Unknown()),
+  usage: Optional(Unknown()),
+  stopReason: Optional(String())
+}, { additionalProperties: false });
+const ChatAbortedEventSchema = _Object_({
+  ...ChatEventBaseSchema,
+  state: Literal("aborted"),
+  message: Optional(Unknown()),
+  stopReason: Optional(String())
+}, { additionalProperties: false });
+const ChatErrorEventSchema = _Object_({
+  ...ChatEventBaseSchema,
+  state: Literal("error"),
+  message: Optional(Unknown()),
+  errorMessage: Optional(String()),
+  errorKind: Optional(ChatEventErrorKindSchema),
+  usage: Optional(Unknown()),
+  stopReason: Optional(String())
+}, { additionalProperties: false });
+const ChatEventSchema = Union([
+  ChatDeltaEventSchema,
+  ChatFinalEventSchema,
+  ChatAbortedEventSchema,
+  ChatErrorEventSchema
+]);
+const NodePendingWorkTypeSchema = String({ enum: ["status.request", "location.request"] });
+const NodePendingWorkPrioritySchema = String({ enum: ["normal", "high"] });
+const NodePresenceAliveReasonSchema = String({ enum: [
+  "background",
+  "silent_push",
+  "bg_app_refresh",
+  "significant_location",
+  "manual",
+  "connect"
+] });
+const NodePresenceAlivePayloadSchema = _Object_({
+  trigger: NodePresenceAliveReasonSchema,
+  sentAtMs: Optional(Integer({ minimum: 0 })),
+  displayName: Optional(NonEmptyString),
+  version: Optional(NonEmptyString),
+  platform: Optional(NonEmptyString),
+  deviceFamily: Optional(NonEmptyString),
+  modelIdentifier: Optional(NonEmptyString),
+  pushTransport: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const NodeEventResultSchema = _Object_({
+  ok: Boolean(),
+  event: NonEmptyString,
+  handled: Boolean(),
+  reason: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const NodePairRequestParamsSchema = _Object_({
+  nodeId: NonEmptyString,
+  displayName: Optional(NonEmptyString),
+  platform: Optional(NonEmptyString),
+  version: Optional(NonEmptyString),
+  coreVersion: Optional(NonEmptyString),
+  uiVersion: Optional(NonEmptyString),
+  deviceFamily: Optional(NonEmptyString),
+  modelIdentifier: Optional(NonEmptyString),
+  caps: Optional(_Array_(NonEmptyString)),
+  commands: Optional(_Array_(NonEmptyString)),
+  permissions: Optional(Record(NonEmptyString, Boolean())),
+  remoteIp: Optional(NonEmptyString),
+  silent: Optional(Boolean())
+}, { additionalProperties: false });
+const NodePairListParamsSchema = _Object_({}, { additionalProperties: false });
+const NodePairApproveParamsSchema = _Object_({ requestId: NonEmptyString }, { additionalProperties: false });
+const NodePairRejectParamsSchema = _Object_({ requestId: NonEmptyString }, { additionalProperties: false });
+const NodePairRemoveParamsSchema = _Object_({ nodeId: NonEmptyString }, { additionalProperties: false });
+const NodePairVerifyParamsSchema = _Object_({
+  nodeId: NonEmptyString,
+  token: NonEmptyString
+}, { additionalProperties: false });
+const NodeRenameParamsSchema = _Object_({
+  nodeId: NonEmptyString,
+  displayName: NonEmptyString
+}, { additionalProperties: false });
+const NodeListParamsSchema = _Object_({}, { additionalProperties: false });
+const NodePendingAckParamsSchema = _Object_({ ids: _Array_(NonEmptyString, { minItems: 1 }) }, { additionalProperties: false });
+const NodeDescribeParamsSchema = _Object_({ nodeId: NonEmptyString }, { additionalProperties: false });
+const NodeInvokeParamsSchema = _Object_({
+  nodeId: NonEmptyString,
+  command: NonEmptyString,
+  params: Optional(Unknown()),
+  timeoutMs: Optional(Integer({ minimum: 0 })),
+  idempotencyKey: NonEmptyString
+}, { additionalProperties: false });
+const NodeInvokeResultParamsSchema = _Object_({
+  id: NonEmptyString,
+  nodeId: NonEmptyString,
+  ok: Boolean(),
+  payload: Optional(Unknown()),
+  payloadJSON: Optional(String()),
+  error: Optional(_Object_({
+    code: Optional(NonEmptyString),
+    message: Optional(NonEmptyString)
+  }, { additionalProperties: false }))
+}, { additionalProperties: false });
+const NodeEventParamsSchema = _Object_({
+  event: NonEmptyString,
+  payload: Optional(Unknown()),
+  payloadJSON: Optional(String())
+}, { additionalProperties: false });
+const NodePendingDrainParamsSchema = _Object_({ maxItems: Optional(Integer({
+  minimum: 1,
+  maximum: 10
+})) }, { additionalProperties: false });
+const NodePendingDrainItemSchema = _Object_({
+  id: NonEmptyString,
+  type: NodePendingWorkTypeSchema,
+  priority: String({ enum: [
+    "default",
+    "normal",
+    "high"
+  ] }),
+  createdAtMs: Integer({ minimum: 0 }),
+  expiresAtMs: Optional(Union([Integer({ minimum: 0 }), Null()])),
+  payload: Optional(Record(String(), Unknown()))
+}, { additionalProperties: false });
+_Object_({
+  nodeId: NonEmptyString,
+  revision: Integer({ minimum: 0 }),
+  items: _Array_(NodePendingDrainItemSchema),
+  hasMore: Boolean()
+}, { additionalProperties: false });
+const NodePendingEnqueueParamsSchema = _Object_({
+  nodeId: NonEmptyString,
+  type: NodePendingWorkTypeSchema,
+  priority: Optional(NodePendingWorkPrioritySchema),
+  expiresInMs: Optional(Integer({
+    minimum: 1e3,
+    maximum: 864e5
+  })),
+  wake: Optional(Boolean())
+}, { additionalProperties: false });
+_Object_({
+  nodeId: NonEmptyString,
+  revision: Integer({ minimum: 0 }),
+  queued: NodePendingDrainItemSchema,
+  wakeTriggered: Boolean()
+}, { additionalProperties: false });
+_Object_({
+  id: NonEmptyString,
+  nodeId: NonEmptyString,
+  command: NonEmptyString,
+  paramsJSON: Optional(String()),
+  timeoutMs: Optional(Integer({ minimum: 0 })),
+  idempotencyKey: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const PluginApprovalRequestParamsSchema = _Object_({
+  pluginId: Optional(NonEmptyString),
+  title: String({
+    minLength: 1,
+    maxLength: 80
+  }),
+  description: String({
+    minLength: 1,
+    maxLength: 256
+  }),
+  severity: Optional(String({ enum: [
+    "info",
+    "warning",
+    "critical"
+  ] })),
+  toolName: Optional(String()),
+  toolCallId: Optional(String()),
+  allowedDecisions: Optional(_Array_(String({ enum: [
+    "allow-once",
+    "allow-always",
+    "deny"
+  ] }), {
+    minItems: 1,
+    maxItems: 3
+  })),
+  agentId: Optional(String()),
+  sessionKey: Optional(String()),
+  turnSourceChannel: Optional(String()),
+  turnSourceTo: Optional(String()),
+  turnSourceAccountId: Optional(String()),
+  turnSourceThreadId: Optional(Union([String(), Number()])),
+  timeoutMs: Optional(Integer({
+    minimum: 1,
+    maximum: MAX_PLUGIN_APPROVAL_TIMEOUT_MS
+  })),
+  twoPhase: Optional(Boolean())
+}, { additionalProperties: false });
+const PluginApprovalResolveParamsSchema = _Object_({
+  id: NonEmptyString,
+  decision: NonEmptyString
+}, { additionalProperties: false });
+const PluginJsonValueSchema = Unknown();
+const PluginControlUiDescriptorSchema = _Object_({
+  id: NonEmptyString,
+  pluginId: NonEmptyString,
+  pluginName: Optional(NonEmptyString),
+  surface: Union([
+    Literal("session"),
+    Literal("tool"),
+    Literal("run"),
+    Literal("settings")
+  ]),
+  label: NonEmptyString,
+  description: Optional(String()),
+  placement: Optional(String()),
+  schema: Optional(PluginJsonValueSchema),
+  requiredScopes: Optional(_Array_(NonEmptyString))
+}, { additionalProperties: false });
+const PluginsUiDescriptorsParamsSchema = _Object_({}, { additionalProperties: false });
+_Object_({
+  ok: Literal(true),
+  descriptors: _Array_(PluginControlUiDescriptorSchema)
+}, { additionalProperties: false });
+const PluginsSessionActionParamsSchema = _Object_({
+  pluginId: NonEmptyString,
+  actionId: NonEmptyString,
+  sessionKey: Optional(NonEmptyString),
+  payload: Optional(PluginJsonValueSchema)
+}, { additionalProperties: false });
+const PluginsSessionActionSuccessResultSchema = _Object_({
+  ok: Literal(true),
+  result: Optional(PluginJsonValueSchema),
+  continueAgent: Optional(Boolean()),
+  reply: Optional(PluginJsonValueSchema)
+}, { additionalProperties: false });
+const PluginsSessionActionFailureResultSchema = _Object_({
+  ok: Literal(false),
+  error: String(),
+  code: Optional(String()),
+  details: Optional(PluginJsonValueSchema)
+}, { additionalProperties: false });
+const PluginsSessionActionResultSchema = Union([PluginsSessionActionSuccessResultSchema, PluginsSessionActionFailureResultSchema]);
+const ApnsEnvironmentSchema = String({ enum: ["sandbox", "production"] });
+const PushTestParamsSchema = _Object_({
+  nodeId: NonEmptyString,
+  title: Optional(String()),
+  body: Optional(String()),
+  environment: Optional(ApnsEnvironmentSchema)
+}, { additionalProperties: false });
+_Object_({
+  ok: Boolean(),
+  status: Integer(),
+  apnsId: Optional(String()),
+  reason: Optional(String()),
+  tokenSuffix: String(),
+  topic: String(),
+  environment: ApnsEnvironmentSchema,
+  transport: String({ enum: ["direct", "relay"] })
+}, { additionalProperties: false });
+const WebPushKeysSchema = _Object_({
+  p256dh: String({
+    minLength: 1,
+    maxLength: 512
+  }),
+  auth: String({
+    minLength: 1,
+    maxLength: 512
+  })
+}, { additionalProperties: false });
+const WebPushVapidPublicKeyParamsSchema = _Object_({}, { additionalProperties: false });
+const WebPushSubscribeParamsSchema = _Object_({
+  endpoint: String({
+    minLength: 1,
+    maxLength: 2048,
+    pattern: "^https://"
+  }),
+  keys: WebPushKeysSchema
+}, { additionalProperties: false });
+const WebPushUnsubscribeParamsSchema = _Object_({ endpoint: String({
+  minLength: 1,
+  maxLength: 2048,
+  pattern: "^https://"
+}) }, { additionalProperties: false });
+const WebPushTestParamsSchema = _Object_({
+  title: Optional(String()),
+  body: Optional(String())
+}, { additionalProperties: false });
+_Object_({}, { additionalProperties: false });
+const SecretsResolveParamsSchema = _Object_({
+  commandName: NonEmptyString,
+  targetIds: _Array_(NonEmptyString),
+  allowedPaths: Optional(_Array_(NonEmptyString)),
+  forcedActivePaths: Optional(_Array_(NonEmptyString)),
+  optionalActivePaths: Optional(_Array_(NonEmptyString)),
+  providerOverrides: Optional(_Object_({
+    webSearch: Optional(NonEmptyString),
+    webFetch: Optional(NonEmptyString)
+  }, { additionalProperties: false }))
+}, { additionalProperties: false });
+const SecretsResolveAssignmentSchema = _Object_({
+  path: Optional(NonEmptyString),
+  pathSegments: _Array_(NonEmptyString),
+  value: Unknown()
+}, { additionalProperties: false });
+const SecretsResolveResultSchema = _Object_({
+  ok: Optional(Boolean()),
+  assignments: Optional(_Array_(SecretsResolveAssignmentSchema)),
+  diagnostics: Optional(_Array_(NonEmptyString)),
+  inactiveRefPaths: Optional(_Array_(NonEmptyString))
+}, { additionalProperties: false });
+const SessionCompactionCheckpointReasonSchema = Union([
+  Literal("manual"),
+  Literal("auto-threshold"),
+  Literal("overflow-retry"),
+  Literal("timeout-retry")
+]);
+_Object_({
+  operationId: NonEmptyString,
+  operation: Literal("compact"),
+  phase: Union([Literal("start"), Literal("end")]),
+  sessionKey: NonEmptyString,
+  ts: Integer({ minimum: 0 }),
+  completed: Optional(Boolean()),
+  reason: Optional(String())
+}, { additionalProperties: false });
+const SessionCompactionTranscriptReferenceSchema = _Object_({
+  sessionId: NonEmptyString,
+  sessionFile: Optional(NonEmptyString),
+  leafId: Optional(NonEmptyString),
+  entryId: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const SessionCompactionCheckpointSchema = _Object_({
+  checkpointId: NonEmptyString,
+  sessionKey: NonEmptyString,
+  sessionId: NonEmptyString,
+  createdAt: Integer({ minimum: 0 }),
+  reason: SessionCompactionCheckpointReasonSchema,
+  tokensBefore: Optional(Integer({ minimum: 0 })),
+  tokensAfter: Optional(Integer({ minimum: 0 })),
+  summary: Optional(String()),
+  firstKeptEntryId: Optional(NonEmptyString),
+  preCompaction: SessionCompactionTranscriptReferenceSchema,
+  postCompaction: SessionCompactionTranscriptReferenceSchema
+}, { additionalProperties: false });
+const SessionsListParamsSchema = _Object_({
+  /**
+  * Maximum rows to return. Omitted Gateway RPC calls use a bounded default
+  * to keep large session stores from monopolizing the event loop.
+  */
+  limit: Optional(Integer({ minimum: 1 })),
+  offset: Optional(Integer({ minimum: 0 })),
+  activeMinutes: Optional(Integer({ minimum: 1 })),
+  includeGlobal: Optional(Boolean()),
+  includeUnknown: Optional(Boolean()),
+  /**
+  * Limit returned agent-scoped rows to agents currently present in config.
+  * Broad disk discovery remains the default for recovery/ACP consumers.
+  */
+  configuredAgentsOnly: Optional(Boolean()),
+  /**
+  * Read first 8KB of each session transcript to derive title from first user message.
+  * Performs a file read per session - use `limit` to bound result set on large stores.
+  */
+  includeDerivedTitles: Optional(Boolean()),
+  /**
+  * Read last 16KB of each session transcript to extract most recent message preview.
+  * Performs a file read per session - use `limit` to bound result set on large stores.
+  */
+  includeLastMessage: Optional(Boolean()),
+  label: Optional(SessionLabelString),
+  spawnedBy: Optional(NonEmptyString),
+  agentId: Optional(NonEmptyString),
+  search: Optional(String())
+}, { additionalProperties: false });
+const SessionsCleanupParamsSchema = _Object_({
+  agent: Optional(NonEmptyString),
+  allAgents: Optional(Boolean()),
+  enforce: Optional(Boolean()),
+  activeKey: Optional(NonEmptyString),
+  fixMissing: Optional(Boolean()),
+  fixDmScope: Optional(Boolean())
+}, { additionalProperties: false });
+const SessionsPreviewParamsSchema = _Object_({
+  keys: _Array_(NonEmptyString, { minItems: 1 }),
+  limit: Optional(Integer({ minimum: 1 })),
+  maxChars: Optional(Integer({ minimum: 20 }))
+}, { additionalProperties: false });
+const SessionsDescribeParamsSchema = _Object_({
+  key: NonEmptyString,
+  includeDerivedTitles: Optional(Boolean()),
+  includeLastMessage: Optional(Boolean())
+}, { additionalProperties: false });
+const SessionsResolveParamsSchema = _Object_({
+  key: Optional(NonEmptyString),
+  sessionId: Optional(NonEmptyString),
+  label: Optional(SessionLabelString),
+  agentId: Optional(NonEmptyString),
+  spawnedBy: Optional(NonEmptyString),
+  includeGlobal: Optional(Boolean()),
+  includeUnknown: Optional(Boolean())
+}, { additionalProperties: false });
+const SessionsCreateParamsSchema = _Object_({
+  key: Optional(NonEmptyString),
+  agentId: Optional(NonEmptyString),
+  label: Optional(SessionLabelString),
+  model: Optional(NonEmptyString),
+  parentSessionKey: Optional(NonEmptyString),
+  emitCommandHooks: Optional(Boolean()),
+  task: Optional(String()),
+  message: Optional(String())
+}, { additionalProperties: false });
+const SessionsSendParamsSchema = _Object_({
+  key: NonEmptyString,
+  message: String(),
+  thinking: Optional(String()),
+  attachments: Optional(_Array_(Unknown())),
+  timeoutMs: Optional(Integer({ minimum: 0 })),
+  idempotencyKey: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const SessionsMessagesSubscribeParamsSchema = _Object_({ key: NonEmptyString }, { additionalProperties: false });
+const SessionsMessagesUnsubscribeParamsSchema = _Object_({ key: NonEmptyString }, { additionalProperties: false });
+const SessionsAbortParamsSchema = _Object_({
+  key: Optional(NonEmptyString),
+  runId: Optional(NonEmptyString),
+  agentId: Optional(NonEmptyString)
+}, { additionalProperties: false });
+const SessionsPatchParamsSchema = _Object_({
+  key: NonEmptyString,
+  label: Optional(Union([SessionLabelString, Null()])),
+  thinkingLevel: Optional(Union([NonEmptyString, Null()])),
+  fastMode: Optional(Union([Boolean(), Null()])),
+  verboseLevel: Optional(Union([NonEmptyString, Null()])),
+  traceLevel: Optional(Union([NonEmptyString, Null()])),
+  reasoningLevel: Optional(Union([NonEmptyString, Null()])),
+  responseUsage: Optional(Union([
+    Literal("off"),
+    Literal("tokens"),
+    Literal("full"),
+    Literal("on"),
+    Null()
+  ])),
+  elevatedLevel: Optional(Union([NonEmptyString, Null()])),
+  execHost: Optional(Union([NonEmptyString, Null()])),
+  execSecurity: Optional(Union([NonEmptyString, Null()])),
+  execAsk: Optional(Union([NonEmptyString, Null()])),
+  execNode: Optional(Union([NonEmptyString, Null()])),
+  model: Optional(Union([NonEmptyString, Null()])),
+  spawnedBy: Optional(Union([NonEmptyString, Null()])),
+  spawnedWorkspaceDir: Optional(Union([NonEmptyString, Null()])),
+  spawnDepth: Optional(Union([Integer({ minimum: 0 }), Null()])),
+  subagentRole: Optional(Union([
+    Literal("orchestrator"),
+    Literal("leaf"),
+    Null()
+  ])),
+  subagentControlScope: Optional(Union([
+    Literal("children"),
+    Literal("none"),
+    Null()
+  ])),
+  inheritedToolAllow: Optional(Union([_Array_(NonEmptyString), Null()])),
+  inheritedToolDeny: Optional(Union([_Array_(NonEmptyString), Null()])),
+  sendPolicy: Optional(Union([
+    Literal("allow"),
+    Literal("deny"),
+    Null()
+  ])),
+  groupActivation: Optional(Union([
+    Literal("mention"),
+    Literal("always"),
+    Null()
+  ]))
+}, { additionalProperties: false });
+const SessionsPluginPatchParamsSchema = _Object_({
+  key: NonEmptyString,
+  pluginId: NonEmptyString,
+  namespace: NonEmptyString,
+  value: Optional(PluginJsonValueSchema),
+  unset: Optional(Boolean())
+}, { additionalProperties: false });
+_Object_({
+  ok: Literal(true),
+  key: NonEmptyString,
+  value: Optional(PluginJsonValueSchema)
+}, { additionalProperties: false });
+const SessionsResetParamsSchema = _Object_({
+  key: NonEmptyString,
+  reason: Optional(Union([Literal("new"), Literal("reset")]))
+}, { additionalProperties: false });
+const SessionsDeleteParamsSchema = _Object_({
+  key: NonEmptyString,
+  deleteTranscript: Optional(Boolean()),
+  emitLifecycleHooks: Optional(Boolean())
+}, { additionalProperties: false });
+const SessionsCompactParamsSchema = _Object_({
+  key: NonEmptyString,
+  maxLines: Optional(Integer({ minimum: 1 }))
+}, { additionalProperties: false });
+const SessionsCompactionListParamsSchema = _Object_({ key: NonEmptyString }, { additionalProperties: false });
+const SessionsCompactionGetParamsSchema = _Object_({
+  key: NonEmptyString,
+  checkpointId: NonEmptyString
+}, { additionalProperties: false });
+const SessionsCompactionBranchParamsSchema = _Object_({
+  key: NonEmptyString,
+  checkpointId: NonEmptyString
+}, { additionalProperties: false });
+const SessionsCompactionRestoreParamsSchema = _Object_({
+  key: NonEmptyString,
+  checkpointId: NonEmptyString
+}, { additionalProperties: false });
+_Object_({
+  ok: Literal(true),
+  key: NonEmptyString,
+  checkpoints: _Array_(SessionCompactionCheckpointSchema)
+}, { additionalProperties: false });
+_Object_({
+  ok: Literal(true),
+  key: NonEmptyString,
+  checkpoint: SessionCompactionCheckpointSchema
+}, { additionalProperties: false });
+_Object_({
+  ok: Literal(true),
+  sourceKey: NonEmptyString,
+  key: NonEmptyString,
+  sessionId: NonEmptyString,
+  checkpoint: SessionCompactionCheckpointSchema,
+  entry: _Object_({
+    sessionId: NonEmptyString,
+    updatedAt: Integer({ minimum: 0 })
+  }, { additionalProperties: true })
+}, { additionalProperties: false });
+_Object_({
+  ok: Literal(true),
+  key: NonEmptyString,
+  sessionId: NonEmptyString,
+  checkpoint: SessionCompactionCheckpointSchema,
+  entry: _Object_({
+    sessionId: NonEmptyString,
+    updatedAt: Integer({ minimum: 0 })
+  }, { additionalProperties: true })
+}, { additionalProperties: false });
+const SessionsUsageParamsSchema = _Object_({
+  /** Specific session key to analyze; if omitted returns sessions for the effective agent. */
+  key: Optional(NonEmptyString),
+  /** Agent scope for list-style usage queries. */
+  agentId: Optional(NonEmptyString),
+  /** Start date for range filter (YYYY-MM-DD). */
+  startDate: Optional(String({ pattern: "^\\d{4}-\\d{2}-\\d{2}$" })),
+  /** End date for range filter (YYYY-MM-DD). */
+  endDate: Optional(String({ pattern: "^\\d{4}-\\d{2}-\\d{2}$" })),
+  /** How start/end dates should be interpreted. Defaults to UTC when omitted. */
+  mode: Optional(Union([
+    Literal("utc"),
+    Literal("gateway"),
+    Literal("specific")
+  ])),
+  /** Preset range for usage queries when explicit start/end dates are omitted. */
+  range: Optional(Union([
+    Literal("7d"),
+    Literal("30d"),
+    Literal("90d"),
+    Literal("1y"),
+    Literal("all")
+  ])),
+  /** Usage row grouping. `family` rolls up known rotated session ids for a logical key. */
+  groupBy: Optional(Union([Literal("instance"), Literal("family")])),
+  /** Backward-compatible alias for requesting family grouping. */
+  includeHistorical: Optional(Boolean()),
+  /** UTC offset to use when mode is `specific` (for example, UTC-4 or UTC+5:30). */
+  utcOffset: Optional(String({ pattern: "^UTC[+-]\\d{1,2}(?::[0-5]\\d)?$" })),
+  /** Maximum sessions to return (default 50). */
+  limit: Optional(Integer({ minimum: 1 })),
+  /** Include context weight breakdown (systemPromptReport). */
+  includeContextWeight: Optional(Boolean())
+}, { additionalProperties: false });
+const TaskLedgerStatusSchema = Union([
+  Literal("queued"),
+  Literal("running"),
+  Literal("completed"),
+  Literal("failed"),
+  Literal("cancelled"),
+  Literal("timed_out")
+]);
+const TimestampSchema = Union([String(), Integer({ minimum: 0 })]);
+const TaskSummarySchema = _Object_({
+  id: NonEmptyString,
+  kind: Optional(String()),
+  runtime: Optional(String()),
+  status: TaskLedgerStatusSchema,
+  title: Optional(String()),
+  agentId: Optional(String()),
+  sessionKey: Optional(String()),
+  childSessionKey: Optional(String()),
+  ownerKey: Optional(String()),
+  runId: Optional(String()),
+  taskId: Optional(String()),
+  flowId: Optional(String()),
+  parentTaskId: Optional(String()),
+  sourceId: Optional(String()),
+  createdAt: Optional(TimestampSchema),
+  updatedAt: Optional(TimestampSchema),
+  startedAt: Optional(TimestampSchema),
+  endedAt: Optional(TimestampSchema),
+  progressSummary: Optional(String()),
+  terminalSummary: Optional(String()),
+  error: Optional(String())
+}, { additionalProperties: false });
+const TasksListParamsSchema = _Object_({
+  status: Optional(Union([TaskLedgerStatusSchema, _Array_(TaskLedgerStatusSchema)])),
+  agentId: Optional(NonEmptyString),
+  sessionKey: Optional(NonEmptyString),
+  limit: Optional(Integer({
+    minimum: 1,
+    maximum: 500
+  })),
+  cursor: Optional(String())
+}, { additionalProperties: false });
+_Object_({
+  tasks: _Array_(TaskSummarySchema),
+  nextCursor: Optional(String())
+}, { additionalProperties: false });
+const TasksGetParamsSchema = _Object_({ taskId: NonEmptyString }, { additionalProperties: false });
+_Object_({ task: TaskSummarySchema }, { additionalProperties: false });
+const TasksCancelParamsSchema = _Object_({
+  taskId: NonEmptyString,
+  reason: Optional(String())
+}, { additionalProperties: false });
+_Object_({
+  found: Boolean(),
+  cancelled: Boolean(),
+  reason: Optional(String()),
+  task: Optional(TaskSummarySchema)
+}, { additionalProperties: false });
+const WizardRunStatusSchema = Union([
+  Literal("running"),
+  Literal("done"),
+  Literal("cancelled"),
+  Literal("error")
+]);
+const WizardStartParamsSchema = _Object_({
+  mode: Optional(Union([Literal("local"), Literal("remote")])),
+  workspace: Optional(String())
+}, { additionalProperties: false });
+const WizardAnswerSchema = _Object_({
+  stepId: NonEmptyString,
+  value: Optional(Unknown())
+}, { additionalProperties: false });
+const WizardNextParamsSchema = _Object_({
+  sessionId: NonEmptyString,
+  answer: Optional(WizardAnswerSchema)
+}, { additionalProperties: false });
+const WizardSessionIdParamsSchema = _Object_({ sessionId: NonEmptyString }, { additionalProperties: false });
+const WizardCancelParamsSchema = WizardSessionIdParamsSchema;
+const WizardStatusParamsSchema = WizardSessionIdParamsSchema;
+const WizardStepOptionSchema = _Object_({
+  value: Unknown(),
+  label: NonEmptyString,
+  hint: Optional(String())
+}, { additionalProperties: false });
+const WizardStepSchema = _Object_({
+  id: NonEmptyString,
+  type: Union([
+    Literal("note"),
+    Literal("select"),
+    Literal("text"),
+    Literal("confirm"),
+    Literal("multiselect"),
+    Literal("progress"),
+    Literal("action")
+  ]),
+  title: Optional(String()),
+  message: Optional(String()),
+  format: Optional(Union([Literal("plain")])),
+  options: Optional(_Array_(WizardStepOptionSchema)),
+  initialValue: Optional(Unknown()),
+  placeholder: Optional(String()),
+  sensitive: Optional(Boolean()),
+  executor: Optional(Union([Literal("gateway"), Literal("client")]))
+}, { additionalProperties: false });
+const WizardResultFields = {
+  done: Boolean(),
+  step: Optional(WizardStepSchema),
+  status: Optional(WizardRunStatusSchema),
+  error: Optional(String())
+};
+_Object_(WizardResultFields, { additionalProperties: false });
+_Object_({
+  sessionId: NonEmptyString,
+  ...WizardResultFields
+}, { additionalProperties: false });
+_Object_({
+  status: WizardRunStatusSchema,
+  error: Optional(String())
+}, { additionalProperties: false });
+const AjvCtor = Ajv;
+let ajv;
+function getAjv() {
+  ajv ??= new AjvCtor({
+    allErrors: true,
+    strict: false,
+    removeAdditional: false
+  });
+  return ajv;
+}
+function lazyCompile(schema) {
+  let compiled;
+  const getCompiled = () => {
+    compiled ??= getAjv().compile(schema);
+    return compiled;
+  };
+  const validate = (data, dataCxt) => {
+    const current = getCompiled();
+    const valid = current(data, dataCxt);
+    validate.errors = current.errors;
+    validate.evaluated = current.evaluated;
+    return valid;
+  };
+  Object.defineProperties(validate, {
+    errors: {
+      configurable: true,
+      enumerable: true,
+      get: () => compiled?.errors ?? null,
+      set: (errors) => {
+        if (compiled) compiled.errors = errors ?? null;
+      }
+    },
+    evaluated: {
+      configurable: true,
+      enumerable: true,
+      get: () => compiled?.evaluated,
+      set: (evaluated) => {
+        if (compiled) compiled.evaluated = evaluated;
+      }
+    },
+    schema: {
+      configurable: true,
+      enumerable: true,
+      get: () => compiled?.schema ?? schema
+    },
+    schemaEnv: {
+      configurable: true,
+      enumerable: true,
+      get: () => getCompiled().schemaEnv
+    },
+    source: {
+      configurable: true,
+      enumerable: true,
+      get: () => compiled?.source
+    }
+  });
+  return validate;
+}
+lazyCompile(CommandsListParamsSchema);
+lazyCompile(ConnectParamsSchema);
+const validateRequestFrame = lazyCompile(RequestFrameSchema);
+const validateResponseFrame = lazyCompile(ResponseFrameSchema);
+const validateEventFrame = lazyCompile(EventFrameSchema);
+lazyCompile(MessageActionParamsSchema);
+lazyCompile(SendParamsSchema);
+lazyCompile(PollParamsSchema);
+lazyCompile(AgentParamsSchema);
+lazyCompile(AgentIdentityParamsSchema);
+lazyCompile(AgentWaitParamsSchema);
+lazyCompile(WakeParamsSchema);
+lazyCompile(AgentsListParamsSchema);
+lazyCompile(AgentsCreateParamsSchema);
+lazyCompile(AgentsUpdateParamsSchema);
+lazyCompile(AgentsDeleteParamsSchema);
+lazyCompile(AgentsFilesListParamsSchema);
+lazyCompile(AgentsFilesGetParamsSchema);
+lazyCompile(AgentsFilesSetParamsSchema);
+lazyCompile(ArtifactsListParamsSchema);
+lazyCompile(ArtifactsGetParamsSchema);
+lazyCompile(ArtifactsDownloadParamsSchema);
+lazyCompile(NodePairRequestParamsSchema);
+lazyCompile(NodePairListParamsSchema);
+lazyCompile(NodePairApproveParamsSchema);
+lazyCompile(NodePairRejectParamsSchema);
+lazyCompile(NodePairRemoveParamsSchema);
+lazyCompile(NodePairVerifyParamsSchema);
+lazyCompile(NodeRenameParamsSchema);
+lazyCompile(NodeListParamsSchema);
+lazyCompile(EnvironmentsListParamsSchema);
+lazyCompile(EnvironmentsStatusParamsSchema);
+lazyCompile(NodePendingAckParamsSchema);
+lazyCompile(NodeDescribeParamsSchema);
+lazyCompile(NodeInvokeParamsSchema);
+lazyCompile(NodeInvokeResultParamsSchema);
+lazyCompile(NodeEventParamsSchema);
+lazyCompile(NodeEventResultSchema);
+lazyCompile(NodePresenceAlivePayloadSchema);
+lazyCompile(NodePendingDrainParamsSchema);
+lazyCompile(NodePendingEnqueueParamsSchema);
+lazyCompile(PushTestParamsSchema);
+lazyCompile(WebPushVapidPublicKeyParamsSchema);
+lazyCompile(WebPushSubscribeParamsSchema);
+lazyCompile(WebPushUnsubscribeParamsSchema);
+lazyCompile(WebPushTestParamsSchema);
+lazyCompile(SecretsResolveParamsSchema);
+lazyCompile(SecretsResolveResultSchema);
+lazyCompile(SessionsListParamsSchema);
+lazyCompile(SessionsCleanupParamsSchema);
+lazyCompile(SessionsPreviewParamsSchema);
+lazyCompile(SessionsDescribeParamsSchema);
+lazyCompile(SessionsResolveParamsSchema);
+lazyCompile(SessionsCreateParamsSchema);
+lazyCompile(SessionsSendParamsSchema);
+lazyCompile(SessionsMessagesSubscribeParamsSchema);
+lazyCompile(SessionsMessagesUnsubscribeParamsSchema);
+lazyCompile(SessionsAbortParamsSchema);
+lazyCompile(SessionsPatchParamsSchema);
+lazyCompile(SessionsPluginPatchParamsSchema);
+lazyCompile(SessionsResetParamsSchema);
+lazyCompile(SessionsDeleteParamsSchema);
+lazyCompile(SessionsCompactParamsSchema);
+lazyCompile(SessionsCompactionListParamsSchema);
+lazyCompile(SessionsCompactionGetParamsSchema);
+lazyCompile(SessionsCompactionBranchParamsSchema);
+lazyCompile(SessionsCompactionRestoreParamsSchema);
+lazyCompile(SessionsUsageParamsSchema);
+lazyCompile(TasksListParamsSchema);
+lazyCompile(TasksGetParamsSchema);
+lazyCompile(TasksCancelParamsSchema);
+lazyCompile(ConfigGetParamsSchema);
+lazyCompile(ConfigSetParamsSchema);
+lazyCompile(ConfigApplyParamsSchema);
+lazyCompile(ConfigPatchParamsSchema);
+lazyCompile(ConfigSchemaParamsSchema);
+lazyCompile(ConfigSchemaLookupParamsSchema);
+lazyCompile(ConfigSchemaLookupResultSchema);
+lazyCompile(WizardStartParamsSchema);
+lazyCompile(WizardNextParamsSchema);
+lazyCompile(WizardCancelParamsSchema);
+lazyCompile(WizardStatusParamsSchema);
+lazyCompile(TalkModeParamsSchema);
+lazyCompile(TalkEventSchema);
+lazyCompile(TalkCatalogParamsSchema);
+lazyCompile(TalkCatalogResultSchema);
+lazyCompile(TalkConfigParamsSchema);
+lazyCompile(TalkConfigResultSchema);
+lazyCompile(TalkClientCreateParamsSchema);
+lazyCompile(TalkClientCreateResultSchema);
+lazyCompile(TalkClientToolCallParamsSchema);
+lazyCompile(TalkClientToolCallResultSchema);
+lazyCompile(TalkSessionCreateParamsSchema);
+lazyCompile(TalkSessionCreateResultSchema);
+lazyCompile(TalkSessionJoinParamsSchema);
+lazyCompile(TalkSessionJoinResultSchema);
+lazyCompile(TalkSessionAppendAudioParamsSchema);
+lazyCompile(TalkSessionTurnParamsSchema);
+lazyCompile(TalkSessionCancelTurnParamsSchema);
+lazyCompile(TalkSessionCancelOutputParamsSchema);
+lazyCompile(TalkSessionTurnResultSchema);
+lazyCompile(TalkSessionSubmitToolResultParamsSchema);
+lazyCompile(TalkSessionCloseParamsSchema);
+lazyCompile(TalkSessionOkResultSchema);
+lazyCompile(TalkSpeakParamsSchema);
+lazyCompile(TalkSpeakResultSchema);
+lazyCompile(ChannelsStatusParamsSchema);
+lazyCompile(ChannelsStartParamsSchema);
+lazyCompile(ChannelsStopParamsSchema);
+lazyCompile(ChannelsLogoutParamsSchema);
+lazyCompile(ModelsListParamsSchema);
+lazyCompile(SkillsStatusParamsSchema);
+lazyCompile(ToolsCatalogParamsSchema);
+lazyCompile(ToolsEffectiveParamsSchema);
+lazyCompile(ToolsInvokeParamsSchema);
+lazyCompile(SkillsBinsParamsSchema);
+lazyCompile(SkillsInstallParamsSchema);
+lazyCompile(SkillsUploadBeginParamsSchema);
+lazyCompile(SkillsUploadChunkParamsSchema);
+lazyCompile(SkillsUploadCommitParamsSchema);
+lazyCompile(SkillsUpdateParamsSchema);
+lazyCompile(SkillsSearchParamsSchema);
+lazyCompile(SkillsDetailParamsSchema);
+lazyCompile(CronListParamsSchema);
+lazyCompile(CronStatusParamsSchema);
+lazyCompile(CronGetParamsSchema);
+lazyCompile(CronAddParamsSchema);
+lazyCompile(CronUpdateParamsSchema);
+lazyCompile(CronRemoveParamsSchema);
+lazyCompile(CronRunParamsSchema);
+lazyCompile(CronRunsParamsSchema);
+lazyCompile(DevicePairListParamsSchema);
+lazyCompile(DevicePairApproveParamsSchema);
+lazyCompile(DevicePairRejectParamsSchema);
+lazyCompile(DevicePairRemoveParamsSchema);
+lazyCompile(DeviceTokenRotateParamsSchema);
+lazyCompile(DeviceTokenRevokeParamsSchema);
+lazyCompile(ExecApprovalsGetParamsSchema);
+lazyCompile(ExecApprovalsSetParamsSchema);
+lazyCompile(ExecApprovalGetParamsSchema);
+lazyCompile(ExecApprovalRequestParamsSchema);
+lazyCompile(ExecApprovalResolveParamsSchema);
+lazyCompile(PluginApprovalRequestParamsSchema);
+lazyCompile(PluginApprovalResolveParamsSchema);
+lazyCompile(PluginsUiDescriptorsParamsSchema);
+lazyCompile(PluginsSessionActionParamsSchema);
+lazyCompile(PluginsSessionActionResultSchema);
+lazyCompile(ExecApprovalsNodeGetParamsSchema);
+lazyCompile(ExecApprovalsNodeSetParamsSchema);
+lazyCompile(LogsTailParamsSchema);
+lazyCompile(ChatHistoryParamsSchema);
+lazyCompile(ChatSendParamsSchema);
+lazyCompile(ChatAbortParamsSchema);
+lazyCompile(ChatInjectParamsSchema);
+lazyCompile(ChatEventSchema);
+lazyCompile(UpdateStatusParamsSchema);
+lazyCompile(UpdateRunParamsSchema);
+lazyCompile(WebLoginStartParamsSchema);
+lazyCompile(WebLoginWaitParamsSchema);
+export {
+  ModelsListParamsSchema as $a,
+  UpdateStatusParamsSchema as $i,
+  TalkSpeakResultSchema as Aa,
+  SessionsResolveParamsSchema as Ar,
+  validateRequestFrame as At,
+  AgentsDeleteParamsSchema as Ba,
+  CronRunParamsSchema as Bi,
+  PluginsSessionActionResultSchema as Br,
+  TalkSessionJoinParamsSchema as Ca,
+  ExecApprovalRequestParamsSchema as Ci,
+  SessionsDeleteParamsSchema as Cr,
+  TalkSessionTurnParamsSchema as Da,
+  EnvironmentStatusSchema as Di,
+  SessionsPluginPatchParamsSchema as Dr,
+  TalkSessionSubmitToolResultParamsSchema as Ea,
+  ExecApprovalsSetParamsSchema as Ei,
+  SessionsPatchParamsSchema as Er,
+  ArtifactsGetParamsSchema as Fa,
+  CronAddParamsSchema as Fi,
+  WebPushSubscribeParamsSchema as Fr,
+  AgentsFilesListParamsSchema as Ga,
+  ConfigGetParamsSchema as Gi,
+  NodePairApproveParamsSchema as Gr,
+  AgentsFileEntrySchema as Ha,
+  CronStatusParamsSchema as Hi,
+  NodeEventResultSchema as Hr,
+  ArtifactsListParamsSchema as Ia,
+  CronGetParamsSchema as Ii,
+  WebPushTestParamsSchema as Ir,
+  ConfigSchemaLookupResultSchema as Ji,
+  NodePairRemoveParamsSchema as Jr,
+  ConfigPatchParamsSchema as Ki,
+  NodePairListParamsSchema as Kr,
+  AgentSummarySchema as La,
+  WebPushUnsubscribeParamsSchema as Lr,
+  WebLoginWaitParamsSchema as Ma,
+  SessionsUsageParamsSchema as Mr,
+  ArtifactSummarySchema as Na,
+  PushTestParamsSchema as Nr,
+  TalkSessionTurnResultSchema as Oa,
+  EnvironmentSummarySchema as Oi,
+  SessionsPreviewParamsSchema as Or,
+  ArtifactsDownloadParamsSchema as Pa,
+  UpdateRunParamsSchema as Qi,
+  NodePendingDrainParamsSchema as Qr,
+  AgentsCreateParamsSchema as Ra,
+  CronListParamsSchema as Ri,
+  WebPushVapidPublicKeyParamsSchema as Rr,
+  TalkSessionCreateResultSchema as Sa,
+  ExecApprovalGetParamsSchema as Si,
+  AGENT_INTERNAL_EVENT_TYPE_TASK_COMPLETION as So,
+  SessionsCreateParamsSchema as Sr,
+  TalkSessionOkResultSchema as Ta,
+  ExecApprovalsGetParamsSchema as Ti,
+  SessionsListParamsSchema as Tr,
+  AgentsFilesGetParamsSchema as Ua,
+  CronUpdateParamsSchema as Ui,
+  NodeInvokeParamsSchema as Ur,
+  CronRunsParamsSchema as Vi,
+  PluginsUiDescriptorsParamsSchema as Vr,
+  ConfigApplyParamsSchema as Wi,
+  NodeListParamsSchema as Wr,
+  NodePairVerifyParamsSchema as Xr,
+  validateEventFrame as Y,
+  AgentsListParamsSchema as Ya,
+  ConfigSchemaParamsSchema as Yi,
+  NodePairRequestParamsSchema as Yr,
+  AgentsUpdateParamsSchema as Za,
+  ConfigSetParamsSchema as Zi,
+  NodePendingAckParamsSchema as Zr,
+  TalkSessionAppendAudioParamsSchema as _a,
+  MessageActionParamsSchema as _o,
+  SessionsCompactParamsSchema as _r,
+  ChannelsStatusParamsSchema as aa,
+  ChatHistoryParamsSchema as ai,
+  SkillsStatusParamsSchema as ao,
+  WizardStatusParamsSchema as ar,
+  TalkSessionCloseParamsSchema as ba,
+  SnapshotSchema as bi,
+  WakeParamsSchema as bo,
+  SessionsCompactionListParamsSchema as br,
+  TalkCatalogParamsSchema as ca,
+  LogsTailParamsSchema as ci,
+  SkillsUploadChunkParamsSchema as co,
+  TaskSummarySchema as cr,
+  TalkClientCreateResultSchema as da,
+  ErrorShapeSchema as di,
+  ToolsEffectiveParamsSchema as do,
+  TasksGetParamsSchema as dr,
+  COMMAND_DESCRIPTION_MAX_LENGTH as ea,
+  NodePendingEnqueueParamsSchema as ei,
+  SkillsDetailParamsSchema as eo,
+  WizardCancelParamsSchema as er,
+  TalkClientToolCallParamsSchema as fa,
+  EventFrameSchema as fi,
+  ToolsInvokeParamsSchema as fo,
+  TalkEventSchema as ga,
+  ResponseFrameSchema as gi,
+  AgentParamsSchema as go,
+  SessionsCleanupParamsSchema as gr,
+  TalkConfigResultSchema as ha,
+  RequestFrameSchema as hi,
+  SessionsAbortParamsSchema as hr,
+  ChannelsStartParamsSchema as ia,
+  ChatEventSchema as ii,
+  WebLoginStartParamsSchema as ja,
+  EnvironmentsStatusParamsSchema as ji,
+  SessionsSendParamsSchema as jr,
+  validateResponseFrame as jt,
+  TalkSpeakParamsSchema as ka,
+  EnvironmentsListParamsSchema as ki,
+  SessionsResetParamsSchema as kr,
+  TalkCatalogResultSchema as la,
+  SkillsUploadCommitParamsSchema as lo,
+  TasksCancelParamsSchema as lr,
+  TalkConfigParamsSchema as ma,
+  AgentIdentityParamsSchema as mo,
+  NodePresenceAlivePayloadSchema as ni,
+  SkillsInstallParamsSchema as no,
+  ChatInjectParamsSchema as oi,
+  SkillsUpdateParamsSchema as oo,
+  TalkClientToolCallResultSchema as pa,
+  TasksListParamsSchema as pr,
+  AgentsFilesSetParamsSchema as qa,
+  ConfigSchemaLookupParamsSchema as qi,
+  NodePairRejectParamsSchema as qr,
+  ChannelsLogoutParamsSchema as ra,
+  NodePresenceAliveReasonSchema as ri,
+  SkillsSearchParamsSchema as ro,
+  WizardStartParamsSchema as rr,
+  ChannelsStopParamsSchema as sa,
+  ChatSendParamsSchema as si,
+  SkillsUploadBeginParamsSchema as so,
+  WizardStepSchema as sr,
+  CommandsListParamsSchema as ta,
+  WizardNextParamsSchema as tr,
+  TalkClientCreateParamsSchema as ua,
+  ConnectParamsSchema as ui,
+  ToolsCatalogParamsSchema as uo,
+  TalkSessionCancelOutputParamsSchema as va,
+  PollParamsSchema as vo,
+  SessionsCompactionBranchParamsSchema as vr,
+  TalkSessionJoinResultSchema as wa,
+  ExecApprovalResolveParamsSchema as wi,
+  SessionsDescribeParamsSchema as wr,
+  TalkSessionCreateParamsSchema as xa,
+  StateVersionSchema as xi,
+  SessionsCompactionRestoreParamsSchema as xr,
+  TalkSessionCancelTurnParamsSchema as ya,
+  PresenceEntrySchema as yi,
+  SendParamsSchema as yo,
+  SessionsCompactionGetParamsSchema as yr,
+  CronRemoveParamsSchema as zi,
+  PluginsSessionActionParamsSchema as zr
+};