@savvy-web/mcp 3.1.3 → 3.2.1

package/errors.js

@@ -10,8 +10,9 @@ import { Schema } from "effect";
 * typed failure reaches the client as
 * `{ isError: true, content: [{ type: "text", text: error.message }] }` and
 * `structuredContent` is never populated for it
-* (`.repos/effect/packages/effect/src/unstable/ai/McpServer.ts:1513-1517,1592-1607`
-* at rc.115 — see the header of `server.ts`). So a structured `remediation`
+* (rc.116's `registerToolkit`, `declaredFailureResult` in
+* `.repos/effect/packages/effect/src/unstable/ai/McpServer.ts` — see the
+* header of `server.ts`). So a structured `remediation`
 * field is invisible to a real client: every member folds its hint into
 * `message` at construction through {@link composeRemediatedMessage}, and any
 * caller-supplied value echoed back passes through {@link truncateEchoed}.

package/index.d.ts

@@ -173,9 +173,8 @@ export declare const makeSilkRuntimeLayer: (cwd: string) => Layer.Layer<McpServi
 /**
  * Everything {@link ServerLayer} still needs from the platform: the three
  * services `makeSilkRuntimeLayer` requires, plus `Stdio`, which
- * `McpServer.layerStdio` itself requires (`McpServer.ts:1217-1225`).
- * `NodeServices.layer` supplies all four in `main.ts`; tests swap `Stdio`
- * for `Stdio.layerTest`.
+ * `McpServer.layerStdio` itself requires. `NodeServices.layer` supplies all
+ * four in `main.ts`; tests swap `Stdio` for `Stdio.layerTest`.
  *
  * @public
  */
@@ -184,10 +183,11 @@ type PlatformServices = FileSystem.FileSystem | Path.Path | ChildProcessSpawner.
  * The whole server as one layer: the ten-tool toolkit, the silk-effects
  * runtime discharging its dependencies, over `McpServer.layerStdio`.
  *
- * `protocols` lists the newest two adapters, newest first — see gotcha 2 in
- * the module remarks. `Cause.IllegalArgumentError` in `layerStdio`'s error
- * channel is `orDie`d: `protocols` is a static two-element literal, so it is
- * an implementer-time defect, not a runtime condition.
+ * `protocols` lists the stateless `2026-07-28` adapter first, then the two
+ * newest stateful ones — see gotcha 2 in the module remarks.
+ * `Cause.IllegalArgumentError` in `layerStdio`'s error channel is `orDie`d:
+ * `protocols` is a static literal with exactly one stateless member, so a
+ * failure there is an implementer-time defect, not a runtime condition.
  *
  * @public
  */

package/markdown.js

@@ -6,10 +6,11 @@ import { Context } from "effect";
 * to the server's registration step.
 *
 * @remarks
-* rc.115's `McpServer.registerToolkit` renders every success as
+* rc.116's `McpServer.registerToolkit` renders every success as
 * `content: [{ type: "text", text: JSON.stringify(encodedResult) }]` plus
 * `structuredContent` and offers no hook over the text
-* (`unstable/ai/McpServer.ts:1577-1585`). `server.ts` therefore registers the
+* (`unstable/ai/McpServer.ts`, `toolResultContent`; Effect-TS/effect#8316
+* proposes one). `server.ts` therefore registers the
 * toolkit itself through the public `McpServer.addTool` and reads this
 * annotation to put the tool's markdown projection in `content[0].text`
 * while `structuredContent` stays the typed object — the dual channel every

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/mcp",
-	"version": "3.1.3",
+	"version": "3.2.1",
 	"private": false,
 	"description": "The savvy MCP server — Silk Suite tooling and library knowledge for coding agents",
 	"homepage": "https://github.com/savvy-web/systems/tree/main/packages/mcp",
