@nekro-nxt/contracts 0.4.0 → 0.6.0

package/src/host-api.ts

@@ -1,10 +1,44 @@
+import { CommandCatalogEntrySchema, CommandExecutionRecordSchema, CommandPolicySchema } from './commands.js'
 import { z } from 'zod'
+import {
+  hostLogDebugLeaseSchema,
+  hostLogDebugRequestSchema,
+  hostLogEntrySchema,
+  hostLogPageSchema,
+  hostLogSettingsSchema,
+  hostLogSourceSchema,
+  hostLogStatusSchema,
+} from './logs.js'
 import { McpServerFormSchema } from './extension-capabilities.js'
+import {
+  BoundCredentialsSchema,
+  CredentialBindingsRequestSchema,
+  CreateCredentialRequestSchema,
+  CredentialsViewSchema,
+  CredentialUsesViewSchema,
+  RemoveCredentialRequestSchema,
+  RemoveCredentialResultSchema,
+  ReplaceCredentialValueRequestSchema,
+  SetModelProviderAccessRequestSchema,
+  UpdateCredentialRequestSchema,
+} from './credentials.js'
+import {
+  AddLinkedAccountRequestSchema,
+  LinkedAccountMethodSchema,
+  LinkedAccountPlatformIdSchema,
+  LinkedAccountUsesViewSchema,
+  LinkedAccountViewSchema,
+  LocalGithubLoginSchema,
+  RemoveLinkedAccountRequestSchema,
+  ReplaceLinkedAccountTokenRequestSchema,
+} from './linked-accounts.js'
 import { HostUpgradeSummarySchema, RuntimeCompatibilityDiagnosticSchema } from './runtime-compatibility.js'
+import { AgentAliasesSchema, ResponseTimingSettingsSchema } from './response-timing.js'
 import {
   AgentIdSchema,
   AgentRevisionIdSchema,
   AuthoringAttemptIdSchema,
+  SubConversationIdSchema,
   AuthoringTaskIdSchema,
   AssetIdSchema,
   ChannelEventIdSchema,
@@ -12,6 +46,8 @@ import {
   ChannelIdSchema,
   ChannelMemberIdSchema,
   ConnectionIdSchema,
+  CredentialIdSchema,
+  LinkedAccountIdSchema,
   ConnectionEventIdSchema,
   DshPluginEntryIdSchema,
   DshPluginPackageIdSchema,
@@ -34,13 +70,13 @@ import {
   CommunityExtensionDetailSchema,
   CommunityExtensionSummarySchema,
   CommunityExtensionSortSchema,
+  CommunityFreshnessSchema,
   CommunityListingInputSchema,
   CommunityReleaseIdSchema,
   CommunityReviewStatusSchema,
   CommunityStatusSchema,
-  CommunitySourceSchema,
   CommunityEndpointSchema,
-  CommunityInstalledSchema,
+  CommunitySyncSchema,
   CommunityMyExtensionSchema,
   CommunityReviewReportSchema,
 } from './community.js'
@@ -101,6 +137,9 @@ const DynamicAttemptErrorSchema = z
     phase: z.enum(['approval', 'host-load', 'host-apply', 'client-load', 'client-apply', 'client-render']),
     message: z.string(),
     stack: z.string().optional(),
+    /** A render failure also names the contribution slot that failed and whether its frame gave up. */
+    slot: NonEmptyStringSchema.optional(),
+    abdicated: z.boolean().optional(),
     pluginId: DynamicIdSchema,
     packageId: DynamicIdSchema,
     pluginRunId: DynamicIdSchema,
@@ -131,6 +170,7 @@ const AuthoringTaskStatusSchema = z.enum([
   'interrupted',
   'stopped',
   'completed',
+  'paused',
 ])
 
 const AuthoringAttemptStateSchema = z.enum([
@@ -175,6 +215,8 @@ const AuthoringAttemptSummarySchema = z
       })
       .strict()
       .optional(),
+    /** Verified without loading its interface, because no browser was available; the interface itself is unchecked. */
+    uiUnverified: z.boolean().optional(),
     createdAt: z.number().int().nonnegative(),
     settledAt: z.number().int().nonnegative().optional(),
   })
@@ -189,6 +231,15 @@ const AuthoringTaskSummarySchema = z
     title: z.string(),
     requirementSummary: z.string(),
     status: AuthoringTaskStatusSchema,
+    /** `create` builds a new extension; `revise` changes `targetExtensionId` starting from `baseRevisionId`. */
+    kind: z.enum(['create', 'revise']).default('create'),
+    targetExtensionId: ExtensionIdSchema.optional(),
+    baseRevisionId: ExtensionRevisionIdSchema.optional(),
+    referenceRevisionId: ExtensionRevisionIdSchema.optional(),
+    /** Why the task is paused; it continues when the agent picks it up in a later conversation. */
+    pausedReason: z.string().optional(),
+    /** The conversation the task runs in is live, so its candidate can be previewed directly. */
+    live: z.boolean().default(false),
     approvalPolicy: z.enum(['risk-stable', 'fully-automatic']),
     approvedRiskDigest: z
       .string()
@@ -282,6 +333,23 @@ export const ImageUnderstandingPolicyApiSchema = z
   })
   .strict()
 
+export const CommandAccountUsageSchema = z.enum(['read', 'issues', 'pull-requests', 'push'])
+/** What the user wants a granted account used for; told to the agent only. */
+export type CommandAccountUsage = z.output<typeof CommandAccountUsageSchema>
+
+/**
+ * One linked account the agent's commands act as, at most one per platform (`service`). Grants saved before linked
+ * accounts name the account without its `acc_` prefix; both forms resolve to the same account.
+ */
+const CommandAccountGrantSchema = z
+  .object({
+    service: LinkedAccountPlatformIdSchema,
+    accountId: NonEmptyStringSchema.max(72),
+    /** Told to the agent as guidance, not enforced; empty gives no hint. */
+    usage: z.array(CommandAccountUsageSchema).max(4).default([]),
+  })
+  .strict()
+
 const AgentCapabilitiesSchema = z
   .object({
     subagents: z.boolean(),
@@ -296,12 +364,33 @@ const AgentCapabilitiesSchema = z
     codeRun: z.boolean().default(false),
     /** Network for commands; absent in older clients means on. */
     commandNetwork: z.boolean().default(true),
+    communityFeedbackAuto: z.boolean().default(false),
+    /** Linked accounts this agent's commands act as, one per platform; absent in older clients means none. */
+    commandAccounts: z.array(CommandAccountGrantSchema).max(8).default([]),
+    /**
+     * What the agent may do with extensions without the console: `manual` only develops and test-runs, `confirm` asks
+     * an administrator in the channel for every step, `autonomous` takes ordinary steps that only affect itself.
+     */
+    extensionAutonomy: z.enum(['manual', 'confirm', 'autonomous']).default('manual'),
+    /** Whose requests make the agent develop or change extensions: anyone in the channel, or administrators only. */
+    extensionRequesters: z.enum(['everyone', 'admins']).default('everyone'),
+    /**
+     * Whose requests make the agent change extension configuration. With `everyone`, members may only have it change
+     * ordinary fields of its own configuration; network fields, the host layer and credentials still need an
+     * administrator.
+     */
+    extensionConfigRequesters: z.enum(['everyone', 'admins']).default('admins'),
   })
   .strict()
 
 export const DynamicClientApprovalPolicySchema = z.enum(['manual', 'automatic'])
 
-export const NotificationEventKeySchema = z.enum(['dynamic-client-approval-requested'])
+export const NotificationEventKeySchema = z.enum([
+  'dynamic-client-approval-requested',
+  'community-feedback-update',
+  'credential-requested',
+  'extension-notification',
+])
 export type NotificationEventKey = z.output<typeof NotificationEventKeySchema>
 
 export const NotificationSettingsViewSchema = z
@@ -315,7 +404,14 @@ export const NotificationSettingsViewSchema = z
         deviceKeyConfigured: z.boolean(),
       })
       .strict(),
-    events: z.record(NotificationEventKeySchema, z.boolean()),
+    events: z
+      .object({
+        'dynamic-client-approval-requested': z.boolean(),
+        'community-feedback-update': z.boolean().default(true),
+        'credential-requested': z.boolean().default(true),
+        'extension-notification': z.boolean().default(true),
+      })
+      .strict(),
   })
   .strict()
 
@@ -331,7 +427,14 @@ export const UpdateNotificationSettingsRequestSchema = z
         clearDeviceKey: z.boolean().optional(),
       })
       .strict(),
-    events: z.record(NotificationEventKeySchema, z.boolean()),
+    events: z
+      .object({
+        'dynamic-client-approval-requested': z.boolean(),
+        'community-feedback-update': z.boolean().optional(),
+        'credential-requested': z.boolean().optional(),
+        'extension-notification': z.boolean().optional(),
+      })
+      .strict(),
   })
   .strict()
   .refine((value) => !(value.bark.deviceKey !== undefined && value.bark.clearDeviceKey === true), {
@@ -350,6 +453,122 @@ export const ClientNotificationFeedResponseSchema = z
   })
   .strict()
 
+/** Which model writes one kind of compaction summary: that kind's default, or a model chosen for this agent. */
+export const AgentCompactionModelChoiceSchema = z.discriminatedUnion('mode', [
+  z.object({ mode: z.literal('follow') }).strict(),
+  z.object({ mode: z.literal('custom'), model: AgentModelSchema }).strict(),
+])
+
+/**
+ * In-session compaction follows the main model by default, so the replayed conversation hits the provider's cache;
+ * compaction into a new session follows the host's compaction model.
+ */
+export const AgentCompactionPolicySchema = z
+  .object({ inSession: AgentCompactionModelChoiceSchema, newSession: AgentCompactionModelChoiceSchema })
+  .strict()
+
+/** The host's idle compaction threshold, summary model and wait limit. */
+export const CompactionSettingsSchema = z
+  .object({
+    /** Minimum context occupancy for idle rollover; older settings inherit 50%. */
+    idleThresholdPercent: z.number().int().min(1).max(100).default(50),
+    newSessionModel: z.discriminatedUnion('mode', [
+      z.object({ mode: z.literal('main') }).strict(),
+      z.object({ mode: z.literal('custom'), model: AgentModelSchema }).strict(),
+    ]),
+    /** Past this the new session starts with a fallback note instead of a summary. */
+    timeoutSeconds: z.number().int().min(30).max(900),
+  })
+  .strict()
+
+export type CompactionSettings = z.output<typeof CompactionSettingsSchema>
+
+export const DEFAULT_COMPACTION_SETTINGS: CompactionSettings = {
+  idleThresholdPercent: 50,
+  newSessionModel: { mode: 'main' },
+  timeoutSeconds: 180,
+}
+
+export const FALLBACK_MODEL_LIMIT = 3
+
+/**
+ * Models an agent switches to, in order, when its main model has used up its quota or stays unavailable after the
+ * usual retries. Empty leaves the main model alone, as before fallback models existed.
+ */
+export const AgentFallbackModelsSchema = z
+  .array(AgentModelSchema)
+  .max(FALLBACK_MODEL_LIMIT)
+  .refine(
+    (models) => new Set(models.map((model) => `${model.provider}\0${model.model}`)).size === models.length,
+    '备用模型不能重复。',
+  )
+
+/** Why a channel conversation left its main model. */
+export const ModelFallbackReasonSchema = z.enum(['quota', 'rate-limit', 'unavailable'])
+export type ModelFallbackReason = z.output<typeof ModelFallbackReasonSchema>
+
+/** How long a model that failed is passed over before conversations try it again. */
+export const ModelFallbackSettingsSchema = z
+  .object({
+    /** After rate limits, server errors, timeouts or empty replies that outlasted the usual retries. */
+    unavailableCooldownMinutes: z.number().int().min(1).max(240),
+    /** After the quota or balance ran out. */
+    quotaCooldownMinutes: z.number().int().min(5).max(1440),
+  })
+  .strict()
+
+export type ModelFallbackSettings = z.output<typeof ModelFallbackSettingsSchema>
+
+export const DEFAULT_MODEL_FALLBACK_SETTINGS: ModelFallbackSettings = {
+  unavailableCooldownMinutes: 10,
+  quotaCooldownMinutes: 60,
+}
+
+/** The name an agent passes to open a sub-conversation on its main model; no candidate may take it. */
+export const SUB_CONVERSATION_MAIN_MODEL = '主模型'
+
+export const SUB_CONVERSATION_MODEL_LIMITS = { candidates: 8, name: 20, guidance: 200 } as const
+
+/**
+ * Models an agent may open sub-conversations with, each named so the agent can pick it and described so it knows
+ * when to. Without a `default`, a sub-conversation opened without naming a model follows the main model.
+ */
+export const AgentSubConversationModelsSchema = z
+  .object({
+    candidates: z
+      .array(
+        z
+          .object({
+            // Names are listed to the agent separated by commas, so they carry none and no line breaks.
+            name: z
+              .string()
+              .trim()
+              .min(1, '请填写子对话模型的名称。')
+              .max(SUB_CONVERSATION_MODEL_LIMITS.name)
+              .regex(/^[^\s,，、]+(?: [^\s,，、]+)*$/u, '子对话模型的名称不能含换行、逗号或顿号。')
+              .refine((name) => name !== SUB_CONVERSATION_MAIN_MODEL, `「${SUB_CONVERSATION_MAIN_MODEL}」是保留名称。`),
+            model: AgentModelSchema,
+            guidance: z.string().trim().max(SUB_CONVERSATION_MODEL_LIMITS.guidance),
+          })
+          .strict(),
+      )
+      .max(SUB_CONVERSATION_MODEL_LIMITS.candidates),
+    default: z.string().trim().min(1).optional(),
+  })
+  .strict()
+  .superRefine((policy, context) => {
+    const names = policy.candidates.map((candidate) => candidate.name)
+    if (new Set(names).size !== names.length)
+      context.addIssue({ code: 'custom', message: '子对话模型的名称不能重复。' })
+    if (policy.default !== undefined && !names.includes(policy.default)) {
+      context.addIssue({ code: 'custom', message: '默认的子对话模型不在候选里。' })
+    }
+  })
+
+export type AgentSubConversationModels = z.output<typeof AgentSubConversationModelsSchema>
+
+export const NO_SUB_CONVERSATION_MODELS: AgentSubConversationModels = { candidates: [] }
+
 const AgentRevisionRequestContentSchema = z
   .object({
     displayName: z.string().trim().min(1).max(80),
@@ -361,6 +580,10 @@ const AgentRevisionRequestContentSchema = z
     model: AgentModelSchema,
     imagePolicy: ImageUnderstandingPolicyApiSchema.optional(),
     dynamicClientApprovalPolicy: DynamicClientApprovalPolicySchema.optional(),
+    compaction: AgentCompactionPolicySchema.optional(),
+    subConversationModels: AgentSubConversationModelsSchema.optional(),
+    fallbackModels: AgentFallbackModelsSchema.optional(),
+    aliases: AgentAliasesSchema.optional(),
   })
   .strict()
 
