effect 4.1.0 → 4.1.2

package/src/ai/Tool.ts

@@ -2096,8 +2096,9 @@ export const getStrictMode = <T extends Any>(tool: T): boolean | undefined => Co
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-const suspectProtoRx = /"__proto__"\s*:/
-const suspectConstructorRx = /"constructor"\s*:/
+// Text that may decode to a forbidden key. `JSON.parse` decodes Unicode
+// escapes (e.g. `"\u005f_proto__"`), so any `\u` escape also triggers the scan.
+const suspectRx = /"__proto__"\s*:|"constructor"\s*:|\\u/
 
 function _parse(text: string) {
   // Parse normally
@@ -2108,15 +2109,8 @@ function _parse(text: string) {
     return obj
   }
 
-  if (
-    suspectProtoRx.test(text) === false &&
-    suspectConstructorRx.test(text) === false
-  ) {
-    return obj
-  }
-
   // Scan result for proto keys
-  return filter(obj)
+  return suspectRx.test(text) ? filter(obj) : obj
 }
 
 function filter(obj: any) {
@@ -2133,6 +2127,7 @@ function filter(obj: any) {
 
       if (
         Object.hasOwn(node, "constructor") &&
+        node.constructor !== null &&
         Object.hasOwn(node.constructor, "prototype")
       ) {
         throw new SyntaxError("Object contains forbidden prototype property")

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,12 +203,12 @@ const projectContent = Match.type<PublicMcpSchema.ContentBlock>().pipe(
   Match.exhaustive
 )
 
-const projectResource = (resource: PublicMcpSchema.Resource) => McpSchema.Resource.make(resource)
+// Registrations may be plain objects, so encode with the wire struct.
+const projectResource = (resource: PublicMcpSchema.Resource) => Schema.encodeEffect(McpSchema.Resource)(resource)
 const projectResourceTemplate = (resourceTemplate: PublicMcpSchema.ResourceTemplate) =>
-  McpSchema.ResourceTemplate.make(resourceTemplate)
+  Schema.encodeEffect(McpSchema.ResourceTemplate)(resourceTemplate)
 
-const projectPrompt = (prompt: PublicMcpSchema.Prompt) =>
-  McpProtocol.transcode(PublicMcpSchema.Prompt, McpSchema.Prompt, prompt)
+const projectPrompt = (prompt: PublicMcpSchema.Prompt) => Schema.encodeEffect(McpSchema.Prompt)(prompt)
 
 const projectTool = (tool: PublicMcpSchema.Tool) => McpProtocol.transcode(PublicMcpSchema.Tool, McpSchema.Tool, tool)
 
@@ -231,6 +232,8 @@ const projectCompleteResult = Effect.fnUntraced(function*(
 type ProtocolError =
   | McpCore.ResourceNotFound
   | McpCore.PromptNotFound
+  | McpCore.SkillNotFound
+  | McpCore.DirectoryNotFound
   | McpCore.ToolError
   | McpCore.UnsupportedByProtocol
   | McpProtocol.ProtocolError
@@ -297,7 +300,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 +323,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 +340,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 +349,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 +513,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 +524,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 +684,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 +729,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,