@code-yeongyu/senpi 2026.10.25-4 → 2026.10.26-2

package/dist/core/extensions/builtin/mcp/modern/tool-schema.js

@@ -0,0 +1,75 @@
+import { Ajv2020 } from "ajv/dist/2020.js";
+export class McpToolSchemaError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.name = "McpToolSchemaError";
+        this.code = code;
+    }
+}
+const validators = new WeakMap();
+const dialect = "https://json-schema.org/draft/2020-12/schema";
+/** No coercion/default insertion/removal, no network resolver, no shared $id namespace. */
+export function compileModernSchema(schema) {
+    const cached = typeof schema === "boolean" ? undefined : validators.get(schema);
+    if (cached !== undefined)
+        return cached;
+    checkBounds(schema);
+    if (typeof schema !== "boolean" &&
+        schema.$schema !== undefined &&
+        schema.$schema !== dialect &&
+        schema.$schema !== `${dialect}#`) {
+        throw new McpToolSchemaError("MCP_SCHEMA_UNSUPPORTED_DIALECT", "Modern MCP supports JSON Schema 2020-12.");
+    }
+    try {
+        if (typeof schema !== "boolean" && schema.$async !== undefined)
+            throw new McpToolSchemaError("MCP_SCHEMA_INVALID", "Async schemas are unsupported.");
+        const ajv = new Ajv2020({
+            strict: false,
+            validateFormats: false,
+            allErrors: false,
+            inlineRefs: false,
+            addUsedSchema: false,
+        });
+        const validate = ajv.compile(schema);
+        if (typeof schema !== "boolean")
+            validators.set(schema, validate);
+        return validate;
+    }
+    catch (error) {
+        if (error instanceof McpToolSchemaError)
+            throw error;
+        throw new McpToolSchemaError("MCP_SCHEMA_INVALID", "Invalid MCP schema or unresolved schema reference.");
+    }
+}
+/** Reject one unusable definition, never its valid siblings; diagnostics contain no schema or arguments. */
+export function hasSupportedModernToolSchemas(tool) {
+    try {
+        compileModernSchema(tool.inputSchema);
+        if (tool.outputSchema !== undefined)
+            compileModernSchema(tool.outputSchema);
+        return true;
+    }
+    catch (error) {
+        if (!(error instanceof McpToolSchemaError))
+            throw error;
+        console.warn(`MCP tool ${JSON.stringify(tool.name)} skipped: ${error.code}: ${error.message}`);
+        return false;
+    }
+}
+function checkBounds(schema) {
+    const pending = [{ value: schema, depth: 0 }];
+    let nodes = 0;
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === undefined)
+            break;
+        if (++nodes > 16_384 || current.depth > 64) {
+            throw new McpToolSchemaError("MCP_SCHEMA_LIMIT", "MCP schema exceeds the depth or node limit.");
+        }
+        if (current.value !== null && typeof current.value === "object") {
+            for (const value of Object.values(current.value))
+                pending.push({ value, depth: current.depth + 1 });
+        }
+    }
+}
+//# sourceMappingURL=tool-schema.js.map

package/dist/core/extensions/builtin/mcp/modern/tools.d.ts

