@nekro-nxt/contracts 0.2.0 → 0.4.0

package/src/extension-capabilities.ts

@@ -2,10 +2,28 @@ import { z } from 'zod'
 
 /**
  * Host capability level this build implements. A Revision that declares `requires.sdk` above it is rejected at
- * import with an "upgrade NekroNXT" message instead of an opaque schema error. Bump only when a new optional
- * Manifest capability ships; never reuse a level for a different meaning.
+ * import with an "upgrade NekroNXT" message instead of an opaque schema error. Bump when a Manifest capability
+ * ships; never reuse a level for a different meaning. Level 7 is Manifest V7 (host instance + agent attachments); level 8 adds the asset library, image info, tool result
+ * images, the search index and host-layer model calls.
  */
-export const EXTENSION_SDK_LEVEL = 6
+export const EXTENSION_SDK_LEVEL = 8
+
+/**
+ * The first NekroNXT version of each capability level, so users read "needs NekroNXT 0.5.0" rather than a level
+ * number. Add the row for a new level in the change that raises EXTENSION_SDK_LEVEL; a test keeps the two in step.
+ */
+export const EXTENSION_SDK_RELEASES: readonly { readonly level: number; readonly version: string }[] = [
+  { level: 6, version: '0.3.0' },
+  { level: 7, version: '0.4.0' },
+  { level: 8, version: '0.5.0' },
+]
+
+/** The oldest NekroNXT version that supports `level`; undefined for a level no release supports yet. */
+export const extensionSdkVersion = (level: number): string | undefined =>
+  EXTENSION_SDK_RELEASES.find((release) => release.level >= level)?.version
+
+/** Manifest V7 itself; extensions that use nothing newer need this level. */
+export const EXTENSION_SDK_BASE_LEVEL = 7
 
 export const ExtensionRequiresSchema = z.object({ sdk: z.number().int().min(1).max(1000) }).strict()
 export type ExtensionRequires = z.output<typeof ExtensionRequiresSchema>
@@ -150,6 +168,86 @@ export const ExtensionPlatformCapabilitySchema = z
   .strict()
 export type ExtensionPlatformCapability = z.output<typeof ExtensionPlatformCapabilitySchema>
 
