effect 4.1.0 → 4.1.1

package/src/ai/internal/mcpCore.ts

@@ -5,6 +5,7 @@
  */
 
 import * as Arr from "../../Array.ts"
+import * as Cause from "../../Cause.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import type * as McpProtocol from "../McpProtocol.ts"
@@ -247,7 +248,8 @@ export interface ResourceTemplateRegistration {
  * @internal
  */
 export interface Resources {
-  readonly register: (registration: ResourceRegistration) => Effect.Effect<void>
+  // Synchronous, so a caller can check skill ownership and register in one step.
+  readonly register: (registration: ResourceRegistration) => void
   readonly registerTemplate: (registration: ResourceTemplateRegistration) => Effect.Effect<void>
   readonly list: (
     invocation: McpInvocation
@@ -264,6 +266,91 @@ export interface Resources {
   >
 }
 
+/**
+ * A file of a skill, with the digest and size of the bytes it is served as.
+ *
+ * @internal
+ */
+export interface SkillResource {
+  readonly uri: string
+  readonly digest: string
+  readonly size: number
+}
+
+/**
+ * A `skills/list` and `skills/get` entry. `resources` is `"dynamic"` for a
+ * skill whose content cannot carry stable digests.
+ *
+ * @internal
+ */
+export interface Skill {
+  readonly uri: string
+  readonly frontmatter: Readonly<Record<string, unknown>>
+  readonly resources: ReadonlyArray<SkillResource> | "dynamic"
+}
+
+/**
+ * A `resources/directory/read` child: a file, with the metadata
+ * `resources/list` gives it, or a subdirectory with the `inode/directory` MIME
+ * type.
+ *
+ * @internal
+ */
+export interface DirectoryChild {
+  readonly uri: string
+  readonly name: string
+  readonly description?: string | undefined
+  readonly mimeType: string
+  readonly size?: number | undefined
+}
+
+/**
+ * @internal
+ */
+export class SkillNotFound extends Data.TaggedError("SkillNotFound")<{
+  readonly uri: string
+}> {}
+
+/**
+ * @internal
+ */
+export class DirectoryNotFound extends Data.TaggedError("DirectoryNotFound")<{
+  readonly uri: string
+}> {}
+
+/**
+ * @internal
+ */
+export interface SkillRegistration {
+  readonly entry: Skill
+  readonly isVisible: (profile: NegotiatedProtocolProfile<string>) => boolean
+  readonly visible?: Visible | undefined
+  // Hides the skill's directories on `resources/directory/read`.
+  readonly visibleInDirectories?: Visible | undefined
+  readonly get: (invocation: McpInvocation) => Effect.Effect<Skill, SkillNotFound | RequestRejected>
+  // `undefined` when this skill has no directory at `uri`. Directories shared
+  // by several skills, such as a common path prefix, list the union of what
+  // each skill returns.
+  readonly directory: (uri: string) => ReadonlyArray<DirectoryChild> | undefined
+}
+
+/**
+ * @internal
+ */
+export interface Skills {
+  // Fails when the skill's directory overlaps another skill's, or one of its
+  // files is already registered as a resource.
+  readonly register: (registration: SkillRegistration) => Effect.Effect<void, Cause.IllegalArgumentError>
+  // Whether `uri` is a file of a registered skill, which only that skill may serve.
+  readonly ownsFile: (uri: string) => boolean
+  readonly list: (invocation: McpInvocation) => Effect.Effect<ReadonlyArray<Skill>, RequestRejected>
+  readonly get: (uri: string, invocation: McpInvocation) => Effect.Effect<Skill, SkillNotFound | RequestRejected>
+  readonly readDirectory: (
+    uri: string,
+    invocation: McpInvocation
+  ) => Effect.Effect<ReadonlyArray<DirectoryChild>, DirectoryNotFound | RequestRejected>
+}
+
 /**
  * @internal
  */
@@ -423,10 +510,12 @@ export interface McpCore {
   readonly resources: Resources
   readonly prompts: Prompts
   readonly completions: Completions
+  readonly skills: Skills
   readonly registrationPresence: Effect.Effect<{
     readonly tools: boolean
     readonly resources: boolean
     readonly prompts: boolean
+    readonly skills: boolean
   }>
 }
 
@@ -438,6 +527,13 @@ export interface McpCore {
  */
 export type Visible = (invocation: McpInvocation) => Effect.Effect<boolean, RequestRejected>
 
+// Whether one skill directory contains the other, or both are the same.
+const skillsOverlap = (a: string, b: string): boolean => {
+  const rootA = a.slice(0, -"/SKILL.md".length)
+  const rootB = b.slice(0, -"/SKILL.md".length)
+  return rootA === rootB || rootA.startsWith(`${rootB}/`) || rootB.startsWith(`${rootA}/`)
+}
+
 /**
  * @internal
  */
@@ -446,6 +542,8 @@ export const make: Effect.Effect<McpCore> = Effect.sync(() => {
   const resourceRegistrations: Array<ResourceRegistration> = []
   const resourceTemplateRegistrations: Array<ResourceTemplateRegistration> = []
   const promptRegistrations = new Map<string, PromptRegistration>()
+  const skillRegistrations = new Map<string, SkillRegistration>()
+  const skillFiles = new Set<string>()
   const completionRegistrations = new Map<
     string,
     (
@@ -494,15 +592,14 @@ export const make: Effect.Effect<McpCore> = Effect.sync(() => {
   }
 
   const resources: Resources = {
-    register: (registration) =>
-      Effect.sync(() => {
-        const index = resourceRegistrations.findIndex((entry) => entry.descriptor.uri === registration.descriptor.uri)
-        if (index === -1) {
-          resourceRegistrations.push(registration)
-        } else {
-          resourceRegistrations[index] = registration
-        }
-      }),
+    register: (registration) => {
+      const index = resourceRegistrations.findIndex((entry) => entry.descriptor.uri === registration.descriptor.uri)
+      if (index === -1) {
+        resourceRegistrations.push(registration)
+      } else {
+        resourceRegistrations[index] = registration
+      }
+    },
     registerTemplate: (registration) =>
       Effect.sync(() => {
         const index = resourceTemplateRegistrations.findIndex(
@@ -569,11 +666,67 @@ export const make: Effect.Effect<McpCore> = Effect.sync(() => {
     })
   }
 
+  const skills: Skills = {
+    register: (registration) =>
+      Effect.suspend(() => {
+        const { uri, resources } = registration.entry
+        const fail = (reason: string) => Effect.fail(new Cause.IllegalArgumentError(`Skill ${uri}: ${reason}`))
+        for (const other of skillRegistrations.keys()) {
+          if (skillsOverlap(uri, other)) return fail(`its directory overlaps the skill ${other}`)
+        }
+        const files = resources === "dynamic" ? [] : resources.map((resource) => resource.uri)
+        for (const file of files) {
+          if (resourceRegistrations.some((entry) => entry.descriptor.uri === file)) {
+            return fail(`${file} is already registered as a resource`)
+          }
+        }
+        skillRegistrations.set(uri, registration)
+        for (const file of files) skillFiles.add(file)
+        return Effect.void
+      }),
+    ownsFile: (uri) => skillFiles.has(uri),
+    list: (invocation) =>
+      filterList(
+        Array.from(skillRegistrations.values(), (registration) => ({
+          descriptor: registration.entry,
+          isVisible: registration.isVisible,
+          visible: registration.visible
+        })),
+        invocation
+      ),
+    get: (uri, invocation) =>
+      Effect.suspend(() => {
+        const registration = skillRegistrations.get(uri)
+        return registration !== undefined && registration.isVisible(invocation.protocol)
+          ? registration.get(invocation)
+          : Effect.fail(new SkillNotFound({ uri }))
+      }),
+    readDirectory: Effect.fnUntraced(function*(uri, invocation) {
+      const children = new Map<string, DirectoryChild>()
+      let found = false
+      for (const registration of skillRegistrations.values()) {
+        const own = registration.directory(uri)
+        if (own === undefined || !registration.isVisible(invocation.protocol)) continue
+        if (
+          registration.visibleInDirectories !== undefined &&
+          !(yield* registration.visibleInDirectories(invocation))
+        ) continue
+        found = true
+        for (const child of own) children.set(child.uri, child)
+      }
+      if (!found) {
+        return yield* new DirectoryNotFound({ uri })
+      }
+      return Array.from(children.values()).sort((a, b) => a.uri < b.uri ? -1 : a.uri > b.uri ? 1 : 0)
+    })
+  }
+
   const registrationPresence = Effect.sync(() => ({
     tools: registrations.size > 0,
     resources: resourceRegistrations.length > 0 || resourceTemplateRegistrations.length > 0,
-    prompts: promptRegistrations.size > 0
+    prompts: promptRegistrations.size > 0,
+    skills: skillRegistrations.size > 0
   }))
 
-  return { tools, resources, prompts, completions, registrationPresence }
+  return { tools, resources, prompts, completions, skills, registrationPresence }
 })

package/src/ai/internal/mcpProtocol/v2024_11_05.ts

@@ -10,9 +10,10 @@ import * as McpCore from "../mcpCore.ts"
 import * as McpProtocol from "../mcpProtocol.ts"
 import * as McpRuntime from "../mcpRuntime.ts"
 import * as McpSchema from "../mcpSchema/v2024_11_05.ts"
+import * as McpSkills from "../mcpSkills.ts"
 
 // Pings can arrive before initialize and do not require a client session.
-const ClientRequestRpcs = McpSchema.ClientRequestRpcs.omit("ping").middleware(
+const ClientRequestRpcs = McpSchema.ClientRequestRpcs.omit("ping").merge(McpSkills.LegacyRpcs).middleware(
   PublicMcpSchema.McpServerClientMiddleware
 ).add(McpSchema.Ping)
 
@@ -124,6 +125,7 @@ export const protocol = McpProtocol.make({
   handlerRpcs: AdapterRpcs,
   makeHandlers: (core, lifecycle) =>
     AdapterRpcs.of({
+      ...McpSkills.legacyHandlers(core),
       initialize: (request, { client }) =>
         lifecycle.initialize(McpSchema.protocolVersion, profileFromInitialize(request), client.id).pipe(
           Effect.map((result) =>

package/src/ai/internal/mcpProtocol/v2025_03_26.ts

@@ -10,9 +10,10 @@ import * as McpCore from "../mcpCore.ts"
 import * as McpProtocol from "../mcpProtocol.ts"
 import * as McpRuntime from "../mcpRuntime.ts"
 import * as McpSchema from "../mcpSchema/v2025_03_26.ts"
+import * as McpSkills from "../mcpSkills.ts"
 
 // Pings can arrive before initialize and do not require a client session.
-const ClientRequestRpcs = McpSchema.ClientRequestRpcs.omit("ping").middleware(
+const ClientRequestRpcs = McpSchema.ClientRequestRpcs.omit("ping").merge(McpSkills.LegacyRpcs).middleware(
   PublicMcpSchema.McpServerClientMiddleware
 ).add(McpSchema.Ping)
 
@@ -127,6 +128,7 @@ export const protocol = McpProtocol.make({
   handlerRpcs: AdapterRpcs,
   makeHandlers: (core, lifecycle) =>
     AdapterRpcs.of({
+      ...McpSkills.legacyHandlers(core),
       initialize: (request, { client }) =>
         lifecycle.initialize(McpSchema.protocolVersion, profileFromInitialize(request), client.id).pipe(
           Effect.map((result) =>

package/src/ai/internal/mcpProtocol/v2025_06_18.ts

@@ -9,9 +9,10 @@ import * as McpCore from "../mcpCore.ts"
 import * as McpProtocol from "../mcpProtocol.ts"
 import * as McpRuntime from "../mcpRuntime.ts"
 import * as McpSchema from "../mcpSchema/v2025_06_18.ts"
+import * as McpSkills from "../mcpSkills.ts"
 
 // Pings can arrive before initialize and do not require a client session.
-const ClientRequestRpcs = McpSchema.ClientRequestRpcs.omit("ping").middleware(
+const ClientRequestRpcs = McpSchema.ClientRequestRpcs.omit("ping").merge(McpSkills.LegacyRpcs).middleware(
   PublicMcpSchema.McpServerClientMiddleware
 ).add(McpSchema.Ping)
 
@@ -143,6 +144,7 @@ export const protocol = McpProtocol.make({
   handlerRpcs: AdapterRpcs,
   makeHandlers: (core, lifecycle) =>
     AdapterRpcs.of({
+      ...McpSkills.legacyHandlers(core),
       initialize: (request, { client }) =>
         lifecycle.initialize(McpSchema.protocolVersion, profileFromInitialize(request), client.id).pipe(
           Effect.map((result) =>

package/src/ai/internal/mcpProtocol/v2025_11_25.ts

@@ -8,9 +8,10 @@ import * as McpCore from "../mcpCore.ts"
 import * as McpProtocol from "../mcpProtocol.ts"
 import * as McpRuntime from "../mcpRuntime.ts"
 import * as McpSchema from "../mcpSchema/v2025_11_25.ts"
+import * as McpSkills from "../mcpSkills.ts"
 
 // Pings can arrive before initialize and do not require a client session.
-const ClientRequestRpcs = McpSchema.ClientRequestRpcs.omit("ping").middleware(
+const ClientRequestRpcs = McpSchema.ClientRequestRpcs.omit("ping").merge(McpSkills.LegacyRpcs).middleware(
   PublicMcpSchema.McpServerClientMiddleware
 ).add(McpSchema.Ping)
 
@@ -133,6 +134,7 @@ export const protocol = McpProtocol.make({
   handlerRpcs: AdapterRpcs,
   makeHandlers: (core, lifecycle) =>
     AdapterRpcs.of({
+      ...McpSkills.legacyHandlers(core),
       initialize: (request, { client }) =>
         lifecycle.initialize(McpSchema.protocolVersion, {
           protocolVersion: McpSchema.protocolVersion,

package/src/ai/internal/mcpProtocol/v2026_07_28.ts

@@ -25,6 +25,7 @@ import * as PublicMcpSchema from "../../McpSchema.ts"
 import * as McpCore from "../mcpCore.ts"
 import * as McpProtocol from "../mcpProtocol.ts"
 import * as McpSchema from "../mcpSchema/v2026_07_28.ts"
+import * as McpSkills from "../mcpSkills.ts"
 
 const InputResponses = Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown))
 const decodeRequestMetadata = Schema.decodeUnknownEffect(McpSchema.RequestMetaObject)
@@ -202,9 +203,10 @@ const projectContent = Match.type<PublicMcpSchema.ContentBlock>().pipe(
   Match.exhaustive
 )
 
-const projectResource = (resource: PublicMcpSchema.Resource) => McpSchema.Resource.make(resource)
+const projectResource = (resource: PublicMcpSchema.Resource) =>
+  McpProtocol.transcode(PublicMcpSchema.Resource, McpSchema.Resource, resource)
 const projectResourceTemplate = (resourceTemplate: PublicMcpSchema.ResourceTemplate) =>
-  McpSchema.ResourceTemplate.make(resourceTemplate)
+  McpProtocol.transcode(PublicMcpSchema.ResourceTemplate, McpSchema.ResourceTemplate, resourceTemplate)
 
 const projectPrompt = (prompt: PublicMcpSchema.Prompt) =>
   McpProtocol.transcode(PublicMcpSchema.Prompt, McpSchema.Prompt, prompt)
@@ -231,6 +233,8 @@ const projectCompleteResult = Effect.fnUntraced(function*(
 type ProtocolError =
   | McpCore.ResourceNotFound
   | McpCore.PromptNotFound
+  | McpCore.SkillNotFound
+  | McpCore.DirectoryNotFound
   | McpCore.ToolError
   | McpCore.UnsupportedByProtocol
   | McpProtocol.ProtocolError
@@ -297,7 +301,7 @@ const unsupported = (
 /**
  * @internal
  */
-export const handlerRpcs = McpSchema.ClientRequestRpcs.merge(McpSchema.ClientNotificationRpcs)
+export const handlerRpcs = McpSchema.ClientRequestRpcs.merge(McpSchema.ClientNotificationRpcs, McpSkills.StatelessRpcs)
 
 /**
  * @internal
@@ -320,6 +324,9 @@ export const makeHandlers = (
   ]))
   const decodeCompleteResult = Schema.decodeUnknownEffect(McpSchema.CompleteResult)
   const decodeListToolsResult = Schema.decodeUnknownEffect(McpSchema.ListToolsResult)
+  const decodeListSkillsResult = Schema.decodeUnknownEffect(McpSkills.ListSkillsResult)
+  const decodeGetSkillResult = Schema.decodeUnknownEffect(McpSkills.GetSkillResult)
+  const decodeReadResourceDirectoryResult = Schema.decodeUnknownEffect(McpSkills.ReadResourceDirectoryResult)
   const sendNotification = context.sendNotification
   const supportsSubscriptions = sendNotification !== undefined
   // Older adapters accept arbitrary JSON; this binding requires extension settings objects.
@@ -334,7 +341,8 @@ export const makeHandlers = (
   }
   const getDiscovery = Effect.map(context.registrationPresence, (presence) => {
     const capabilities: Types.Mutable<typeof McpSchema.ServerCapabilities.Type> = { completions: {}, logging: {} }
-    if (extensions !== undefined) capabilities.extensions = extensions
+    const declared = McpSkills.declareExtension(extensions, presence.skills)
+    if (declared !== undefined) capabilities.extensions = declared
     if (presence.tools) capabilities.tools = { listChanged: supportsSubscriptions }
     if (presence.resources) {
       capabilities.resources = { listChanged: supportsSubscriptions, subscribe: supportsSubscriptions }
@@ -342,6 +350,10 @@ export const makeHandlers = (
     if (presence.prompts) capabilities.prompts = { listChanged: supportsSubscriptions }
     return { supportedVersions: context.supportedVersions, capabilities, serverInfo: context.serverInfo }
   })
+  const requireSkills = (method: string) =>
+    McpSkills.requireSkills(core, method).pipe(
+      Effect.catch((error) => failWithHttpStatus(404, error))
+    )
   const getInvocation = PublicMcpSchema.McpRequestContext.useSync(
     McpProtocol.invocationFromRequestContext
   )
@@ -502,7 +514,7 @@ export const makeHandlers = (
       const resources = yield* core.resources.list(invocation)
       const result = yield* projectCompleteResult({
         ...cacheHint("resources"),
-        resources: resources.map(projectResource)
+        resources: yield* Effect.forEach(resources, projectResource)
       }, context.serverInfo)
       return yield* decodeListResourcesResult(result)
     }, Effect.mapError(projectError)),
@@ -513,7 +525,7 @@ export const makeHandlers = (
       const resourceTemplates = yield* core.resources.listTemplates(invocation)
       const result = yield* projectCompleteResult({
         ...cacheHint("resourceTemplates"),
-        resourceTemplates: resourceTemplates.map(projectResourceTemplate)
+        resourceTemplates: yield* Effect.forEach(resourceTemplates, projectResourceTemplate)
       }, context.serverInfo)
       return yield* decodeListResourceTemplatesResult(result)
     }, Effect.mapError(projectError)),
@@ -673,6 +685,28 @@ export const makeHandlers = (
         context.serverInfo
       )
     }, Effect.mapError(projectError)),
+    "skills/list": Effect.fnUntraced(function*(request: typeof McpSkills.ListSkills.payloadSchema.Type) {
+      yield* requireSkills("skills/list")
+      yield* McpSkills.rejectCursor(request.cursor)
+      const skills = yield* core.skills.list(yield* getInvocation)
+      const result = yield* projectCompleteResult({ ...cacheHint("skills"), skills }, context.serverInfo)
+      return yield* decodeListSkillsResult(result)
+    }, Effect.mapError(projectError)),
+    "skills/get": Effect.fnUntraced(function*(request: typeof McpSkills.GetSkill.payloadSchema.Type) {
+      yield* requireSkills("skills/get")
+      const skill = yield* core.skills.get(request.uri, yield* getInvocation)
+      const result = yield* projectCompleteResult({ ...cacheHint("skills"), skill }, context.serverInfo)
+      return yield* decodeGetSkillResult(result)
+    }, Effect.mapError(projectError)),
+    "resources/directory/read": Effect.fnUntraced(function*(
+      request: typeof McpSkills.ReadResourceDirectory.payloadSchema.Type
+    ) {
+      yield* requireSkills("resources/directory/read")
+      yield* McpSkills.rejectCursor(request.cursor)
+      const resources = yield* core.skills.readDirectory(request.uri, yield* getInvocation)
+      const result = yield* projectCompleteResult({ ...cacheHint("skills"), resources }, context.serverInfo)
+      return yield* decodeReadResourceDirectoryResult(result)
+    }, Effect.mapError(projectError)),
     "notifications/cancelled": Effect.fnUntraced(function*(
       _request: typeof McpSchema.CancelledNotification.payloadSchema.Type
     ) {
@@ -696,7 +730,7 @@ const runtime = {
 export const protocol = McpProtocol.make({
   protocolVersion: McpSchema.protocolVersion,
   runtime,
-  clientRpcs: McpSchema.ClientRpcs,
+  clientRpcs: McpSchema.ClientRpcs.merge(McpSkills.StatelessRpcs),
   clientNotificationRpcs: McpSchema.ClientNotificationRpcs,
   serverRequestRpcs: McpSchema.ServerRequestRpcs,
   serverNotificationRpcs: McpSchema.ServerNotificationRpcs,

package/src/ai/internal/mcpProtocol.ts

@@ -257,6 +257,20 @@ export class ProtocolError extends Data.TaggedError("ProtocolError")<{
           message: `Prompt '${error.name}' not found`
         })
       }
+      if (error._tag === "SkillNotFound" && Predicate.hasProperty(error, "uri") && Predicate.isString(error.uri)) {
+        return new ProtocolError({
+          code: PublicMcpSchema.INVALID_PARAMS_ERROR_CODE,
+          message: `Skill '${error.uri}' not found`
+        })
+      }
+      if (
+        error._tag === "DirectoryNotFound" && Predicate.hasProperty(error, "uri") && Predicate.isString(error.uri)
+      ) {
+        return new ProtocolError({
+          code: PublicMcpSchema.INVALID_PARAMS_ERROR_CODE,
+          message: `Directory '${error.uri}' not found`
+        })
+      }
       if (error._tag === "ResourceNotFound" && Predicate.hasProperty(error, "uri") && Predicate.isString(error.uri)) {
         return new ProtocolError({
           code: LEGACY_RESOURCE_NOT_FOUND_ERROR_CODE,
@@ -450,6 +464,7 @@ export interface HandlerInstallationContext {
     readonly tools: boolean
     readonly resources: boolean
     readonly prompts: boolean
+    readonly skills: boolean
   }>
 }
 

package/src/ai/internal/mcpRuntime.ts

@@ -19,11 +19,13 @@ import * as Result from "../../Result.ts"
 import * as RpcGroup from "../../rpc/RpcGroup.ts"
 import type * as RpcMessage from "../../rpc/RpcMessage.ts"
 import type * as Scope from "../../Scope.ts"
+import type * as Types from "../../Types.ts"
 import type * as PublicMcpProtocol from "../McpProtocol.ts"
 import * as PublicMcpSchema from "../McpSchema.ts"
 import type * as McpCore from "./mcpCore.ts"
 import * as McpProtocol from "./mcpProtocol.ts"
 import * as McpProtocolRegistry from "./mcpProtocolRegistry.ts"
+import * as McpSkills from "./mcpSkills.ts"
 import * as McpStatefulRuntime from "./mcpStatefulRuntime.ts"
 
 const MCP_SESSION_ID_HEADER = "mcp-session-id"
@@ -542,16 +544,17 @@ export const make = Effect.fnUntraced(function*(
             const presence = yield* options.core.registrationPresence
             return yield* Effect.withFiber((fiber) => {
               const httpRequest = Context.getOrUndefined(fiber.context, HttpServerRequest.HttpServerRequest)
-              const capabilities: McpCore.CanonicalServerCapabilities = {
+              const capabilities: Types.Mutable<McpCore.CanonicalServerCapabilities> = {
                 completions: true,
                 logging: true,
                 ...(presence.tools ? { tools: { listChanged: true } } : {}),
                 ...(presence.resources
                   ? { resources: { listChanged: true, subscribe: httpRequest === undefined } }
                   : {}),
-                ...(presence.prompts ? { prompts: { listChanged: true } } : {}),
-                ...(options.serverInfo.extensions ? { extensions: options.serverInfo.extensions } : {})
+                ...(presence.prompts ? { prompts: { listChanged: true } } : {})
               }
+              const extensions = McpSkills.declareExtension(options.serverInfo.extensions, presence.skills)
+              if (extensions !== undefined) capabilities.extensions = extensions
               const initializePayload = PublicMcpSchema.Initialize.payloadSchema.make({
                 protocolVersion,
                 capabilities: profile.clientCapabilities,