@@ -0,0 +1,107 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import { z } from "zod";
+import type { McpJsonSchema } from "../tool-contracts.ts";
+export declare function listModernTools(client: Client, params?: Parameters<Client["listTools"]>[0], options?: RequestOptions): Promise<{
+    nextCursor?: string | undefined;
+    tools: {
+        description?: string | undefined;
+        annotations?: {
+            title?: string | undefined;
+            readOnlyHint?: boolean | undefined;
+            destructiveHint?: boolean | undefined;
+            idempotentHint?: boolean | undefined;
+            openWorldHint?: boolean | undefined;
+        } | undefined;
+        execution?: {
+            taskSupport?: "forbidden" | "optional" | "required" | undefined;
+        } | undefined;
+        _meta?: Record<string, unknown> | undefined;
+        icons?: {
+            src: string;
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            theme?: "dark" | "light" | undefined;
+        }[] | undefined;
+        name: string;
+        title?: string | undefined;
+        inputSchema: boolean | Record<string, z.JSONType>;
+        outputSchema?: boolean | Record<string, z.JSONType> | undefined;
+    }[];
+}>;
+export declare function callModernTool(client: Client, params: Parameters<Client["callTool"]>[0], outputSchema: McpJsonSchema | undefined, options?: RequestOptions): Promise<{
+    isError?: boolean | undefined;
+    structuredContent?: z.JSONType | undefined;
+    content?: ({
+        type: "text";
+        text: string;
+        annotations?: {
+            audience?: ("assistant" | "user")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: Record<string, unknown> | undefined;
+    } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("assistant" | "user")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: Record<string, unknown> | undefined;
+    } | {
+        type: "audio";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("assistant" | "user")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: Record<string, unknown> | undefined;
+    } | {
+        uri: string;
+        description?: string | undefined;
+        mimeType?: string | undefined;
+        size?: number | undefined;
+        annotations?: {
+            audience?: ("assistant" | "user")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+        icons?: {
+            src: string;
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            theme?: "dark" | "light" | undefined;
+        }[] | undefined;
+        name: string;
+        title?: string | undefined;
+        type: "resource_link";
+    } | {
+        type: "resource";
+        resource: {
+            uri: string;
+            mimeType?: string | undefined;
+            _meta?: Record<string, unknown> | undefined;
+            text: string;
+        } | {
+            uri: string;
+            mimeType?: string | undefined;
+            _meta?: Record<string, unknown> | undefined;
+            blob: string;
+        };
+        annotations?: {
+            audience?: ("assistant" | "user")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: Record<string, unknown> | undefined;
+    })[] | undefined;
+}>;
+//# sourceMappingURL=tools.d.ts.map

package/dist/core/extensions/builtin/mcp/modern/tools.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { loadMcpSdkTypes } from "../sdk.lazy.js";
+import { McpMrtrError } from "./errors.js";
+import { compileModernSchema, hasSupportedModernToolSchemas, McpToolSchemaError } from "./tool-schema.js";
+const jsonSchema = z.union([z.boolean(), z.record(z.string(), z.json())]);
+const modernToolSchema = z.looseObject({
+    name: z.string(),
+    inputSchema: jsonSchema,
+    outputSchema: jsonSchema.optional(),
+});
+const listResult = z.looseObject({
+    tools: z.array(modernToolSchema),
+    nextCursor: z.string().optional(),
+});
+const callResult = z.looseObject({
+    isError: z.boolean().optional(),
+    structuredContent: z.json().optional(),
+});
+export async function listModernTools(client, params, options) {
+    // Keep the SDK behind its documented startup boundary, and its Zod identity separate.
+    const { ResultSchema, ToolSchema } = await loadMcpSdkTypes();
+    const toolMetadata = ToolSchema.omit({ inputSchema: true, outputSchema: true });
+    const raw = await client.request({ method: "tools/list", params }, ResultSchema, options);
+    const parsed = listResult.safeParse(raw);
+    if (!parsed.success)
+        throw new McpMrtrError("MCP_MRTR_INVALID_RESULT");
+    const tools = parsed.data.tools.filter(hasSupportedModernToolSchemas).map((tool) => {
+        const metadata = toolMetadata.safeParse(tool);
+        if (!metadata.success)
+            throw new McpMrtrError("MCP_MRTR_INVALID_RESULT");
+        return { ...tool, ...metadata.data };
+    });
+    return { ...parsed.data, tools };
+}
+export async function callModernTool(client, params, outputSchema, options) {
+    const { CallToolResultSchema, ResultSchema } = await loadMcpSdkTypes();
+    const validate = outputSchema === undefined ? undefined : compileModernSchema(outputSchema);
+    const raw = await client.request({ method: "tools/call", params }, ResultSchema, options);
+    const parsed = callResult.safeParse(raw);
+    if (!parsed.success)
+        throw new McpMrtrError("MCP_MRTR_INVALID_RESULT");
+    const content = CallToolResultSchema.shape.content.optional().safeParse(raw.content);
+    if (!content.success)
+        throw new McpMrtrError("MCP_MRTR_INVALID_RESULT");
+    const result = { ...parsed.data, ...(content.data === undefined ? {} : { content: content.data }) };
+    if (validate !== undefined && result.isError !== true) {
+        if (!Object.hasOwn(result, "structuredContent") || !validate(result.structuredContent)) {
+            throw new McpToolSchemaError("MCP_OUTPUT_SCHEMA_MISMATCH", "Tool result does not match outputSchema.");
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=tools.js.map

package/dist/core/extensions/builtin/mcp/modern/transport.d.ts

@@ -1,6 +1,7 @@
 import type { FetchLike, Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { type JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
 import { type ModernClientInfo } from "./wire.ts";
+import type { McpLogger } from "../log.ts";
 export type ModernHttpTransportOptions = {
     readonly url: string | URL;
     readonly fetch: FetchLike;
@@ -8,6 +9,7 @@ export type ModernHttpTransportOptions = {
     readonly clientCapabilities: Readonly<Record<string, unknown>>;
     readonly protocolVersion?: string;
     readonly headers?: RequestInit["headers"];
+    readonly logger?: Pick<McpLogger, "warn">;
 };
 export declare class ModernTransportError extends Error {
     constructor(message: string);

package/dist/core/extensions/builtin/mcp/modern/transport.js

@@ -4,7 +4,7 @@ import { AuthError } from "../errors.js";
 import { sanitizeModernMessage } from "./diagnostics.js";
 import { McpMrtrError } from "./errors.js";
 import { getModernDispatchGuard, modernDispatchGuard } from "./request.js";
-import { clearMcpParameterHeaders, ModernParameterHeaders } from "./parameter-headers.js";
+import { clearMcpParameterHeaders, ModernParameterHeaders, ParameterHeaderValidationError, } from "./parameter-headers.js";
 export class ModernTransportError extends Error {
     constructor(message) {
         super(message);
@@ -119,6 +119,8 @@ export class ModernHttpTransport {
             }
         }
         catch (error) {
+            if (error instanceof ParameterHeaderValidationError)
+                throw error;
             const failure = error instanceof McpMrtrError || error instanceof AuthError
                 ? error
                 : new McpMrtrError("MCP_MRTR_TRANSPORT_FAILED");
@@ -142,7 +144,7 @@ export class ModernHttpTransport {
                     ...incoming,
                     result: {
                         ...result,
-                        tools: this.#parameterHeaders.filterTools(result.tools, this.#toolLists.get(incoming.id) === true),
+                        tools: this.#parameterHeaders.filterTools(result.tools, this.#toolLists.get(incoming.id) === true, (message) => this.#options.logger?.warn(message)),
                     },
                 };
             }

package/dist/core/extensions/builtin/mcp/resources.js

@@ -19,6 +19,7 @@ import { ResourceUpdatedNotificationSchema, registerMcpNotificationHandler } fro
 import { mcpRequestOptions } from "./request-origin.js";
 import { McpMrtrError } from "./modern/errors.js";
 import { ensureMcpToolCallConnection } from "./health.js";
+import { isModernMcpClient } from "./modern/request.js";
 /** Route resource updated notifications into the shared refresh path. */
 export function subscribeMcpResourceUpdated(client, onChange) {
     registerMcpNotificationHandler(client, ResourceUpdatedNotificationSchema, () => {
@@ -27,6 +28,9 @@ export function subscribeMcpResourceUpdated(client, onChange) {
 }
 /** Best-effort per-resource subscriptions when the server declares support. */
 export async function ensureMcpResourceSubscriptions(client, resources) {
+    // Modern streams derive their resource URI filter from resources/list results.
+    if (isModernMcpClient(client))
+        return;
     if (client.getServerCapabilities()?.resources?.subscribe !== true)
         return;
     await Promise.all(resources.map((resource) => client.subscribeResource({ uri: resource.uri }).catch(() => undefined)));

package/dist/core/extensions/builtin/mcp/tool-client.d.ts

@@ -0,0 +1,13 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type { McpJsonSchema, McpListedTool, McpToolResult } from "./tool-contracts.ts";
+/**
+ * Tool operations have an era-specific contract. The SDK client remains the
+ * lifecycle/request owner, but its legacy tool helpers never parse modern data.
+ */
+export declare function listMcpTools(client: Client, params?: Parameters<Client["listTools"]>[0], options?: RequestOptions): Promise<{
+    tools: McpListedTool[];
+    nextCursor?: string;
+}>;
+export declare function callMcpToolRequest(client: Client, params: Parameters<Client["callTool"]>[0], outputSchema: McpJsonSchema | undefined, options?: RequestOptions): Promise<McpToolResult>;
+//# sourceMappingURL=tool-client.d.ts.map

package/dist/core/extensions/builtin/mcp/tool-client.js

@@ -0,0 +1,17 @@
+import { isModernMcpClient } from "./modern/request.js";
+import { callModernTool, listModernTools } from "./modern/tools.js";
+/**
+ * Tool operations have an era-specific contract. The SDK client remains the
+ * lifecycle/request owner, but its legacy tool helpers never parse modern data.
+ */
+export async function listMcpTools(client, params, options) {
+    if (!isModernMcpClient(client))
+        return client.listTools(params, options);
+    return listModernTools(client, params, options);
+}
+export async function callMcpToolRequest(client, params, outputSchema, options) {
+    if (!isModernMcpClient(client))
+        return client.callTool(params, undefined, options);
+    return callModernTool(client, params, outputSchema, options);
+}
+//# sourceMappingURL=tool-client.js.map

package/dist/core/extensions/builtin/mcp/tool-contracts.d.ts

@@ -0,0 +1,19 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+/** Raw JSON Schema, not the SDK v1 object-root subset. */
+export type McpJsonSchema = boolean | Record<string, unknown>;
+export type McpJsonValue = null | boolean | number | string | McpJsonValue[] | {
+    [key: string]: McpJsonValue;
+};
+export type McpListedTool = Omit<Tool, "inputSchema" | "outputSchema"> & {
+    readonly inputSchema: McpJsonSchema;
+    readonly outputSchema?: McpJsonSchema;
+};
+export interface McpModernToolResult {
+    readonly content?: Awaited<ReturnType<Client["callTool"]>>["content"];
+    readonly structuredContent?: McpJsonValue;
+    readonly isError?: boolean;
+    readonly [key: string]: unknown;
+}
+export type McpToolResult = McpModernToolResult | Awaited<ReturnType<Client["callTool"]>>;
+//# sourceMappingURL=tool-contracts.d.ts.map

package/dist/core/extensions/builtin/mcp/tool-contracts.js

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

package/dist/core/extensions/builtin/mcp/wrap.js

@@ -2,8 +2,8 @@ import { redactMcpLogText } from "./log.js";
 /** The modern operation uses one injectable monotonic clock and scheduler. */
 export const mcpElapsedClock = {
     now: () => performance.now(),
-    schedule: setTimeout,
-    cancel: clearTimeout,
+    schedule: (callback, ms) => setTimeout(callback, ms),
+    cancel: (timer) => clearTimeout(timer),
 };
 export function wrapAsync(scope, fn, sink) {
     return async (...args) => {

package/dist/core/extensions/builtin/permission-system/bash-command-segments.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Splits a shell command into the simple commands it would run, so the `bash` permission decision
+ * can judge every one of them, not only the first.
+ *
+ * The lexer follows bash's word and operator rules closely enough to find each simple command:
+ * `;`, `&&`, `||`, `|`, `|&`, `&` and line breaks end one; subshells `( … )`, command substitution
+ * `$( … )` and backticks, process substitution `<( … )` / `>( … )`, `${ … }` and `$(( … ))` and the
+ * bodies of unquoted here-documents are searched for the commands they run; redirections and their
+ * targets are dropped. Every command name is then normalized: leading assignments and reserved
+ * words are skipped, a path is reduced to its basename, and a wrapper (`env`, `sudo`, `xargs`,
+ * `bash -c`, `find -exec`, …) yields both its own name and the command it runs.
+ *
+ * Anything the lexer does not understand (an unterminated quote, a `case`, a function definition,
+ * a command name built by an expansion, an unknown wrapper option) makes the whole command
+ * `unparsed`, and the caller must not let any command-specific rule allow it.
+ */
+export type BashCommandAnalysis = {
+    readonly kind: "parsed";
+    readonly segments: readonly (readonly string[])[];
+} | {
+    readonly kind: "unparsed";
+};
+/** Longer commands are not lexed at all: they are `unparsed`, so only a `*` rule can decide them. */
+export declare const MAX_COMMAND_LENGTH: number;
+/**
+ * Every simple command `command` would run, each as its normalized words (command name first), in
+ * source order; or `unparsed` when any part of the command is outside what this lexer understands.
+ */
+export declare function analyzeBashCommand(command: string): BashCommandAnalysis;
+/** Lexer steps the last `analyzeBashCommand` call used (for scaling tests). */
+export declare function lastAnalysisSteps(): number;
+/**
+ * Candidate command names for a command the lexer could not parse, used only so a deny rule still
+ * matches: every plain word, at every position, read as the start of a command.
+ */
+export declare function bestEffortCommandLines(command: string): string[][];
+//# sourceMappingURL=bash-command-segments.d.ts.map