@code-yeongyu/senpi 2026.9.15-2 → 2026.9.16

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/kernel-tools-host.ts

@@ -0,0 +1,134 @@
+import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
+import { generateCorrelationId } from "../../bridge/protocol.ts";
+import { RESERVED_AGENT_TOOL } from "../../bridge/reserved.ts";
+import { kernelToolError } from "./kernel-tools-errors.ts";
+import type { KernelToolsDescribeResult, KernelToolsInvokeRequest } from "./kernel-tools-types.ts";
+
+type KernelToolReply = Extract<
+	KernelToHostMessage,
+	{ type: "kernel-tool-describe-reply" } | { type: "kernel-tool-invoke-reply" }
+>;
+
+type Waiter = {
+	readonly resolve: (message: KernelToolReply) => void;
+	readonly reject: (error: Error) => void;
+};
+
+export class KernelToolHostPump {
+	readonly events = new EventTarget();
+	readonly #waiters = new Map<string, Waiter>();
+	readonly #post: (message: HostToKernelMessage) => void;
+	readonly #isOpen: () => boolean;
+
+	constructor(post: (message: HostToKernelMessage) => void, isOpen: () => boolean) {
+		this.#post = post;
+		this.#isOpen = isOpen;
+	}
+
+	consume(message: KernelToHostMessage): boolean {
+		if (message.type === "tool-call" && message.toolName === RESERVED_AGENT_TOOL) {
+			this.events.dispatchEvent(new Event("outerAwaitingAgent"));
+		}
+		if (message.type !== "kernel-tool-describe-reply" && message.type !== "kernel-tool-invoke-reply") return false;
+		const waiter = this.#waiters.get(message.requestId);
+		if (!waiter) return true;
+		this.#waiters.delete(message.requestId);
+		waiter.resolve(message);
+		return true;
+	}
+
+	rejectAll(error: Error): void {
+		for (const [requestId, waiter] of this.#waiters) {
+			this.#waiters.delete(requestId);
+			waiter.reject(error);
+		}
+	}
+
+	async describe(names: readonly string[]): Promise<KernelToolsDescribeResult> {
+		const reply = await this.#request({
+			type: "kernel-tool-describe",
+			requestId: generateCorrelationId(),
+			names: [...names],
+		});
+		if (reply.type !== "kernel-tool-describe-reply") {
+			throw kernelToolError("kernel_tool_failed", "unexpected kernel-tool describe reply");
+		}
+		if (!reply.ok) {
+			throw kernelToolError(codeOf(reply.error.code), reply.error.message);
+		}
+		return { results: reply.results as KernelToolsDescribeResult["results"] };
+	}
+
+	async invoke(request: KernelToolsInvokeRequest, signal?: AbortSignal): Promise<unknown> {
+		this.events.dispatchEvent(new Event("nestedInvoke"));
+		const reply = await this.#request(
+			{
+				type: "kernel-tool-invoke",
+				requestId: generateCorrelationId(),
+				name: request.name,
+				kernel_generation: request.kernel_generation,
+				definition_revision: request.definition_revision,
+				args: request.args,
+				call_id: request.call_id,
+			},
+			signal,
+		);
+		if (reply.type !== "kernel-tool-invoke-reply") {
+			throw kernelToolError("kernel_tool_failed", "unexpected kernel-tool invoke reply");
+		}
+		if (!reply.ok) throw kernelToolError(codeOf(reply.error.code), reply.error.message);
+		return reply.value;
+	}
+
+	#request(
+		message: Extract<HostToKernelMessage, { requestId: string }>,
+		signal?: AbortSignal,
+	): Promise<KernelToolReply> {
+		if (!this.#isOpen()) throw kernelToolError("tools_unavailable", "JavaScript worker is not available");
+		return new Promise((resolve, reject) => {
+			const onAbort = (): void => {
+				if (!this.#waiters.delete(message.requestId)) return;
+				this.#post({ type: "kernel-tool-cancel", requestId: message.requestId });
+				reject(kernelToolError("kernel_tool_stale", "Kernel tool call cancelled"));
+			};
+			const cleanup = (): void => signal?.removeEventListener("abort", onAbort);
+			this.#waiters.set(message.requestId, {
+				resolve: (reply) => {
+					cleanup();
+					resolve(reply);
+				},
+				reject: (error) => {
+					cleanup();
+					reject(error);
+				},
+			});
+			if (signal?.aborted) {
+				onAbort();
+				return;
+			}
+			signal?.addEventListener("abort", onAbort, { once: true });
+			this.#post(message);
+		});
+	}
+}
+
+function codeOf(
+	code: string | undefined,
+):
+	| "kernel_tool_failed"
+	| "kernel_tool_stale"
+	| "kernel_tool_missing"
+	| "kernel_tool_recursion"
+	| "tools_unavailable"
+	| "invalid_tool_definition" {
+	if (
+		code === "kernel_tool_stale" ||
+		code === "kernel_tool_missing" ||
+		code === "kernel_tool_recursion" ||
+		code === "tools_unavailable" ||
+		code === "invalid_tool_definition"
+	) {
+		return code;
+	}
+	return "kernel_tool_failed";
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/kernel-tools-naming.js

@@ -0,0 +1,28 @@
+/** MCP name rules from coding-agent mcp/expose/naming.ts, applied explicitly for kernel tools. */
+export const MCP_TOOL_NAME_MAX_LENGTH = 64;
+
+export function sanitizeNamePart(name) {
+	return name.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+
+export function matcherKey(name) {
+	return name.replace(/-/g, "_");
+}
+
+export function ellipsizeMiddle(value, maxLength) {
+	if (value.length <= maxLength) return value;
+	if (maxLength <= 3) return value.slice(0, maxLength);
+	const marker = "...";
+	const remaining = maxLength - marker.length;
+	const prefixLength = Math.ceil(remaining / 2);
+	const suffixLength = Math.floor(remaining / 2);
+	return `${value.slice(0, prefixLength)}${marker}${value.slice(value.length - suffixLength)}`;
+}
+
+export function normalizeKernelToolName(name) {
+	return ellipsizeMiddle(sanitizeNamePart(name), MCP_TOOL_NAME_MAX_LENGTH);
+}
+
+export function kernelToolKey(name) {
+	return matcherKey(normalizeKernelToolName(name));
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/kernel-tools-parse.d.ts

@@ -0,0 +1,5 @@
+export function parseToolFunction(fn: unknown): {
+	readonly name: string;
+	readonly params: readonly string[];
+	readonly async: boolean;
+};

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/kernel-tools-parse.js

@@ -0,0 +1,255 @@
+import { kernelToolError } from "./kernel-tools-errors.js";
+
+const IDENT = /^[\p{ID_Start}$_][\p{ID_Continue}$\u200c\u200d]*$/u;
+const RESERVED = new Set(
+	"await break case catch class const continue debugger default delete do else enum export extends false finally for function if implements import in instanceof interface let new null package private protected public return static super switch this throw true try typeof var void while with yield".split(
+		" ",
+	),
+);
+
+export function parseToolFunction(fn) {
+	if (typeof fn !== "function") fail();
+	const source = fn.toString();
+	if (source.includes("[native code]")) fail("tool() cannot wrap native functions");
+	return parseHead(source);
+}
+
+function parseHead(source) {
+	const pos = { i: 0, source };
+	skipTrivia(pos);
+	if (keyword(pos, "class")) fail();
+	let async = false;
+	if (keyword(pos, "async")) {
+		skipTrivia(pos);
+		if (!keyword(pos, "function")) fail();
+		async = true;
+	} else if (!keyword(pos, "function")) fail();
+	skipTrivia(pos);
+	if (peek(pos) === "*") fail();
+	const name = ident(pos);
+	if (!name) fail();
+	skipTrivia(pos);
+	if (peek(pos) !== "(") fail();
+	return { name, params: readParams(pos), async };
+}
+
+function readParams(pos) {
+	const parts = splitTopLevel(extractParenInner(pos));
+	if (parts.length === 1 && plainIdent(parts[0]) === "") return [];
+	return parts.map((part) => {
+		const name = plainIdent(part);
+		if (!name) fail("tool() requires simple identifier parameters");
+		return name;
+	});
+}
+
+function plainIdent(part) {
+	const pos = { i: 0, source: part };
+	skipTrivia(pos);
+	if (eof(pos)) return "";
+	const name = ident(pos);
+	if (!name) return null;
+	skipTrivia(pos);
+	return eof(pos) ? name : null;
+}
+
+function splitTopLevel(source) {
+	const parts = [];
+	let current = "";
+	const pos = { i: 0, source };
+	let paren = 0;
+	let square = 0;
+	let curly = 0;
+	while (!eof(pos)) {
+		const start = pos.i;
+		if (skipValue(pos)) {
+			current += source.slice(start, pos.i);
+			continue;
+		}
+		const ch = source[pos.i];
+		pos.i += 1;
+		if (ch === "(") paren += 1;
+		else if (ch === ")") paren -= 1;
+		else if (ch === "[") square += 1;
+		else if (ch === "]") square -= 1;
+		else if (ch === "{") curly += 1;
+		else if (ch === "}") curly -= 1;
+		if (ch === "," && paren === 0 && square === 0 && curly === 0) {
+			parts.push(current);
+			current = "";
+		} else current += ch;
+	}
+	parts.push(current);
+	return parts;
+}
+
+function extractParenInner(pos) {
+	const source = pos.source;
+	if (source[pos.i] !== "(") fail();
+	pos.i += 1;
+	const start = pos.i;
+	let paren = 1;
+	while (pos.i < source.length && paren > 0) {
+		const before = pos.i;
+		if (skipValue(pos)) continue;
+		if (pos.i !== before) continue;
+		const ch = source[pos.i];
+		pos.i += 1;
+		if (ch === "(") paren += 1;
+		else if (ch === ")") paren -= 1;
+	}
+	if (paren !== 0) fail();
+	return source.slice(start, pos.i - 1);
+}
+
+function skipValue(pos) {
+	const ch = peek(pos);
+	if (ch === "'" || ch === '"') {
+		pos.i = skipString(pos.source, pos.i);
+		return true;
+	}
+	if (ch === "`") {
+		pos.i = skipTemplate(pos.source, pos.i);
+		return true;
+	}
+	if (ch === "/" && pos.source[pos.i + 1] === "/") {
+		pos.i = skipLineComment(pos.source, pos.i);
+		return true;
+	}
+	if (ch === "/" && pos.source[pos.i + 1] === "*") {
+		pos.i = skipBlockComment(pos.source, pos.i);
+		return true;
+	}
+	return false;
+}
+
+function skipTrivia(pos) {
+	while (!eof(pos)) {
+		if (/\s/u.test(peek(pos))) {
+			pos.i += 1;
+			continue;
+		}
+		if (peek(pos) === "/" && pos.source[pos.i + 1] === "/") {
+			pos.i = skipLineComment(pos.source, pos.i);
+			continue;
+		}
+		if (peek(pos) === "/" && pos.source[pos.i + 1] === "*") {
+			pos.i = skipBlockComment(pos.source, pos.i);
+			continue;
+		}
+		return;
+	}
+}
+
+function keyword(pos, word) {
+	if (!pos.source.startsWith(word, pos.i)) return false;
+	const next = pos.source[pos.i + word.length];
+	if (next !== undefined && isContinue(next)) return false;
+	pos.i += word.length;
+	return true;
+}
+
+function ident(pos) {
+	if (eof(pos) || !isStart(peek(pos))) return null;
+	const start = pos.i;
+	pos.i += 1;
+	while (!eof(pos) && isContinue(peek(pos))) pos.i += 1;
+	const value = pos.source.slice(start, pos.i);
+	if (!IDENT.test(value) || RESERVED.has(value)) {
+		pos.i = start;
+		return null;
+	}
+	return value;
+}
+
+function peek(pos) {
+	return pos.source[pos.i];
+}
+
+function eof(pos) {
+	return pos.i >= pos.source.length;
+}
+
+function fail(message = "tool() requires a named function") {
+	throw kernelToolError("invalid_tool_definition", message);
+}
+
+function isStart(ch) {
+	return /[\p{ID_Start}$_]/u.test(ch);
+}
+
+function isContinue(ch) {
+	return /[\p{ID_Continue}$\u200c\u200d]/u.test(ch);
+}
+
+function skipLineComment(source, i) {
+	i += 2;
+	while (i < source.length && source[i] !== "\n" && source[i] !== "\r" && source[i] !== "\u2028" && source[i] !== "\u2029") i += 1;
+	return i;
+}
+
+function skipBlockComment(source, i) {
+	const end = source.indexOf("*/", i + 2);
+	if (end < 0) fail();
+	return end + 2;
+}
+
+function skipString(source, i) {
+	const quote = source[i];
+	i += 1;
+	while (i < source.length) {
+		if (source[i] === "\\") {
+			i += 2;
+			continue;
+		}
+		if (source[i] === quote) return i + 1;
+		i += 1;
+	}
+	fail();
+}
+
+function skipTemplate(source, i) {
+	i += 1;
+	while (i < source.length) {
+		if (source[i] === "\\") {
+			i += 2;
+			continue;
+		}
+		if (source[i] === "`") return i + 1;
+		if (source[i] === "$" && source[i + 1] === "{") {
+			i = skipTemplateExpr(source, i + 2);
+			continue;
+		}
+		i += 1;
+	}
+	fail();
+}
+
+function skipTemplateExpr(source, i) {
+	let curly = 1;
+	while (i < source.length && curly > 0) {
+		if (source[i] === "'" || source[i] === '"') {
+			i = skipString(source, i);
+			continue;
+		}
+		if (source[i] === "`") {
+			i = skipTemplate(source, i);
+			continue;
+		}
+		if (source[i] === "/" && source[i + 1] === "/") {
+			i = skipLineComment(source, i);
+			continue;
+		}
+		if (source[i] === "/" && source[i + 1] === "*") {
+			i = skipBlockComment(source, i);
+			continue;
+		}
+		if (source[i] === "{") curly += 1;
+		else if (source[i] === "}") {
+			curly -= 1;
+			if (curly === 0) return i + 1;
+		}
+		i += 1;
+	}
+	fail();
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/kernel-tools-pump.js

@@ -0,0 +1,105 @@
+import { kernelToolCallContext } from "./kernel-tools-context.js";
+import { kernelToolError } from "./kernel-tools-errors.js";
+
+export function createKernelToolPump({ getRuntime, emit, nestedInvokes }) {
+	async function describe(message) {
+		try {
+			const runtime = getRuntime();
+			if (!runtime?.kernelTools) throw kernelToolError("tools_unavailable", "JS runtime not initialized");
+			const results = runtime.kernelTools.describe(message.names).results;
+			emit({ type: "kernel-tool-describe-reply", requestId: message.requestId, ok: true, results });
+		} catch (error) {
+			emit({ type: "kernel-tool-describe-reply", requestId: message.requestId, ok: false, error: pumpError(error) });
+		}
+	}
+
+	async function invoke(message) {
+		const pendingTools = new Map();
+		const controller = new AbortController();
+		nestedInvokes.set(message.requestId, { pendingTools, controller });
+		try {
+			const runtime = getRuntime();
+			if (!runtime?.kernelTools) throw kernelToolError("tools_unavailable", "JS runtime not initialized");
+			const value = await kernelToolCallContext.run(
+				{ pendingTools, callId: message.call_id, generation: message.kernel_generation, signal: controller.signal },
+				() =>
+					runtime.kernelTools.invoke(
+						{
+							name: message.name,
+							kernel_generation: message.kernel_generation,
+							definition_revision: message.definition_revision,
+							args: message.args,
+							call_id: message.call_id,
+						},
+						controller.signal,
+					),
+			);
+			emit({ type: "kernel-tool-invoke-reply", requestId: message.requestId, ok: true, value });
+		} catch (error) {
+			emit({ type: "kernel-tool-invoke-reply", requestId: message.requestId, ok: false, error: pumpError(error) });
+		} finally {
+			nestedInvokes.delete(message.requestId);
+		}
+	}
+
+	return {
+		handle(message) {
+			if (message.type === "kernel-tool-describe") {
+				void describe(message);
+				return true;
+			}
+			if (message.type === "kernel-tool-invoke") {
+				void invoke(message);
+				return true;
+			}
+			if (message.type === "kernel-tool-cancel") {
+				const nested = nestedInvokes.get(message.requestId);
+				if (nested) abortNested(nested, kernelToolError("kernel_tool_stale", "Kernel tool call cancelled"));
+				return true;
+			}
+			return false;
+		},
+		abortAll(error) {
+			for (const nested of nestedInvokes.values()) abortNested(nested, error);
+		},
+		settleToolReply(message) {
+			for (const nested of nestedInvokes.values()) {
+				const pending = nested.pendingTools.get(message.callId);
+				if (!pending) continue;
+				nested.pendingTools.delete(message.callId);
+				if (message.ok) pending.resolve(message.value);
+				else pending.reject(errorFrom(message.error));
+				return true;
+			}
+			return false;
+		},
+	};
+}
+
+function abortNested(nested, error) {
+	nested.controller.abort(error);
+	for (const [callId, pending] of nested.pendingTools) {
+		nested.pendingTools.delete(callId);
+		pending.reject(error);
+	}
+}
+
+function pumpError(error) {
+	if (error instanceof Error) {
+		return {
+			name: error.name,
+			message: error.message,
+			stack: error.stack,
+			...(typeof error.code === "string" ? { code: error.code } : {}),
+		};
+	}
+	return { message: String(error) };
+}
+
+function errorFrom(error) {
+	const result = new Error(error.message);
+	if (error.name) result.name = error.name;
+	if (error.stack) result.stack = error.stack;
+	if (typeof error.code === "string") result.code = error.code;
+	return result;
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/kernel-tools-registry.d.ts

@@ -0,0 +1,27 @@
+export { createToolNamespace } from "./kernel-tools-define.js";
+
+export type KernelToolRegistryOptions = {
+	readonly generation?: number;
+	readonly language?: "js" | "py" | "rb" | "jl";
+	readonly hostToolNames?: readonly string[] | (() => readonly string[]);
+	readonly foreignLanguageNames?: readonly string[] | (() => readonly string[]);
+	readonly reservedNames?: readonly string[];
+};
+
+export function createKernelToolRegistry(options?: KernelToolRegistryOptions): {
+	readonly generation: number;
+	define(fn: { readonly name: string }, metadata?: unknown): unknown;
+	describe(names: readonly string[]): unknown;
+	invoke(
+		request: {
+			readonly name: string;
+			readonly kernel_generation: number;
+			readonly definition_revision: number;
+			readonly args: unknown;
+			readonly call_id: string;
+		},
+		signal?: AbortSignal,
+	): Promise<unknown>;
+	bumpGeneration(): number;
+	setCollisionNames(hostToolNames?: readonly string[], foreignLanguageNames?: readonly string[]): void;
+};

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/kernel-tools-registry.js

@@ -0,0 +1,127 @@
+import { createToolNamespace } from "./kernel-tools-define.js";
+import { kernelToolError } from "./kernel-tools-errors.js";
+import { kernelToolKey, MCP_TOOL_NAME_MAX_LENGTH, sanitizeNamePart } from "./kernel-tools-naming.js";
+import { parseToolFunction } from "./kernel-tools-parse.js";
+import { orderedArgs, resolveToolMetadata, validateInvokeArgs } from "./kernel-tools-schema.js";
+
+export { createToolNamespace };
+
+const DEFAULT_RESERVED = Object.freeze(["__agent__", "__output__", "__schema__"]);
+
+function currentNames(source) {
+	return typeof source === "function" ? source() : (source ?? []);
+}
+
+function hasNameKey(source, key) {
+	return currentNames(source).some((name) => kernelToolKey(name) === key);
+}
+
+export function createKernelToolRegistry(options = {}) {
+	const language = options.language ?? "js";
+	let generation = options.generation ?? 1;
+	const reservedKeys = new Set((options.reservedNames ?? DEFAULT_RESERVED).map(kernelToolKey));
+	let hostSource = options.hostToolNames ?? [];
+	let foreignSource = options.foreignLanguageNames ?? [];
+	const entries = new Map();
+
+	function assertJs() {
+		if (language !== "js") throw kernelToolError("tools_unavailable", "Kernel tools are JavaScript-only");
+	}
+
+	function descriptorFor(entry) {
+		return {
+			name: entry.normalizedName,
+			description: entry.description,
+			input_schema: entry.input_schema,
+			language: "js",
+			kernel_generation: generation,
+			definition_revision: entry.revision,
+		};
+	}
+
+	return {
+		get generation() {
+			return generation;
+		},
+		define(fn, metadata) {
+			assertJs();
+			const parsed = parseToolFunction(fn);
+			const resolved = resolveToolMetadata(metadata, parsed.params);
+			if (sanitizeNamePart(parsed.name) !== parsed.name || parsed.name.length > MCP_TOOL_NAME_MAX_LENGTH) {
+				throw kernelToolError("invalid_tool_definition", "Kernel tool name must match MCP name grammar");
+			}
+			const normalizedName = parsed.name;
+			const key = kernelToolKey(parsed.name);
+			if (reservedKeys.has(key)) throw kernelToolError("reserved_tool_name", `Kernel tool name is reserved: ${parsed.name}`);
+			if (hasNameKey(hostSource, key) || hasNameKey(foreignSource, key)) {
+				throw kernelToolError("tool_name_collision", `Kernel tool name collides: ${parsed.name}`);
+			}
+			const existing = entries.get(key);
+			if (existing && existing.originalName !== parsed.name) {
+				throw kernelToolError("tool_name_collision", `Kernel tool name collides: ${parsed.name}`);
+			}
+			const entry = {
+				originalName: parsed.name,
+				normalizedName,
+				fn,
+				params: parsed.params,
+				description: resolved.description,
+				input_schema: resolved.input_schema,
+				revision: existing ? existing.revision + 1 : 1,
+			};
+			entries.set(key, entry);
+			return descriptorFor(entry);
+		},
+		describe(names) {
+			assertJs();
+			return {
+				results: names.map((name) => {
+					const entry = entries.get(kernelToolKey(name));
+					if (!entry) {
+						return {
+							name,
+							ok: false,
+							error: { code: "kernel_tool_missing", message: `Kernel tool is not defined: ${name}` },
+						};
+					}
+					return { name, ok: true, descriptor: descriptorFor(entry) };
+				}),
+			};
+		},
+		async invoke(request, signal) {
+			assertJs();
+			if (signal?.aborted) {
+				throw signal.reason ?? kernelToolError("kernel_tool_failed", "Kernel tool call aborted");
+			}
+			if (request.kernel_generation !== generation) {
+				throw kernelToolError("kernel_tool_stale", "Kernel tool descriptor generation is stale");
+			}
+			const entry = entries.get(kernelToolKey(request.name));
+			if (!entry) throw kernelToolError("kernel_tool_missing", `Kernel tool is not defined: ${request.name}`);
+			if (entry.revision !== request.definition_revision) {
+				throw kernelToolError("kernel_tool_stale", "Kernel tool descriptor revision is stale");
+			}
+			validateInvokeArgs(entry.input_schema, request.args);
+			try {
+				const value = await entry.fn(...orderedArgs(entry.params, request.args));
+				const live = entries.get(kernelToolKey(request.name));
+				if (request.kernel_generation !== generation || live !== entry) {
+					throw kernelToolError("kernel_tool_stale", "Kernel tool descriptor is stale");
+				}
+				return value;
+			} catch (error) {
+				if (error instanceof Error && typeof error.code === "string") throw error;
+				throw kernelToolError("kernel_tool_failed", error instanceof Error ? error.message : String(error));
+			}
+		},
+		bumpGeneration() {
+			generation += 1;
+			entries.clear();
+			return generation;
+		},
+		setCollisionNames(hostToolNames, foreignLanguageNames) {
+			hostSource = hostToolNames ?? [];
+			foreignSource = foreignLanguageNames ?? [];
+		},
+	};
+}