@@ -36,11 +36,11 @@
 		"savvy-mcp": "bin/savvy-mcp.js"
 	},
 	"dependencies": {
-		"@effect/platform-node": "4.0.0-rc.115",
-		"@effected/commands": "^0.7.2",
-		"@effected/git": "^0.15.2",
-		"@effected/workspaces": "^0.22.1",
-		"@savvy-web/silk-effects": "9.0.1",
-		"effect": "4.0.0-rc.115"
+		"@effect/platform-node": "4.0.0-rc.116",
+		"@effected/commands": "^0.8.0",
+		"@effected/git": "^0.16.0",
+		"@effected/workspaces": "^0.24.0",
+		"@savvy-web/silk-effects": "9.1.0",
+		"effect": "4.0.0-rc.116"
 	}
 }

package/server.js

@@ -2,10 +2,31 @@ import { SilkMarkdown } from "./markdown.js";
 import { makeSilkRuntimeLayer } from "./runtime.js";
 import { SilkToolkit, ToolsLayer } from "./toolkit.js";
 import { CURRENT_MCP_VERSION } from "./version.js";
-import { Cause, Context, Effect, ErrorReporter, Layer, Option, Result, Schema, Sink, Stream } from "effect";
-import { AiError, McpProtocol, McpSchema, McpServer, Tool } from "effect/unstable/ai";
+import { Cause, Context, Effect, ErrorReporter, Layer, Option, Result, Schema, Stream } from "effect";
+import { CurrentLogLevel } from "effect/References";
+import { AiError, McpProtocol, McpSchema, McpServer, Tool, Toolkit } from "effect/unstable/ai";
+import { HttpServerRequest } from "effect/unstable/http";
 
 //#region src/server.ts
+/**
+* The agent-facing orientation every client receives: in the `initialize`
+* result on the stateful protocols and in the `server/discover` result on
+* `2026-07-28`. Says what the server is for, which tool to reach for first,
+* and the traps; the one-line human summary stays in `description`.
+*
+* @public
+*/
+const SERVER_INSTRUCTIONS = [
+	"savvy-mcp serves ten structured tools over a Silk Suite workspace: a pnpm + Turborepo monorepo on @savvy-web/silk.",
+	"Reach for the matching tool before reconstructing an answer from shell output or memory; each encodes the repo's package boundaries, conventions and exclusion rules.",
+	"workspace_info: layout, package names, publish and version state; the default for any structural fact about the repo.",
+	"turbo_inspect: cache, graph and affected-package inspection; read-only, never runs tasks.",
+	"biome_check: structured Biome diagnostics and the ONLY sanctioned route for a Biome fix pass (write/unsafe); a direct Biome invocation skips the repo config and can corrupt vendored trees under .repos/.",
+	"changeset_inspect, changeset_validate, changeset_preview: the branch diff by owning package, typed CSH001-CSH005 diagnostics, and the CHANGELOG the pending changesets would produce.",
+	"changeset_deps_detect (reads) and changeset_deps_regen (deletes and recreates) dependency changesets.",
+	"repos_inspect (reads) and repos_manage (mutates) the vendored reference repos under .repos/; repos_manage restore discards uncommitted worktree edits.",
+	"Every successful result carries a markdown transcript in content[0].text and the typed object in structuredContent; read structuredContent when you need fields. A failure is an isError result whose content[0].text carries the message and remediation, with no structuredContent. Every tool takes an optional cwd; omit it to use the server's project directory."
+].join("\n");
 const INTERNAL_TOOL_ERROR_MESSAGE = "Tool execution failed due to an internal server error.";
 const toolErrorResult = (message) => new McpSchema.CallToolResult({
 	isError: true,
@@ -14,13 +35,21 @@ const toolErrorResult = (message) => new McpSchema.CallToolResult({
 		text: message
 	}]
 });
