@code-yeongyu/senpi 2026.10.25-3 → 2026.10.26-1

package/dist/modes/rpc/session-binding.js

@@ -14,14 +14,9 @@ export async function createRpcSessionBinding(sessionId, entry, writer, requestC
     // session is inside is what the loop-lag watchdog blames for a stall. The record
     // stream already carries that transition; no extra subscription is needed.
     const toolSpans = createToolAttributionSpans(sessionId);
-    const enqueueRecords = (chunk) => {
-        for (const line of chunk.split("\n")) {
-            if (!line)
-                continue;
-            const record = JSON.parse(line);
-            toolSpans.observe(record);
-            writer.enqueue(sessionId, record);
-        }
+    const enqueueRecord = (record) => {
+        toolSpans.observe(record);
+        writer.enqueue(sessionId, record);
     };
     // Attachments share one entry, so resolve the host from the live runtime. In
     // particular, switch_session must use the entry's replacement-aware method
@@ -48,16 +43,25 @@ export async function createRpcSessionBinding(sessionId, entry, writer, requestC
     // an unawaited prompt (senpi#2871).
     let droppedAfterClose = false;
     const handler = await runWithProviderScope(entry.scope, async () => {
-        const writeInScope = bindToProviderScope(enqueueRecords);
+        const writeInScope = bindToProviderScope(enqueueRecord);
+        const dropAfterClose = () => {
+            if (!droppedAfterClose)
+                process.stderr.write(`senpi rpc host: dropped a record for closed session ${sessionId} at ${new Date().toISOString()}\n`);
+            droppedAfterClose = true;
+        };
+        const writeRecord = (record) => {
+            if (entry.scope.state === "closed")
+                return dropAfterClose();
+            writeInScope(record);
+        };
         const taggedSink = {
-            writeRaw: (chunk) => {
-                if (entry.scope.state === "closed") {
-                    if (!droppedAfterClose)
-                        process.stderr.write(`senpi rpc host: dropped a record for closed session ${sessionId} at ${new Date().toISOString()}\n`);
-                    droppedAfterClose = true;
-                    return;
-                }
-                writeInScope(chunk);
+            writeRecord,
+            // A late raw reply after the scope closed is dropped like any record (senpi#2871); while the scope is
+            // open, records arrive only through writeRecord, so a raw write is a wiring bug.
+            writeRaw: () => {
+                if (entry.scope.state === "closed")
+                    return dropAfterClose();
+                throw new Error("Shared session bindings deliver records through writeRecord, never writeRaw");
             },
             waitForBackpressure: bindToProviderScope(async () => { }),
         };
@@ -65,7 +69,6 @@ export async function createRpcSessionBinding(sessionId, entry, writer, requestC
             sessionId,
             shutdownHandler: bindToProviderScope(requestClose),
             disposeRuntime: false,
-            eventFlushScheduler: (flush) => flush(),
             publishLoadedSurfacesChanged: (previous, digest) => {
                 if (entry.scope.state !== "closed")
                     writer.publishLoadedSurfacesChanged(sessionId, previous, digest);

package/dist/modes/rpc/session-command-activity.js

@@ -1,6 +1,7 @@
 /** Whether the command itself refreshes activity, apart from attached-client keepalives. */
 const observations = new Set([
     "get_state",
+    "get_snapshot",
     "get_effect_status",
     "get_pending_inputs",
     "get_messages",

package/dist/modes/rpc/session-event-fanout.d.ts

@@ -50,7 +50,7 @@ export declare class SessionEventFanout {
     pendingQuestionCount(sessionId: string): number;
     /** Deliver one line to the connections attached to a session, never to the rest of the fanout. */
     deliverToSession(sessionId: string, line: string): void;
-    rememberSnapshot(sessionId: string, value: Record<string, unknown>, line: string, placeholderLine?: string, source?: Record<string, unknown>): void;
+    rememberSnapshot(sessionId: string, value: Record<string, unknown>, line: string, placeholderLine?: string): void;
     forgetSession(sessionId: string): void;
     private replaySnapshot;
     private resyncSnapshot;

package/dist/modes/rpc/session-event-fanout.js

@@ -1,6 +1,6 @@
 import { MEDIA_PLACEHOLDERS_CAPABILITY } from "./custom-capability.js";
 import { serializeJsonLine } from "./jsonl.js";
-import { omitInlineMedia } from "./media-placeholders.js";
+import { carriesMedia, omitNormalInlineMedia } from "./media-placeholders.js";
 import { SocketEventSinkActor } from "./socket-event-fanout.js";
 import { EVENT_RESYNC_CAPABILITY } from "./socket-peer-recovery.js";
 const BROADCAST_LIFECYCLE_RECORDS = new Set([
@@ -15,9 +15,11 @@ const BROADCAST_LIFECYCLE_RECORDS = new Set([
 function snapshotPlaceholderLine(record) {
     if (record.placeholderLine !== undefined)
         return record.placeholderLine;
-    const redacted = record.source === undefined ? undefined : omitInlineMedia(record.source);
-    record.placeholderLine =
-        redacted === undefined || redacted === record.source ? record.line : serializeJsonLine(redacted);
+    if (!record.mayCarryMedia)
+        return record.line;
+    const source = JSON.parse(record.line);
+    const redacted = omitNormalInlineMedia(source);
+    record.placeholderLine = redacted === source ? record.line : serializeJsonLine(redacted);
     return record.placeholderLine;
 }
 export class SessionEventFanout {
@@ -147,13 +149,20 @@ export class SessionEventFanout {
             if (this.connectionSessions.get(id)?.has(sessionId))
                 actor.enqueue(line);
     }
-    rememberSnapshot(sessionId, value, line, placeholderLine, source) {
+    rememberSnapshot(sessionId, value, line, placeholderLine) {
+        const record = {
+            line,
+            placeholderLine,
+            hasMessage: value.message != null,
+            mayCarryMedia: carriesMedia(value),
+        };
         if (value.type === "session_lifecycle") {
-            this.lifecycleSnapshots.set(sessionId, { line, placeholderLine, source });
+            this.lifecycleSnapshots.set(sessionId, record);
             return;
         }
         if (value.type === "extension_ui_request" && value.method === "question" && typeof value.id === "string") {
             const pending = this.pendingQuestions.get(sessionId) ?? new Map();
+            // Writer acceptance already detached and JSON-normalized the frame.
             pending.set(value.id, { ...value });
             this.pendingQuestions.set(sessionId, pending);
             return;
@@ -169,7 +178,6 @@ export class SessionEventFanout {
             return;
         }
         const event = value.assistantMessageEvent;
-        const record = { line, placeholderLine, source };
         if (value.type === "message_start" || (value.type === "message_update" && event?.type === "text_start")) {
             this.sessionSnapshots.set(sessionId, [record]);
         }
@@ -200,7 +208,7 @@ export class SessionEventFanout {
         const current = this.connectionSessions.get(id) ?? new Set();
         return [...new Set([...attached, ...current])].map((sessionId) => {
             const records = this.sessionSnapshots.get(sessionId) ?? [];
-            const latest = records.findLast((record) => record.source?.message != null);
+            const latest = records.findLast((record) => record.hasMessage);
             // The producer may mutate its partial object after emission. The serialized
             // record, not that object, fixes the recovery cut before later deltas enqueue.
             const frozen = latest === undefined ? undefined : JSON.parse(latest.line);
@@ -211,7 +219,7 @@ export class SessionEventFanout {
                 message: typeof frozen === "object" && frozen !== null && "message" in frozen ? frozen.message : null,
                 ...(!current.has(sessionId) ? { closed: true } : {}),
             };
-            return placeholders ? omitInlineMedia(record) : record;
+            return placeholders ? omitNormalInlineMedia(record) : record;
         });
     }
 }

package/dist/modes/rpc/session-event-writer.js

@@ -2,8 +2,9 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { bindPrivateMcpForms } from "../../core/mcp-form-types.js";
 import { McpPresenterAuthority } from "./mcp-presenter-authority.js";
 import { MEDIA_PLACEHOLDERS_CAPABILITY } from "./custom-capability.js";
+import { normalizeJsonValue } from "./json-normal-value.js";
 import { serializeJsonLine } from "./jsonl.js";
-import { omitInlineMedia } from "./media-placeholders.js";
+import { omitNormalInlineMedia } from "./media-placeholders.js";
 import { RpcSecurityPresentations } from "./security-presentations.js";
 import { SessionEventFanout } from "./session-event-fanout.js";
 import { SessionOpenTurns } from "./session-open-turns.js";
@@ -330,7 +331,7 @@ export class SessionEventWriter {
         if (this.sealedSessions.has(sessionId))
             return false;
         const targetId = this.connectionContext.getStore();
-        const record = value;
+        const record = normalizeJsonValue(value).value;
         const isTargeted = record.type === "response" ||
             record.type === "bash_execution_update" ||
             // Relocation records belong to the one connection that offers it (session-relocation-channel.ts).
@@ -338,8 +339,22 @@ export class SessionEventWriter {
             record.type === "relocation_due" ||
             (record.type === "extension_ui_request" &&
                 ["select", "confirm", "input", "editor"].includes(String(record.method)));
-        const tagged = { ...value, sessionId };
+        const tagged = { ...record, sessionId };
         const line = serializeJsonLine(tagged);
+        // Observation records are per-subscription opt-ins on the subscriber's own actor FIFO: never attachments,
+        // the attach replay, response broadcast, or the stdio lane, which cannot subscribe.
+        if (record.type === "snapshot_marker" ||
+            record.type === "ui_request_pending" ||
+            record.type === "ui_request_settled") {
+            const targets = record.type === "snapshot_marker"
+                ? this.status.mirrorTargets(sessionId, "snapshot_marker").filter((id) => id === targetId)
+                : this.status.dialogTargets(sessionId);
+            for (const target of targets)
+                this.fanout.get(target)?.actor.enqueue(line);
+            if (targets.length > 0)
+                this.requestFlush();
+            return true;
+        }
         if (this.fanout.isEmpty() && this.exceedsStdioCapacity(line)) {
             this.closeSession(sessionId, {
                 type: "response",
@@ -357,10 +372,12 @@ export class SessionEventWriter {
         // A record is only walked and re-serialized when a target asked for placeholders;
         // otherwise this is byte-for-byte today's path, with serializeJsonLine called once.
         const hasPlaceholderTarget = targets.some((target) => this.fanout.connectionHas(target, MEDIA_PLACEHOLDERS_CAPABILITY));
-        const redacted = hasPlaceholderTarget ? omitInlineMedia(tagged, this.mediaPersisters.get(sessionId)) : tagged;
+        const redacted = hasPlaceholderTarget
+            ? omitNormalInlineMedia(tagged, this.mediaPersisters.get(sessionId))
+            : tagged;
         const placeholderLine = redacted === tagged ? undefined : serializeJsonLine(redacted);
         if (!isTargeted)
-            this.fanout.rememberSnapshot(sessionId, tagged, line, placeholderLine, tagged);
+            this.fanout.rememberSnapshot(sessionId, tagged, line, placeholderLine);
         for (const target of targets) {
             if (target !== undefined && !this.fanout.get(target))
                 continue;

package/dist/modes/rpc/session-extension-ui-requests.d.ts

@@ -1,3 +1,4 @@
+import type { UiRequestChange } from "./snapshot-types.ts";
 import type { RpcExtensionUIRequest, RpcExtensionUIResponse } from "./rpc-types.ts";
 type PendingRequest = {
     resolve: (value: RpcExtensionUIResponse) => void;
@@ -9,7 +10,7 @@ export declare const sessionDialogRequests: WeakMap<object, SessionExtensionUiRe
 export declare class SessionExtensionUiRequests {
     private readonly pending;
     private readonly changed;
-    constructor(changed?: () => void);
+    constructor(changed?: (change?: UiRequestChange) => void);
     set(id: string, request: PendingRequest): void;
     delete(id: string): void;
     snapshot(): RpcExtensionUIRequest[];

package/dist/modes/rpc/session-extension-ui-requests.js

@@ -7,11 +7,13 @@ export class SessionExtensionUiRequests {
     }
     set(id, request) {
         this.pending.set(id, request);
-        this.changed?.();
+        this.changed?.(request.frame
+            ? { type: "ui_request_pending", uiRequestId: id, method: request.frame.method, request: request.frame }
+            : undefined);
     }
     delete(id) {
-        this.pending.delete(id);
-        this.changed?.();
+        if (this.pending.delete(id))
+            this.changed?.({ type: "ui_request_settled", uiRequestId: id, disposition: "cancelled" });
     }
     snapshot() {
         return [...this.pending.values()].flatMap((request) => (request.frame ? [request.frame] : []));
@@ -22,22 +24,25 @@ export class SessionExtensionUiRequests {
             return false;
         beforeAnswer?.();
         this.pending.delete(response.id);
-        this.changed?.();
+        this.changed?.({
+            type: "ui_request_settled",
+            uiRequestId: response.id,
+            disposition: "cancelled" in response ? "cancelled" : "answered",
+        });
         request.resolve(response);
         return true;
     }
     cancelAll() {
-        for (const [id, request] of this.pending)
+        for (const [id, request] of this.pending) {
+            this.delete(id);
             request.resolve({ type: "extension_ui_response", id, cancelled: true });
-        this.pending.clear();
-        this.changed?.();
+        }
     }
     close() {
-        for (const request of this.pending.values()) {
+        for (const [id, request] of this.pending) {
+            this.delete(id);
             request.reject(new Error("Extension UI request cancelled: session closed"));
         }
-        this.pending.clear();
-        this.changed?.();
     }
 }
 //# sourceMappingURL=session-extension-ui-requests.js.map

package/dist/modes/rpc/session-held.js

@@ -9,6 +9,7 @@ import { RpcSessionRegistryError } from "./session-registry-types.js";
 // a read or a control needed to finish/cancel an already-admitted turn.
 const READ_ONLY_OR_CONTROL = new Set([
     "get_state",
+    "get_snapshot",
     "get_effect_status",
     "get_pending_inputs",
     "get_steering_messages",

package/dist/modes/rpc/session-status-stream.d.ts

@@ -67,7 +67,8 @@ export declare class SessionStatusStream {
     publishEffect(sessionId: string, status: EffectStatus): void;
     seal(sessionId: string, terminal: SessionStatusTerminal, cause: SessionStatusCause, by: SessionStatusActor): void;
     forget(sessionId: string): void;
-    mirrorTargets(sessionId: string, recordType: string): readonly string[];
+    dialogTargets(sessionId: string): readonly string[];
+    mirrorTargets(sessionId: string, recordType: string, dialogs?: boolean): readonly string[];
     matchingConnections(sessionId: string): ReadonlyMap<string, boolean>;
     /** The live view, falling back to the last one seen once the registry has dropped a sealed entry. */
     private currentView;

package/dist/modes/rpc/session-status-stream.js

@@ -171,8 +171,14 @@ export class SessionStatusStream {
         this.lastViews.delete(sessionId);
         this.lastChanges.delete(sessionId);
     }
-    mirrorTargets(sessionId, recordType) {
-        const subscriptions = [...this.pendings.values(), ...this.subscriptions.values()].filter((subscription) => mirrorsRecord(subscription.options.mirror, recordType));
+    dialogTargets(sessionId) {
+        return this.mirrorTargets(sessionId, "ui_request_pending", true);
+    }
+    mirrorTargets(sessionId, recordType, dialogs = false) {
+        const subscriptions = [...this.pendings.values(), ...this.subscriptions.values()].filter((subscription) => (dialogs ? subscription.options.dialogs === true : true) &&
+            (recordType === "snapshot_marker" || dialogs
+                ? subscription.options.mirror.kind !== "none"
+                : mirrorsRecord(subscription.options.mirror, recordType)));
         if (subscriptions.length === 0)
             return [];
         const entry = this.source?.entryView(sessionId) ?? this.lastViews.get(sessionId)?.entry;

package/dist/modes/rpc/session-status-subscriptions.d.ts

@@ -29,6 +29,7 @@ export interface SubscriptionOptions {
     readonly includeContext: boolean;
     readonly mirror: MirrorSelection;
     readonly effects: boolean;
+    readonly dialogs?: boolean;
 }
 export interface SubscriptionRefusal {
     readonly reason: string;
@@ -36,7 +37,7 @@ export interface SubscriptionRefusal {
 }
 export declare function parseSubscription(request: Readonly<Pick<Extract<RpcCommand, {
     type: "subscribe_sessions";
-}>, "sessions" | "mirror" | "include_workers" | "include_context" | "effects">>): {
+}>, "sessions" | "mirror" | "include_workers" | "include_context" | "effects" | "dialogs">>): {
     readonly options: SubscriptionOptions;
 } | {
     readonly refusal: SubscriptionRefusal;

package/dist/modes/rpc/session-status-subscriptions.js

@@ -59,12 +59,16 @@ export function parseSubscription(request) {
     const includeContext = optionalBoolean(request.include_context, "include_context");
     if (typeof includeContext === "object")
         return { refusal: includeContext };
+    const dialogs = optionalBoolean(request.dialogs, "dialogs");
+    if (typeof dialogs === "object")
+        return { refusal: dialogs };
     const effects = optionalBoolean(request.effects, "effects");
     if (typeof effects === "object")
         return { refusal: effects };
     return {
         options: {
             selector: selector.selector,
+            dialogs: dialogs ?? false,
             // A childrenOf subscription exists to watch machine-driven children, which open as workers.
             includeWorkers: includeWorkers ?? selector.selector.kind === "childrenOf",
             includeContext: includeContext ?? false,

package/dist/modes/rpc/session-worker.js

@@ -76,7 +76,8 @@ class WorkerEventWriter extends SessionEventWriter {
         }));
     }
     enqueue(_sessionId, record) {
-        if (Buffer.byteLength(JSON.stringify(record)) > SESSION_WORKER_LIMITS.outputBytes)
+        const line = JSON.stringify(record);
+        if (Buffer.byteLength(line) > SESSION_WORKER_LIMITS.outputBytes)
             failWorker("session_worker_output_limit");
         const session = entry?.runtime?.session;
         if (!session)
@@ -97,7 +98,9 @@ class WorkerEventWriter extends SessionEventWriter {
             failWorker("session_worker_snapshot_limit");
         exchange((signal) => ({
             type: "output",
-            record,
+            // Keep one JSON-normal transfer format, including toJSON and non-cloneable fields.
+            // S12 replaces this whole-record serialization with compact records and permits.
+            record: JSON.parse(line),
             connection: this.currentConnection(),
             signal,
             activity,

package/dist/modes/rpc/snapshot-types.d.ts

@@ -0,0 +1,29 @@
+import type { SessionEntry } from "../../core/session-manager.ts";
+import type { RpcExtensionUIRequest } from "./rpc-question-types.ts";
+import type { RpcSessionState } from "./rpc-session-state-types.ts";
+export type RpcSnapshot = {
+    readonly state: RpcSessionState;
+    readonly entries: SessionEntry[];
+    readonly next_before: string | null;
+    readonly history_truncated: boolean;
+    readonly markerId: string;
+};
+export type RpcSnapshotMarker = {
+    readonly type: "snapshot_marker";
+    readonly sessionId: string;
+    readonly markerId: string;
+};
+export type UiRequestChange = {
+    readonly type: "ui_request_pending";
+    readonly uiRequestId: string;
+    readonly method: RpcExtensionUIRequest["method"];
+    readonly request: RpcExtensionUIRequest;
+} | {
+    readonly type: "ui_request_settled";
+    readonly uiRequestId: string;
+    readonly disposition: "answered" | "cancelled";
+};
+export type RpcUiRequestEvent = UiRequestChange & {
+    readonly sessionId: string;
+};
+//# sourceMappingURL=snapshot-types.d.ts.map

package/dist/modes/rpc/snapshot-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=snapshot-types.js.map

package/dist/modes/rpc/ui-answer-ledger.d.ts

@@ -0,0 +1,13 @@
+/** Session-generation receipts: deliberately never persisted to the transcript. */
+export type UiAnswerReceipt = {
+    readonly uiRequestId: string;
+    readonly answerId?: string;
+};
+export declare class UiAnswerLedger {
+    private readonly answers;
+    lookup(uiRequestId: string, answerId: string | undefined): "replay" | "already_answered" | undefined;
+    record(uiRequestId: string, answerId: string | undefined): void;
+    snapshot(): UiAnswerReceipt[];
+}
+export declare function sessionUiAnswerLedger(session: object): UiAnswerLedger;
+//# sourceMappingURL=ui-answer-ledger.d.ts.map

package/dist/modes/rpc/ui-answer-ledger.js

@@ -0,0 +1,34 @@
+export class UiAnswerLedger {
+    constructor() {
+        this.answers = new Map();
+    }
+    lookup(uiRequestId, answerId) {
+        const receipt = this.answers.get(uiRequestId);
+        if (!receipt)
+            return undefined;
+        return answerId !== undefined && answerId === receipt.answerId ? "replay" : "already_answered";
+    }
+    record(uiRequestId, answerId) {
+        if (this.answers.has(uiRequestId))
+            return;
+        this.answers.set(uiRequestId, { uiRequestId, ...(answerId === undefined ? {} : { answerId }) });
+        if (this.answers.size > 1024) {
+            const oldest = this.answers.keys().next();
+            if (!oldest.done)
+                this.answers.delete(oldest.value);
+        }
+    }
+    snapshot() {
+        return [...this.answers.values()].slice(-64).map((receipt) => ({ ...receipt }));
+    }
+}
+const ledgers = new WeakMap();
+export function sessionUiAnswerLedger(session) {
+    let ledger = ledgers.get(session);
+    if (!ledger) {
+        ledger = new UiAnswerLedger();
+        ledgers.set(session, ledger);
+    }
+    return ledger;
+}
+//# sourceMappingURL=ui-answer-ledger.js.map

package/dist/senpi

@@ -10,7 +10,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import "./valid-cwd.js";
 import "./internal-role.js";
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync, realpathSync } from "node:fs";
+import { existsSync, fstatSync, realpathSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { processBunRuntimeOptions, resolveBunReexec } from "./bun-runtime.js";
@@ -20,6 +20,24 @@ import { APP_NAME, DISPLAY_VERSION, findNodePackageDir, getAgentDir, getInstallP
 import { hasInheritedInspectorOption, releaseInheritedInspectorForChild } from "./inspector-policy.js";
 import { prepareRuntimeSnapshot } from "./runtime-snapshot/enter.js";
 import { handleBootstrapSelfUpdate } from "./self-update-bootstrap.js";
+/** Only a presenter-enabled launch may carry its reserved private channel through CLI re-execution. */
+function reexecStdio() {
+    const argv = process.argv.slice(2);
+    const presenter = argv.indexOf("--mcp-presenter-fd");
+    if (presenter < 0 || argv[presenter + 1] !== "4")
+        return "inherit";
+    try {
+        const stat = fstatSync(4);
+        if (!stat.isSocket() && !stat.isFIFO())
+            return "inherit";
+    }
+    catch {
+        return "inherit";
+    }
+    const owner = argv.indexOf("--owner-fd");
+    const lifetime = (owner >= 0 && argv[owner + 1] === "3") || process.env.SENPI_RPC_HOST_WATCH_FD === "3";
+    return ["inherit", "inherit", "inherit", lifetime ? 3 : "ignore", 4];
+}
 // Upstream's `cli/setup.ts` helper is deliberately not used here: this launcher only decides the
 // runtime and process structure, and `cli-main.ts` performs the equivalent process/title/env/http
 // setup for both entry paths (Node launcher and the Bun binary).
@@ -52,7 +70,7 @@ function reexecUnderBunIfNeeded() {
         return false;
     }
     const result = spawnSync(decision.bunPath, [scriptRealPath, ...process.argv.slice(2)], {
-        stdio: "inherit",
+        stdio: reexecStdio(),
         windowsHide: true,
     });
     if (result.signal) {
@@ -125,7 +143,7 @@ async function spawnFullCli() {
     return await new Promise((resolve, reject) => {
         const child = spawn(process.execPath, [...process.execArgv, fullCliPath, ...args], {
             env: childEnvironment,
-            stdio: "inherit",
+            stdio: reexecStdio(),
         });
         child.on("error", (error) => {
             reject(error);

package/docs/mcp.md

@@ -386,6 +386,26 @@ above.
 
 ## Resources and prompts
 
+MCP 2026-07-28 tool schemas use JSON Schema 2020-12 by default. Explicit
+2020-12 declarations are supported; other dialect declarations produce
+`MCP_SCHEMA_UNSUPPORTED_DIALECT`. Tool discovery, the disk cache, and MCP
+exposure retain the full schema, including `$defs`, `$ref` siblings, and
+`additionalProperties`. Boolean roots use an equivalent `allOf` container
+at the object-shaped model-tool API boundary.
+
+Modern structured results may be any JSON value, including `null`, `false`,
+and `0`. Successful results with an `outputSchema` must contain conforming
+`structuredContent`; execution-error results are exempt. Validation never
+coerces values, inserts defaults, removes properties, or fetches references
+from the network. Unresolved references are rejected. Schemas are bounded
+to 64 nesting levels and 16,384 JSON nodes; `format` is an annotation.
+
+Object-only model providers may require a lossy schema adaptation in the AI
+provider layer. That wire adaptation does not change MCP's source schema
+or the arguments sent to the server: modern calls validate the model's
+arguments without coercion. Legacy connections retain the SDK's existing
+schema validation and compatibility conversion.
+
 - `mcp_list_resources` / `mcp_read_resource` register automatically when a
   connected server lists resources.
 - Mention `@mcp:<server>/<uri>` in your prompt to inline a resource's content