@code-yeongyu/senpi 2026.9.15 → 2026.9.16

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/context-manager.ts

@@ -8,8 +8,12 @@ import {
 	type JavaScriptRunInput,
 	type LifecycleState,
 	type ResultMessage,
+	resolveKernelToolNameSource,
 	type ToolCallMessage,
 } from "./kernel-contract.ts";
+import { kernelToolError } from "./kernel-tools-errors.ts";
+import { KernelToolHostPump } from "./kernel-tools-host.ts";
+import type { KernelToolsDescribeResult, KernelToolsInvokeRequest } from "./kernel-tools-types.ts";
 import { type JavaScriptKernelOptions, LocalModuleLoader } from "./local-module-loader.ts";
 import { terminateProcessTrees } from "./process-tree-host.ts";
 import { JavaScriptRunQueue, type PendingJavaScriptRun, stoppedResult } from "./run-queue.ts";
@@ -23,6 +27,10 @@ export { type JavaScriptWorkerEntryUrlOptions, resolveJsWorkerEntryUrl } from ".
 /** How long a lost worker's children get to honour SIGTERM before the host sends SIGKILL. */
 const WORKER_LOSS_CHILD_GRACE_MS = 1_000;
 
+// Pull-API fallback queue bound: a nextToolCall consumer this far behind is already stalled, and the
+// normal push path (onMessage) never reads the queue, so unbounded growth only pins tool args (#1695).
+const MAX_PENDING_TOOL_CALLS = 256;
+
 export class JavaScriptKernel {
 	readonly #options: JavaScriptKernelOptions;
 	readonly #moduleLoader: LocalModuleLoader;
@@ -32,6 +40,10 @@ export class JavaScriptKernel {
 	#recovery: Promise<void> | null = null;
 	#closePromise: Promise<void> | null = null;
 	readonly #runs = new JavaScriptRunQueue();
+	readonly #kernelTools = new KernelToolHostPump(
+		(message) => this.#slot.postMessage(message),
+		() => this.#lifecycle === "open" && this.#slot.present,
+	);
 	#timeout: NodeJS.Timeout | null = null;
 	#toolWaiters: Array<(message: ToolCallMessage) => void> = [];
 	#pendingToolCalls: ToolCallMessage[] = [];
@@ -52,6 +64,18 @@ export class JavaScriptKernel {
 		return this.#slot.mode;
 	}
 
+	get kernelToolEvents(): EventTarget {
+		return this.#kernelTools.events;
+	}
+
+	describeKernelTools(names: readonly string[]): Promise<KernelToolsDescribeResult> {
+		return this.#kernelTools.describe(names);
+	}
+
+	invokeKernelTool(request: KernelToolsInvokeRequest, signal?: AbortSignal): Promise<unknown> {
+		return this.#kernelTools.invoke(request, signal);
+	}
+
 	async run(input: JavaScriptRunInput): Promise<ResultMessage> {
 		assertJavaScriptKernelOpen(this.#lifecycle, "run");
 		const promise = this.#runs.enqueue(input);
@@ -77,6 +101,7 @@ export class JavaScriptKernel {
 	async reset(): Promise<void> {
 		assertJavaScriptKernelOpen(this.#lifecycle, "reset");
 		await this.#terminate();
+		this.#clearToolCalls();
 		assertJavaScriptKernelOpen(this.#lifecycle, "reset");
 		await this.#ensureReady();
 		this.#startNext();
@@ -97,6 +122,8 @@ export class JavaScriptKernel {
 		this.#slot.postMessage({ type: "close" });
 		this.#lifecycle = "closing";
 		this.#runs.settleAll("JS kernel closed");
+		this.#kernelTools.rejectAll(kernelToolError("kernel_tool_stale", "JS kernel closed"));
+		this.#clearToolCalls();
 		const recovery = this.#recovery;
 		const closePromise = (async () => {
 			if (recovery) await recovery;
@@ -140,6 +167,11 @@ export class JavaScriptKernel {
 		if (next.input.timeoutMs) {
 			this.#timeout = setTimeout(() => void this.#timeoutActive(next), next.input.timeoutMs);
 		}
+		this.#slot.postMessage({
+			type: "kernel-tools-names",
+			hostToolNames: resolveKernelToolNameSource(this.#options.hostToolNames),
+			foreignLanguageNames: resolveKernelToolNameSource(this.#options.foreignLanguageNames),
+		});
 		this.#slot.postMessage({
 			type: "run",
 			cellId: next.input.cellId,
@@ -170,15 +202,19 @@ export class JavaScriptKernel {
 		message: string,
 		durationMs = 0,
 	): Promise<{ readonly retained: boolean; readonly note?: string }> {
-		run.interruptResult = { type: "result", cellId: run.input.cellId, ok: false, error: { message }, durationMs };
-		run.interruptAck ??= Promise.withResolvers<void>();
-		this.#slot.postMessage({ type: "interrupt", reason });
-		if ((await awaitCooperativeSettlement(run)) === "settled") return { retained: run.settledByWorker };
-		if (!this.#runs.releaseActive(run)) return { retained: run.settledByWorker };
-		const retirement = await this.#terminate();
-		this.#runs.settle(run, run.interruptResult ?? stoppedResult(run.input.cellId, message));
-		void this.#recover(() => Promise.resolve());
-		return retirement === "abandoned" ? { retained: false, note: abandonedWorkerNote() } : { retained: false };
+		try {
+			run.interruptResult = { type: "result", cellId: run.input.cellId, ok: false, error: { message }, durationMs };
+			run.interruptAck ??= Promise.withResolvers<void>();
+			this.#slot.postMessage({ type: "interrupt", reason });
+			if ((await awaitCooperativeSettlement(run)) === "settled") return { retained: run.settledByWorker };
+			if (!this.#runs.releaseActive(run)) return { retained: run.settledByWorker };
+			const retirement = await this.#terminate();
+			this.#runs.settle(run, run.interruptResult ?? stoppedResult(run.input.cellId, message));
+			void this.#recover(() => Promise.resolve());
+			return retirement === "abandoned" ? { retained: false, note: abandonedWorkerNote() } : { retained: false };
+		} finally {
+			this.#clearToolCalls();
+		}
 	}
 
 	async #restartAfterStop(): Promise<void> {
@@ -210,6 +246,7 @@ export class JavaScriptKernel {
 	}
 
 	#handleMessage(message: KernelToHostMessage): void {
+		if (this.#kernelTools.consume(message) && message.type !== "tool-call") return;
 		if (message.type === "status" && message.event.op === INTERRUPT_ACK_OP) {
 			this.#runs.active?.interruptAck?.resolve();
 			return;
@@ -223,7 +260,10 @@ export class JavaScriptKernel {
 		if (message.type === "tool-call") {
 			const waiter = this.#toolWaiters.shift();
 			if (waiter) waiter(message);
-			else this.#pendingToolCalls.push(message);
+			else {
+				this.#pendingToolCalls.push(message);
+				if (this.#pendingToolCalls.length > MAX_PENDING_TOOL_CALLS) this.#pendingToolCalls.shift();
+			}
 			return;
 		}
 		if (message.type !== "result") return;
@@ -240,6 +280,7 @@ export class JavaScriptKernel {
 		const active = this.#runs.active;
 		if (!active && this.#slot.startingUp) return;
 		this.#clearTimeout();
+		this.#kernelTools.rejectAll(kernelToolError("kernel_tool_stale", error.message));
 		if (active) {
 			this.#runs.releaseActive(active);
 			this.#runs.settle(active, {
@@ -250,9 +291,15 @@ export class JavaScriptKernel {
 				durationMs: this.#runs.durationMs(active, performance.now()),
 			});
 		}
+		this.#clearToolCalls();
 		void this.#restartAfterStop();
 	}
 
+	#clearToolCalls(): void {
+		this.#pendingToolCalls.length = 0;
+		this.#toolWaiters.length = 0;
+	}
+
 	#clearTimeout(): void {
 		if (this.#timeout) clearTimeout(this.#timeout);
 		this.#timeout = null;
@@ -271,6 +318,7 @@ export class JavaScriptKernel {
 	 */
 	async #terminate(): Promise<WorkerRetirement> {
 		this.#clearTimeout();
+		this.#kernelTools.rejectAll(kernelToolError("kernel_tool_stale", "JavaScript worker reset"));
 		const retirement = await this.#slot.retire();
 		await this.#retireWorkerChildren();
 		return retirement;

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