+const toolResultContent = (encoded) => encoded === void 0 ? [] : [{
+	type: "text",
+	text: JSON.stringify(encoded)
+}];
+const omitRequestServices = Context.omit(McpSchema.McpRequestContext, McpSchema.McpServerClient, HttpServerRequest.HttpServerRequest, CurrentLogLevel);
+const isParameterValidationError = (error) => AiError.isAiError(error) && error.reason._tag === "ToolParameterValidationError";
 /**
 * Hoist a `$ref`-rooted JSON Schema document onto its referenced definition.
 * `Schema.toJsonSchemaDocument` emits `{ $ref: "#/$defs/<id>", $defs }` for
 * any schema annotated with an `identifier` — every result schema here is —
-* and `McpSchema.ToolJsonSchema` needs a `type: "object"` root, so without
-* this no tool would serve an `outputSchema` (rc.115's own `registerToolkit`
-* has the same blind spot). The definitions stay attached for nested refs.
+* and a strict MCP client needs a `type: "object"` root on `outputSchema`,
+* so without this no tool would serve one. The definitions stay attached
+* for nested refs. (rc.116's own `registerToolkit` inlines the top-level
+* reference of the INPUT schema through an internal helper and serves the
+* output document verbatim; this is the public-API equivalent for both.)
 */
 const hoistRootRef = (schema) => {
 	const ref = schema.$ref;
@@ -35,33 +64,88 @@ const hoistRootRef = (schema) => {
 		$defs: defs
 	};
 };