@@ -390,18 +613,23 @@ const ReviseAgentRequestSchema = AgentRevisionRequestContentSchema.extend({
   validatePersonaDocumentProjection(value, context)
 })
 
-// The defaults that fill `scheduledTasks`, `codeRun` and `commandNetwork` for older clients must not reset them in a
-// partial update.
+// Defaults that fill capabilities for older clients must not
+// reset them in a partial update.
 const UpdateAgentCapabilitiesRequestSchema = AgentCapabilitiesSchema.partial()
   .extend({
     scheduledTasks: z.boolean().optional(),
     codeRun: z.boolean().optional(),
     commandNetwork: z.boolean().optional(),
+    communityFeedbackAuto: z.boolean().optional(),
+    commandAccounts: z.array(CommandAccountGrantSchema).max(8).optional(),
+    extensionAutonomy: z.enum(['manual', 'confirm', 'autonomous']).optional(),
+    extensionRequesters: z.enum(['everyone', 'admins']).optional(),
+    extensionConfigRequesters: z.enum(['everyone', 'admins']).optional(),
   })
   .strict()
   .refine((value) => Object.values(value).some((entry) => entry !== undefined), '至少提供一个能力。')
 
-const TriggerPolicySchema = z.enum(['always', 'mentioned-or-replied', 'command', 'observe-only'])
+const TriggerPolicySchema = z.enum(['always', 'mentioned-or-replied', 'smart', 'command', 'observe-only'])
 
 export const WorkTreeOrderSchema = z
   .object({
@@ -413,12 +641,35 @@ export const WorkTreeOrderSchema = z
 
 export type WorkTreeOrder = z.output<typeof WorkTreeOrderSchema>
 
+/** The group key of 「未接线」 in `collapsedGroupIds`; agent groups use the agent id. */
+export const UNBOUND_CHANNEL_GROUP_ID = 'unbound'
+
+/**
+ * How the console arranges its channel list: pinned channels in their order and the groups it has collapsed. Shared
+ * by every device signed in to the console; it never changes bindings.
+ */
+export const ChannelListViewSchema = z
+  .object({
+    pinnedChannelIds: z.array(ChannelIdSchema).max(200),
+    collapsedGroupIds: z.array(z.union([AgentIdSchema, z.literal(UNBOUND_CHANNEL_GROUP_ID)])).max(500),
+  })
+  .strict()
+
+export type ChannelListView = z.output<typeof ChannelListViewSchema>
+
 const SnapshotMessagePartSchema = z.discriminatedUnion('type', [
   z.object({ type: z.literal('text'), text: z.string() }).strict(),
   z
     .object({ type: z.literal('mention'), memberId: ChannelMemberIdSchema, displayName: z.string().optional() })
     .strict(),
-  z.object({ type: z.literal('image'), assetId: AssetIdSchema, alt: z.string().optional() }).strict(),
+  z
+    .object({
+      type: z.literal('image'),
+      assetId: AssetIdSchema,
+      alt: z.string().optional(),
+      sticker: z.literal(true).optional(),
+    })
+    .strict(),
   z.object({ type: z.literal('file'), assetId: AssetIdSchema, name: z.string().optional() }).strict(),
   z.object({ type: z.literal('audio'), assetId: AssetIdSchema }).strict(),
   z.object({ type: z.literal('quote'), messageId: LogicalMessageIdSchema }).strict(),
@@ -465,7 +716,10 @@ export const HostSnapshotMessageSchema = z
       })
       .strict()
       .optional(),
-    origin: z.enum(['admin-console']).optional(),
+    origin: z.enum(['admin-console', 'command', 'extension-notice']).optional(),
+    command: CommandExecutionRecordSchema.optional(),
+    /** A host notice about extension work: a request an administrator must confirm, or what an action did. */
+    extensionNotice: z.object({ requestNumber: z.number().int().positive().optional() }).strict().optional(),
     /** What the agent's inbound hooks decided for this message, when anything differs from the default. */
     inboundHook: z
       .object({
@@ -477,11 +731,29 @@ export const HostSnapshotMessageSchema = z
       })
       .strict()
       .optional(),
+    /** Extensions that processed the agent's message before it was sent; `followUp` marks a message one appended. */
+    outboundProcessing: z
+      .object({
+        extensions: z.array(z.string()),
+        rewritten: z.boolean(),
+        followUp: z.literal(true).optional(),
+      })
+      .strict()
+      .optional(),
     /** A scheduled task came due: a Host fact shown as a notice, not a member message. */
     scheduledTask: z
       .object({ label: z.string(), extensionName: z.string().optional(), note: z.string().optional() })
       .strict()
       .optional(),
+    /** The agent finished waiting for someone to finish speaking: a Host fact shown as a notice. */
+    responseWait: z
+      .object({
+        displayName: z.string().optional(),
+        cause: z.enum(['quiet', 'limit']),
+        waitedSeconds: z.number().int().nonnegative(),
+      })
+      .strict()
+      .optional(),
   })
   .strict()
 
@@ -535,6 +807,8 @@ export const PlatformUserListResponseSchema = z
           activeChannelCount: z.number().int().nonnegative(),
           channelPreview: z.array(PlatformUserChannelPreviewSchema).max(3),
           historicalOnly: z.boolean(),
+          /** Listed in Settings → Administrators. */
+          administrator: z.boolean().default(false),
         })
         .strict(),
     ),
@@ -566,7 +840,14 @@ export const ChannelFactSseDataSchema = z
   })
   .strict()
 