+export const EXTENSION_ASSET_LIBRARY_DEFAULT_QUOTA_BYTES = 2 * 1024 * 1024 * 1024
+export const EXTENSION_ASSET_LIBRARY_MAX_QUOTA_BYTES = 32 * 1024 * 1024 * 1024
+
+export const ExtensionAssetLibraryCapabilitySchema = z
+  .object({
+    quotaBytes: z
+      .number()
+      .int()
+      .min(1024 * 1024)
+      .max(EXTENSION_ASSET_LIBRARY_MAX_QUOTA_BYTES)
+      .optional(),
+  })
+  .strict()
+export type ExtensionAssetLibraryCapability = z.output<typeof ExtensionAssetLibraryCapabilitySchema>
+
+/**
+ * `write` creates Assets in the current channel; `library` keeps Assets in the extension's own library so they can be
+ * used in any channel later.
+ */
+export const ExtensionAssetsCapabilitySchema = z
+  .object({
+    write: z.literal(true).optional(),
+    library: ExtensionAssetLibraryCapabilitySchema.optional(),
+  })
+  .strict()
+  .refine((value) => value.write !== undefined || value.library !== undefined, 'assets 至少声明 write 或 library。')
+export type ExtensionAssetsCapability = z.output<typeof ExtensionAssetsCapabilitySchema>
+
+const IndexNameSchema = z
+  .string()
+  .trim()
+  .regex(/^[a-z][a-z0-9_]{0,31}$/u, '索引、字段和过滤项名称只能使用小写字母、数字和下划线，以字母开头。')
+
+export const EXTENSION_INDEX_MAX_TEXT_FIELDS = 4
+export const EXTENSION_INDEX_MAX_FILTERS = 4
+
+/**
+ * One searchable collection. Text fields are matched by keywords (and vectors when the Host has them enabled); weights
+ * rank keyword matches. Filter fields hold short keyword values, possibly several per document.
+ */
+export const ExtensionIndexCollectionSchema = z
+  .object({
+    name: IndexNameSchema,
+    fields: z
+      .array(z.object({ name: IndexNameSchema, weight: z.number().min(0.1).max(10).default(1) }).strict())
+      .min(1)
+      .max(EXTENSION_INDEX_MAX_TEXT_FIELDS),
+    filters: z.array(IndexNameSchema).max(EXTENSION_INDEX_MAX_FILTERS).default([]),
+  })
+  .strict()
+  .superRefine((value, context) => {
+    const names = [...value.fields.map(({ name }) => name), ...value.filters]
+    if (new Set(names).size !== names.length) {
+      context.addIssue({ code: 'custom', message: '同一索引里的字段与过滤项不能重名。' })
+    }
+  })
+export type ExtensionIndexCollection = z.output<typeof ExtensionIndexCollectionSchema>
+
+export const ExtensionIndexCapabilitySchema = z
+  .object({
+    collections: z
+      .array(ExtensionIndexCollectionSchema)
+      .min(1)
+      .max(4)
+      .refine((value) => new Set(value.map(({ name }) => name)).size === value.length, '索引名称不能重复。'),
+  })
+  .strict()
+export type ExtensionIndexCapability = z.output<typeof ExtensionIndexCapabilitySchema>
+
+export const EXTENSION_MODEL_MAX_CALLS_PER_MINUTE = 120
+
+/** Calls to a model the user picks from the Host's configured models, with images allowed; host layer only. */
+export const ExtensionModelsCapabilitySchema = z
+  .object({
+    maxCallsPerMinute: z.number().int().min(1).max(EXTENSION_MODEL_MAX_CALLS_PER_MINUTE),
+    maxOutputTokens: z.number().int().min(64).max(EXTENSION_LLM_MAX_OUTPUT_TOKENS),
+  })
+  .strict()
+export type ExtensionModelsCapability = z.output<typeof ExtensionModelsCapabilitySchema>
+
 /** A header or environment value: literal text, or the current value of a `meta.role: 'secret'` config field. */
 export const ExtensionMcpValueSchema = z.union([
   z.string().max(4096),
@@ -252,17 +350,17 @@ const mcpTarget = (server: ExtensionMcpServer): string =>
     : JSON.stringify(['streamable-http', server.name, server.url])
 
 /**
- * Optional Host capabilities of an agent-scope Revision. Every field is additive to Manifest V6: an absent field
- * means the Revision cannot use that capability, exactly as before the field existed.
+ * Agent-layer capabilities (`permissions.agent`): what the extension may do inside the agents it is enabled for. An
+ * absent field means the extension cannot use that capability.
  */
 export const ExtensionCapabilitiesSchema = z
   .object({
     network: ExtensionNetworkCapabilitySchema.optional(),
     storage: ExtensionStorageCapabilitySchema.optional(),
-    assets: z
-      .object({ write: z.literal(true) })
-      .strict()
-      .optional(),
+    assets: ExtensionAssetsCapabilitySchema.optional(),
+    index: ExtensionIndexCapabilitySchema.optional(),
+    /** Host layer only; the agent layer uses `llm`, which runs on the agent's own model. */
+    models: ExtensionModelsCapabilitySchema.optional(),
     history: z
       .object({ read: z.literal(true) })
       .strict()
@@ -281,6 +379,45 @@ export const ExtensionCapabilitiesSchema = z
   .strict()
 export type ExtensionCapabilities = z.output<typeof ExtensionCapabilitiesSchema>
 
+/**
+ * Host-layer capabilities (`permissions.host`): what the extension's single host instance may do through the `nxt`
+ * service its factory receives. Host storage is the extension's `shared` partition.
+ */
+export const HostLayerCapabilitiesSchema = z
+  .object({
+    network: ExtensionNetworkCapabilitySchema.optional(),
+    storage: z
+      .object({ quotaBytes: z.number().int().min(1024).max(EXTENSION_STORAGE_MAX_QUOTA_BYTES).optional() })
+      .strict()
+      .optional(),
+    /** The same library agent attachments use; the host instance lists and imports into it. */
+    assets: z.object({ library: ExtensionAssetLibraryCapabilitySchema }).strict().optional(),
+    /** The same collections agent attachments declare; pages search and maintain them. */
+    index: ExtensionIndexCapabilitySchema.optional(),
+    models: ExtensionModelsCapabilitySchema.optional(),
+  })
+  .strict()
+export type HostLayerCapabilities = z.output<typeof HostLayerCapabilitiesSchema>
+
+/** Host-layer capabilities in the agent-capability shape, so digests, expansion and summaries share one implementation. */
+export const hostLayerAsCapabilities = (host: HostLayerCapabilities | undefined): ExtensionCapabilities | undefined =>
+  host === undefined || Object.keys(host).length === 0
+    ? undefined
+    : {
+        ...(host.network === undefined ? {} : { network: host.network }),
+        ...(host.storage === undefined
+          ? {}
+          : {
+              storage: {
+                scopes: ['shared'],
+                ...(host.storage.quotaBytes === undefined ? {} : { quotaBytes: host.storage.quotaBytes }),
+              },
+            }),
+        ...(host.assets === undefined ? {} : { assets: { library: host.assets.library } }),
+        ...(host.index === undefined ? {} : { index: host.index }),
+        ...(host.models === undefined ? {} : { models: host.models }),
+      }
+
 const NETWORK_MODE_RANK = { domains: 0, config: 1, unrestricted: 2 } as const
 
 const networkExpands = (
@@ -313,7 +450,16 @@ export const extensionCapabilitiesExpand = (
   if (next === undefined) return false
   if (networkExpands(previous?.network, next.network)) return true
   if (next.storage?.scopes.some((scope) => !(previous?.storage?.scopes ?? []).includes(scope))) return true
-  if (next.assets !== undefined && previous?.assets === undefined) return true
+  if (next.assets?.write !== undefined && previous?.assets?.write === undefined) return true
+  if (next.assets?.library !== undefined && previous?.assets?.library === undefined) return true
+  if (
+    next.models !== undefined &&
+    (previous?.models === undefined ||
+      next.models.maxCallsPerMinute > previous.models.maxCallsPerMinute ||
+      next.models.maxOutputTokens > previous.models.maxOutputTokens)
+  ) {
+    return true
+  }
   if (next.history !== undefined && previous?.history === undefined) return true
   const platformKey = ({ adapter, action }: { readonly adapter: string; readonly action: string }) =>
     `${adapter}:${action}`
@@ -350,6 +496,11 @@ export const extensionCapabilitiesExpand = (
   return false
 }
 
+const formatLibraryQuota = (bytes: number): string =>
+  bytes >= 1024 * 1024 * 1024
+    ? `${+(bytes / 1024 / 1024 / 1024).toFixed(1)} GB`
+    : `${Math.round(bytes / 1024 / 1024)} MB`
+
 /** Capability risk tiers shown on the approval page (§7 of the capability decision). */
 export type ExtensionCapabilityRisk = 'normal' | 'sensitive' | 'high'
 
@@ -360,9 +511,17 @@ export interface ExtensionCapabilitySummaryItem {
   readonly detail?: string
 }
 
-/** User-facing summary of declared capabilities, in a stable order, for approval and inspection pages. */
+/**
+ * User-facing summary of declared capabilities, in a stable order, for approval and inspection pages. `layer: 'host'`
+ * phrases host-layer capabilities (passed through {@link hostLayerAsCapabilities}) for the host instance.
+ */
 export const summarizeExtensionCapabilities = (
   capabilities: ExtensionCapabilities | undefined,
+  options: {
+    readonly layer?: 'host' | 'agent'
+    /** Display name of a config field, so `network.mode: 'config'` names the fields as the user knows them. */
+    readonly fieldTitle?: (key: string) => string
+  } = {},
 ): readonly ExtensionCapabilitySummaryItem[] => {
   if (capabilities === undefined) return []
   const items: ExtensionCapabilitySummaryItem[] = []
@@ -370,11 +529,18 @@ export const summarizeExtensionCapabilities = (
   if (network?.mode === 'domains') {
     items.push({ key: 'network', risk: 'normal', label: '访问指定网站', detail: network.domains.join('、') })
   } else if (network?.mode === 'config') {
-    items.push({ key: 'network', risk: 'normal', label: '访问你在配置中填写的地址', detail: network.fields.join('、') })
+    items.push({
+      key: 'network',
+      risk: 'normal',
+      label: '访问你在配置中填写的地址',
+      detail: network.fields.map((field) => options.fieldTitle?.(field) ?? field).join('、'),
+    })
   } else if (network?.mode === 'unrestricted') {
     items.push({ key: 'network', risk: 'high', label: '访问任意公网地址', detail: network.purpose })
   }
-  if (capabilities.storage !== undefined) {
+  if (capabilities.storage !== undefined && options.layer === 'host') {
+    items.push({ key: 'storage', risk: 'normal', label: '在本机保存扩展数据，页面与启用它的智能体共用' })
+  } else if (capabilities.storage !== undefined) {
     const shared = capabilities.storage.scopes.includes('shared')
     items.push({
       key: 'storage',
@@ -382,8 +548,32 @@ export const summarizeExtensionCapabilities = (
       label: shared ? '保存数据，并在启用它的智能体之间共享' : '为这个智能体保存数据',
     })
   }
-  if (capabilities.assets !== undefined)
+  if (capabilities.assets?.write !== undefined)
     items.push({ key: 'assets', risk: 'normal', label: '在当前频道生成图片或文件' })
+  if (capabilities.assets?.library !== undefined) {
+    items.push({
+      key: 'assets.library',
+      risk: 'sensitive',
+      label: '把频道里的图片收进扩展资源库，之后可以在其他频道使用',
+      detail: `最多 ${formatLibraryQuota(capabilities.assets.library.quotaBytes ?? EXTENSION_ASSET_LIBRARY_DEFAULT_QUOTA_BYTES)}`,
+    })
+  }
+  if (capabilities.index !== undefined) {
+    items.push({
+      key: 'index',
+      risk: 'normal',
+      label: '建立可搜索的索引',
+      detail: capabilities.index.collections.map(({ name }) => name).join('、'),
+    })
+  }
+  if (capabilities.models !== undefined) {
+    items.push({
+      key: 'models',
+      risk: 'sensitive',
+      label: '使用本机已配置的模型，可以发送图片',
+      detail: `每分钟最多 ${capabilities.models.maxCallsPerMinute} 次，计入所选模型的用量`,
+    })
+  }
   if (capabilities.history !== undefined)
     items.push({ key: 'history', risk: 'normal', label: '读取当前频道的聊天记录' })
   const hook = capabilities.inboundHook

package/src/extension-ui.ts

@@ -1,5 +1,10 @@
 import { z } from 'zod'
-import { ExtensionCapabilitiesSchema } from './extension-capabilities.js'
+import {
+  ExtensionCapabilitiesSchema,
+  HostLayerCapabilitiesSchema,
+  hostLayerAsCapabilities,
+  EXTENSION_SDK_BASE_LEVEL,
+} from './extension-capabilities.js'
 import { ExtensionIdSchema, ExtensionRevisionIdSchema, HostUiPageInstanceIdSchema } from './domain.js'
 import { ConfigSchemaDocumentSchema } from './config-schema.js'
 
@@ -132,11 +137,23 @@ export const HostPageContributionSchema = z
       .string()
       .trim()
       .regex(/^(?:[a-z0-9][a-z0-9/_-]*)?$/u),
+    /** Registers a navigation rail entry for this page; at most one page of an extension may declare it. */
+    rail: z
+      .object({ order: z.number().int().min(0).max(999).optional() })
+      .strict()
+      .optional(),
   })
   .strict()
 
 export type HostPageContribution = z.output<typeof HostPageContributionSchema>
 
+/** Rail position of a page that registers a rail entry without an explicit order. */
+export const HOST_PAGE_DEFAULT_RAIL_ORDER = 100
+
+/** The stored rail position of a page; `null` when the page has no rail entry. */
+export const hostPageRailOrder = (page: Pick<HostPageContribution, 'rail'>): number | null =>
+  page.rail === undefined ? null : (page.rail.order ?? HOST_PAGE_DEFAULT_RAIL_ORDER)
+
 export const HostUiNavigationItemSchema = z
   .object({
     id: z.string().trim().min(1).max(80),
@@ -189,31 +206,96 @@ export const HostUiNetworkOriginSchema = z
     return url.origin
   })
 
+const checkBrowserPermissions = (
+  value: { readonly permissions: readonly HostUiPermission[]; readonly networkOrigins: readonly string[] },
+  context: z.RefinementCtx,
+): void => {
+  if (new Set(value.permissions).size !== value.permissions.length) {
+    context.addIssue({ code: 'custom', path: ['permissions'], message: 'Host UI permissions must be unique.' })
+  }
+  if (new Set(value.networkOrigins).size !== value.networkOrigins.length) {
+    context.addIssue({ code: 'custom', path: ['networkOrigins'], message: 'Host UI network origins must be unique.' })
+  }
+  if (value.networkOrigins.length > 0 && !value.permissions.includes('network.request')) {
+    context.addIssue({
+      code: 'custom',
+      path: ['networkOrigins'],
+      message: 'Host UI network origins require network.request.',
+    })
+  }
+}
+
+/**
+ * One approval: browser-side permissions plus the capabilities of one layer. Grants, digests and the approval page
+ * use this shape for both the host approval and each agent approval.
+ */
 export const HostUiPermissionDeclarationSchema = z
   .object({
     permissions: z.array(HostUiPermissionSchema).max(HostUiPermissionSchema.options.length),
     networkOrigins: z.array(HostUiNetworkOriginSchema).max(32).default([]),
-    /** Host capabilities of an agent-scope Revision; absent keeps the pre-capability digest unchanged. */
     capabilities: ExtensionCapabilitiesSchema.optional(),
   })
   .strict()
+  .superRefine(checkBrowserPermissions)
+
+export type HostUiPermissionDeclaration = z.output<typeof HostUiPermissionDeclarationSchema>
+
+/**
+ * Manifest V7 `permissions`: browser-side permissions of pages and panels (`host.call`), host-layer capabilities used
+ * by the single host instance, and agent-layer capabilities used inside each enabled agent.
+ */
+export const ExtensionPermissionsSchema = z
+  .object({
+    permissions: z.array(HostUiPermissionSchema).max(HostUiPermissionSchema.options.length).default([]),
+    networkOrigins: z.array(HostUiNetworkOriginSchema).max(32).default([]),
+    host: HostLayerCapabilitiesSchema.optional(),
+    agent: ExtensionCapabilitiesSchema.optional(),
+  })
+  .strict()
+  .superRefine(checkBrowserPermissions)
   .superRefine((value, context) => {
-    if (new Set(value.permissions).size !== value.permissions.length) {
-      context.addIssue({ code: 'custom', path: ['permissions'], message: 'Host UI permissions must be unique.' })
-    }
-    if (new Set(value.networkOrigins).size !== value.networkOrigins.length) {
-      context.addIssue({ code: 'custom', path: ['networkOrigins'], message: 'Host UI network origins must be unique.' })
-    }
-    if (value.networkOrigins.length > 0 && !value.permissions.includes('network.request')) {
+    if (value.agent?.models !== undefined) {
       context.addIssue({
         code: 'custom',
-        path: ['networkOrigins'],
-        message: 'Host UI network origins require network.request.',
+        path: ['agent', 'models'],
+        message: 'models 只能在 permissions.host 中声明；智能体层使用 llm 调用智能体自己的模型。',
       })
     }
+    // Both layers read and write the same collections, so a name must mean one definition.
+    for (const collection of value.agent?.index?.collections ?? []) {
+      const host = value.host?.index?.collections.find(({ name }) => name === collection.name)
+      if (host !== undefined && JSON.stringify(host) !== JSON.stringify(collection)) {
+        context.addIssue({
+          code: 'custom',
+          path: ['agent', 'index'],
+          message: `索引 ${collection.name} 在 permissions.host 与 permissions.agent 中的定义不一致。`,
+        })
+      }
+    }
   })
 
-export type HostUiPermissionDeclaration = z.output<typeof HostUiPermissionDeclarationSchema>
+export type ExtensionPermissions = z.output<typeof ExtensionPermissionsSchema>
+
+export const EMPTY_EXTENSION_PERMISSIONS: ExtensionPermissions = { permissions: [], networkOrigins: [] }
+
+/** What installing the extension on this machine asks the user to approve. */
+export const hostPermissionDeclaration = (permissions: ExtensionPermissions): HostUiPermissionDeclaration => {
+  const capabilities = hostLayerAsCapabilities(permissions.host)
+  return {
+    permissions: [...permissions.permissions],
+    networkOrigins: [...permissions.networkOrigins],
+    ...(capabilities === undefined ? {} : { capabilities }),
+  }
+}
+
+/** What enabling the extension for one agent asks the user to approve. */
+export const agentPermissionDeclaration = (permissions: ExtensionPermissions): HostUiPermissionDeclaration => ({
+  permissions: [],
+  networkOrigins: [],
+  ...(permissions.agent === undefined || Object.keys(permissions.agent).length === 0
+    ? {}
+    : { capabilities: permissions.agent }),
+})
 
 export const HostUiOwnerSchema = z.discriminatedUnion('kind', [
   z
@@ -246,6 +328,11 @@ export const HostUiPageEntrySchema = z
     startPath: z.string(),
     visible: z.boolean(),
     sortOrder: z.number().int().nonnegative(),
+    /** Present when the page registered a navigation rail entry; lower orders come first. */
+    rail: z
+      .object({ order: z.number().int().min(0).max(999) })
+      .strict()
+      .optional(),
     routeBase: z.string().regex(/^\/apps\/hup_[0-9A-Za-z]+$/u),
     client: z
       .object({
@@ -308,8 +395,17 @@ export type DshNxtHostUi = z.output<typeof DshNxtHostUiSchema>
 export const ExtensionPanelAnchorSchema = z.enum(['agent', 'channel', 'extension', 'connection'])
 export type ExtensionPanelAnchor = z.output<typeof ExtensionPanelAnchorSchema>
 
-export const AGENT_PANEL_ANCHORS = ['agent', 'channel', 'extension'] as const satisfies readonly ExtensionPanelAnchor[]
-export const ADAPTER_PANEL_ANCHORS = ['connection', 'channel'] as const satisfies readonly ExtensionPanelAnchor[]
+/**
+ * Which layer a panel belongs to. Agent and channel panels follow the agents the extension is enabled for (a channel
+ * panel also shows on channels of the extension's own adapter); extension and connection panels belong to the host
+ * instance.
+ */
+export const PANEL_ANCHOR_LAYER = {
+  agent: 'agent',
+  channel: 'agent',
+  extension: 'host',
+  connection: 'host',
+} as const satisfies Readonly<Record<ExtensionPanelAnchor, 'agent' | 'host'>>
 
 export const PanelDensitySchema = z.enum(['compact', 'full'])
 export type PanelDensity = z.output<typeof PanelDensitySchema>
@@ -402,10 +498,22 @@ export const MessageRendererContributionSchema = z
   .strict()
 export type MessageRendererContribution = z.output<typeof MessageRendererContributionSchema>
 
-/** Optional configuration surface shared by every extension scope. */
+/** What an extension provides, derived from its Manifest; for listing and filtering, never a lifecycle switch. */
+export const EXTENSION_PROVIDES = ['agent', 'page', 'adapter', 'mcp'] as const
+export const ExtensionProvideSchema = z.enum(EXTENSION_PROVIDES)
+export type ExtensionProvide = z.output<typeof ExtensionProvideSchema>
+
+/** One configuration form: a serialized Schemastery document. */
 export const ExtensionConfigDeclarationSchema = z.object({ schema: ConfigSchemaDocumentSchema }).strict()
 export type ExtensionConfigDeclaration = z.output<typeof ExtensionConfigDeclarationSchema>
 
+/** Manifest V7 `config`: the host instance's configuration and each enabled agent's configuration. */
+export const ExtensionLayeredConfigSchema = z
+  .object({ host: ExtensionConfigDeclarationSchema.optional(), agent: ExtensionConfigDeclarationSchema.optional() })
+  .strict()
+export type ExtensionLayeredConfig = z.output<typeof ExtensionLayeredConfigSchema>
+export type ExtensionConfigLayer = 'host' | 'agent'
+
 /** Product projection of what one Revision contributes to the shell. */
 export const ExtensionUiContributionsSchema = z
   .object({
@@ -431,3 +539,22 @@ export const EXTENSION_DATA_HOOK_PERMISSIONS = {
 } as const satisfies Readonly<Record<string, HostUiPermission>>
 
 export type ExtensionDataHookName = keyof typeof EXTENSION_DATA_HOOK_PERMISSIONS
+
+/**
+ * The capability level a set of permissions needs: Manifest V7 itself, or the level that introduced the newest
+ * capability it declares. Packaging and import compare it with `requires.sdk`, so an extension cannot claim a level
+ * too old for what it uses.
+ */
+export const requiredExtensionSdkLevel = (
+  permissions: ExtensionPermissions | undefined,
+): { readonly level: number; readonly capabilities: readonly string[] } => {
+  const level8 = [
+    permissions?.host?.assets === undefined ? undefined : '扩展资源库',
+    permissions?.agent?.assets?.library === undefined ? undefined : '扩展资源库',
+    permissions?.host?.index === undefined && permissions?.agent?.index === undefined ? undefined : '检索索引',
+    permissions?.host?.models === undefined ? undefined : '本机层模型调用',
+  ].filter((name): name is string => name !== undefined)
+  return level8.length > 0
+    ? { level: 8, capabilities: [...new Set(level8)] }
+    : { level: EXTENSION_SDK_BASE_LEVEL, capabilities: [] }
+}