+/**
+* The served input schema: MCP requires an object root, so a top-level `$ref`
+* is inlined, and a strict tool is emitted with `onExcessProperty: "error"`
+* so the client sees `additionalProperties: false`. Mirrors rc.116's
+* `toolInputJsonSchema` through public API (`Schema.toJsonSchemaDocument` +
+* {@link hoistRootRef} in place of the internal `resolveTopLevelReference`).
+*/
+const toolInputJsonSchema = (schema, strict) => {
+	const document = Schema.toJsonSchemaDocument(schema, { onExcessProperty: strict ? "error" : "ignore" });
+	const withDefs = Object.keys(document.definitions).length === 0 ? document.schema : {
+		...document.schema,
+		$defs: document.definitions
+	};
+	return hoistRootRef(withDefs);
+};
 /** MCP models `structuredContent` as a JSON object, so a `null` or array encoded result is omitted. */
 const toStructuredContent = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 /**
 * Register a toolkit with the running `McpServer`, rendering each success as
 * the tool's markdown transcript in `content[0].text` and the encoded result
-* in `structuredContent`. A port of rc.115's `McpServer.registerToolkit`
-* (`McpServer.ts:1525-1611`) that differs in the success branch only.
+* in `structuredContent`. A port of rc.116's `McpServer.registerToolkit`
+* that differs in the success branch and the `outputSchema` gate only (see
+* the module remarks).
 *
 * @remarks
 * `Effect.context<never>()` captures the registration-time services (the
 * handlers' declared dependencies, discharged by the runtime layer) so each
-* call runs against them; `McpServerClient` is provided per call by the
-* framework and is the one service excluded from that capture.
+* call runs against them; the per-request services (`McpRequestContext`,
+* the legacy `McpServerClient`, the HTTP request, the request log level) are
+* omitted from that capture because the framework provides them per call.
+*
+* @internal exported for the in-process suite, which registers fixture
+* toolkits (a strict tool, for one) through the same path the served
+* toolkit takes.
 */
 const registerSilkToolkit = (toolkit) => Effect.gen(function* () {
 	const registry = yield* McpServer.McpServer;
-	const built = yield* toolkit;
-	const services = yield* Effect.context();
+	const built = yield* toolkit.pipe(Effect.updateContext((context) => {
+		const services = new Map(context.mapUnsafe);
+		for (const tool of Object.values(toolkit.tools)) {
+			const handler = services.get(tool.id);
+			if (handler !== void 0) services.set(tool.id, {
+				...handler,
+				context: omitRequestServices(handler.context)
+			});
+		}
+		return Context.makeUnsafe(services);
+	}));
+	const services = omitRequestServices(yield* Effect.context());
 	const reportCause = (cause) => Effect.provideContext(ErrorReporter.report(cause), services);
+	const internalToolError = (cause) => {
+		const failure = Cause.findFail(cause);
+		return Result.isFailure(failure) && !Cause.hasDies(cause) ? Effect.failCause(failure.failure) : Effect.logError(cause).pipe(Effect.andThen(reportCause(cause)), Effect.as(toolErrorResult(INTERNAL_TOOL_ERROR_MESSAGE)));
+	};
+	const registrations = [];
 	for (const tool of Object.values(built.tools)) {
+		const strict = Tool.getStrictMode(tool) === true;
+		const rawJsonSchema = Tool.isDynamic(tool) ? tool.jsonSchema : void 0;
+		if (strict && rawJsonSchema !== void 0) return yield* Effect.die(`McpServer cannot strictly validate the raw JSON Schema for tool '${tool.name}'; use an Effect Schema instead`);
+		const decodeOptions = strict ? { onExcessProperty: "error" } : void 0;
 		const annotations = tool.annotations;
 		const renderMarkdown = Context.getOrUndefined(annotations, SilkMarkdown);
+		const toolMeta = Context.getOrUndefined(annotations, Tool.Meta);
 		const isDeclaredFailure = Schema.is(tool.failureSchema);
+		const encodeFailure = Schema.encodeUnknownEffect(tool.failureSchema);
+		const declaredFailureResult = (error) => error instanceof Error ? Effect.succeed(toolErrorResult(error.message)) : Effect.map(encodeFailure(error), (encoded) => new McpSchema.CallToolResult({
+			isError: true,
+			content: toolResultContent(encoded)
+		}));
+		const handleCause = (cause) => {
+			const failure = Cause.findFail(cause);
+			if (Result.isSuccess(failure)) {
+				const error = failure.success.error;
+				const origin = Context.get(Cause.reasonAnnotations(failure.success), Toolkit.FailureOrigin);
+				if (origin === "parameters" && isParameterValidationError(error)) return Effect.fail(new McpSchema.InvalidParams({ message: error.reason.message }));
+				if (origin === "handler" && isDeclaredFailure(error)) return Effect.logError(cause).pipe(Effect.andThen(Effect.catchCause(declaredFailureResult(error), internalToolError)));
+			}
+			return internalToolError(cause);
+		};
 		const outputJsonSchema = hoistRootRef(Tool.getJsonSchemaFromSchema(tool.successSchema));
-		const outputSchema = outputJsonSchema.type === "object" ? yield* Schema.decodeUnknownEffect(McpSchema.ToolJsonSchema)(outputJsonSchema).pipe(Effect.orDie) : void 0;
-		const inputSchema = yield* Schema.decodeUnknownEffect(McpSchema.ToolJsonSchema)(Tool.getJsonSchema(tool)).pipe(Effect.orDie);
-		const toolMeta = Context.getOrUndefined(annotations, Tool.Meta);
+		const outputSchema = outputJsonSchema.type === "object" ? yield* Schema.decodeUnknownEffect(McpSchema.ToolOutputJson)(outputJsonSchema).pipe(Effect.orDie) : void 0;
+		const inputSchema = yield* Schema.decodeUnknownEffect(McpSchema.ToolJson)(rawJsonSchema ?? toolInputJsonSchema(tool.parametersSchema, strict)).pipe(Effect.orDie);
 		const description = Tool.getDescription(tool);
 		const mcpTool = new McpSchema.Tool({
 			name: tool.name,
@@ -77,29 +161,20 @@ const registerSilkToolkit = (toolkit) => Effect.gen(function* () {
 			},
 			...toolMeta === void 0 ? {} : { _meta: toolMeta }
 		});
-		yield* registry.addTool({
+		registrations.push({
 			tool: mcpTool,
 			annotations,
-			handle: (payload) => built.handle(tool.name, payload ?? {}).pipe(Stream.unwrap, Stream.run(Sink.last()), Effect.flatMap(Effect.fromOption), Effect.map((result) => new McpSchema.CallToolResult({
-				isError: false,
-				structuredContent: toStructuredContent(result.encodedResult),
-				content: [{
+			handle: (payload) => built.handle(tool.name, payload ?? {}, void 0, decodeOptions).pipe(Stream.unwrap, Stream.runLast, Effect.flatMap(Effect.fromOption), Effect.flatMap((result) => result.isFailure && result.failureOrigin !== "handler" ? Effect.failCause(Cause.annotate(Cause.fail(result.result), Context.make(Toolkit.FailureOrigin, result.failureOrigin ?? "result"))) : Effect.succeed(new McpSchema.CallToolResult({
+				isError: result.isFailure,
+				structuredContent: result.isFailure ? void 0 : toStructuredContent(result.encodedResult),
+				content: result.isFailure || renderMarkdown === void 0 ? toolResultContent(result.encodedResult) : [{
 					type: "text",
-					text: renderMarkdown === void 0 ? JSON.stringify(result.encodedResult) : renderMarkdown(result.result)
+					text: renderMarkdown(result.result)
 				}]
-			})), Effect.provideContext(services), Effect.tapCause(Effect.logError), Effect.catchCause((cause) => {
-				const failure = Cause.findError(cause);
-				if (Result.isFailure(failure)) return Cause.hasDies(cause) ? Effect.as(reportCause(cause), toolErrorResult(INTERNAL_TOOL_ERROR_MESSAGE)) : Effect.failCause(failure.failure);
-				const error = failure.success;
-				if (AiError.isAiError(error)) {
-					const reason = error.reason;
-					return reason._tag === "ToolParameterValidationError" ? Effect.fail(new McpSchema.InvalidParams({ message: reason.message })) : Effect.as(reportCause(cause), toolErrorResult(INTERNAL_TOOL_ERROR_MESSAGE));
-				}
-				const message = isDeclaredFailure(error) && error instanceof Error ? error.message : INTERNAL_TOOL_ERROR_MESSAGE;
-				return Effect.as(reportCause(cause), toolErrorResult(message));
-			}))
+			}))), Effect.catchCause(handleCause), Effect.provideContext(services))
 		});
 	}
+	for (const registration of registrations) yield* registry.addTool(registration);
 });
 /**
 * The toolkit registration as a layer: {@link registerSilkToolkit} over
@@ -112,18 +187,25 @@ const SilkToolsLayer = (cwd) => Layer.effectDiscard(registerSilkToolkit(SilkTool
 * The whole server as one layer: the ten-tool toolkit, the silk-effects
 * runtime discharging its dependencies, over `McpServer.layerStdio`.
 *
-* `protocols` lists the newest two adapters, newest first — see gotcha 2 in
-* the module remarks. `Cause.IllegalArgumentError` in `layerStdio`'s error
-* channel is `orDie`d: `protocols` is a static two-element literal, so it is
-* an implementer-time defect, not a runtime condition.
+* `protocols` lists the stateless `2026-07-28` adapter first, then the two
+* newest stateful ones — see gotcha 2 in the module remarks.
+* `Cause.IllegalArgumentError` in `layerStdio`'s error channel is `orDie`d:
+* `protocols` is a static literal with exactly one stateless member, so a
+* failure there is an implementer-time defect, not a runtime condition.
 *
 * @public
 */
 const ServerLayer = (cwd) => SilkToolsLayer(cwd).pipe(Layer.provide(makeSilkRuntimeLayer(cwd)), Layer.provide(McpServer.layerStdio({
 	name: "savvy-mcp",
 	version: CURRENT_MCP_VERSION,
-	protocols: [McpProtocol.v2025_11_25, McpProtocol.v2025_06_18]
+	description: "Structured Silk Suite workspace tools: workspace, turbo, biome, changesets and vendored repos.",
+	instructions: SERVER_INSTRUCTIONS,
+	protocols: [
+		McpProtocol.v2026_07_28,
+		McpProtocol.v2025_11_25,
+		McpProtocol.v2025_06_18
+	]
 })), Layer.orDie);
 
 //#endregion
-export { ServerLayer };
+export { SERVER_INSTRUCTIONS, ServerLayer, registerSilkToolkit };

package/version.js

@@ -6,7 +6,7 @@
 *
 * @packageDocumentation
 */
-const CURRENT_MCP_VERSION = "3.1.3";
+const CURRENT_MCP_VERSION = "3.2.1";
 
 //#endregion
 export { CURRENT_MCP_VERSION };