@code-yeongyu/senpi 2026.7.22-2 → 2026.7.23

package/node_modules/@code-yeongyu/senpi-codemode/src/codemode/tools.ts

@@ -0,0 +1,106 @@
+import type { AgentToolResult, ToolDefinition } from "@code-yeongyu/senpi";
+import { type Static, Type } from "typebox";
+import type { CodeModeCellState, CodeModeObservation, CodeModeSessionRuntime } from "./runtime.ts";
+
+const DEFAULT_YIELD_TIME_MS = 10_000;
+
+const execInputSchema = Type.Object({
+	code: Type.String({ minLength: 1, description: "JavaScript program to execute in a dedicated Code Mode cell." }),
+	yield_time_ms: Type.Optional(
+		Type.Integer({ minimum: 1, maximum: 60_000, description: "Return a yielded cell after this many milliseconds." }),
+	),
+});
+
+const waitInputSchema = Type.Object({
+	cell_id: Type.String({ minLength: 1, description: "Code Mode cell id returned by exec." }),
+	yield_time_ms: Type.Optional(
+		Type.Integer({ minimum: 1, maximum: 60_000, description: "Return again after this many milliseconds." }),
+	),
+	terminate: Type.Optional(Type.Boolean({ description: "Interrupt and close the cell instead of waiting." })),
+});
+
+type ExecInput = Static<typeof execInputSchema>;
+type WaitInput = Static<typeof waitInputSchema>;
+
+export interface CodeModeToolDetails {
+	readonly cellId: string;
+	readonly state: CodeModeCellState;
+	readonly isError?: boolean;
+}
+
+export type CodeModeTool =
+	| ToolDefinition<typeof execInputSchema, CodeModeToolDetails>
+	| ToolDefinition<typeof waitInputSchema, CodeModeToolDetails>;
+
+export interface CreateCodeModeToolsOptions {
+	readonly runtime: CodeModeSessionRuntime;
+}
+
+export function createCodeModeTools(options: CreateCodeModeToolsOptions): {
+	readonly exec: ToolDefinition<typeof execInputSchema, CodeModeToolDetails>;
+	readonly wait: ToolDefinition<typeof waitInputSchema, CodeModeToolDetails>;
+} {
+	return {
+		exec: {
+			name: "exec",
+			label: "GPT Code Mode Exec",
+			description:
+				"Run JavaScript in a dedicated GPT Code Mode cell. Call active Senpi tools as `tools.<name>(args)`. " +
+				"If the cell yields, call wait with its cell_id.",
+			promptSnippet: "Execute JavaScript that composes active tools in a dedicated Code Mode cell.",
+			promptGuidelines: [
+				"Use exec for bounded JavaScript composition of active tools; use eval for persistent multi-language analysis.",
+				"Call wait only when exec reports a yielded cell, and terminate abandoned cells with wait({ cell_id, terminate: true }).",
+			],
+			parameters: execInputSchema,
+			executionMode: "sequential",
+			async execute(_toolCallId, params: ExecInput, signal) {
+				return resultFrom(
+					await options.runtime.execute(params.code, params.yield_time_ms ?? DEFAULT_YIELD_TIME_MS, signal),
+				);
+			},
+		},
+		wait: {
+			name: "wait",
+			label: "GPT Code Mode Wait",
+			description: "Observe a yielded GPT Code Mode cell or terminate it.",
+			promptSnippet: "Wait for, or terminate, a yielded GPT Code Mode cell.",
+			parameters: waitInputSchema,
+			executionMode: "sequential",
+			async execute(_toolCallId, params: WaitInput, signal) {
+				return resultFrom(
+					await options.runtime.wait(
+						params.cell_id,
+						params.yield_time_ms ?? DEFAULT_YIELD_TIME_MS,
+						params.terminate ?? false,
+						signal,
+					),
+				);
+			},
+		},
+	};
+}
+
+function resultFrom(observation: CodeModeObservation): AgentToolResult<CodeModeToolDetails> {
+	const text =
+		observation.output ||
+		(observation.state === "yielded"
+			? `Code Mode cell ${observation.cellId} is still running. Call wait with this cell_id.`
+			: observation.state === "missing"
+				? `Code Mode cell ${observation.cellId} does not exist.`
+				: observation.state === "terminated"
+					? `Code Mode cell ${observation.cellId} was terminated.`
+					: (observation.error ?? `Code Mode cell ${observation.cellId} completed.`));
+	return {
+		content: [{ type: "text", text }],
+		details: {
+			cellId: observation.cellId,
+			state: observation.state,
+			...(observation.state === "error" || observation.state === "missing" ? { isError: true } : {}),
+		},
+	};
+}
+
+export function isGptCodeModeModel(modelId: string | undefined): boolean {
+	return modelId !== undefined && /(^|[/.:])gpt[-.]/iu.test(modelId);
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/extension/runtime-factory.ts

@@ -0,0 +1,114 @@
+import type { ExtensionContext } from "@code-yeongyu/senpi";
+import type { AgentExecuteTool } from "../bridges/agent-bridge.ts";
+import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
+import {
+	type CodemodeSettings,
+	loadCodemodeSettings,
+	type ResolvedCodemodeSettings,
+	resolveEnabledLanguages,
+} from "../config/settings.ts";
+import {
+	createInterpreterDetector,
+	getInterpreterAvailability,
+	type InterpreterAvailability,
+} from "../interpreters/detect.ts";
+import { resolveSessionArtifactsDir } from "../output/streaming-output.ts";
+import type { EnabledEvalLanguages, EvalLanguage } from "../tool/types.ts";
+import {
+	type CodemodeSessionManager,
+	type CreateCodemodeSessionManagerOptions,
+	createCodemodeSessionManager,
+} from "./session-manager.ts";
+
+export interface CodemodeRuntimeAPI {
+	readonly executeTool: AgentExecuteTool;
+	getActiveTools(): string[];
+}
+
+export interface RuntimeFactoryOptions {
+	readonly createSessionManager?: (
+		options: CreateCodemodeSessionManagerOptions,
+	) => CodemodeSessionManager | Promise<CodemodeSessionManager>;
+}
+
+export type SessionRuntime = {
+	readonly sessionId: string;
+	readonly cwd: string;
+	readonly parallelPoolWidth: number;
+	readonly manager: CodemodeSessionManager;
+	readonly enabledLanguages: EnabledEvalLanguages;
+	readonly settings: ResolvedCodemodeSettings;
+	readonly artifactsDir: string;
+	readonly executeTool: AgentExecuteTool;
+	readonly spawns: boolean;
+};
+
+export async function createRuntime(
+	pi: CodemodeRuntimeAPI,
+	ctx: ExtensionContext,
+	event: unknown,
+	complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>,
+	options: RuntimeFactoryOptions,
+): Promise<SessionRuntime> {
+	const loaded = await loadCodemodeSettings({ cwd: ctx.cwd });
+	const settings: ResolvedCodemodeSettings = {
+		...loaded.settings,
+		languages: resolveEnabledLanguages(loaded.settings),
+	};
+	const availability = await getInterpreterAvailability(settings, createInterpreterDetector());
+	const enabledLanguages = enabledLanguagesFrom(settings, availability);
+	const artifacts = resolveSessionArtifactsDir(ctx.sessionManager.getSessionFile());
+	const activeTools = new Set(pi.getActiveTools());
+	const executeTool = createExecuteTool(pi, activeTools);
+	const create = options.createSessionManager ?? createCodemodeSessionManager;
+	const sessionId = sessionIdFrom(event);
+	const configuredPoolWidth = settings.parallelPoolWidth;
+	const parallelPoolWidth = Number.isFinite(configuredPoolWidth) ? Math.max(1, Math.trunc(configuredPoolWidth)) : 1;
+	const manager = await create({
+		sessionId,
+		cwd: ctx.cwd,
+		settings,
+		availability,
+		artifactsDir: artifacts.dir,
+		executeTool,
+		complete,
+	});
+	return {
+		sessionId,
+		cwd: ctx.cwd,
+		parallelPoolWidth,
+		manager,
+		enabledLanguages,
+		settings,
+		artifactsDir: artifacts.dir,
+		executeTool,
+		spawns: activeTools.has(settings.taskTools.task),
+	};
+}
+
+export function createExecuteTool(pi: CodemodeRuntimeAPI, activeTools?: ReadonlySet<string>): AgentExecuteTool {
+	const executeTool: AgentExecuteTool = (toolName, params, executeOptions) =>
+		pi.executeTool(toolName, params, executeOptions);
+	return Object.assign(executeTool, {
+		isToolAvailable: (name: string): boolean => activeTools?.has(name) ?? pi.getActiveTools().includes(name),
+	});
+}
+
+function sessionIdFrom(event: unknown): string {
+	if (typeof event === "object" && event !== null && "sessionId" in event && typeof event.sessionId === "string") {
+		return event.sessionId;
+	}
+	return crypto.randomUUID();
+}
+
+export function enabledLanguagesFrom(
+	settings: CodemodeSettings,
+	availability: InterpreterAvailability,
+): Record<EvalLanguage, boolean> {
+	return {
+		py: settings.languages.py && availability.py.detected.ok,
+		js: settings.languages.js && availability.js.detected.ok,
+		rb: settings.languages.rb && availability.rb.detected.ok,
+		jl: settings.languages.jl && availability.jl.detected.ok,
+	};
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/extension/session-manager-proxy.ts

@@ -0,0 +1,116 @@
+import type { ExtensionContext } from "@code-yeongyu/senpi";
+import type { KernelToHostMessage } from "../bridge/protocol.ts";
+import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
+import type { EvalKernel, EvalLanguage } from "../tool/types.ts";
+import {
+	CodemodeSessionDisposedError,
+	type CodemodeSessionManager,
+	type EvalExecutionTracker,
+} from "./session-manager.ts";
+
+type TrackedExecution = {
+	readonly promise: Promise<unknown>;
+	readonly controller: AbortController;
+};
+
+export class CodemodeSessionNotStartedError extends Error {
+	readonly name = "CodemodeSessionNotStartedError";
+
+	constructor() {
+		super("codemode session has not started");
+	}
+}
+
+export class SessionManagerProxy implements CodemodeSessionManager, EvalExecutionTracker {
+	#current: CodemodeSessionManager | undefined;
+	#generation = 0;
+	#started = false;
+	#acceptingExecutions = false;
+	readonly #executions = new Set<TrackedExecution>();
+
+	beginReplacement(): number {
+		this.#generation++;
+		this.#acceptingExecutions = false;
+		this.#abortExecutions();
+		return this.#generation;
+	}
+
+	async replace(generation: number, next: CodemodeSessionManager): Promise<boolean> {
+		if (generation !== this.#generation) {
+			await next.dispose();
+			return false;
+		}
+		await this.#settleExecutions();
+		if (generation !== this.#generation) {
+			await next.dispose();
+			return false;
+		}
+		const current = this.#current;
+		this.#current = undefined;
+		await current?.dispose();
+		if (generation !== this.#generation) {
+			await next.dispose();
+			return false;
+		}
+		this.#current = next;
+		this.#started = true;
+		this.#acceptingExecutions = true;
+		return true;
+	}
+
+	assertEvalExecutionAllowed(): void {
+		if (this.#acceptingExecutions && this.#current !== undefined) return;
+		if (this.#started) throw new CodemodeSessionDisposedError();
+		throw new CodemodeSessionNotStartedError();
+	}
+
+	async trackEvalExecution<Result>(execution: Promise<Result>, controller: AbortController): Promise<Result> {
+		this.assertEvalExecutionAllowed();
+		const tracked: TrackedExecution = { promise: execution, controller };
+		this.#executions.add(tracked);
+		try {
+			return await execution;
+		} finally {
+			this.#executions.delete(tracked);
+		}
+	}
+
+	async getKernel(language: EvalLanguage, onMessage: (message: KernelToHostMessage) => void): Promise<EvalKernel> {
+		this.assertEvalExecutionAllowed();
+		const current = this.#current;
+		if (current === undefined) throw new CodemodeSessionNotStartedError();
+		return await current.getKernel(language, onMessage);
+	}
+
+	async complete(request: CompletionRequest, ctx: ExtensionContext): Promise<CompletionResult> {
+		this.assertEvalExecutionAllowed();
+		const current = this.#current;
+		if (current === undefined) throw new CodemodeSessionNotStartedError();
+		return await current.complete(request, ctx);
+	}
+
+	setContext(ctx: ExtensionContext): void {
+		this.#current?.setContext?.(ctx);
+	}
+
+	async dispose(): Promise<void> {
+		this.#generation++;
+		this.#acceptingExecutions = false;
+		this.#abortExecutions();
+		await this.#settleExecutions();
+		const current = this.#current;
+		this.#current = undefined;
+		await current?.dispose();
+	}
+
+	#abortExecutions(): void {
+		if (this.#executions.size === 0) return;
+		const error = new CodemodeSessionDisposedError();
+		for (const execution of this.#executions) execution.controller.abort(error);
+	}
+
+	async #settleExecutions(): Promise<void> {
+		if (this.#executions.size === 0) return;
+		await Promise.allSettled([...this.#executions].map((execution) => execution.promise));
+	}
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/index.ts

@@ -1,31 +1,20 @@
 import * as os from "node:os";
 import type { ExtensionContext } from "@code-yeongyu/senpi";
-import type { KernelToHostMessage } from "./bridge/protocol.ts";
 import type { AgentExecuteTool } from "./bridges/agent-bridge.ts";
+import { CodeModeSessionRuntime } from "./codemode/runtime.ts";
+import { type CodeModeTool, createCodeModeTools, isGptCodeModeModel } from "./codemode/tools.ts";
 import { type CompletionRequest, type CompletionResult, createCompletionHandler } from "./completion/handler.ts";
+import { defaultCodemodeSettings } from "./config/settings.ts";
 import {
-	type CodemodeSettings,
-	defaultCodemodeSettings,
-	loadCodemodeSettings,
-	type ResolvedCodemodeSettings,
-	resolveEnabledLanguages,
-} from "./config/settings.ts";
-import {
-	CodemodeSessionDisposedError,
-	type CodemodeSessionManager,
-	type CreateCodemodeSessionManagerOptions,
-	createCodemodeSessionManager,
-	type EvalExecutionTracker,
-} from "./extension/session-manager.ts";
-import {
-	createInterpreterDetector,
-	getInterpreterAvailability,
-	type InterpreterAvailability,
-} from "./interpreters/detect.ts";
-import { resolveSessionArtifactsDir } from "./output/streaming-output.ts";
+	createExecuteTool,
+	createRuntime,
+	enabledLanguagesFrom,
+	type SessionRuntime,
+} from "./extension/runtime-factory.ts";
+import type { CodemodeSessionManager, CreateCodemodeSessionManagerOptions } from "./extension/session-manager.ts";
+import { SessionManagerProxy } from "./extension/session-manager-proxy.ts";
 import { createEvalTool } from "./tool/eval-tool.ts";
 import { renderEvalCall, renderEvalResult } from "./tool/render.ts";
-import type { EnabledEvalLanguages, EvalKernel, EvalLanguage } from "./tool/types.ts";
 
 const SESSION_LIFECYCLE_EVENTS = [
 	"session_start",
@@ -38,25 +27,13 @@ type SessionLifecycleEvent = (typeof SESSION_LIFECYCLE_EVENTS)[number];
 
 type CodemodeEvent = SessionLifecycleEvent | "model_select";
 
-type TrackedExecution = {
-	readonly promise: Promise<unknown>;
-	readonly controller: AbortController;
-};
-
-type SessionRuntime = {
-	readonly manager: CodemodeSessionManager;
-	readonly enabledLanguages: EnabledEvalLanguages;
-	readonly settings: ResolvedCodemodeSettings;
-	readonly artifactsDir: string;
-	readonly executeTool: AgentExecuteTool;
-	readonly spawns: boolean;
-};
-
 export interface CodemodeExtensionAPI {
 	registerTool(tool: ReturnType<typeof createEvalTool>): void;
 	on(event: CodemodeEvent, handler: (event: unknown, ctx: ExtensionContext) => Promise<void> | void): void;
 	executeTool: AgentExecuteTool;
 	getActiveTools(): string[];
+	setActiveTools?(toolNames: string[]): void | Promise<void>;
+	getAllTools?(): readonly { readonly name: string }[];
 }
 
 export interface SenpiCodemodeOptions {
@@ -66,19 +43,17 @@ export interface SenpiCodemodeOptions {
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
 }
 
-class CodemodeSessionNotStartedError extends Error {
-	readonly name = "CodemodeSessionNotStartedError";
-
-	constructor() {
-		super("codemode session has not started");
-	}
-}
+type DynamicCodeModeExtensionAPI = CodemodeExtensionAPI & {
+	registerTool(tool: CodeModeTool): void;
+	setActiveTools(toolNames: string[]): void | Promise<void>;
+	getAllTools(): readonly { readonly name: string }[];
+};
 
 export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCodemodeOptions = {}): void {
 	const manager = new SessionManagerProxy();
 	const complete = options.complete ?? ((request, ctx) => createCompletionHandler()(ctx)(request));
 	const renderers = { renderCall: renderEvalCall, renderResult: renderEvalResult };
-	let activeRuntime: SessionRuntime | undefined;
+	let activeRuntime: (SessionRuntime & { readonly codeMode?: CodeModeSessionRuntime }) | undefined;
 	let activeModelId: string | undefined;
 	const registerEvalForRuntime = (runtime: SessionRuntime, modelId: string | undefined): void => {
 		pi.registerTool(
@@ -100,9 +75,21 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		);
 	};
 	const dropRuntime = async (): Promise<void> => {
+		const codeMode = activeRuntime?.codeMode;
 		activeRuntime = undefined;
 		activeModelId = undefined;
-		await manager.dispose();
+		await Promise.all([manager.dispose(), codeMode?.dispose()]);
+	};
+	const activateCodeModeTools = async (runtime: CodeModeSessionRuntime): Promise<void> => {
+		if (!isDynamicCodeModeExtensionAPI(pi)) return;
+		const tools = createCodeModeTools({ runtime });
+		pi.registerTool(tools.exec);
+		pi.registerTool(tools.wait);
+		await pi.setActiveTools([...new Set([...pi.getActiveTools(), "exec", "wait"])]);
+	};
+	const deactivateCodeModeTools = async (): Promise<void> => {
+		if (!isDynamicCodeModeExtensionAPI(pi)) return;
+		await pi.setActiveTools(pi.getActiveTools().filter((name) => name !== "exec" && name !== "wait"));
 	};
 	pi.registerTool(
 		createEvalTool({
@@ -119,12 +106,25 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 	);
 
 	pi.on("session_start", async (event, ctx) => {
+		const previousCodeMode = activeRuntime?.codeMode;
 		const generation = manager.beginReplacement();
 		const runtime = await createRuntime(pi, ctx, event, complete, options);
-		if (!(await manager.replace(generation, runtime.manager))) return;
-		activeRuntime = runtime;
+		const replaced = await manager.replace(generation, runtime.manager);
+		if (!replaced) return;
+		await previousCodeMode?.dispose();
+		const codeMode = isGptCodeModeModel(ctx.model?.id)
+			? new CodeModeSessionRuntime({
+					sessionId: runtime.sessionId,
+					cwd: runtime.cwd,
+					parallelPoolWidth: runtime.parallelPoolWidth,
+					executeTool: runtime.executeTool,
+				})
+			: undefined;
+		activeRuntime = { ...runtime, ...(codeMode === undefined ? {} : { codeMode }) };
 		activeModelId = ctx.model?.id;
-		registerEvalForRuntime(runtime, activeModelId);
+		registerEvalForRuntime(activeRuntime, activeModelId);
+		if (codeMode) await activateCodeModeTools(codeMode);
+		else await deactivateCodeModeTools();
 	});
 	pi.on("session_shutdown", async () => dropRuntime());
 	pi.on("session_before_switch", async () => dropRuntime());
@@ -136,9 +136,34 @@ export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCo
 		if (modelId === undefined || modelId === activeModelId) return;
 		activeModelId = modelId;
 		registerEvalForRuntime(runtime, modelId);
+		if (!isGptCodeModeModel(modelId)) {
+			const { codeMode, ...nextRuntime } = runtime;
+			await codeMode?.dispose();
+			activeRuntime = nextRuntime;
+			await deactivateCodeModeTools();
+			return;
+		}
+		if (runtime.codeMode) {
+			if (isDynamicCodeModeExtensionAPI(pi)) {
+				await pi.setActiveTools([...new Set([...pi.getActiveTools(), "exec", "wait"])]);
+			}
+			return;
+		}
+		const codeMode = new CodeModeSessionRuntime({
+			sessionId: runtime.sessionId,
+			cwd: runtime.cwd,
+			parallelPoolWidth: runtime.parallelPoolWidth,
+			executeTool: runtime.executeTool,
+		});
+		activeRuntime = { ...runtime, codeMode };
+		await activateCodeModeTools(codeMode);
 	});
 }
 
+function isDynamicCodeModeExtensionAPI(pi: CodemodeExtensionAPI): pi is DynamicCodeModeExtensionAPI {
+	return typeof pi.setActiveTools === "function" && typeof pi.getAllTools === "function";
+}
+
 function hostLine(): string {
 	const cpu = os.cpus()[0]?.model?.trim();
 	return [`${os.platform()} ${os.arch()}`, cpu, `${os.availableParallelism()} cores`]
@@ -153,160 +178,4 @@ function modelIdFrom(event: unknown): string | undefined {
 	return typeof model.id === "string" ? model.id : undefined;
 }
 
-class SessionManagerProxy implements CodemodeSessionManager, EvalExecutionTracker {
-	#current: CodemodeSessionManager | undefined;
-	#generation = 0;
-	#started = false;
-	#acceptingExecutions = false;
-	readonly #executions = new Set<TrackedExecution>();
-
-	beginReplacement(): number {
-		this.#generation++;
-		this.#acceptingExecutions = false;
-		this.#abortExecutions();
-		return this.#generation;
-	}
-
-	async replace(generation: number, next: CodemodeSessionManager): Promise<boolean> {
-		if (generation !== this.#generation) {
-			await next.dispose();
-			return false;
-		}
-		await this.#settleExecutions();
-		if (generation !== this.#generation) {
-			await next.dispose();
-			return false;
-		}
-		const current = this.#current;
-		this.#current = undefined;
-		await current?.dispose();
-		if (generation !== this.#generation) {
-			await next.dispose();
-			return false;
-		}
-		this.#current = next;
-		this.#started = true;
-		this.#acceptingExecutions = true;
-		return true;
-	}
-
-	assertEvalExecutionAllowed(): void {
-		if (this.#acceptingExecutions && this.#current !== undefined) return;
-		if (this.#started) throw new CodemodeSessionDisposedError();
-		throw new CodemodeSessionNotStartedError();
-	}
-
-	async trackEvalExecution<Result>(execution: Promise<Result>, controller: AbortController): Promise<Result> {
-		this.assertEvalExecutionAllowed();
-		const tracked: TrackedExecution = { promise: execution, controller };
-		this.#executions.add(tracked);
-		try {
-			return await execution;
-		} finally {
-			this.#executions.delete(tracked);
-		}
-	}
-
-	async getKernel(language: EvalLanguage, onMessage: (message: KernelToHostMessage) => void): Promise<EvalKernel> {
-		this.assertEvalExecutionAllowed();
-		const current = this.#current;
-		if (current === undefined) throw new CodemodeSessionNotStartedError();
-		return await current.getKernel(language, onMessage);
-	}
-
-	async complete(request: CompletionRequest, ctx: ExtensionContext): Promise<CompletionResult> {
-		this.assertEvalExecutionAllowed();
-		const current = this.#current;
-		if (current === undefined) throw new CodemodeSessionNotStartedError();
-		return await current.complete(request, ctx);
-	}
-
-	setContext(ctx: ExtensionContext): void {
-		this.#current?.setContext?.(ctx);
-	}
-
-	async dispose(): Promise<void> {
-		this.#generation++;
-		this.#acceptingExecutions = false;
-		this.#abortExecutions();
-		await this.#settleExecutions();
-		const current = this.#current;
-		this.#current = undefined;
-		await current?.dispose();
-	}
-
-	#abortExecutions(): void {
-		if (this.#executions.size === 0) return;
-		const error = new CodemodeSessionDisposedError();
-		for (const execution of this.#executions) execution.controller.abort(error);
-	}
-
-	async #settleExecutions(): Promise<void> {
-		if (this.#executions.size === 0) return;
-		await Promise.allSettled([...this.#executions].map((execution) => execution.promise));
-	}
-}
-
-async function createRuntime(
-	pi: CodemodeExtensionAPI,
-	ctx: ExtensionContext,
-	event: unknown,
-	complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>,
-	options: SenpiCodemodeOptions,
-): Promise<SessionRuntime> {
-	const loaded = await loadCodemodeSettings({ cwd: ctx.cwd });
-	const settings: ResolvedCodemodeSettings = {
-		...loaded.settings,
-		languages: resolveEnabledLanguages(loaded.settings),
-	};
-	const availability = await getInterpreterAvailability(settings, createInterpreterDetector());
-	const enabledLanguages = enabledLanguagesFrom(settings, availability);
-	const artifacts = resolveSessionArtifactsDir(ctx.sessionManager.getSessionFile());
-	const activeTools = new Set(pi.getActiveTools());
-	const executeTool = createExecuteTool(pi, activeTools);
-	const create = options.createSessionManager ?? createCodemodeSessionManager;
-	const manager = await create({
-		sessionId: sessionIdFrom(event),
-		cwd: ctx.cwd,
-		settings,
-		availability,
-		artifactsDir: artifacts.dir,
-		executeTool,
-		complete,
-	});
-	return {
-		manager,
-		enabledLanguages,
-		settings,
-		artifactsDir: artifacts.dir,
-		executeTool,
-		spawns: activeTools.has(settings.taskTools.task),
-	};
-}
-
-function createExecuteTool(pi: CodemodeExtensionAPI, activeTools?: ReadonlySet<string>): AgentExecuteTool {
-	const executeTool: AgentExecuteTool = (toolName, params, executeOptions) =>
-		pi.executeTool(toolName, params, executeOptions);
-	return Object.assign(executeTool, {
-		isToolAvailable: (name: string): boolean => activeTools?.has(name) ?? pi.getActiveTools().includes(name),
-	});
-}
-
-function sessionIdFrom(event: unknown): string {
-	if (typeof event === "object" && event !== null && "sessionId" in event && typeof event.sessionId === "string") {
-		return event.sessionId;
-	}
-	return crypto.randomUUID();
-}
-
-export function enabledLanguagesFrom(
-	settings: CodemodeSettings,
-	availability: InterpreterAvailability,
-): Record<EvalLanguage, boolean> {
-	return {
-		py: settings.languages.py && availability.py.detected.ok,
-		js: settings.languages.js && availability.js.detected.ok,
-		rb: settings.languages.rb && availability.rb.detected.ok,
-		jl: settings.languages.jl && availability.jl.detected.ok,
-	};
-}
+export { enabledLanguagesFrom };

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/js/worker-runtime.js

@@ -63,6 +63,7 @@ export class JsWorkerRuntime {
 				},
 			},
 		);
+		globalThis.tools = globalThis.tool;
 		const originalLog = console.log.bind(console);
 		const originalError = console.error.bind(console);
 		const originalStdoutWrite = process.stdout.write;