@code-yeongyu/senpi-codemode 2026.10.5 → 2026.10.7

package/src/tool/cell-reserved-dispatch.ts

@@ -0,0 +1,51 @@
+import type { ExtensionContext } from "@code-yeongyu/senpi";
+import type { KernelToHostMessage } from "../bridge/protocol.ts";
+import type { ReservedDispatchContext } from "../bridges/reserved-dispatch.ts";
+import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
+import type { CompletionToolCallOptions } from "../completion/tool-bridge.ts";
+import type { CellBridgeRuntime } from "./cell-handler.ts";
+import { marshalToolResult } from "./image.ts";
+import type { EvalKernel, EvalStatusEvent } from "./types.ts";
+
+type ToolCallMessage = Extract<KernelToHostMessage, { type: "tool-call" }>;
+
+/** The in-process (JS kernel) dispatch context for a reserved helper call; mirrors the bridge route for py/rb/jl. */
+export function reservedDispatchContext(
+	message: ToolCallMessage,
+	runtime: CellBridgeRuntime,
+	signal: AbortSignal,
+	emitStatus: (event: EvalStatusEvent) => void,
+): ReservedDispatchContext {
+	const host = runtime.ctx.evalHandleHost;
+	return {
+		callId: message.callId,
+		args: message.args,
+		executeTool: runtime.executeTool,
+		taskToolName: runtime.settings.taskTools.task,
+		taskOutputToolName: runtime.settings.taskTools.output,
+		listTools: runtime.listTools,
+		signal,
+		emitStatus,
+		marshalToolResult,
+		...(runtime.handles === undefined ? {} : { handles: runtime.handles }),
+		...(host === undefined ? {} : { evalHandleHost: host }),
+	};
+}
+
+export function completionCallOptions(
+	message: ToolCallMessage,
+	kernel: EvalKernel,
+	runtime: CellBridgeRuntime,
+	complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>,
+	isActive: () => boolean,
+): CompletionToolCallOptions {
+	return {
+		message,
+		kernel,
+		complete,
+		ctx: runtime.ctx,
+		isActive,
+		...(runtime.handles === undefined ? {} : { handles: runtime.handles }),
+		...(runtime.hardDeadlineMs === undefined ? {} : { hardDeadlineMs: runtime.hardDeadlineMs }),
+	};
+}

package/src/tool/eval-tool-options.ts

@@ -9,6 +9,7 @@ import type { EvalSchemaToolInfo } from "../bridges/schema-bridge.ts";
 import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
 import type { ResolvedCodemodeSettings } from "../config/settings.ts";
 import type { EvalExecutionTracker } from "../extension/session-manager.ts";
+import type { HandleRegistry } from "../handles/handle-registry.ts";
 import type { EvalTimeoutFactory } from "./cell-execution.ts";
 import type { EvalDetachedCellManager } from "./detached-cell-manager.ts";
 import type { EvalExecutionEventPayload } from "./eval-execution-event.ts";
@@ -50,6 +51,8 @@ export interface CreateEvalToolOptions {
 	readonly imageResizer?: EvalImageResizer;
 	readonly executionTracker?: EvalExecutionTracker;
 	readonly cellManager?: EvalDetachedCellManager;
+	/** The session generation's handle registry (`wait()`, `handle()`, completion handles); absent before session_start. */
+	readonly handles?: HandleRegistry;
 	readonly onCellSettled?: (payload: EvalExecutionEventPayload) => void;
 	readonly timeoutFactory?: EvalTimeoutFactory;
 	readonly proxyExecutor?: (params: EvalToolInput, signal?: AbortSignal) => Promise<AgentToolResult<EvalToolDetails>>;

package/src/tool/run-eval-cell.ts

@@ -209,7 +209,7 @@ async function executeCell(
 		const kernel = await execution.wait(options.kernelManager.getKernel(invocation.input.language, onMessage));
 		// Computed before the handler so its construction-time snapshot captures this cell's capability.
 		// Worker messages later restore that snapshot before calling host tools (#1754, #2512).
-		const kernelTools = jsKernelTools(kernel, invocation.input.language);
+		const kernelTools = kernelToolsFor(kernel);
 		const runBound = async (): Promise<AgentToolResult<EvalToolDetails>> => {
 			const queue = kernel.queueSnapshot();
 			state.queuedBehind = [...(queue.activeCellId === null ? [] : [queue.activeCellId]), ...queue.queuedCellIds];
@@ -224,6 +224,8 @@ async function executeCell(
 					: { artifactPath: join(options.artifactsDir, `eval-${randomUUID()}.log`) }),
 				...(options.imageResizer === undefined ? {} : { imageResizer: options.imageResizer }),
 				...(kernelTools === undefined ? {} : { kernelTools }),
+				...(options.handles === undefined ? {} : { handles: options.handles }),
+				hardDeadlineMs: cell.startedAtMs + cell.hardLimitSeconds * 1_000,
 			});
 			handler = activeHandler;
 			cellManager.bindKernel(
@@ -292,16 +294,15 @@ async function executeCell(
 	}
 }
 
-function jsKernelTools(kernel: EvalKernel, language: string): KernelToolsCapability | undefined {
-	if (language !== "js") return undefined;
+function kernelToolsFor(kernel: EvalKernel): KernelToolsCapability | undefined {
 	if (!("describeKernelTools" in kernel) || typeof kernel.describeKernelTools !== "function") return undefined;
-	const js = kernel as EvalKernel & {
+	const withTools = kernel as EvalKernel & {
 		describeKernelTools: (names: readonly string[]) => Promise<KernelToolsDescribeResult>;
 		invokeKernelTool: ExtensionKernelTools["invoke"];
 	};
 	return {
 		capabilities: KERNEL_TOOLS_CAPABILITIES,
-		describe: (names) => js.describeKernelTools(names),
-		invoke: (request, options) => js.invokeKernelTool(request, options),
+		describe: (names) => withTools.describeKernelTools(names),
+		invoke: (request, options) => withTools.invokeKernelTool(request, options),
 	} satisfies ExtensionKernelTools;
 }

package/src/tool/types.ts

@@ -144,9 +144,24 @@ export function createEvalInputSchema(
 export type EvalKernelResult = Extract<KernelToHostMessage, { type: "result" }>;
 export type EvalToolCallMessage = Extract<KernelToHostMessage, { type: "tool-call" }>;
 
+export type HostCellOutcome =
+	| { readonly ok: true; readonly valueRepr?: string }
+	| { readonly ok: false; readonly error: { readonly message: string; readonly name?: string } };
+
+/**
+ * Work the host runs in the cell's place when the entry reaches the front of the kernel's queue: no code is
+ * sent to the interpreter, and aborting the signal (interrupt, timeout, kernel close) ends it without
+ * restarting the interpreter.
+ */
+export type HostCellExecutor = (context: {
+	readonly signal: AbortSignal;
+	readonly emit: (message: KernelToHostMessage) => void;
+}) => Promise<HostCellOutcome>;
+
 export interface EvalKernelRunInput {
 	readonly cellId: string;
 	readonly code: string;
+	readonly host?: HostCellExecutor;
 	readonly timeoutMs?: number;
 	readonly onStarted?: () => void;
 	readonly onMessage?: (message: KernelToHostMessage) => void;