@vitest-agent/mcp 1.3.6 → 2.0.0

package/tools/tdd-task.js

@@ -1,6 +1,6 @@
 import { idempotentProcedure } from "../middleware/idempotency.js";
 import { DataReader, DataStore, GoalDetail } from "@vitest-agent/sdk";
-import { Effect, Match, Option, ParseResult, Schema } from "effect";
+import { Effect, Match, Option, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/tdd-task.ts
 /**
@@ -22,7 +22,7 @@ const TddPhaseRow = Schema.Struct({
 	startedAt: Schema.String,
 	endedAt: Schema.NullOr(Schema.String),
 	transitionReason: Schema.NullOr(Schema.String)
-}).annotations({ identifier: "TddTaskPhaseRow" });
+}).annotate({ identifier: "TddTaskPhaseRow" });
 const TddArtifactDetailRow = Schema.Struct({
 	id: Schema.Number,
 	phaseId: Schema.Number,
@@ -30,7 +30,7 @@ const TddArtifactDetailRow = Schema.Struct({
 	testCaseId: Schema.NullOr(Schema.Number),
 	testRunId: Schema.NullOr(Schema.Number),
 	recordedAt: Schema.String
-}).annotations({ identifier: "TddTaskArtifactRow" });
+}).annotate({ identifier: "TddTaskArtifactRow" });
 const TddTaskDetailSchema = Schema.Struct({
 	tddTaskId: Schema.Number,
 	sessionId: Schema.Number,
@@ -42,35 +42,39 @@ const TddTaskDetailSchema = Schema.Struct({
 	goals: Schema.Array(GoalDetail),
 	phases: Schema.Array(TddPhaseRow),
 	artifacts: Schema.Array(TddArtifactDetailRow)
-}).annotations({ identifier: "TddTaskDetailSchema" });
+}).annotate({ identifier: "TddTaskDetailSchema" });
 const CurrentPhaseLookup = Schema.Struct({
 	id: Schema.Number,
 	phase: Schema.String,
 	startedAt: Schema.String,
 	behaviorId: Schema.NullOr(Schema.Number)
-}).annotations({ identifier: "TddTaskCurrentPhaseLookup" });
+}).annotate({ identifier: "TddTaskCurrentPhaseLookup" });
 const TddTaskStartOk = Schema.Struct({
 	action: Schema.Literal("start"),
 	tddTaskId: Schema.Number,
 	goal: Schema.String,
 	runId: Schema.optional(Schema.String)
-}).annotations({ identifier: "TddTaskStartOk" });
+}).annotate({ identifier: "TddTaskStartOk" });
 const TddTaskEndOk = Schema.Struct({
 	action: Schema.Literal("end"),
 	tddTaskId: Schema.Number,
-	outcome: Schema.Literal("succeeded", "blocked", "abandoned")
-}).annotations({ identifier: "TddTaskEndOk" });
+	outcome: Schema.Literals([
+		"succeeded",
+		"blocked",
+		"abandoned"
+	])
+}).annotate({ identifier: "TddTaskEndOk" });
 const TddTaskGetFound = Schema.Struct({
 	action: Schema.Literal("get"),
 	found: Schema.Literal(true),
 	task: TddTaskDetailSchema,
 	currentPhase: Schema.NullOr(CurrentPhaseLookup)
-}).annotations({ identifier: "TddTaskGetFound" });
+}).annotate({ identifier: "TddTaskGetFound" });
 const TddTaskGetMissing = Schema.Struct({
 	action: Schema.Literal("get"),
 	found: Schema.Literal(false),
 	tddTaskId: Schema.Number
-}).annotations({ identifier: "TddTaskGetMissing" });
+}).annotate({ identifier: "TddTaskGetMissing" });
 const TddTaskResumeFound = Schema.Struct({
 	action: Schema.Literal("resume"),
 	found: Schema.Literal(true),
@@ -80,13 +84,20 @@ const TddTaskResumeFound = Schema.Struct({
 	currentPhase: Schema.NullOr(CurrentPhaseLookup),
 	phasesRecorded: Schema.Number,
 	artifactsRecorded: Schema.Number
-}).annotations({ identifier: "TddTaskResumeFound" });
+}).annotate({ identifier: "TddTaskResumeFound" });
 const TddTaskResumeMissing = Schema.Struct({
 	action: Schema.Literal("resume"),
 	found: Schema.Literal(false),
 	tddTaskId: Schema.Number
-}).annotations({ identifier: "TddTaskResumeMissing" });
-const TddTaskResult = Schema.Union(TddTaskStartOk, TddTaskEndOk, TddTaskGetFound, TddTaskGetMissing, TddTaskResumeFound, TddTaskResumeMissing).annotations({
+}).annotate({ identifier: "TddTaskResumeMissing" });
+const TddTaskResult = Schema.Union([
+	TddTaskStartOk,
+	TddTaskEndOk,
+	TddTaskGetFound,
+	TddTaskGetMissing,
+	TddTaskResumeFound,
+	TddTaskResumeMissing
+]).annotate({
 	identifier: "TddTaskResult",
 	title: "tdd_task result",
 	description: "Discriminate on `action`. `get` and `resume` further discriminate on `found`. `get` carries the full nested task tree."
@@ -146,11 +157,10 @@ const formatTddTaskMarkdown = (data) => {
 	lines.push("", `Use \`tdd_task({ action: "get", tddTaskId: ${data.tddTaskId} })\` for the full detail tree, or call \`tdd_phase_transition_request\` to advance.`);
 	return lines.join("\n");
 };
-const TddTaskAsMarkdown = Schema.transformOrFail(TddTaskResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatTddTaskMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "TddTaskAsMarkdown is one-way."))
-});
+const TddTaskAsMarkdown = TddTaskResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform((data) => formatTddTaskMarkdown(data)),
+	encode: SchemaGetter.forbidden(() => "TddTaskAsMarkdown is one-way.")
+}));
 const StartVariant = Schema.Struct({
 	action: Schema.Literal("start"),
 	goal: Schema.String,
@@ -163,7 +173,11 @@ const StartVariant = Schema.Struct({
 const EndVariant = Schema.Struct({
 	action: Schema.Literal("end"),
 	tddTaskId: Schema.Number,
-	outcome: Schema.Literal("succeeded", "blocked", "abandoned"),
+	outcome: Schema.Literals([
+		"succeeded",
+		"blocked",
+		"abandoned"
+	]),
 	summaryNoteId: Schema.optional(Schema.Number)
 });
 const GetVariant = Schema.Struct({
@@ -174,8 +188,13 @@ const ResumeVariant = Schema.Struct({
 	action: Schema.Literal("resume"),
 	tddTaskId: Schema.Number
 });
-const TddTaskInput = Schema.Union(StartVariant, EndVariant, GetVariant, ResumeVariant);
-const tddTask = idempotentProcedure.input(Schema.standardSchemaV1(TddTaskInput)).mutation(async ({ ctx, input }) => {
+const TddTaskInput = Schema.Union([
+	StartVariant,
+	EndVariant,
+	GetVariant,
+	ResumeVariant
+]);
+const tddTask = idempotentProcedure.input(Schema.toStandardSchemaV1(TddTaskInput)).mutation(async ({ ctx, input }) => {
 	return ctx.runtime.runPromise(Match.value(input).pipe(Match.discriminatorsExhaustive("action")({
 		start: (variant) => Effect.gen(function* () {
 			const reader = yield* DataReader;

package/tools/test.js

@@ -1,6 +1,6 @@
 import { publicProcedure } from "../context.js";
 import { DataReader } from "@vitest-agent/sdk";
-import { Effect, Match, Option, ParseResult, Schema } from "effect";
+import { Effect, Match, Option, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/test.ts
 /**
@@ -20,17 +20,17 @@ const TestRowSchema = Schema.Struct({
 	duration: Schema.NullOr(Schema.Number),
 	module: Schema.String,
 	classification: Schema.NullOr(Schema.String)
-}).annotations({ identifier: "TestListRow" });
+}).annotate({ identifier: "TestListRow" });
 const TestErrorRowMini = Schema.Struct({
 	name: Schema.NullOr(Schema.String),
 	message: Schema.String,
 	diff: Schema.NullOr(Schema.String),
 	stack: Schema.NullOr(Schema.String)
-}).annotations({ identifier: "TestGetErrorRow" });
+}).annotate({ identifier: "TestGetErrorRow" });
 const TestRunRow = Schema.Struct({
-	state: Schema.Literal("passed", "failed"),
+	state: Schema.Literals(["passed", "failed"]),
 	timestamp: Schema.String
-}).annotations({ identifier: "TestGetRunRow" });
+}).annotate({ identifier: "TestGetRunRow" });
 const TestListGroup = Schema.Struct({
 	project: Schema.String,
 	tests: Schema.Array(TestRowSchema)
@@ -39,7 +39,7 @@ const TestListResult = Schema.Struct({
 	action: Schema.Literal("list"),
 	count: Schema.Number,
 	groups: Schema.Array(TestListGroup)
-}).annotations({ identifier: "TestList" });
+}).annotate({ identifier: "TestList" });
 const TestGetFound = Schema.Struct({
 	action: Schema.Literal("get"),
 	found: Schema.Literal(true),
@@ -47,26 +47,32 @@ const TestGetFound = Schema.Struct({
 	test: TestRowSchema,
 	errors: Schema.Array(TestErrorRowMini),
 	runs: Schema.Array(TestRunRow)
-}).annotations({ identifier: "TestGetFound" });
+}).annotate({ identifier: "TestGetFound" });
 const TestGetMissing = Schema.Struct({
 	action: Schema.Literal("get"),
 	found: Schema.Literal(false),
 	project: Schema.String,
 	fullName: Schema.String
-}).annotations({ identifier: "TestGetMissing" });
+}).annotate({ identifier: "TestGetMissing" });
 const TestForFileResult = Schema.Struct({
 	action: Schema.Literal("for_file"),
 	filePath: Schema.String,
 	count: Schema.Number,
 	testFiles: Schema.Array(Schema.String)
-}).annotations({ identifier: "TestForFile" });
+}).annotate({ identifier: "TestForFile" });
 const TestForTagResult = Schema.Struct({
 	action: Schema.Literal("for_tag"),
 	tag: Schema.String,
 	count: Schema.Number,
 	groups: Schema.Array(TestListGroup)
-}).annotations({ identifier: "TestForTag" });
-const TestResult = Schema.Union(TestListResult, TestGetFound, TestGetMissing, TestForFileResult, TestForTagResult).annotations({
+}).annotate({ identifier: "TestForTag" });
+const TestResult = Schema.Union([
+	TestListResult,
+	TestGetFound,
+	TestGetMissing,
+	TestForFileResult,
+	TestForTagResult
+]).annotate({
 	identifier: "TestResult",
 	title: "test result",
 	description: "Discriminate on `action`. `get` further discriminates on `found`. `list`, `for_file`, and `for_tag` all carry counted arrays — `list` and `for_tag` group by project."
@@ -160,11 +166,10 @@ const formatTestMarkdown = (data) => {
 	for (const f of data.testFiles) lines.push(`- \`${f}\``);
 	return lines.join("\n");
 };
-const TestAsMarkdown = Schema.transformOrFail(TestResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatTestMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "TestAsMarkdown is one-way."))
-});
+const TestAsMarkdown = TestResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform((data) => formatTestMarkdown(data)),
+	encode: SchemaGetter.forbidden(() => "TestAsMarkdown is one-way.")
+}));
 const ListVariant = Schema.Struct({
 	action: Schema.Literal("list"),
 	project: Schema.optional(Schema.String),
@@ -186,8 +191,13 @@ const ForTagVariant = Schema.Struct({
 	tag: Schema.String,
 	project: Schema.optional(Schema.String)
 });
-const TestInput = Schema.Union(ListVariant, GetVariant, ForFileVariant, ForTagVariant);
-const test = publicProcedure.input(Schema.standardSchemaV1(TestInput)).query(async ({ ctx, input }) => {
+const TestInput = Schema.Union([
+	ListVariant,
+	GetVariant,
+	ForFileVariant,
+	ForTagVariant
+]);
+const test = publicProcedure.input(Schema.toStandardSchemaV1(TestInput)).query(async ({ ctx, input }) => {
 	return ctx.runtime.runPromise(Match.value(input).pipe(Match.discriminatorsExhaustive("action")({
 		list: (variant) => Effect.gen(function* () {
 			const reader = yield* DataReader;

package/tools/trends.js

@@ -1,6 +1,6 @@
 import { publicProcedure } from "../context.js";
 import { DataReader, TrendRecord } from "@vitest-agent/sdk";
-import { Effect, Option, ParseResult, Schema } from "effect";
+import { Effect, Option, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/trends.ts
 /**
@@ -14,15 +14,15 @@ import { Effect, Option, ParseResult, Schema } from "effect";
 * @packageDocumentation
 */
 const TrendsAvailable = Schema.Struct({
-	dataAvailable: Schema.Literal(true).annotations({ description: "Discriminant — `true` when at least one trend entry exists for the project." }),
+	dataAvailable: Schema.Literal(true).annotate({ description: "Discriminant — `true` when at least one trend entry exists for the project." }),
 	project: Schema.String,
-	trends: TrendRecord.annotations({ description: "Trend entries oldest-first; the latest entry drives `direction` and the headline metrics." })
-}).annotations({ identifier: "TestTrendsAvailable" });
+	trends: TrendRecord.annotate({ description: "Trend entries oldest-first; the latest entry drives `direction` and the headline metrics." })
+}).annotate({ identifier: "TestTrendsAvailable" });
 const TrendsAbsent = Schema.Struct({
-	dataAvailable: Schema.Literal(false).annotations({ description: "Discriminant — `false` when fewer than two runs have been recorded for the project." }),
+	dataAvailable: Schema.Literal(false).annotate({ description: "Discriminant — `false` when fewer than two runs have been recorded for the project." }),
 	project: Schema.String
-}).annotations({ identifier: "TestTrendsAbsent" });
-const TestTrendsResult = Schema.Union(TrendsAvailable, TrendsAbsent).annotations({
+}).annotate({ identifier: "TestTrendsAbsent" });
+const TestTrendsResult = Schema.Union([TrendsAvailable, TrendsAbsent]).annotate({
 	identifier: "TestTrendsResult",
 	title: "test_trends result",
 	description: "Coverage trend record per project. Discriminate on `dataAvailable` to handle the cold-start case."
@@ -88,12 +88,11 @@ const formatTestTrendsMarkdown = (data) => {
 	}
 	return lines.join("\n");
 };
-const TestTrendsAsMarkdown = Schema.transformOrFail(TestTrendsResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatTestTrendsMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "TestTrendsAsMarkdown is one-way: markdown cannot be parsed back to TestTrendsResult."))
-});
-const testTrends = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({
+const TestTrendsAsMarkdown = TestTrendsResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform((data) => formatTestTrendsMarkdown(data)),
+	encode: SchemaGetter.forbidden(() => "TestTrendsAsMarkdown is one-way: markdown cannot be parsed back to TestTrendsResult.")
+}));
+const testTrends = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 	project: Schema.String,
 	limit: Schema.optional(Schema.Number)
 }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {

package/tools/triage-brief.js

@@ -14,14 +14,14 @@ import { Effect, Schema } from "effect";
 * @packageDocumentation
 */
 const TriageBriefResult = Schema.Struct({
-	hasContent: Schema.Boolean.annotations({ description: "`false` when no orientation signal is available yet (run tests to populate)." }),
-	markdown: Schema.String.annotations({ description: "Pre-rendered markdown brief or the empty-state message." })
-}).annotations({
+	hasContent: Schema.Boolean.annotate({ description: "`false` when no orientation signal is available yet (run tests to populate)." }),
+	markdown: Schema.String.annotate({ description: "Pre-rendered markdown brief or the empty-state message." })
+}).annotate({
 	identifier: "TriageBriefResult",
 	title: "triage_brief result",
 	description: "Orientation triage envelope. Branch on `hasContent` for cold-start; consume `markdown` for rendering."
 });
-const triageBrief = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({
+const triageBrief = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 	project: Schema.optional(Schema.String),
 	maxLines: Schema.optional(Schema.Number)
 }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {

package/tools/turn-search.js

@@ -1,6 +1,6 @@
 import { publicProcedure } from "../context.js";
 import { DataReader } from "@vitest-agent/sdk";
-import { Effect, ParseResult, Schema } from "effect";
+import { Effect, Schema, SchemaGetter } from "effect";
 
 //#region src/tools/turn-search.ts
 /**
@@ -9,20 +9,20 @@ import { Effect, ParseResult, Schema } from "effect";
 * @packageDocumentation
 */
 const TurnRow = Schema.Struct({
-	id: Schema.Number.annotations({ description: "Numeric primary key of this turn row." }),
-	sessionId: Schema.Number.annotations({ description: "Owning `sessions.id` (integer FK)." }),
-	turnNo: Schema.Number.annotations({ description: "Turn ordinal within the session (1-based)." }),
-	type: Schema.String.annotations({ description: "Turn category (`user_prompt`, `tool_call`, `tool_result`, `file_edit`, `hook_fire`, `note`, `hypothesis`)." }),
-	payload: Schema.String.annotations({ description: "Type-specific payload as a JSON-encoded string. Decode shape depends on `type`." }),
-	occurredAt: Schema.String.annotations({ description: "ISO-8601 timestamp the turn was recorded at." })
-}).annotations({
+	id: Schema.Number.annotate({ description: "Numeric primary key of this turn row." }),
+	sessionId: Schema.Number.annotate({ description: "Owning `sessions.id` (integer FK)." }),
+	turnNo: Schema.Number.annotate({ description: "Turn ordinal within the session (1-based)." }),
+	type: Schema.String.annotate({ description: "Turn category (`user_prompt`, `tool_call`, `tool_result`, `file_edit`, `hook_fire`, `note`, `hypothesis`)." }),
+	payload: Schema.String.annotate({ description: "Type-specific payload as a JSON-encoded string. Decode shape depends on `type`." }),
+	occurredAt: Schema.String.annotate({ description: "ISO-8601 timestamp the turn was recorded at." })
+}).annotate({
 	identifier: "TurnRow",
 	description: "One row from the turns log."
 });
 const TurnSearchResult = Schema.Struct({
-	count: Schema.Number.annotations({ description: "Number of matching turn rows returned." }),
-	turns: Schema.Array(TurnRow).annotations({ description: "Matching turns ordered by `occurredAt` ascending." })
-}).annotations({
+	count: Schema.Number.annotate({ description: "Number of matching turn rows returned." }),
+	turns: Schema.Array(TurnRow).annotate({ description: "Matching turns ordered by `occurredAt` ascending." })
+}).annotate({
 	identifier: "TurnSearchResult",
 	title: "turn_search result",
 	description: "Turn-log search results across all sessions, optionally filtered by session, time, type."
@@ -33,15 +33,22 @@ const formatTurnSearchMarkdown = (data) => {
 	for (const t of data.turns) lines.push(`- session=${t.sessionId} turn=${t.turnNo} type=${t.type} at=${t.occurredAt}`);
 	return lines.join("\n");
 };
-const TurnSearchAsMarkdown = Schema.transformOrFail(TurnSearchResult, Schema.String, {
-	strict: true,
-	decode: (data) => ParseResult.succeed(formatTurnSearchMarkdown(data)),
-	encode: (text, _options, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, text, "TurnSearchAsMarkdown is one-way: markdown cannot be parsed back to TurnSearchResult."))
-});
-const turnSearch = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({
+const TurnSearchAsMarkdown = TurnSearchResult.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform((data) => formatTurnSearchMarkdown(data)),
+	encode: SchemaGetter.forbidden(() => "TurnSearchAsMarkdown is one-way: markdown cannot be parsed back to TurnSearchResult.")
+}));
+const turnSearch = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 	sessionId: Schema.optional(Schema.Number),
 	since: Schema.optional(Schema.String),
-	type: Schema.optional(Schema.Literal("user_prompt", "tool_call", "tool_result", "file_edit", "hook_fire", "note", "hypothesis")),
+	type: Schema.optional(Schema.Literals([
+		"user_prompt",
+		"tool_call",
+		"tool_result",
+		"file_edit",
+		"hook_fire",
+		"note",
+		"hypothesis"
+	])),
 	limit: Schema.optional(Schema.Number)
 }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
 	const rows = yield* (yield* DataReader).searchTurns({

package/tools/wrapup-prompt.js

@@ -13,18 +13,30 @@ import { Effect, Schema } from "effect";
 * @packageDocumentation
 */
 const WrapupPromptResult = Schema.Struct({
-	hasContent: Schema.Boolean.annotations({ description: "`false` when there is nothing to wrap up for the named session/kind." }),
-	kind: Schema.Literal("stop", "session_end", "pre_compact", "tdd_handoff", "user_prompt_nudge").annotations({ description: "Echo of the wrap-up kind that was rendered (defaulted to `session_end` when omitted)." }),
-	markdown: Schema.String.annotations({ description: "Pre-rendered wrap-up markdown or the empty-state message." })
-}).annotations({
+	hasContent: Schema.Boolean.annotate({ description: "`false` when there is nothing to wrap up for the named session/kind." }),
+	kind: Schema.Literals([
+		"stop",
+		"session_end",
+		"pre_compact",
+		"tdd_handoff",
+		"user_prompt_nudge"
+	]).annotate({ description: "Echo of the wrap-up kind that was rendered (defaulted to `session_end` when omitted)." }),
+	markdown: Schema.String.annotate({ description: "Pre-rendered wrap-up markdown or the empty-state message." })
+}).annotate({
 	identifier: "WrapupPromptResult",
 	title: "wrapup_prompt result",
 	description: "Wrap-up envelope. Branch on `hasContent` for the empty case; consume `markdown` for rendering."
 });
-const wrapupPrompt = publicProcedure.input(Schema.standardSchemaV1(Schema.Struct({
+const wrapupPrompt = publicProcedure.input(Schema.toStandardSchemaV1(Schema.Struct({
 	sessionId: Schema.optional(Schema.Number),
 	chatId: Schema.optional(Schema.String),
-	kind: Schema.optional(Schema.Literal("stop", "session_end", "pre_compact", "tdd_handoff", "user_prompt_nudge")),
+	kind: Schema.optional(Schema.Literals([
+		"stop",
+		"session_end",
+		"pre_compact",
+		"tdd_handoff",
+		"user_prompt_nudge"
+	])),
 	userPromptHint: Schema.optional(Schema.String)
 }))).query(async ({ ctx, input }) => ctx.runtime.runPromise(Effect.gen(function* () {
 	const kind = input.kind ?? "session_end";

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.9"
+      "packageVersion": "7.58.10"
     }
   ]
 }

package/utils/effect-to-zod.js

@@ -1,10 +1,19 @@
-import { JSONSchema } from "effect";
+import { Schema } from "effect";
 import { z } from "zod";
 
 //#region src/utils/effect-to-zod.ts
 /**
-* Convert an Effect `Schema.Schema<A, I, never>` to a zod schema by
-* serializing it to JSON Schema (`JSONSchema.make`) and ingesting the
+* Bridge an Effect Schema to a zod schema by routing through JSON
+* Schema. Used at the MCP `registerTool` boundary so a tool can keep
+* Effect Schema as the canonical source of truth for its output shape
+* while the SDK still receives the zod instance it expects in the
+* `outputSchema` field.
+*
+* @packageDocumentation
+*/
+/**
+* Convert an Effect `Schema.Codec<A, I>` to a zod schema by
+* serializing it to JSON Schema (`Schema.toJsonSchemaDocument`) and ingesting the
 * result via zod 4's `z.fromJSONSchema`.
 *
 * Trade-offs:
@@ -22,7 +31,7 @@ import { z } from "zod";
 *
 * Implementation note: zod 4's `z.fromJSONSchema` does not resolve
 * `$ref` lookups into `$defs` — every `{ $ref: "#/$defs/X" }` it
-* encounters throws "Reference not found". Effect's `JSONSchema.make`
+* encounters throws "Reference not found". Effect's `Schema.toJsonSchemaDocument`
 * emits a `$ref`-and-`$defs` representation whenever a Schema carries
 * an `identifier` annotation. The bridge therefore inlines every
 * `$ref` in the document before handing it to zod (recursive
@@ -42,7 +51,11 @@ import { z } from "zod";
 * if the rich listing matters.
 */
 const effectToZodSchema = (schema) => {
-	const jsonSchema = JSONSchema.make(schema);
+	const document = Schema.toJsonSchemaDocument(schema);
+	const jsonSchema = {
+		...document.schema,
+		$defs: document.definitions
+	};
 	const inlined = inlineAllRefs(jsonSchema);
 	const zodSchema = z.fromJSONSchema(inlined);
 	if (isObjectLike(zodSchema)) return zodSchema;