@code-yeongyu/senpi 2026.9.15 → 2026.9.16-2

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

@@ -6,6 +6,14 @@ export type ToolCallMessage = Extract<KernelToHostMessage, { type: "tool-call" }
 
 export type JavaScriptKernelMode = "worker" | "inline";
 
+/** Snapshot or live provider consulted when the worker registry checks collisions. */
+export type KernelToolNameSource = readonly string[] | (() => readonly string[]);
+
+export function resolveKernelToolNameSource(names?: KernelToolNameSource): string[] {
+	if (typeof names === "function") return [...names()];
+	return names === undefined ? [] : [...names];
+}
+
 export interface JavaScriptKernelOptions {
 	readonly sessionId: string;
 	readonly cwd: string;
@@ -14,6 +22,10 @@ export interface JavaScriptKernelOptions {
 	readonly workerEntryUrl?: URL;
 	/** Per-session PI_* values applied to the worker environment before the first cell runs. */
 	readonly sessionEnv?: SessionEnvironment;
+	/** Host tool names denied as JS kernel-tool identifiers (init protocol). */
+	readonly hostToolNames?: KernelToolNameSource;
+	/** Tool names registered in another kernel language, denied as JS kernel-tool identifiers. */
+	readonly foreignLanguageNames?: KernelToolNameSource;
 }
 
 export interface JavaScriptRunInput {

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

@@ -0,0 +1,13 @@
+export const kernelToolCallContext: {
+	run<T>(store: KernelToolCallStore, fn: () => T): T;
+	getStore(): KernelToolCallStore | undefined;
+};
+
+export type KernelToolCallStore = {
+	readonly pendingTools: Map<string, { resolve: (value: unknown) => void; reject: (error: Error) => void }>;
+	readonly callId: string;
+	readonly generation: number;
+	readonly signal: AbortSignal;
+};
+
+export function inKernelToolInvoke(): boolean;

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

@@ -0,0 +1,7 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+export const kernelToolCallContext = new AsyncLocalStorage();
+
+export function inKernelToolInvoke() {
+	return kernelToolCallContext.getStore() != null;
+}

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

@@ -0,0 +1,10 @@
+export type KernelToolFunction = {
+	readonly name: string;
+};
+
+export function createToolNamespace(
+	define: (fn: KernelToolFunction, metadata?: unknown) => unknown,
+	callHost: (name: string, args: unknown) => Promise<unknown>,
+): ((fn: KernelToolFunction, metadata?: unknown) => unknown) & {
+	readonly [name: string]: (args?: unknown) => Promise<unknown>;
+};

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

@@ -0,0 +1,12 @@
+export function createToolNamespace(define, callHost) {
+	const registrar = function tool(fn, metadata) {
+		return define(fn, metadata);
+	};
+	return new Proxy(registrar, {
+		get(target, prop) {
+			if (typeof prop !== "string") return undefined;
+			if (prop in Function.prototype || prop === "arguments" || prop === "caller") return target[prop];
+			return async (args) => await callHost(prop, args ?? {});
+		},
+	});
+}

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

@@ -0,0 +1,22 @@
+export const KERNEL_TOOL_ERROR_CODES = Object.freeze([
+	"tools_unavailable",
+	"invalid_tool_definition",
+	"reserved_tool_name",
+	"tool_name_collision",
+	"kernel_tool_stale",
+	"kernel_tool_missing",
+	"kernel_tool_failed",
+	"kernel_tool_recursion",
+]);
+
+export class KernelToolError extends Error {
+	constructor(code, message) {
+		super(message);
+		this.name = "KernelToolError";
+		this.code = code;
+	}
+}
+
+export function kernelToolError(code, message) {
+	return new KernelToolError(code, message);
+}

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

@@ -0,0 +1,26 @@
+export const KERNEL_TOOL_ERROR_CODES = [
+	"tools_unavailable",
+	"invalid_tool_definition",
+	"reserved_tool_name",
+	"tool_name_collision",
+	"kernel_tool_stale",
+	"kernel_tool_missing",
+	"kernel_tool_failed",
+	"kernel_tool_recursion",
+] as const;
+
+export type KernelToolErrorCode = (typeof KERNEL_TOOL_ERROR_CODES)[number];
+
+export class KernelToolError extends Error {
+	readonly name = "KernelToolError";
+	readonly code: KernelToolErrorCode;
+
+	constructor(code: KernelToolErrorCode, message: string) {
+		super(message);
+		this.code = code;
+	}
+}
+
+export function kernelToolError(code: KernelToolErrorCode, message: string): KernelToolError {
+	return new KernelToolError(code, message);
+}

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;
+};