@code-yeongyu/senpi 2026.9.15 → 2026.9.16

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 ?? [];
+		},
+	};
+}

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

@@ -0,0 +1,69 @@
+import { kernelToolError } from "./kernel-tools-errors.js";
+
+export function defaultInputSchema(params) {
+	return {
+		type: "object",
+		properties: Object.fromEntries(params.map((name) => [name, {}])),
+		required: [...params],
+		additionalProperties: false,
+	};
+}
+
+export function resolveToolMetadata(metadata, params) {
+	if (metadata === undefined) return { description: "", input_schema: defaultInputSchema(params) };
+	if (!isPlainJsonObject(metadata)) {
+		throw kernelToolError("invalid_tool_definition", "tool() metadata must be plain JSON");
+	}
+	const description = metadata.description === undefined ? "" : metadata.description;
+	if (typeof description !== "string") {
+		throw kernelToolError("invalid_tool_definition", "tool() description must be a string");
+	}
+	if (metadata.schema === undefined) return { description, input_schema: defaultInputSchema(params) };
+	const schema = metadata.schema;
+	if (!isPlainJsonObject(schema) || schema.type !== "object" || !isPlainJsonObject(schema.properties)) {
+		throw kernelToolError("invalid_tool_definition", "tool() metadata schema must be a JSON object schema");
+	}
+	const propertyKeys = Object.keys(schema.properties);
+	if (propertyKeys.length !== params.length || params.some((name) => !Object.hasOwn(schema.properties, name))) {
+		throw kernelToolError("invalid_tool_definition", "tool() metadata schema properties must match parameters");
+	}
+	return { description, input_schema: schema };
+}
+
+export function validateInvokeArgs(schema, args) {
+	if (!isPlainJsonObject(args)) throw kernelToolError("invalid_tool_definition", "kernel tool args must be a JSON object");
+	const required = Array.isArray(schema.required) ? schema.required : [];
+	for (const key of required) {
+		if (!Object.hasOwn(args, key)) {
+			throw kernelToolError("invalid_tool_definition", `missing kernel tool argument: ${key}`);
+		}
+	}
+	if (schema.additionalProperties === false) {
+		const allowed = new Set(Object.keys(schema.properties ?? {}));
+		for (const key of Object.keys(args)) {
+			if (!allowed.has(key)) {
+				throw kernelToolError("invalid_tool_definition", `unexpected kernel tool argument: ${key}`);
+			}
+		}
+	}
+}
+
+export function isPlainJsonObject(value) {
+	return isJsonValue(value) && value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function isJsonValue(value) {
+	if (value === null) return true;
+	const type = typeof value;
+	if (type === "string" || type === "boolean") return true;
+	if (type === "number") return Number.isFinite(value);
+	if (type !== "object") return false;
+	if (Array.isArray(value)) return value.every(isJsonValue);
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return false;
+	return Object.values(value).every(isJsonValue);
+}
+
+export function orderedArgs(params, args) {
+	return params.map((name) => args[name]);
+}

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

@@ -0,0 +1,42 @@
+import type { KernelToolErrorCode } from "./kernel-tools-errors.ts";
+
+export type { KernelToolErrorCode };
+
+export type KernelToolDescriptor = {
+	readonly name: string;
+	readonly description: string;
+	readonly input_schema: unknown;
+	readonly language: "js";
+	readonly kernel_generation: number;
+	readonly definition_revision: number;
+};
+
+export type KernelToolsInvokeRequest = {
+	readonly name: string;
+	readonly kernel_generation: number;
+	readonly definition_revision: number;
+	readonly args: unknown;
+	readonly call_id: string;
+};
+
+export type KernelToolsDescribeEntry =
+	| { readonly name: string; readonly ok: true; readonly descriptor: KernelToolDescriptor }
+	| {
+			readonly name: string;
+			readonly ok: false;
+			readonly error: { readonly code: KernelToolErrorCode; readonly message: string };
+	  };
+
+export type KernelToolsDescribeResult = {
+	readonly results: readonly KernelToolsDescribeEntry[];
+};
+
+export type KernelToolsCapability = {
+	describe(names: readonly string[]): Promise<KernelToolsDescribeResult>;
+	invoke(request: KernelToolsInvokeRequest, signal?: AbortSignal): Promise<unknown>;
+};
+
+export const KERNEL_TOOLS_UNSUPPORTED = {
+	code: "tools_unavailable" as const,
+	message: "Kernel tools require a live JavaScript worker context",
+};

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

@@ -7,9 +7,11 @@ export const JAVASCRIPT_KERNEL_PRELUDE = [
 	"read(path, options?): read UTF-8 text; plain paths use cwd and local:// uses the session local root.",
 	"write(path, content): write UTF-8 or binary data and return the resolved path.",
 	"tool.<name>(args): request a host tool call through the bridge; resolves to { text, images?, details?, hasError? }.",
+	"tool(fn, metadata?): register a named JavaScript function as a fenced kernel tool for in-process children.",
 	"completion(prompt, options?): request a host completion bridge call.",
 	"output(...ids, options?): retrieve task output through the reserved output bridge.",
 	"agent(prompt, options?): delegate work through the reserved agent bridge.",
+	"workpool(agent, name, options?): await a host-owned pool adapter with pool_id, push, close, inspect, and cancel; options only accept mode.",
 	"parallel(thunks): run async thunks through the configured bounded pool; preserves order and rethrows the lowest-index error after all settle.",
 	"pipeline(items, ...stages): map items through staged async transforms with a barrier between stages.",
 ].join("\n");