-export const ChannelRuntimePhaseSchema = z.enum(['idle', 'thinking', 'using-tool', 'waiting-input', 'unavailable'])
+export const ChannelRuntimePhaseSchema = z.enum([
+  'idle',
+  'thinking',
+  'using-tool',
+  'compacting',
+  'waiting-input',
+  'unavailable',
+])
 
 export const ChannelRuntimeUsageSchema = z
   .object({
@@ -587,7 +868,8 @@ const channelRuntimeToolFields = {
   inputPreview: z.string().optional(),
   resultPreview: z.string().optional(),
   wroteToChannel: z.boolean().optional(),
-  deliveryState: z.enum(['sent', 'partially-sent', 'failed', 'unknown']).optional(),
+  /** `cancelled`: an extension stopped the message before it was sent. */
+  deliveryState: z.enum(['sent', 'partially-sent', 'failed', 'unknown', 'cancelled']).optional(),
   durationMs: z.number().int().nonnegative().optional(),
 }
 
@@ -796,6 +1078,21 @@ export const ChannelRuntimeProjectionSchema = z
     episodeId: EpisodeIdSchema.optional(),
     phase: ChannelRuntimePhaseSchema,
     summary: z.string(),
+    /** A compaction under way: inside the current session, or before a new session opens. */
+    compaction: z
+      .object({ kind: z.enum(['in-session', 'new-session']), startedAt: z.number().int().nonnegative() })
+      .strict()
+      .optional(),
+    /** The conversation runs on a fallback model; it tries the main model again at a new message after `retryMainAt`. */
+    modelFallback: z
+      .object({
+        model: AgentModelSchema,
+        reason: ModelFallbackReasonSchema,
+        since: z.number().int().nonnegative(),
+        retryMainAt: z.number().int().nonnegative(),
+      })
+      .strict()
+      .optional(),
     pendingInjectCount: z.number().int().nonnegative(),
     occupancy: ChannelRuntimeOccupancySchema.optional(),
     cache: ChannelRuntimeCacheSchema.optional(),
@@ -945,6 +1242,42 @@ export const DEFAULT_MESSAGE_PACING: MessagePacing = 'normal'
 
 export const MessagePacingSettingsSchema = z.object({ pacing: MessagePacingSchema }).strict()
 
+/**
+ * A conversation of its own under a channel's conversation (docs/NekroNxt界面交互模型.md §5.6): the agent opens one
+ * for a separate piece of work, and the host opens scripted ones to check creation candidates. It has its own log
+ * and context, and is shown under its channel.
+ */
+export const SubConversationSchema = z
+  .object({
+    id: SubConversationIdSchema,
+    channelId: ChannelIdSchema,
+    episodeId: EpisodeIdSchema,
+    agentId: AgentIdSchema,
+    title: z.string().min(1).max(200),
+    /** `agent`: the agent opened it with a tool; `host`: NekroNXT opened it, such as to check a candidate. */
+    openedBy: z.enum(['agent', 'host']),
+    /** `model`: the agent's model talks in it; `script`: the host plays fixed tool calls. */
+    driver: z.enum(['model', 'script']),
+    status: z.enum(['open', 'closed']),
+    closeReason: z.enum(['completed', 'closed-by-agent', 'closed-by-admin', 'failed', 'conversation-ended']).optional(),
+    /** What it handed back to the channel's conversation when it ended. */
+    summary: z.string().max(4000).optional(),
+    authoringTaskId: AuthoringTaskIdSchema.optional(),
+    /** The model a model-driven sub-conversation talks in; absent for scripts and ones opened before it was kept. */
+    model: AgentModelSchema.optional(),
+    createdAt: z.number().int().nonnegative(),
+    closedAt: z.number().int().nonnegative().optional(),
+  })
+  .strict()
+
+export type SubConversation = z.output<typeof SubConversationSchema>
+
+/** How long ended sub-conversations are kept before they are cleaned up. */
+export const SubConversationRetentionSchema = z.enum(['1d', '3d', '7d', '30d', 'never'])
+export type SubConversationRetention = z.output<typeof SubConversationRetentionSchema>
+export const DEFAULT_SUB_CONVERSATION_RETENTION: SubConversationRetention = '7d'
+export const SubConversationSettingsSchema = z.object({ retention: SubConversationRetentionSchema }).strict()
+
 /** `keyword`: SQLite keyword search only; `builtin`: keywords fused with the built-in semantic model. */
 export const RetrievalModeSchema = z.enum(['keyword', 'builtin'])
 export type RetrievalMode = z.output<typeof RetrievalModeSchema>
@@ -985,6 +1318,23 @@ export const RetrievalStatusSchema = z
   .strict()
 export type RetrievalStatus = z.output<typeof RetrievalStatusSchema>
 
+/** Where the Host keeps restore points it takes before an upgrade, or none. */
+export const UpgradeBackupModeSchema = z.enum(['data', 'directory', 'off'])
+export const UpgradeBackupSettingsSchema = z
+  .object({
+    mode: UpgradeBackupModeSchema,
+    /** The chosen directory when `mode` is `directory`. */
+    directory: z.string().nullable(),
+    /** Set through the server's environment; the settings page cannot change it. */
+    locked: z.boolean(),
+    /** Restore points kept; older ones are removed after an upgrade succeeds. */
+    keep: z.number().int().positive(),
+    /** Restore points currently in the chosen place. */
+    usage: z.object({ count: z.number().int().nonnegative(), bytes: z.number().int().nonnegative() }).strict(),
+  })
+  .strict()
+export type UpgradeBackupSettings = z.output<typeof UpgradeBackupSettingsSchema>
+
 /** What the agent keeps about individual members of one channel; each note comes with that member's messages. */
 export const ChannelMemberNotesViewSchema = z
   .object({
@@ -1145,11 +1495,23 @@ export const AttentionItemSchema = z
       'connection-unhealthy',
       'agent-model-unavailable',
       'agent-vision-unavailable',
+      'logs-unavailable',
+      'community-feedback',
+      'extension-update',
     ]),
     severity: z.enum(['critical', 'warning', 'info']),
     subject: z
       .object({
-        kind: z.enum(['outbound', 'channel', 'authoring-task', 'connection', 'agent']),
+        kind: z.enum([
+          'outbound',
+          'channel',
+          'authoring-task',
+          'connection',
+          'agent',
+          'logs',
+          'community-feedback',
+          'extension-update',
+        ]),
         id: NonEmptyStringSchema,
       })
       .strict(),
@@ -1166,7 +1528,16 @@ export const AttentionItemSchema = z
     detail: z.string().max(400),
     action: z
       .object({
-        kind: z.enum(['open-channel', 'resolve-delivery', 'open-authoring-task', 'open-connection', 'open-agent']),
+        kind: z.enum([
+          'open-channel',
+          'resolve-delivery',
+          'open-authoring-task',
+          'open-connection',
+          'open-agent',
+          'open-logs',
+          'open-community-feedback',
+          'open-extension-updates',
+        ]),
         label: z.string().min(1).max(40),
       })
       .strict(),
@@ -1311,8 +1682,73 @@ export const CodeRunAvailabilitySchema = z
 
 export type CodeRunAvailability = z.output<typeof CodeRunAvailabilitySchema>
 
+/** The GitHub CLI commands call: found on this machine, or downloaded by NekroNXT where it can. */
+export const GithubCliAvailabilitySchema = CodeRunAvailabilitySchema
+export type GithubCliAvailability = z.output<typeof GithubCliAvailabilitySchema>
+
+/** The optional headless Chromium that loads and checks creation candidates when no page is open. */
+export const VerificationBrowserAvailabilitySchema = CodeRunAvailabilitySchema
+export type VerificationBrowserAvailability = z.output<typeof VerificationBrowserAvailabilitySchema>
+
+/** A platform's own program that linked accounts work through, such as the GitHub CLI. */
+export const LinkedAccountPlatformToolSchema = z
+  .object({
+    /** The runtime download routes it is managed by (`downloadGithubCli`, `removeGithubCli`). */
+    id: z.enum(['github-cli']),
+    name: z.string(),
+    availability: GithubCliAvailabilitySchema,
+  })
+  .strict()
+
+/** 设置 → 关联账号: every platform the host supports, with its accounts and tools. */
+export const LinkedAccountsViewSchema = z
+  .object({
+    platforms: z.array(
+      z
+        .object({
+          id: LinkedAccountPlatformIdSchema,
+          name: z.string(),
+          addMethods: z.array(LinkedAccountMethodSchema),
+          tool: LinkedAccountPlatformToolSchema.optional(),
+          accounts: z.array(LinkedAccountViewSchema),
+        })
+        .strict(),
+    ),
+    /** Logins found in the local GitHub CLI; empty when it is missing or not logged in. */
+    localGithubLogins: z.array(LocalGithubLoginSchema),
+  })
+  .strict()
+export type LinkedAccountsView = z.output<typeof LinkedAccountsViewSchema>
+
+export const RemoveLinkedAccountResultSchema = z.discriminatedUnion('removed', [
+  z.object({ removed: z.literal(true), view: LinkedAccountsViewSchema }).strict(),
+  z.object({ removed: z.literal(false), grantedAgentIds: z.array(AgentIdSchema) }).strict(),
+])
+export type RemoveLinkedAccountResult = z.output<typeof RemoveLinkedAccountResultSchema>
+
+/** An extension action an agent asked an administrator to confirm, or one it took on its own. */
+export const ExtensionRequestSchema = z
+  .object({
+    number: z.number().int().positive(),
+    kind: z.string(),
+    agentId: AgentIdSchema,
+    channelId: ChannelIdSchema.nullable(),
+    extensionId: ExtensionIdSchema.nullable(),
+    summary: z.string(),
+    status: z.enum(['pending', 'approved', 'rejected', 'expired', 'completed', 'failed']),
+    autonomous: z.boolean(),
+    resultMessage: z.string().nullable(),
+    decidedBy: z.string().nullable(),
+    createdAt: z.number().int().nonnegative(),
+    expiresAt: z.number().int().nonnegative(),
+    decidedAt: z.number().int().nonnegative().nullable(),
+  })
+  .strict()
+export type ExtensionRequestView = z.output<typeof ExtensionRequestSchema>
+
 export const HostSnapshotSchema = z
   .object({
+    communityFeedback: CommunityFeedbackSnapshotSchema.optional(),
     upgrade: HostUpgradeSummarySchema.optional(),
     cursor: HostSyncCursorSchema,
     diagnosticsSampledAt: z.number().int().nonnegative(),
@@ -1337,6 +1773,14 @@ export const HostSnapshotSchema = z
           name: z.string(),
           description: z.string().optional(),
           inputModalities: z.array(z.string()).optional(),
+          /** Selectable thinking levels, least to most; absent when the model offers no choice. */
+          reasoning: z
+            .object({
+              efforts: z.array(z.object({ id: NonEmptyStringSchema, name: z.string() }).strict()).min(1),
+              defaultEffort: NonEmptyStringSchema.optional(),
+            })
+            .strict()
+            .optional(),
         })
         .strict(),
     ),
@@ -1345,10 +1789,15 @@ export const HostSnapshotSchema = z
         subagents: z.object({ available: z.boolean() }).strict(),
         /** Optional in older hosts, which never offer `run_code`. */
         codeRun: CodeRunAvailabilitySchema.optional(),
+        /** Optional in older hosts, which never offer command accounts. */
+        githubCli: GithubCliAvailabilitySchema.optional(),
+        /** Optional in older hosts, which check candidates only in an open page. */
+        verificationBrowser: VerificationBrowserAvailabilitySchema.optional(),
         /** What this host can confine for commands beyond file writes; optional in older hosts. */
         commandConfinement: z.object({ readScope: z.boolean(), networkControl: z.boolean() }).strict().optional(),
         webSearch: z
           .object({
+            unavailableReason: z.string().optional(),
             provider: z.literal('deepseek-official'),
             available: z.boolean(),
             credentialConfigured: z.boolean(),
@@ -1373,6 +1822,19 @@ export const HostSnapshotSchema = z
           capabilities: AgentCapabilitiesSchema,
           imagePolicy: ImageUnderstandingPolicyApiSchema,
           dynamicClientApprovalPolicy: DynamicClientApprovalPolicySchema,
+          /** Optional for older hosts, whose agents always follow both defaults. */
+          compaction: AgentCompactionPolicySchema.optional(),
+          /** Optional for older hosts, whose agents offer no candidates. */
+          subConversationModels: AgentSubConversationModelsSchema.optional(),
+          /** Optional for older hosts, whose agents have no fallback models. */
+          fallbackModels: AgentFallbackModelsSchema.optional(),
+          /** Optional for older hosts, whose agents have no aliases. */
+          aliases: AgentAliasesSchema.optional(),
+          /**
+           * Enabled extensions that process the agent's messages before they are sent, in the order they run. Absent
+           * when none does.
+           */
+          outboundOrder: z.array(ExtensionIdSchema).optional(),
           imageDiagnostics: z
             .object({
               route: z
@@ -1427,6 +1889,8 @@ export const HostSnapshotSchema = z
           platformChannelId: NonEmptyStringSchema,
           kind: z.enum(['internal', 'group', 'direct']),
           displayName: z.string().optional(),
+          localDisplayName: z.string().optional(),
+          platformDisplayName: z.string().optional(),
           boundAgentId: AgentIdSchema.optional(),
           runtimePhase: ChannelRuntimePhaseSchema.default('idle'),
           activity: ChannelActivitySummarySchema.default({ unreadCount: 0, unreadCapped: false }),
@@ -1438,10 +1902,14 @@ export const HostSnapshotSchema = z
                 channelId: ChannelIdSchema,
                 agentId: AgentIdSchema,
                 triggerPolicy: TriggerPolicySchema,
+                /** Channel pause, independent of the response rule. */
+                paused: z.boolean().default(false),
                 processingFeedback: z.enum(['auto', 'off']).default('auto'),
                 /** Absent means `observe`. */
                 localAgentMessages: z.enum(['observe', 'trigger']).optional(),
                 activityTriggerOverrides: ActivityTriggerOverridesSchema.default({}),
+                /** Absent on older hosts; missing keys use the defaults. */
+                responseTiming: ResponseTimingSettingsSchema.optional(),
                 boundAt: z.number().int().safe().nonnegative(),
               })
               .strict(),
@@ -1454,6 +1922,7 @@ export const HostSnapshotSchema = z
       channelIdsByAgent: {},
       unboundChannelIds: [],
     }),
+    channelListView: ChannelListViewSchema.default({ pinnedChannelIds: [], collapsedGroupIds: [] }),
     messages: z.array(HostSnapshotMessageSchema),
     connections: z.array(
       z
@@ -1462,6 +1931,8 @@ export const HostSnapshotSchema = z
           adapterKey: NonEmptyStringSchema,
           alias: ConnectionAliasOutputSchema.optional(),
           activityTriggerDefaults: z.array(AdapterActivityKeySchema).default([]),
+          configuredSecrets: z.array(z.string()).optional(),
+          boundCredentials: BoundCredentialsSchema.optional(),
           status: z
             .object({
               state: z.enum(['stopped', 'connecting', 'connected', 'reconnecting', 'failed']),
@@ -1526,11 +1997,50 @@ export const HostSnapshotSchema = z
           displayName: z.string(),
           description: z.string(),
           createdByAgentId: AgentIdSchema.optional(),
+          /** The Revision of another extension this one was branched from. */
+          branchOf: z
+            .object({
+              extensionId: ExtensionIdSchema,
+              revisionId: ExtensionRevisionIdSchema,
+              /** Present while the original is on this machine. */
+              displayName: z.string().optional(),
+            })
+            .strict()
+            .optional(),
+          /** Shape version of the data stored on this machine. */
+          dataVersion: z.number().int().positive().default(1),
+          /** The unfinished revise task of this extension, if any. */
+          openRevisionTaskId: AuthoringTaskIdSchema.optional(),
+          /** Whether this machine publishes (`owner`) or follows the line on each community. */
+          communityLinks: z
+            .array(z.object({ communityUrl: z.string(), role: z.enum(['owner', 'subscriber']) }).strict())
+            .default([]),
           revisions: z.array(
             z
               .object({
                 id: ExtensionRevisionIdSchema,
                 revisionNumber: z.number().int().positive(),
+                /** Version number from the lineage, `v3` (or `v3·2` for a second Revision of the same generation). */
+                versionLabel: z.string(),
+                parentRevisionId: ExtensionRevisionIdSchema.optional(),
+                origin: z.enum(['authored', 'file', 'community', 'branch']),
+                authoringTaskId: AuthoringTaskIdSchema.optional(),
+                dataVersion: z.number().int().positive(),
+                /** Community releases this Revision is; installs and publishes from here both record one. */
+                releases: z
+                  .array(
+                    z
+                      .object({
+                        communityUrl: z.string(),
+                        releaseId: CommunityReleaseIdSchema,
+                        number: z.number().int().positive().nullable(),
+                        publisherHandle: z.string(),
+                        via: z.enum(['install', 'publish']),
+                        recordedAt: z.number().int().nonnegative(),
+                      })
+                      .strict(),
+                  )
+                  .default([]),
                 format: z.enum(['current', 'unavailable']).optional(),
                 ui: ExtensionUiContributionsSchema.default(EMPTY_EXTENSION_UI_CONTRIBUTIONS),
                 /** The host instance's configuration form (`config.host`). */
@@ -1543,8 +2053,6 @@ export const HostSnapshotSchema = z
                   .regex(/^\/api\/extensions\/[^/]+\/revisions\/[^/]+\/icon\/[a-f0-9]{64}\.(?:svg|png|webp)$/u)
                   .optional(),
                 createdAt: z.number().int().safe().nonnegative(),
-                /** 从社区安装的版本的来源；本机保存与文件导入没有来源。 */
-                source: CommunitySourceSchema.optional(),
                 provides: z.array(ExtensionProvideSchema),
                 /** Whether this Revision can be enabled for agents (agent-layer contributions or capabilities). */
                 agentLayer: z.boolean(),
@@ -1597,6 +2105,7 @@ export const HostSnapshotSchema = z
                 /** Secret fields are removed; `configuredSecrets` lists those the Host stores. */
                 config: JsonValueSchema,
                 configuredSecrets: z.array(z.string()).optional(),
+                boundCredentials: BoundCredentialsSchema.optional(),
                 activatedAt: z.number().int().safe().nonnegative(),
                 runtime: z
                   .object({
@@ -1632,6 +2141,7 @@ export const HostSnapshotSchema = z
               /** Secret fields are removed; `configuredSecrets` lists those the Host stores. */
               config: JsonValueSchema.default({}),
               configuredSecrets: z.array(z.string()).optional(),
+              boundCredentials: BoundCredentialsSchema.optional(),
               runtime: z
                 .object({
                   status: z.enum(['active', 'restore-failed', 'dispose-failed']),
@@ -1712,18 +2222,36 @@ export const HostSnapshotSchema = z
         .strict(),
     ),
     authoringTasks: z.array(AuthoringTaskSummarySchema).default([]),
+    /** Open sub-conversations, and the most recently ended ones of each channel. */
+    subConversations: z.array(SubConversationSchema).default([]),
     scheduledTasks: z.array(ScheduledTaskSchema).default([]),
+    /** Extension requests waiting for an administrator. */
+    extensionRequests: z.array(ExtensionRequestSchema).default([]),
   })
   .strict()
 
+export const CHANNEL_COMPOSER_MAX_ATTACHMENTS = 20
+export const CHANNEL_COMPOSER_MAX_BYTES = 64 * 1024 * 1024
+
 const MessageInputPartSchema = z.discriminatedUnion('type', [
   z.object({ type: z.literal('text'), text: z.string().trim().min(1) }).strict(),
   z.object({ type: z.literal('mention'), memberId: ChannelMemberIdSchema }).strict(),
+  z.object({ type: z.literal('image'), assetId: AssetIdSchema, alt: z.string().trim().max(500).optional() }).strict(),
+  z.object({ type: z.literal('file'), assetId: AssetIdSchema, name: z.string().trim().max(255).optional() }).strict(),
 ])
 
 const SendChannelMessageRequestSchema = z
   .object({
-    parts: z.array(MessageInputPartSchema).min(1),
+    parts: z
+      .array(MessageInputPartSchema)
+      .min(1)
+      .max(256)
+      .refine(
+        (parts) =>
+          parts.filter((part) => part.type === 'image' || part.type === 'file').length <=
+          CHANNEL_COMPOSER_MAX_ATTACHMENTS,
+        '每条消息最多添加 20 个附件。',
+      ),
     clientEventId: NonEmptyStringSchema.optional(),
     senderMemberId: ChannelMemberIdSchema.optional(),
   })
@@ -1822,6 +2350,8 @@ export const DshPluginCatalogEntrySchema = z
     loadError: z.object({ code: NonEmptyStringSchema, message: NonEmptyStringSchema }).strict().optional(),
     packageId: DshPluginPackageIdSchema.optional(),
     installSource: z.enum(['registry', 'tarball', 'imported']).optional(),
+    /** Published by the DSH maintainers on npm for the DSH release this build runs. */
+    official: z.boolean().optional(),
     installedAt: z.number().int().safe().nonnegative().optional(),
     clientUiDetected: z.boolean().optional(),
     hostUi: DshNxtHostUiSchema.optional(),
@@ -1836,6 +2366,8 @@ export const DshPluginCatalogEntrySchema = z
             suggestedScope: z.enum(['host', 'agent']),
             selectedScope: z.enum(['host', 'agent']).optional(),
             config: JsonValueSchema,
+            /** Host services this official entry declared and received; known once it has loaded. */
+            grantedServices: z.array(NonEmptyStringSchema).optional(),
             activations: z.array(
               z
                 .object({
@@ -1845,9 +2377,13 @@ export const DshPluginCatalogEntrySchema = z
                   activatedAt: z.number().int().safe().nonnegative(),
                   diagnostic: z
                     .object({
-                      status: z.enum(['active', 'load-failed', 'restore-failed', 'dispose-failed']),
-                      phase: z.enum(['import', 'apply', 'update', 'dispose', 'restore']),
+                      status: z.enum(['active', 'pending', 'load-failed', 'restore-failed', 'dispose-failed']),
+                      phase: z.enum(['import', 'dependency', 'apply', 'update', 'dispose', 'restore']),
                       message: z.string().optional(),
+                      /** Services a pending entry still waits for. */
+                      waitingFor: z.array(NonEmptyStringSchema).optional(),
+                      /** The waited-for services this entry can never receive, since only official plugins get them. */
+                      restrictedServices: z.array(NonEmptyStringSchema).optional(),
                       observedAt: z.number().int().safe().nonnegative(),
                     })
                     .optional(),
@@ -1962,6 +2498,9 @@ export type HostSseEvent = z.output<typeof HostSseEventSchema>
 /** Request content a model accepts; `image` enables native vision for agents using the model. */
 export const LlmModelInputModalitiesSchema = z.array(z.enum(['text', 'image'])).min(1)
 
+/** Thinking levels a model offers, least to most; the ids are the adapter's own. */
+export const LlmModelReasoningEffortsSchema = z.array(NonEmptyStringSchema).min(1)
+
 export const LlmProviderModelSchema = z
   .object({
     id: NonEmptyStringSchema,
@@ -1969,6 +2508,7 @@ export const LlmProviderModelSchema = z
     contextWindow: z.number().int().positive().optional(),
     maxTokens: z.number().int().positive().optional(),
     inputModalities: LlmModelInputModalitiesSchema.optional(),
+    reasoningEfforts: LlmModelReasoningEffortsSchema.optional(),
   })
   .strict()
 
@@ -1979,6 +2519,7 @@ export const LlmDiscoveredModelSchema = z
     contextWindow: z.number().int().positive().optional(),
     maxTokens: z.number().int().positive().optional(),
     inputModalities: LlmModelInputModalitiesSchema.optional(),
+    reasoningEfforts: LlmModelReasoningEffortsSchema.optional(),
   })
   .strict()
 
@@ -2022,6 +2563,60 @@ export const LlmProviderViewSchema = z
     discoverable: z.boolean(),
     /** `null` when the current configuration was never tested; absent from hosts that do not record tests. */
     lastTest: LlmProviderTestResultSchema.nullable().optional(),
+    /** Present when the provider can sign in with a subscription account instead of an API key. */
+    subscription: z
+      .object({
+        label: NonEmptyStringSchema,
+        /** The route uses the signed-in account rather than an API key. */
+        active: z.boolean(),
+        accountLabel: z.string().nullable(),
+      })
+      .strict()
+      .optional(),
+  })
+  .strict()
+
+export const SubscriptionStatusSchema = z
+  .object({
+    provider: NonEmptyStringSchema,
+    label: NonEmptyStringSchema,
+    usageUrl: z.url(),
+    available: z.boolean(),
+    mode: z.enum(['unconfigured', 'api-key', 'subscription']),
+    activeAccountId: z.string().nullable(),
+    accounts: z.array(
+      z
+        .object({
+          id: NonEmptyStringSchema,
+          label: NonEmptyStringSchema,
+          email: z.string().nullable(),
+          createdAt: z.number().int().nonnegative(),
+        })
+        .strict(),
+    ),
+    login: z
+      .object({
+        id: NonEmptyStringSchema,
+        status: z.enum(['running', 'authorized', 'cancelled', 'failed']),
+        notices: z.array(
+          z.object({ message: z.string(), url: z.string().optional(), code: z.string().optional() }).strict(),
+        ),
+        prompt: z
+          .object({
+            id: NonEmptyStringSchema,
+            kind: z.enum(['text', 'secret', 'select']),
+            message: z.string(),
+            placeholder: z.string().optional(),
+            options: z
+              .array(z.object({ id: z.string(), label: z.string(), description: z.string().optional() }).strict())
+              .optional(),
+          })
+          .strict()
+          .nullable(),
+        error: z.string().nullable(),
+      })
+      .strict()
+      .nullable(),
   })
   .strict()
 
@@ -2126,6 +2721,8 @@ const defineContract = <
 })
 
 const agentParam = z.object({ agentId: AgentIdSchema }).strict()
+const credentialParam = z.object({ credentialId: CredentialIdSchema }).strict()
+const linkedAccountParam = z.object({ accountId: LinkedAccountIdSchema }).strict()
 const agentRevisionParam = z.object({ agentId: AgentIdSchema, revisionId: AgentRevisionIdSchema }).strict()
 
 export const AgentRevisionChangedFieldSchema = z.enum([
@@ -2135,6 +2732,10 @@ export const AgentRevisionChangedFieldSchema = z.enum([
   'capabilities',
   'imagePolicy',
   'approvalPolicy',
+  'compaction',
+  'subConversationModels',
+  'fallbackModels',
+  'aliases',
 ])
 
 export const AgentRevisionHistorySchema = z
@@ -2163,75 +2764,419 @@ const connectionParam = z.object({ connectionId: ConnectionIdSchema }).strict()
 const agentExtensionParam = z.object({ agentId: AgentIdSchema, extensionId: ExtensionIdSchema }).strict()
 
 const PermissionApprovalSchema = z.object({ permissionDigest: z.string().regex(/^[a-f0-9]{64}$/u) }).strict()
-const extensionParam = z.object({ extensionId: ExtensionIdSchema }).strict()
-const dshPluginPackageParam = z.object({ packageId: DshPluginPackageIdSchema }).strict()
-const dshPluginEntryParam = z.object({ entryId: DshPluginEntryIdSchema }).strict()
-const extensionRevisionParam = z
-  .object({ extensionId: ExtensionIdSchema, revisionId: ExtensionRevisionIdSchema })
+
+/** One version of one line in the lineage view of an extension family. */
+export const ExtensionLineageNodeSchema = z
+  .object({
+    revisionId: ExtensionRevisionIdSchema,
+    extensionId: ExtensionIdSchema,
+    label: z.string(),
+    parentRevisionId: ExtensionRevisionIdSchema.optional(),
+    origin: z.enum(['authored', 'file', 'community', 'branch']),
+    createdAt: z.number().int().nonnegative(),
+    current: z.boolean(),
+    releaseNumbers: z.array(z.number().int().positive()),
+  })
   .strict()
-const dshSettingsParam = z.object({ namespace: NonEmptyStringSchema }).strict()
-const dshCredentialParam = z.object({ ref: DshCredentialRefSchema }).strict()
-const llmProviderParam = z.object({ provider: NonEmptyStringSchema }).strict()
-const authoringTaskParam = z.object({ taskId: AuthoringTaskIdSchema }).strict()
-const scheduledTaskParam = z.object({ taskId: ScheduledTaskIdSchema }).strict()
-const authoringAttemptParam = z.object({ taskId: AuthoringTaskIdSchema, attemptId: AuthoringAttemptIdSchema }).strict()
 
-const DshPluginInstallInspectionSchema = z
+/** Every line of the family an extension belongs to: the original and every branch of a branch on this machine. */
+export const ExtensionLineageSchema = z
   .object({
-    token: NonEmptyStringSchema,
-    operationId: z.string().uuid().optional(),
-    packageName: NonEmptyStringSchema,
-    packageVersion: NonEmptyStringSchema,
-    packageDigest: z.string().regex(/^[a-f0-9]{64}$/u),
-    lockfileDigest: z.string().regex(/^[a-f0-9]{64}$/u),
-    blockedBuilds: z.array(NonEmptyStringSchema),
-    clientUiDetected: z.boolean(),
-    hostUi: DshNxtHostUiSchema.optional(),
-    entries: z.array(
+    lines: z.array(
       z
         .object({
-          entryKey: NonEmptyStringSchema,
-          moduleName: NonEmptyStringSchema,
-          suggestedScope: z.enum(['host', 'agent']),
+          extensionId: ExtensionIdSchema,
+          displayName: z.string(),
+          branchOf: z
+            .object({ extensionId: ExtensionIdSchema, revisionId: ExtensionRevisionIdSchema })
+            .strict()
+            .optional(),
+          nodes: z.array(ExtensionLineageNodeSchema),
         })
         .strict(),
     ),
   })
   .strict()
 
-const BinaryUploadRequestSchema = z
+const DataChangeCountSchema = z
   .object({
-    bytes: z.instanceof(Uint8Array),
-    fileName: z.string().max(255).optional(),
-    operationId: z.string().uuid().optional(),
+    added: z.number().int().nonnegative(),
+    overwritten: z.number().int().nonnegative(),
+    removed: z.number().int().nonnegative(),
+    unchanged: z.number().int().nonnegative(),
   })
   .strict()
-const encodeBinaryUpload = (input: z.output<typeof BinaryUploadRequestSchema>) => ({
-  body: input.bytes,
-  headers: {
-    'content-type': 'application/octet-stream',
-    ...(input.fileName === undefined ? {} : { 'x-file-name': input.fileName }),
-    ...(input.operationId === undefined ? {} : { 'x-operation-id': input.operationId }),
-  },
-})
 
-export const HostApiContracts = {
-  retryRuntimeCompatibility: defineContract({
-    method: 'POST',
-    path: '/api/runtime/compatibility/retry',
-    params: EmptyParamsSchema,
-    request: z
-      .object({ objectKind: RuntimeCompatibilityDiagnosticSchema.shape.objectKind, objectId: z.string().min(1) })
+/** Where a data migration takes data from. */
+export const ExtensionDataSourceSchema = z.discriminatedUnion('kind', [
+  z.object({ kind: z.literal('extension'), extensionId: ExtensionIdSchema }).strict(),
+  z.object({ kind: z.literal('snapshot'), snapshotId: z.string().min(1).max(80) }).strict(),
+  z.object({ kind: z.literal('package'), token: z.string().min(1).max(80) }).strict(),
+])
+
+export const ExtensionDataMigrationInputSchema = z
+  .object({
+    source: ExtensionDataSourceSchema,
+    mode: z.enum(['overwrite', 'replace']),
+    /** Storage of a source agent goes to the mapped agent here; unmapped agents are skipped. */
+    agentMap: z.record(z.string(), AgentIdSchema).optional(),
+    /** Also move the host and agent configuration (never credentials) the same way. */
+    includeConfig: z.boolean().optional(),
+  })
+  .strict()
+
+export const ExtensionDataPreviewSchema = z
+  .object({
+    diff: z
+      .object({ storage: DataChangeCountSchema, index: DataChangeCountSchema, library: DataChangeCountSchema })
       .strict(),
-    response: z.object({ diagnostics: z.array(RuntimeCompatibilityDiagnosticSchema) }).strict(),
-    error: HostApiErrorSchema,
-    invalidatesSnapshot: true,
-  }),
-  snapshot: defineContract({
-    method: 'GET',
-    path: '/api/snapshot',
-    params: EmptyParamsSchema,
-    request: NoRequestBodySchema,
+    destructive: z.boolean(),
+    sourceDataVersion: z.number().int().positive(),
+    targetDataVersion: z.number().int().positive(),
+    needsMigration: z.boolean(),
+    /** Configuration fields that would change, when configuration moves too. */
+    config: z
+      .object({
+        hostFields: z.array(z.string()),
+        agents: z.array(z.object({ agentId: AgentIdSchema, fields: z.array(z.string()) }).strict()),
+      })
+      .strict()
+      .optional(),
+  })
+  .strict()
+
+export const ExtensionDataStateSchema = z
+  .object({
+    dataVersion: z.number().int().positive(),
+    counts: z
+      .object({
+        storage: z.number().int().nonnegative(),
+        index: z.number().int().nonnegative(),
+        library: z.number().int().nonnegative(),
+      })
+      .strict(),
+    snapshots: z.array(
+      z
+        .object({
+          id: z.string(),
+          reason: z.enum(['switch', 'migration', 'manual']),
+          label: z.string(),
+          dataVersion: z.number().int().positive(),
+          byteSize: z.number().int().nonnegative(),
+          createdAt: z.number().int().nonnegative(),
+        })
+        .strict(),
+    ),
+  })
+  .strict()
+
+export const ExtensionDataPackageInspectionSchema = z
+  .object({
+    token: z.string(),
+    extensionId: z.string(),
+    displayName: z.string(),
+    dataVersion: z.number().int().positive(),
+    exportedAt: z.number().int().nonnegative(),
+    agents: z.array(z.object({ id: z.string(), name: z.string() }).strict()),
+    counts: z
+      .object({
+        storage: z.number().int().nonnegative(),
+        index: z.number().int().nonnegative(),
+        library: z.number().int().nonnegative(),
+      })
+      .strict(),
+  })
+  .strict()
+
+export const AdministratorSchema = z
+  .object({
+    connectionId: ConnectionIdSchema,
+    connectionName: z.string(),
+    platformUserId: z.string(),
+    identityId: PlatformIdentityIdSchema.optional(),
+    displayName: z.string(),
+    addedVia: z.enum(['console', 'claim']),
+    addedAt: z.number().int().nonnegative(),
+  })
+  .strict()
+
+const extensionParam = z.object({ extensionId: ExtensionIdSchema }).strict()
+
+export const ExtensionConfigVersionSourceSchema = z.enum(['console', 'agent', 'chat-admin', 'revert', 'auto-revert'])
+export type ExtensionConfigVersionSource = z.output<typeof ExtensionConfigVersionSourceSchema>
+
+/**
+ * One saved state of an extension's host configuration or of one agent's configuration. Versions are numbered per
+ * extension, layer and agent; reverting writes an old one again as a new version. Secret fields only show whether
+ * they were set and which named credential they were bound to.
+ */
+export const ExtensionConfigVersionSchema = z
+  .object({
+    id: z.number().int().positive(),
+    extensionId: ExtensionIdSchema,
+    layer: z.enum(['host', 'agent']),
+    agentId: AgentIdSchema.nullable(),
+    version: z.number().int().positive(),
+    config: JsonValueSchema,
+    configuredSecrets: z.array(z.string()).optional(),
+    boundCredentials: z.record(z.string(), CredentialIdSchema).optional(),
+    source: ExtensionConfigVersionSourceSchema,
+    actorAgentId: AgentIdSchema.nullable(),
+    requesterMemberId: z.string().nullable(),
+    reason: z.string().nullable(),
+    createdAt: z.number().int().nonnegative(),
+  })
+  .strict()
+export type ExtensionConfigVersion = z.output<typeof ExtensionConfigVersionSchema>
+
+const extensionConfigVersionParam = z
+  .object({
+    extensionId: ExtensionIdSchema,
+    /** Decimal text of the version id; the path builder only takes strings. */
+    versionId: z.string().regex(/^[1-9]\d{0,15}$/u),
+  })
+  .strict()
+const dshPluginPackageParam = z.object({ packageId: DshPluginPackageIdSchema }).strict()
+const dshPluginEntryParam = z.object({ entryId: DshPluginEntryIdSchema }).strict()
+const extensionRevisionParam = z
+  .object({ extensionId: ExtensionIdSchema, revisionId: ExtensionRevisionIdSchema })
+  .strict()
+const dshSettingsParam = z.object({ namespace: NonEmptyStringSchema }).strict()
+const dshCredentialParam = z.object({ ref: DshCredentialRefSchema }).strict()
+const llmProviderParam = z.object({ provider: NonEmptyStringSchema }).strict()
+const authoringTaskParam = z.object({ taskId: AuthoringTaskIdSchema }).strict()
+const subConversationParam = z.object({ conversationId: SubConversationIdSchema }).strict()
+const scheduledTaskParam = z.object({ taskId: ScheduledTaskIdSchema }).strict()
+const authoringAttemptParam = z.object({ taskId: AuthoringTaskIdSchema, attemptId: AuthoringAttemptIdSchema }).strict()
+
+const DshPluginInstallInspectionSchema = z
+  .object({
+    token: NonEmptyStringSchema,
+    operationId: z.string().uuid().optional(),
+    packageName: NonEmptyStringSchema,
+    packageVersion: NonEmptyStringSchema,
+    packageDigest: z.string().regex(/^[a-f0-9]{64}$/u),
+    lockfileDigest: z.string().regex(/^[a-f0-9]{64}$/u),
+    blockedBuilds: z.array(NonEmptyStringSchema),
+    clientUiDetected: z.boolean(),
+    hostUi: DshNxtHostUiSchema.optional(),
+    entries: z.array(
+      z
+        .object({
+          entryKey: NonEmptyStringSchema,
+          moduleName: NonEmptyStringSchema,
+          suggestedScope: z.enum(['host', 'agent']),
+        })
+        .strict(),
+    ),
+  })
+  .strict()
+
+const BinaryUploadRequestSchema = z
+  .object({
+    bytes: z.instanceof(Uint8Array),
+    fileName: z.string().max(255).optional(),
+    operationId: z.string().uuid().optional(),
+  })
+  .strict()
+const encodeBinaryUpload = (input: z.output<typeof BinaryUploadRequestSchema>) => ({
+  body: input.bytes,
+  headers: {
+    'content-type': 'application/octet-stream',
+    ...(input.fileName === undefined ? {} : { 'x-file-name': input.fileName }),
+    ...(input.operationId === undefined ? {} : { 'x-operation-id': input.operationId }),
+  },
+})
+
+export const HostApiContracts = {
+  listCommands: defineContract({
+    method: 'GET',
+    path: '/api/commands',
+    params: z.object({ channelId: ChannelIdSchema.optional() }).strict(),
+    request: NoRequestBodySchema,
+    response: z
+      .object({
+        commands: z.array(CommandCatalogEntrySchema),
+        problems: z.array(z.string()),
+        /** Host-wide behavior: whether platform members without a grant are told so. */
+        settings: z.object({ unauthorizedFeedback: z.boolean() }).strict(),
+        /** Present when a channel was requested. */
+        channel: z
+          .object({
+            kind: z.enum(['internal', 'direct', 'group']),
+            /** The channel is an external group where commands must address the account. */
+            requiresMention: z.boolean(),
+            bareCommands: z.boolean(),
+          })
+          .strict()
+          .optional(),
+      })
+      .strict(),
+    error: HostApiErrorSchema,
+  }),
+  executeCommand: defineContract({
+    method: 'POST',
+    path: '/api/commands/execute',
+    params: EmptyParamsSchema,
+    request: z
+      .object({ channelId: ChannelIdSchema, text: z.string().min(1).max(16000), requestId: z.string().min(1).max(200) })
+      .strict(),
+    response: CommandExecutionRecordSchema,
+    error: HostApiErrorSchema,
+    invalidatesSnapshot: true,
+  }),
+  getCommandExecution: defineContract({
+    method: 'GET',
+    path: '/api/commands/executions/:executionId',
+    params: z.object({ executionId: z.string().min(1) }).strict(),
+    request: NoRequestBodySchema,
+    response: CommandExecutionRecordSchema,
+    error: HostApiErrorSchema,
+  }),
+  setCommandPolicy: defineContract({
+    method: 'PUT',
+    path: '/api/commands/policy',
+    params: EmptyParamsSchema,
+    request: z
+      .object({
+        scope: z.union([z.literal('global'), ChannelIdSchema]),
+        name: z.string().min(1),
+        policy: CommandPolicySchema,
+      })
+      .strict(),
+    response: z.object({ saved: z.literal(true) }).strict(),
+    error: HostApiErrorSchema,
+    invalidatesSnapshot: true,
+  }),
+  listCommandMembers: defineContract({
+    method: 'GET',
+    path: '/api/commands/members/:channelId',
+    params: z.object({ channelId: ChannelIdSchema }).strict(),
+    request: NoRequestBodySchema,
+    response: z
+      .object({
+        members: z.array(
+          z
+            .object({
+              identityId: PlatformIdentityIdSchema,
+              displayName: z.string(),
+              platformUserId: z.string(),
+              authorized: z.boolean(),
+            })
+            .strict(),
+        ),
+      })
+      .strict(),
+    error: HostApiErrorSchema,
+  }),
+  setCommandSettings: defineContract({
+    method: 'PUT',
+    path: '/api/commands/settings',
+    params: EmptyParamsSchema,
+    request: z.object({ unauthorizedFeedback: z.boolean() }).strict(),
+    response: z.object({ saved: z.literal(true) }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  setCommandChannelSettings: defineContract({
+    method: 'PUT',
+    path: '/api/commands/channel-settings',
+    params: EmptyParamsSchema,
+    request: z.object({ channelId: ChannelIdSchema, bareCommands: z.boolean() }).strict(),
+    response: z.object({ saved: z.literal(true) }).strict(),
+    error: HostApiErrorSchema,
+    invalidatesSnapshot: true,
+  }),
+  setCommandGrant: defineContract({
+    method: 'PUT',
+    path: '/api/commands/grants',
+    params: EmptyParamsSchema,
+    request: z
+      .object({ channelId: ChannelIdSchema, identityId: PlatformIdentityIdSchema, enabled: z.boolean() })
+      .strict(),
+    response: z.object({ saved: z.literal(true) }).strict(),
+    error: HostApiErrorSchema,
+    invalidatesSnapshot: true,
+  }),
+  queryLogs: defineContract({
+    method: 'GET',
+    path: '/api/logs',
+    params: z.object({ query: z.string().max(32_768).optional() }).strict(),
+    request: NoRequestBodySchema,
+    response: hostLogPageSchema,
+    error: HostApiErrorSchema,
+  }),
+  getLog: defineContract({
+    method: 'GET',
+    path: '/api/logs/:id',
+    params: z.object({ id: z.string().min(1).max(256) }).strict(),
+    request: NoRequestBodySchema,
+    response: z.object({ entry: hostLogEntrySchema }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  logSources: defineContract({
+    method: 'GET',
+    path: '/api/logs/sources',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: z.object({ sources: z.array(hostLogSourceSchema) }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  logStatus: defineContract({
+    method: 'GET',
+    path: '/api/logs/status',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: hostLogStatusSchema,
+    error: HostApiErrorSchema,
+  }),
+  logSettings: defineContract({
+    method: 'GET',
+    path: '/api/logs/settings',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: hostLogSettingsSchema,
+    error: HostApiErrorSchema,
+  }),
+  updateLogSettings: defineContract({
+    method: 'PUT',
+    path: '/api/logs/settings',
+    params: EmptyParamsSchema,
+    request: hostLogSettingsSchema,
+    response: hostLogSettingsSchema,
+    error: HostApiErrorSchema,
+  }),
+  startLogDebug: defineContract({
+    method: 'POST',
+    path: '/api/logs/debug',
+    params: EmptyParamsSchema,
+    request: hostLogDebugRequestSchema,
+    response: z.object({ lease: hostLogDebugLeaseSchema }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  stopLogDebug: defineContract({
+    method: 'DELETE',
+    path: '/api/logs/debug/:id',
+    params: z.object({ id: z.string().min(1).max(256) }).strict(),
+    request: NoRequestBodySchema,
+    response: z.object({ stopped: z.literal(true) }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  retryRuntimeCompatibility: defineContract({
+    method: 'POST',
+    path: '/api/runtime/compatibility/retry',
+    params: EmptyParamsSchema,
+    request: z
+      .object({ objectKind: RuntimeCompatibilityDiagnosticSchema.shape.objectKind, objectId: z.string().min(1) })
+      .strict(),
+    response: z.object({ diagnostics: z.array(RuntimeCompatibilityDiagnosticSchema) }).strict(),
+    error: HostApiErrorSchema,
+    invalidatesSnapshot: true,
+  }),
+  snapshot: defineContract({
+    method: 'GET',
+    path: '/api/snapshot',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
     response: HostSnapshotSchema,
     error: HostApiErrorSchema,
   }),
@@ -2244,11 +3189,20 @@ export const HostApiContracts = {
       .object({
         task: AuthoringTaskSummarySchema,
         attempts: z.array(AuthoringAttemptSummarySchema),
-        /** Secret fields of the latest candidate and which have a test value for this task's dynamic runs. */
-        testSecrets: z
+        /**
+         * Test configuration of this task's dynamic runs: fields of the latest candidate the user can type, which
+         * credentials are set, the user's values and the values the agent provided.
+         */
+        testConfig: z
           .object({
-            fields: z.array(z.object({ key: z.string(), title: z.string() }).strict()),
+            fields: z.array(
+              z.object({ key: z.string(), title: z.string(), kind: z.enum(['secret', 'string', 'number']) }).strict(),
+            ),
             configured: z.array(z.string()),
+            values: z.record(z.string(), z.union([z.string(), z.number()])),
+            agentValues: z.record(z.string(), JsonValueSchema),
+            /** Secret fields bound to a named credential, by the user or else by the agent. */
+            boundCredentials: BoundCredentialsSchema.optional(),
           })
           .strict()
           .optional(),
@@ -2298,12 +3252,26 @@ export const HostApiContracts = {
     response: AuthoringTaskSummarySchema,
     error: HostApiErrorSchema,
   }),
-  setAuthoringTestSecrets: defineContract({
+  setAuthoringTestConfig: defineContract({
     method: 'PUT',
     path: '/api/authoring/tasks/:taskId/test-secrets',
     params: authoringTaskParam,
-    request: z.object({ secrets: z.record(z.string(), z.string().max(8192)) }).strict(),
-    response: z.object({ configured: z.array(z.string()) }).strict(),
+    request: z
+      .object({
+        secrets: z.record(z.string(), z.string().max(8192)),
+        /** Text and number values; an empty string goes back to the agent's value or the default. */
+        values: z.record(z.string(), z.union([z.string().max(8192), z.number()])).optional(),
+        /** Secret fields to bind to named credentials instead of a typed value; `null` leaves the field unset. */
+        credentialBindings: CredentialBindingsRequestSchema.optional(),
+      })
+      .strict(),
+    response: z
+      .object({
+        configured: z.array(z.string()),
+        values: z.record(z.string(), z.union([z.string(), z.number()])),
+        boundCredentials: BoundCredentialsSchema.optional(),
+      })
+      .strict(),
     error: HostApiErrorSchema,
   }),
   deleteAuthoringTask: defineContract({
@@ -2501,6 +3469,8 @@ export const HostApiContracts = {
         /** Messages from another local agent's account: `observe` keeps them as context unless they @ this agent. */
         localAgentMessages: z.enum(['observe', 'trigger']).optional(),
         activityTriggerOverrides: ActivityTriggerOverridesSchema.optional(),
+        /** Omitted keeps the binding's current timing; `{}` resets every field to its default. */
+        responseTiming: ResponseTimingSettingsSchema.optional(),
       })
       .strict(),
     response: z
@@ -2508,9 +3478,11 @@ export const HostApiContracts = {
         channelId: ChannelIdSchema,
         agentId: AgentIdSchema,
         triggerPolicy: TriggerPolicySchema,
+        paused: z.boolean().default(false),
         processingFeedback: z.enum(['auto', 'off']).default('auto'),
         localAgentMessages: z.enum(['observe', 'trigger']).optional(),
         activityTriggerOverrides: ActivityTriggerOverridesSchema.default({}),
+        responseTiming: ResponseTimingSettingsSchema.optional(),
         boundAt: z.number().int().safe().nonnegative(),
       })
       .strict(),
@@ -2534,6 +3506,23 @@ export const HostApiContracts = {
     response: WorkTreeOrderSchema,
     error: HostApiErrorSchema,
   }),
+  getChannelListView: defineContract({
+    method: 'GET',
+    path: '/api/channel-list-view',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: ChannelListViewSchema,
+    error: HostApiErrorSchema,
+  }),
+  updateChannelListView: defineContract({
+    invalidatesSnapshot: true,
+    method: 'PUT',
+    path: '/api/channel-list-view',
+    params: EmptyParamsSchema,
+    request: ChannelListViewSchema,
+    response: ChannelListViewSchema,
+    error: HostApiErrorSchema,
+  }),
   listChannelMessages: defineContract({
     method: 'GET',
     path: '/api/channels/:channelId/messages',
@@ -2569,12 +3558,44 @@ export const HostApiContracts = {
       .strict(),
     error: HostApiErrorSchema,
   }),
+  uploadChannelAsset: defineContract({
+    method: 'POST',
+    path: '/api/channels/:channelId/assets',
+    params: channelParam,
+    request: BinaryUploadRequestSchema,
+    encodeRequest: (input) => ({
+      body: input.bytes,
+      headers: {
+        'content-type': 'application/octet-stream',
+        'x-file-name': encodeURIComponent(input.fileName ?? '附件'),
+      },
+    }),
+    response: z
+      .object({
+        assetId: AssetIdSchema,
+        mediaType: z.string().min(1),
+        byteSize: z.number().int().nonnegative(),
+        fileName: z.string().min(1).max(255),
+        partType: z.enum(['image', 'file']),
+      })
+      .strict(),
+    error: HostApiErrorSchema,
+  }),
+  deleteChannelAsset: defineContract({
+    method: 'DELETE',
+    path: '/api/channels/:channelId/assets/:assetId',
+    params: z.object({ channelId: ChannelIdSchema, assetId: AssetIdSchema }).strict(),
+    request: NoRequestBodySchema,
+    response: z.object({ assetId: AssetIdSchema, revoked: z.literal(true) }).strict(),
+    error: HostApiErrorSchema,
+  }),
   renameChannel: defineContract({
     invalidatesSnapshot: true,
     method: 'POST',
     path: '/api/channels/:channelId/display-name',
     params: channelParam,
-    request: z.object({ displayName: z.string().trim().min(1).max(120) }).strict(),
+    /** Empty selects the known platform name for an external channel. */
+    request: z.object({ displayName: z.string().trim().max(120) }).strict(),
     response: z.object({ channelId: ChannelIdSchema, displayName: z.string().trim().min(1).max(120) }).strict(),
     error: HostApiErrorSchema,
   }),
@@ -2616,6 +3637,57 @@ export const HostApiContracts = {
     response: ChannelRuntimeContextSchema,
     error: HostApiErrorSchema,
   }),
+  listSubConversations: defineContract({
+    method: 'GET',
+    path: '/api/sub-conversations/channels/:channelId',
+    params: channelParam,
+    request: NoRequestBodySchema,
+    response: z.object({ items: z.array(SubConversationSchema) }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  getSubConversationRuntime: defineContract({
+    method: 'GET',
+    path: '/api/sub-conversations/:conversationId/runtime',
+    params: subConversationParam,
+    request: NoRequestBodySchema,
+    // Read from memory while it runs and from its stored log after it ended.
+    response: z.object({ conversation: SubConversationSchema, runtime: ChannelRuntimeProjectionSchema }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  closeSubConversation: defineContract({
+    invalidatesSnapshot: true,
+    method: 'POST',
+    path: '/api/sub-conversations/:conversationId/close',
+    params: subConversationParam,
+    request: z.object({}).strict(),
+    response: SubConversationSchema,
+    error: HostApiErrorSchema,
+  }),
+  deleteSubConversation: defineContract({
+    invalidatesSnapshot: true,
+    method: 'DELETE',
+    path: '/api/sub-conversations/:conversationId',
+    params: subConversationParam,
+    request: NoRequestBodySchema,
+    response: z.object({ deleted: z.literal(true) }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  getSubConversationSettings: defineContract({
+    method: 'GET',
+    path: '/api/settings/sub-conversations',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: SubConversationSettingsSchema,
+    error: HostApiErrorSchema,
+  }),
+  updateSubConversationSettings: defineContract({
+    method: 'PUT',
+    path: '/api/settings/sub-conversations',
+    params: EmptyParamsSchema,
+    request: SubConversationSettingsSchema,
+    response: SubConversationSettingsSchema,
+    error: HostApiErrorSchema,
+  }),
   getChannelRuntimeInput: defineContract({
     method: 'GET',
     path: '/api/channels/:channelId/runtime/inputs/:messageId',
@@ -2699,6 +3771,57 @@ export const HostApiContracts = {
     response: MessagePacingSettingsSchema,
     error: HostApiErrorSchema,
   }),
+  getCompactionSettings: defineContract({
+    method: 'GET',
+    path: '/api/settings/compaction',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: CompactionSettingsSchema,
+    error: HostApiErrorSchema,
+  }),
+  updateCompactionSettings: defineContract({
+    invalidatesSnapshot: true,
+    method: 'PUT',
+    path: '/api/settings/compaction',
+    params: EmptyParamsSchema,
+    request: CompactionSettingsSchema,
+    response: CompactionSettingsSchema,
+    error: HostApiErrorSchema,
+  }),
+  getModelFallbackSettings: defineContract({
+    method: 'GET',
+    path: '/api/settings/model-fallback',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: ModelFallbackSettingsSchema,
+    error: HostApiErrorSchema,
+  }),
+  updateModelFallbackSettings: defineContract({
+    method: 'PUT',
+    path: '/api/settings/model-fallback',
+    params: EmptyParamsSchema,
+    request: ModelFallbackSettingsSchema,
+    response: ModelFallbackSettingsSchema,
+    error: HostApiErrorSchema,
+  }),
+  getUpgradeBackupSettings: defineContract({
+    method: 'GET',
+    path: '/api/settings/upgrade-backup',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: UpgradeBackupSettingsSchema,
+    error: HostApiErrorSchema,
+  }),
+  updateUpgradeBackupSettings: defineContract({
+    method: 'PUT',
+    path: '/api/settings/upgrade-backup',
+    params: EmptyParamsSchema,
+    request: z
+      .object({ mode: UpgradeBackupModeSchema, directory: z.string().trim().min(1).max(1024).optional() })
+      .strict(),
+    response: UpgradeBackupSettingsSchema,
+    error: HostApiErrorSchema,
+  }),
   getRetrievalStatus: defineContract({
     method: 'GET',
     path: '/api/settings/retrieval',
@@ -2749,6 +3872,154 @@ export const HostApiContracts = {
     response: CodeRunAvailabilitySchema,
     error: HostApiErrorSchema,
   }),
+  downloadGithubCli: defineContract({
+    invalidatesSnapshot: true,
+    method: 'POST',
+    path: '/api/runtimes/github-cli/download',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: GithubCliAvailabilitySchema,
+    error: HostApiErrorSchema,
+  }),
+  removeGithubCli: defineContract({
+    invalidatesSnapshot: true,
+    method: 'DELETE',
+    path: '/api/runtimes/github-cli',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: GithubCliAvailabilitySchema,
+    error: HostApiErrorSchema,
+  }),
+  downloadVerificationBrowser: defineContract({
+    invalidatesSnapshot: true,
+    method: 'POST',
+    path: '/api/runtimes/verification-browser/download',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: VerificationBrowserAvailabilitySchema,
+    error: HostApiErrorSchema,
+  }),
+  removeVerificationBrowser: defineContract({
+    invalidatesSnapshot: true,
+    method: 'DELETE',
+    path: '/api/runtimes/verification-browser',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: VerificationBrowserAvailabilitySchema,
+    error: HostApiErrorSchema,
+  }),
+  getLinkedAccounts: defineContract({
+    method: 'GET',
+    path: '/api/settings/linked-accounts',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: LinkedAccountsViewSchema,
+    error: HostApiErrorSchema,
+  }),
+  addLinkedAccount: defineContract({
+    invalidatesSnapshot: true,
+    method: 'POST',
+    path: '/api/settings/linked-accounts',
+    params: EmptyParamsSchema,
+    request: AddLinkedAccountRequestSchema,
+    response: LinkedAccountsViewSchema,
+    error: HostApiErrorSchema,
+  }),
+  replaceLinkedAccountToken: defineContract({
+    invalidatesSnapshot: true,
+    method: 'PUT',
+    path: '/api/settings/linked-accounts/:accountId/token',
+    params: linkedAccountParam,
+    request: ReplaceLinkedAccountTokenRequestSchema,
+    response: LinkedAccountsViewSchema,
+    error: HostApiErrorSchema,
+  }),
+  removeLinkedAccount: defineContract({
+    invalidatesSnapshot: true,
+    method: 'POST',
+    path: '/api/settings/linked-accounts/:accountId/remove',
+    params: linkedAccountParam,
+    request: RemoveLinkedAccountRequestSchema,
+    response: RemoveLinkedAccountResultSchema,
+    error: HostApiErrorSchema,
+  }),
+  getLinkedAccountUses: defineContract({
+    method: 'GET',
+    path: '/api/settings/linked-accounts/:accountId/uses',
+    params: linkedAccountParam,
+    request: NoRequestBodySchema,
+    response: LinkedAccountUsesViewSchema,
+    error: HostApiErrorSchema,
+  }),
+  getCredentials: defineContract({
+    method: 'GET',
+    path: '/api/settings/credentials',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: CredentialsViewSchema,
+    error: HostApiErrorSchema,
+  }),
+  createCredential: defineContract({
+    invalidatesSnapshot: true,
+    method: 'POST',
+    path: '/api/settings/credentials',
+    params: EmptyParamsSchema,
+    request: CreateCredentialRequestSchema,
+    response: CredentialsViewSchema,
+    error: HostApiErrorSchema,
+  }),
+  updateCredential: defineContract({
+    invalidatesSnapshot: true,
+    method: 'PATCH',
+    path: '/api/settings/credentials/:credentialId',
+    params: credentialParam,
+    request: UpdateCredentialRequestSchema,
+    response: CredentialsViewSchema,
+    error: HostApiErrorSchema,
+  }),
+  replaceCredentialValue: defineContract({
+    invalidatesSnapshot: true,
+    method: 'PUT',
+    path: '/api/settings/credentials/:credentialId/value',
+    params: credentialParam,
+    request: ReplaceCredentialValueRequestSchema,
+    response: CredentialsViewSchema,
+    error: HostApiErrorSchema,
+  }),
+  removeCredential: defineContract({
+    invalidatesSnapshot: true,
+    method: 'POST',
+    path: '/api/settings/credentials/:credentialId/remove',
+    params: credentialParam,
+    request: RemoveCredentialRequestSchema,
+    response: RemoveCredentialResultSchema,
+    error: HostApiErrorSchema,
+  }),
+  getCredentialUses: defineContract({
+    method: 'GET',
+    path: '/api/settings/credentials/:credentialId/uses',
+    params: credentialParam,
+    request: NoRequestBodySchema,
+    response: CredentialUsesViewSchema,
+    error: HostApiErrorSchema,
+  }),
+  dismissCredentialRequest: defineContract({
+    method: 'DELETE',
+    path: '/api/settings/credentials/requests/:requestId',
+    params: z.object({ requestId: NonEmptyStringSchema.max(64) }).strict(),
+    request: NoRequestBodySchema,
+    response: CredentialsViewSchema,
+    error: HostApiErrorSchema,
+  }),
+  setModelProviderAccess: defineContract({
+    invalidatesSnapshot: true,
+    method: 'PUT',
+    path: '/api/settings/credentials/model-providers/:provider',
+    params: z.object({ provider: NonEmptyStringSchema.max(128) }).strict(),
+    request: SetModelProviderAccessRequestSchema,
+    response: CredentialsViewSchema,
+    error: HostApiErrorSchema,
+  }),
   getChannelMemberNotes: defineContract({
     method: 'GET',
     path: '/api/channels/:channelId/member-notes',
@@ -2899,7 +4170,13 @@ export const HostApiContracts = {
     method: 'POST',
     path: '/api/connections/:connectionId/configuration',
     params: connectionParam,
-    request: z.object({ configuration: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])) }).strict(),
+    request: z
+      .object({
+        configuration: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])),
+        /** Omitted keys keep their value; null explicitly clears an optional credential. */
+        credentials: z.record(z.string().min(1), z.string().min(1).max(16_384).nullable()).optional(),
+      })
+      .strict(),
     response: z
       .object({
         connectionId: ConnectionIdSchema,
@@ -3016,61 +4293,194 @@ export const HostApiContracts = {
     request: z.object({ targetKey: NonEmptyStringSchema }).strict(),
     response: z.object({ disabled: z.literal(true) }).strict(),
     error: HostApiErrorSchema,
-  }),
-  removeDshPluginPackage: defineContract({
+  }),
+  removeDshPluginPackage: defineContract({
+    invalidatesSnapshot: true,
+    method: 'DELETE',
+    path: '/api/dsh/plugin-installs/:packageId',
+    params: dshPluginPackageParam,
+    request: NoRequestBodySchema,
+    response: z.object({ removed: z.literal(true) }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  inspectExtensionImport: defineContract({
+    timeoutMs: 300_000,
+    method: 'POST',
+    path: '/api/extensions/imports/inspect',
+    params: EmptyParamsSchema,
+    request: BinaryUploadRequestSchema,
+    encodeRequest: encodeBinaryUpload,
+    response: ExtensionImportInspectionSchema,
+    error: HostApiErrorSchema,
+  }),
+  /**
+   * Management-edge endpoints: they exist only when the Server is reached through its management edge (a management
+   * key is set); clients tell that from the edge's CSRF cookie.
+   */
+  listManagementDevices: defineContract({
+    method: 'GET',
+    path: '/api/management/devices',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: z.object({ devices: z.array(ManagementDeviceViewSchema) }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  revokeManagementDevice: defineContract({
+    method: 'DELETE',
+    path: '/api/management/devices/:deviceId',
+    params: z.object({ deviceId: ManagementDeviceIdSchema }).strict(),
+    request: NoRequestBodySchema,
+    response: z.object({ revoked: z.boolean() }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  managementLogout: defineContract({
+    method: 'DELETE',
+    path: '/api/management/session',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: z.object({ authenticated: z.literal(false) }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  getCommunityStatus: defineContract({
+    method: 'GET',
+    path: '/api/community/status',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: CommunityStatusSchema,
+    error: HostApiErrorSchema,
+  }),
+  getCommunityFeedbackSettings: defineContract({
+    method: 'GET',
+    path: '/api/community/feedback/settings',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: CommunityFeedbackSettingsSchema,
+    error: HostApiErrorSchema,
+  }),
+  updateCommunityFeedbackSettings: defineContract({
+    method: 'PUT',
+    path: '/api/community/feedback/settings',
+    params: EmptyParamsSchema,
+    request: CommunityFeedbackSettingsUpdateSchema,
+    response: CommunityFeedbackSettingsSchema,
+    error: HostApiErrorSchema,
+    invalidatesSnapshot: true,
+  }),
+  listCommunityFeedback: defineContract({
+    timeoutMs: 60_000,
+    method: 'GET',
+    path: '/api/community/feedback',
+    params: z.object({ refresh: z.literal('1').optional() }).strict(),
+    request: NoRequestBodySchema,
+    response: CommunityFeedbackLocalListSchema,
+    error: HostApiErrorSchema,
+  }),
+  getCommunityFeedback: defineContract({
+    timeoutMs: 60_000,
+    method: 'GET',
+    path: '/api/community/feedback/items/:ref',
+    params: z.object({ ref: CommunityFeedbackRefSchema }).strict(),
+    request: NoRequestBodySchema,
+    response: CommunityFeedbackSchema,
+    error: HostApiErrorSchema,
+  }),
+  createCommunityFeedbackDraft: defineContract({
+    method: 'POST',
+    path: '/api/community/feedback/drafts',
+    params: EmptyParamsSchema,
+    request: CommunityFeedbackDraftInputSchema,
+    response: CommunityFeedbackDraftSchema,
+    error: HostApiErrorSchema,
+    invalidatesSnapshot: true,
+  }),
+  updateCommunityFeedbackDraft: defineContract({
+    method: 'PUT',
+    path: '/api/community/feedback/drafts/:draftId',
+    params: z.object({ draftId: CommunityFeedbackDraftIdSchema }).strict(),
+    request: CommunityFeedbackDraftUpdateSchema,
+    response: CommunityFeedbackDraftSchema,
+    error: HostApiErrorSchema,
+    invalidatesSnapshot: true,
+  }),
+  sendCommunityFeedbackDraft: defineContract({
+    timeoutMs: 60_000,
+    method: 'POST',
+    path: '/api/community/feedback/drafts/:draftId/send',
+    params: z.object({ draftId: CommunityFeedbackDraftIdSchema }).strict(),
+    request: z.object({ consent: z.boolean().default(false) }).strict(),
+    response: CommunityFeedbackDraftSchema,
+    error: HostApiErrorSchema,
     invalidatesSnapshot: true,
+  }),
+  discardCommunityFeedbackDraft: defineContract({
     method: 'DELETE',
-    path: '/api/dsh/plugin-installs/:packageId',
-    params: dshPluginPackageParam,
+    path: '/api/community/feedback/drafts/:draftId',
+    params: z.object({ draftId: CommunityFeedbackDraftIdSchema }).strict(),
     request: NoRequestBodySchema,
-    response: z.object({ removed: z.literal(true) }).strict(),
+    response: CommunityFeedbackDraftSchema,
     error: HostApiErrorSchema,
+    invalidatesSnapshot: true,
   }),
-  inspectExtensionImport: defineContract({
-    timeoutMs: 300_000,
-    method: 'POST',
-    path: '/api/extensions/imports/inspect',
-    params: EmptyParamsSchema,
-    request: BinaryUploadRequestSchema,
-    encodeRequest: encodeBinaryUpload,
-    response: ExtensionImportInspectionSchema,
+  previewCommunityFeedbackPayload: defineContract({
+    method: 'GET',
+    path: '/api/community/feedback/drafts/:draftId/preview',
+    params: z.object({ draftId: CommunityFeedbackDraftIdSchema }).strict(),
+    request: NoRequestBodySchema,
+    response: CommunityFeedbackPayloadSchema,
     error: HostApiErrorSchema,
   }),
-  /**
-   * Management-edge endpoints: they exist only when the Server is reached through its management edge (a management
-   * key is set); clients tell that from the edge's CSRF cookie.
-   */
-  listManagementDevices: defineContract({
+  getLastSentCommunityFeedbackPayload: defineContract({
     method: 'GET',
-    path: '/api/management/devices',
+    path: '/api/community/feedback/last-sent',
     params: EmptyParamsSchema,
     request: NoRequestBodySchema,
-    response: z.object({ devices: z.array(ManagementDeviceViewSchema) }).strict(),
+    response: CommunityFeedbackLastPayloadSchema,
     error: HostApiErrorSchema,
   }),
-  revokeManagementDevice: defineContract({
-    method: 'DELETE',
-    path: '/api/management/devices/:deviceId',
-    params: z.object({ deviceId: ManagementDeviceIdSchema }).strict(),
-    request: NoRequestBodySchema,
-    response: z.object({ revoked: z.boolean() }).strict(),
+  replyCommunityFeedback: defineContract({
+    method: 'POST',
+    path: '/api/community/feedback/items/:ref/messages',
+    params: z.object({ ref: CommunityFeedbackRefSchema }).strict(),
+    request: z.object({ body: z.string().trim().min(1).max(4000) }).strict(),
+    response: CommunityFeedbackSchema,
     error: HostApiErrorSchema,
+    invalidatesSnapshot: true,
   }),
-  managementLogout: defineContract({
-    method: 'DELETE',
-    path: '/api/management/session',
-    params: EmptyParamsSchema,
-    request: NoRequestBodySchema,
-    response: z.object({ authenticated: z.literal(false) }).strict(),
+  withdrawCommunityFeedback: defineContract({
+    method: 'POST',
+    path: '/api/community/feedback/items/:ref/withdraw',
+    params: z.object({ ref: CommunityFeedbackRefSchema }).strict(),
+    request: CommunityFeedbackWithdrawSchema,
+    response: CommunityFeedbackSchema,
     error: HostApiErrorSchema,
+    invalidatesSnapshot: true,
   }),
-  getCommunityStatus: defineContract({
-    method: 'GET',
-    path: '/api/community/status',
-    params: EmptyParamsSchema,
-    request: NoRequestBodySchema,
-    response: CommunityStatusSchema,
+  reopenCommunityFeedback: defineContract({
+    method: 'POST',
+    path: '/api/community/feedback/items/:ref/reopen',
+    params: z.object({ ref: CommunityFeedbackRefSchema }).strict(),
+    request: CommunityFeedbackReopenSchema,
+    response: CommunityFeedbackSchema,
     error: HostApiErrorSchema,
+    invalidatesSnapshot: true,
+  }),
+  markCommunityFeedbackAffected: defineContract({
+    method: 'POST',
+    path: '/api/community/feedback/items/:ref/affected',
+    params: z.object({ ref: CommunityFeedbackRefSchema }).strict(),
+    request: z.object({ affected: z.boolean().default(true), consent: z.boolean().default(false) }).strict(),
+    response: CommunityFeedbackSchema,
+    error: HostApiErrorSchema,
+    invalidatesSnapshot: true,
+  }),
+  confirmCommunityFeedbackFixed: defineContract({
+    method: 'POST',
+    path: '/api/community/feedback/items/:ref/confirm-fixed',
+    params: z.object({ ref: CommunityFeedbackRefSchema }).strict(),
+    request: z.object({}).strict(),
+    response: CommunityFeedbackSchema,
+    error: HostApiErrorSchema,
+    invalidatesSnapshot: true,
   }),
   startCommunityLogin: defineContract({
     method: 'POST',
@@ -3102,19 +4512,24 @@ export const HostApiContracts = {
         /** 排序方式，默认最近更新；游标只在同一种排序下有效。 */
         sort: CommunityExtensionSortSchema.optional(),
         cursor: z.string().max(200).optional(),
+        /** 跳过本机缓存，重新向社区读取。 */
+        refresh: z.enum(['1']).optional(),
       })
       .strict(),
     request: NoRequestBodySchema,
-    response: z.object({ items: z.array(CommunityExtensionSummarySchema), nextCursor: z.string().nullable() }).strict(),
+    response: z
+      .object({ items: z.array(CommunityExtensionSummarySchema), nextCursor: z.string().nullable() })
+      .extend(CommunityFreshnessSchema.shape)
+      .strict(),
     error: HostApiErrorSchema,
   }),
   getCommunityExtension: defineContract({
     timeoutMs: 30_000,
     method: 'GET',
     path: '/api/community/extensions/:extensionId',
-    params: z.object({ extensionId: ExtensionIdSchema }).strict(),
+    params: z.object({ extensionId: ExtensionIdSchema, refresh: z.enum(['1']).optional() }).strict(),
     request: NoRequestBodySchema,
-    response: CommunityExtensionDetailSchema,
+    response: CommunityExtensionDetailSchema.extend(CommunityFreshnessSchema.shape),
     error: HostApiErrorSchema,
   }),
   /** 下载社区发布并按包摘要校验，结果与本地文件导入的检查相同，再经 `commitExtensionImport` 确认。 */
@@ -3151,13 +4566,13 @@ export const HostApiContracts = {
       .strict(),
     error: HostApiErrorSchema,
   }),
-  listCommunityInstalled: defineContract({
-    timeoutMs: 30_000,
+  listCommunitySync: defineContract({
+    timeoutMs: 60_000,
     method: 'GET',
-    path: '/api/community/installed',
+    path: '/api/community/sync',
     params: z.object({ refresh: z.enum(['1']).optional() }).strict(),
     request: NoRequestBodySchema,
-    response: CommunityInstalledSchema,
+    response: CommunitySyncSchema,
     error: HostApiErrorSchema,
   }),
   listCommunityMine: defineContract({
@@ -3222,6 +4637,7 @@ export const HostApiContracts = {
     response: z
       .object({
         releaseId: CommunityReleaseIdSchema,
+        releaseNumber: z.number().int().positive(),
         reviewStatus: CommunityReviewStatusSchema,
         pageUrl: z.string().url(),
         reportUrl: z.string().url(),
@@ -3240,19 +4656,24 @@ export const HostApiContracts = {
         tag: z.string().trim().min(1).max(40).optional(),
         official: z.literal('1').optional(),
         cursor: z.string().min(1).max(500).optional(),
+        /** 跳过本机缓存，重新向社区读取。 */
+        refresh: z.enum(['1']).optional(),
       })
       .strict(),
     request: NoRequestBodySchema,
-    response: z.object({ items: z.array(CommunityPersonaSummarySchema), nextCursor: z.string().nullable() }).strict(),
+    response: z
+      .object({ items: z.array(CommunityPersonaSummarySchema), nextCursor: z.string().nullable() })
+      .extend(CommunityFreshnessSchema.shape)
+      .strict(),
     error: HostApiErrorSchema,
   }),
   getCommunityPersona: defineContract({
     timeoutMs: 30_000,
     method: 'GET',
     path: '/api/community/personas/:personaId',
-    params: z.object({ personaId: CommunityPersonaIdSchema }).strict(),
+    params: z.object({ personaId: CommunityPersonaIdSchema, refresh: z.enum(['1']).optional() }).strict(),
     request: NoRequestBodySchema,
-    response: CommunityPersonaDetailSchema,
+    response: CommunityPersonaDetailSchema.extend(CommunityFreshnessSchema.shape),
     error: HostApiErrorSchema,
   }),
   /**
@@ -3447,6 +4868,31 @@ export const HostApiContracts = {
     response: LlmProviderSettingsSchema,
     error: HostApiErrorSchema,
   }),
+  llmSubscriptionStatus: defineContract({
+    method: 'GET',
+    path: '/api/llm/subscriptions/:provider',
+    params: llmProviderParam,
+    request: NoRequestBodySchema,
+    response: SubscriptionStatusSchema,
+    error: HostApiErrorSchema,
+  }),
+  llmSubscriptionAction: defineContract({
+    invalidatesSnapshot: true,
+    method: 'POST',
+    path: '/api/llm/subscriptions/:provider',
+    params: llmProviderParam,
+    request: z.discriminatedUnion('action', [
+      z.object({ action: z.literal('use-subscription'), expectedRevision: z.number().int().nonnegative() }).strict(),
+      z.object({ action: z.enum(['login', 'cancel']) }).strict(),
+      z.object({ action: z.literal('answer'), promptId: NonEmptyStringSchema, value: z.string().max(4096) }).strict(),
+      z.object({ action: z.enum(['activate', 'remove']), accountId: NonEmptyStringSchema }).strict(),
+      z
+        .object({ action: z.literal('rename'), accountId: NonEmptyStringSchema, label: z.string().min(1).max(80) })
+        .strict(),
+    ]),
+    response: z.object({ status: SubscriptionStatusSchema, revocationConfirmed: z.boolean().optional() }).strict(),
+    error: HostApiErrorSchema,
+  }),
   llmDiscoverModels: defineContract({
     method: 'POST',
     path: '/api/llm/discover-models',
@@ -3594,7 +5040,19 @@ export const HostApiContracts = {
     path: '/api/dynamic/:agentId/decline',
     params: agentParam,
     request: z
-      .object({ episodeId: EpisodeIdSchema, requestId: DynamicIdSchema, pluginRunId: DynamicIdSchema.optional() })
+      .object({
+        episodeId: EpisodeIdSchema,
+        requestId: DynamicIdSchema,
+        pluginRunId: DynamicIdSchema.optional(),
+        /**
+         * Why the run did not go ahead: the user declined it, or the page could not start one of its halves. A failed
+         * half is settled as a failed attempt (its Host is retracted and the agent hears about it), not as a decline.
+         */
+        reason: z.enum(['rejected', 'host-half-failed', 'client-half-failed']).optional(),
+        startedHere: z.boolean().optional(),
+        message: z.string().max(4000).optional(),
+        stack: z.string().max(16000).optional(),
+      })
       .strict(),
     response: z.object({ accepted: z.boolean() }).strict(),
     error: HostApiErrorSchema,
@@ -3750,36 +5208,20 @@ export const HostApiContracts = {
     method: 'POST',
     path: '/api/extensions/save-from-dynamic',
     params: EmptyParamsSchema,
-    request: z.union([
-      z
-        .object({
-          taskId: AuthoringTaskIdSchema,
-          attemptId: AuthoringAttemptIdSchema,
-          displayName: z.string().trim().min(1).max(80),
-          slug: z
-            .string()
-            .trim()
-            .regex(/^[a-z0-9][a-z0-9-]{1,62}[a-z0-9]$/u),
-          description: z.string().max(500).default(''),
-          targetExtensionId: ExtensionIdSchema.optional(),
-        })
-        .strict(),
-      z
-        .object({
-          agentId: AgentIdSchema,
-          episodeId: EpisodeIdSchema,
-          pluginId: DynamicIdSchema,
-          packageId: DynamicIdSchema,
-          displayName: z.string().trim().min(1).max(80),
-          slug: z
-            .string()
-            .trim()
-            .regex(/^[a-z0-9][a-z0-9-]{1,62}[a-z0-9]$/u),
-          description: z.string().max(500).default(''),
-          targetExtensionId: ExtensionIdSchema.optional(),
-        })
-        .strict(),
-    ]),
+    request: z
+      .object({
+        taskId: AuthoringTaskIdSchema,
+        /** The candidate the user saw; saving refuses when a newer one appeared since. */
+        attemptId: AuthoringAttemptIdSchema,
+        displayName: z.string().trim().min(1).max(80),
+        slug: z
+          .string()
+          .trim()
+          .regex(/^[a-z0-9][a-z0-9-]{1,62}[a-z0-9]$/u),
+        description: z.string().max(500).default(''),
+        targetExtensionId: ExtensionIdSchema.optional(),
+      })
+      .strict(),
     response: z
       .object({
         extensionId: ExtensionIdSchema,
@@ -3860,6 +5302,7 @@ export const HostApiContracts = {
             extensionRevisionId: ExtensionRevisionIdSchema,
             config: JsonValueSchema,
             configuredSecrets: z.array(z.string()).optional(),
+            boundCredentials: BoundCredentialsSchema.optional(),
             activatedAt: z.number().int().safe().nonnegative(),
           })
           .strict()
@@ -3880,6 +5323,16 @@ export const HostApiContracts = {
     response: z.object({ disabled: z.literal(true), pending: ExtensionActivationTransitionSchema.optional() }).strict(),
     error: HostApiErrorSchema,
   }),
+  putAgentOutboundOrder: defineContract({
+    invalidatesSnapshot: true,
+    method: 'PUT',
+    path: '/api/agents/:agentId/outbound-order',
+    params: agentParam,
+    /** Every enabled extension that processes the agent's messages before sending, in the new order. */
+    request: z.object({ extensionIds: z.array(ExtensionIdSchema).max(64) }).strict(),
+    response: z.object({ extensionIds: z.array(ExtensionIdSchema) }).strict(),
+    error: HostApiErrorSchema,
+  }),
   updateExtensionActivationConfig: defineContract({
     invalidatesSnapshot: true,
     method: 'PUT',
@@ -3890,9 +5343,17 @@ export const HostApiContracts = {
         config: JsonValueSchema,
         /** Write-only credential drafts keyed by secret field; an absent or empty draft keeps the stored one. */
         secrets: z.record(z.string(), z.string().max(8192)).optional(),
+        /** Secret fields to bind to named credentials instead of a typed value; a field takes one or the other. */
+        credentialBindings: CredentialBindingsRequestSchema.optional(),
+      })
+      .strict(),
+    response: z
+      .object({
+        config: JsonValueSchema,
+        configuredSecrets: z.array(z.string()).optional(),
+        boundCredentials: BoundCredentialsSchema.optional(),
       })
       .strict(),
-    response: z.object({ config: JsonValueSchema, configuredSecrets: z.array(z.string()).optional() }).strict(),
     error: HostApiErrorSchema,
   }),
   updateHostExtensionConfig: defineContract({
@@ -3906,9 +5367,37 @@ export const HostApiContracts = {
         config: JsonValueSchema,
         /** Write-only credential drafts keyed by secret field; an absent or empty draft keeps the stored one. */
         secrets: z.record(z.string(), z.string().max(8192)).optional(),
+        /** Secret fields to bind to named credentials instead of a typed value; a field takes one or the other. */
+        credentialBindings: CredentialBindingsRequestSchema.optional(),
       })
       .strict(),
-    response: z.object({ config: JsonValueSchema, configuredSecrets: z.array(z.string()).optional() }).strict(),
+    response: z
+      .object({
+        config: JsonValueSchema,
+        configuredSecrets: z.array(z.string()).optional(),
+        boundCredentials: BoundCredentialsSchema.optional(),
+      })
+      .strict(),
+    error: HostApiErrorSchema,
+  }),
+  /** Configuration history of one extension, newest first: the host layer and every agent's configuration. */
+  getExtensionConfigVersions: defineContract({
+    method: 'GET',
+    path: '/api/extensions/:extensionId/config-versions',
+    params: extensionParam,
+    request: NoRequestBodySchema,
+    response: z.object({ versions: z.array(ExtensionConfigVersionSchema) }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  /** Writes an earlier configuration again as a new version of the same layer (and agent). */
+  revertExtensionConfig: defineContract({
+    invalidatesSnapshot: true,
+    timeoutMs: 300_000,
+    method: 'POST',
+    path: '/api/extensions/:extensionId/config-versions/:versionId/revert',
+    params: extensionConfigVersionParam,
+    request: z.object({ reason: z.string().trim().max(500).optional() }).strict(),
+    response: z.object({ version: ExtensionConfigVersionSchema }).strict(),
     error: HostApiErrorSchema,
   }),
   installHostExtension: defineContract({
@@ -3924,6 +5413,8 @@ export const HostApiContracts = {
         permissionApproval: PermissionApprovalSchema.optional(),
         /** Approval of expanded agent-layer capabilities for the agents that move to this Revision. */
         agentPermissionApproval: PermissionApprovalSchema.optional(),
+        /** Data copy to put back first, when the target Revision only reads an older data version. */
+        restoreDataSnapshotId: z.string().min(1).max(80).optional(),
       })
       .strict(),
     response: z
@@ -4040,6 +5531,15 @@ export const HostApiContracts = {
       .strict(),
     error: HostApiErrorSchema,
   }),
+  setChannelPaused: defineContract({
+    method: 'POST',
+    path: '/api/channels/:channelId/pause',
+    params: channelParam,
+    request: z.object({ paused: z.boolean() }).strict(),
+    response: z.object({ paused: z.boolean(), changed: z.boolean(), stopped: z.boolean() }).strict(),
+    error: HostApiErrorSchema,
+    invalidatesSnapshot: true,
+  }),
   resolveOutbound: defineContract({
     method: 'POST',
     path: '/api/outbound/:outboundId/resolve',
@@ -4114,6 +5614,196 @@ export const HostApiContracts = {
     response: z.object({ deleted: z.literal(true) }).strict(),
     error: HostApiErrorSchema,
   }),
+  getExtensionLineage: defineContract({
+    method: 'GET',
+    path: '/api/extensions/:extensionId/lineage',
+    params: extensionParam,
+    request: NoRequestBodySchema,
+    response: ExtensionLineageSchema,
+    error: HostApiErrorSchema,
+  }),
+  branchExtension: defineContract({
+    invalidatesSnapshot: true,
+    timeoutMs: 300_000,
+    method: 'POST',
+    path: '/api/extensions/:extensionId/branch',
+    params: extensionParam,
+    request: z
+      .object({
+        revisionId: ExtensionRevisionIdSchema,
+        name: z.string().trim().min(1).max(80),
+        slug: z
+          .string()
+          .trim()
+          .regex(/^[a-z0-9][a-z0-9-]{1,62}[a-z0-9]$/u)
+          .optional(),
+        copyData: z.boolean(),
+      })
+      .strict(),
+    response: z.object({ extensionId: ExtensionIdSchema, revisionId: ExtensionRevisionIdSchema }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  rollbackExtension: defineContract({
+    invalidatesSnapshot: true,
+    timeoutMs: 300_000,
+    method: 'POST',
+    path: '/api/extensions/:extensionId/revert',
+    params: extensionParam,
+    request: NoRequestBodySchema,
+    response: z.object({ message: z.string() }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  getExtensionData: defineContract({
+    method: 'GET',
+    path: '/api/extensions/:extensionId/data',
+    params: extensionParam,
+    request: NoRequestBodySchema,
+    response: ExtensionDataStateSchema,
+    error: HostApiErrorSchema,
+  }),
+  previewExtensionDataMigration: defineContract({
+    timeoutMs: 60_000,
+    method: 'POST',
+    path: '/api/extensions/:extensionId/data/preview',
+    params: extensionParam,
+    request: ExtensionDataMigrationInputSchema,
+    response: ExtensionDataPreviewSchema,
+    error: HostApiErrorSchema,
+  }),
+  migrateExtensionData: defineContract({
+    invalidatesSnapshot: true,
+    timeoutMs: 300_000,
+    method: 'POST',
+    path: '/api/extensions/:extensionId/data/migrate',
+    params: extensionParam,
+    request: ExtensionDataMigrationInputSchema,
+    response: z.object({ snapshotId: z.string(), preview: ExtensionDataPreviewSchema }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  exportExtensionData: defineContract({
+    method: 'GET',
+    timeoutMs: 300_000,
+    path: '/api/extensions/:extensionId/data/export',
+    params: extensionParam,
+    request: NoRequestBodySchema,
+    responseFormat: 'bytes',
+    response: z.instanceof(Uint8Array),
+    error: HostApiErrorSchema,
+  }),
+  /** The same package with the host and agent configuration; secrets are left out. */
+  exportExtensionDataWithConfig: defineContract({
+    method: 'GET',
+    timeoutMs: 300_000,
+    path: '/api/extensions/:extensionId/data/export-config',
+    params: extensionParam,
+    request: NoRequestBodySchema,
+    responseFormat: 'bytes',
+    response: z.instanceof(Uint8Array),
+    error: HostApiErrorSchema,
+  }),
+  createExtensionDataSnapshot: defineContract({
+    method: 'POST',
+    path: '/api/extensions/:extensionId/data/snapshots',
+    params: extensionParam,
+    request: z.object({ label: z.string().trim().min(1).max(80) }).strict(),
+    response: z.object({ snapshotId: z.string() }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  inspectExtensionDataPackage: defineContract({
+    timeoutMs: 300_000,
+    method: 'POST',
+    path: '/api/extensions/data/inspect',
+    params: EmptyParamsSchema,
+    request: BinaryUploadRequestSchema,
+    encodeRequest: encodeBinaryUpload,
+    response: ExtensionDataPackageInspectionSchema,
+    error: HostApiErrorSchema,
+  }),
+  listExtensionRequests: defineContract({
+    method: 'GET',
+    path: '/api/extension-requests',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: z.object({ requests: z.array(ExtensionRequestSchema) }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  approveExtensionRequest: defineContract({
+    invalidatesSnapshot: true,
+    timeoutMs: 300_000,
+    method: 'POST',
+    path: '/api/extension-requests/:number/approve',
+    params: z.object({ number: z.coerce.number().int().positive() }).strict(),
+    request: NoRequestBodySchema,
+    response: z.object({ message: z.string() }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  rejectExtensionRequest: defineContract({
+    method: 'POST',
+    path: '/api/extension-requests/:number/reject',
+    params: z.object({ number: z.coerce.number().int().positive() }).strict(),
+    request: z.object({ reason: z.string().trim().max(500).optional() }).strict(),
+    response: z.object({ ok: z.literal(true) }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  listAdministrators: defineContract({
+    method: 'GET',
+    path: '/api/administrators',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: z.object({ administrators: z.array(AdministratorSchema) }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  addAdministrator: defineContract({
+    method: 'POST',
+    path: '/api/administrators',
+    params: EmptyParamsSchema,
+    request: z.object({ identityId: PlatformIdentityIdSchema }).strict(),
+    response: AdministratorSchema,
+    error: HostApiErrorSchema,
+  }),
+  removeAdministrator: defineContract({
+    method: 'POST',
+    path: '/api/administrators/remove',
+    params: EmptyParamsSchema,
+    request: z.object({ connectionId: ConnectionIdSchema, platformUserId: z.string().min(1) }).strict(),
+    response: z.object({ ok: z.literal(true) }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  createAdministratorClaimCode: defineContract({
+    method: 'POST',
+    path: '/api/administrators/claim-code',
+    params: EmptyParamsSchema,
+    request: NoRequestBodySchema,
+    response: z.object({ code: z.string(), expiresAt: z.number().int().nonnegative() }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  dismissCommunityRelease: defineContract({
+    method: 'POST',
+    path: '/api/community/sync/:extensionId/dismiss',
+    params: extensionParam,
+    request: z.object({ releaseId: CommunityReleaseIdSchema.nullable() }).strict(),
+    response: z.object({ ok: z.literal(true) }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  updateFromCommunity: defineContract({
+    invalidatesSnapshot: true,
+    timeoutMs: 300_000,
+    method: 'POST',
+    path: '/api/community/sync/:extensionId/update',
+    params: extensionParam,
+    request: NoRequestBodySchema,
+    response: z.object({ message: z.string() }).strict(),
+    error: HostApiErrorSchema,
+  }),
+  archiveAuthoringTask: defineContract({
+    invalidatesSnapshot: true,
+    method: 'POST',
+    path: '/api/authoring/tasks/:taskId/archive',
+    params: z.object({ taskId: AuthoringTaskIdSchema }).strict(),
+    request: NoRequestBodySchema,
+    response: z.object({ ok: z.literal(true) }).strict(),
+    error: HostApiErrorSchema,
+  }),
 } as const
 
 export type HostApiContractName = keyof typeof HostApiContracts
@@ -4147,9 +5837,11 @@ const buildValidatedHostApiPath = (
   const consumed = new Set<string>()
   const pathname = contract.path.replace(pathParameterPattern, (_placeholder, key: string) => {
     const value = params[key]
-    if (typeof value !== 'string') throw new TypeError(`Host API path parameter ${key} must be a string.`)
+    if (typeof value !== 'string' && typeof value !== 'number') {
+      throw new TypeError(`Host API path parameter ${key} must be a string or number.`)
+    }
     consumed.add(key)
-    return encodeURIComponent(value)
+    return encodeURIComponent(String(value))
   })
   const query = new URLSearchParams()
   for (const [key, value] of Object.entries(params)) {
@@ -4173,3 +5865,21 @@ export function buildHostApiContractPath<Params extends AnySchema>(
 export function buildHostApiPath<Name extends HostApiContractName>(name: Name, input: HostApiParams<Name>): string {
   return buildValidatedHostApiPath(HostApiContracts[name], input)
 }
+import {
+  CommunityFeedbackDraftIdSchema,
+  CommunityFeedbackDraftInputSchema,
+  CommunityFeedbackDraftSchema,
+  CommunityFeedbackDraftUpdateSchema,
+  CommunityFeedbackLastPayloadSchema,
+  CommunityFeedbackLocalListSchema,
+  CommunityFeedbackPayloadSchema,
+  CommunityFeedbackSettingsSchema,
+  CommunityFeedbackSettingsUpdateSchema,
+  CommunityFeedbackSnapshotSchema,
+} from './community-feedback-host.js'
+import {
+  CommunityFeedbackRefSchema,
+  CommunityFeedbackSchema,
+  CommunityFeedbackWithdrawSchema,
+  CommunityFeedbackReopenSchema,
+} from './community-feedback.js'