@code-yeongyu/senpi-codemode 2026.9.15-2 → 2026.9.16-2

package/src/kernels/rb/prelude.rb

@@ -140,13 +140,22 @@ def __senpi_bridge_request(path, payload)
   return body["value"] if body.is_a?(Hash) && body["ok"] == true
 
   error = body.is_a?(Hash) ? body["error"] : body
-  raise(error.is_a?(Hash) ? error["message"].to_s : error.to_s)
+  raise SenpiBridgeError.new(error.is_a?(Hash) ? error["message"].to_s : error.to_s, error.is_a?(Hash) ? error["code"] : nil)
 end
 
 def __senpi_call_tool(name, args)
   __senpi_bridge_request("/call", { "callId" => "rb-#{Process.pid}-#{rand(1_000_000)}", "toolName" => name, "args" => args })
 end
 
+class SenpiBridgeError < StandardError
+  attr_reader :code
+
+  def initialize(message, code = nil)
+    super(message)
+    @code = code
+  end
+end
+
 class SenpiToolCallable
   def initialize(name)
     @name = name
@@ -177,6 +186,8 @@ def tool
   $__senpi_tool_proxy ||= SenpiToolProxy.new
 end
 
+require_relative "workpool"
+
 def completion(prompt, model: "default", system: nil, schema: nil, **kwargs)
   options = { "model" => model }.merge(kwargs.transform_keys(&:to_s))
   options["system"] = system unless system.nil?
@@ -213,7 +224,7 @@ def agent(prompt, agent: "task", model: nil, label: nil, schema: nil, isolated:
   text_value = record.fetch("text", response)
   result = schema.nil? ? text_value : record.key?("data") ? record["data"] : JSON.parse(text_value.to_s)
   return result unless handle
-  { "text" => text_value, "output" => text_value, "handle" => record["handle"] || (record["id"] && "agent://#{record["id"]}"), "id" => record["id"], "agent" => record.fetch("agent", agent) }.tap do |node|
+  { "text" => text_value, "output" => text_value, "handle" => record["handle"] || (record["id"] && "agent://#{record["id"]}"), "id" => record["id"], "run_epoch" => record["run_epoch"], "agent" => record.fetch("agent", agent) }.tap do |node|
     node["data"] = result unless schema.nil?
   end
 end

package/src/kernels/rb/workpool.rb

@@ -0,0 +1,38 @@
+# Only an opaque host identity is retained; all work remains engine-owned.
+def __senpi_workpool_call(args)
+  tool.workpool(args)
+rescue SenpiBridgeError => error
+  raise SenpiBridgeError.new("No active host workpool tool", "workpool_unavailable") if ["unknown_tool", "inactive_tool"].include?(error.code)
+  raise
+end
+
+class SenpiWorkpool
+  attr_reader :pool_id
+
+  def initialize(pool_id)
+    @pool_id = pool_id
+    freeze
+  end
+
+  def push(items)
+    __senpi_workpool_call({ "op" => "push", "pool_id" => @pool_id, "items" => items })
+  end
+
+  [:close, :inspect, :cancel].each do |op|
+    define_method(op) { __senpi_workpool_call({ "op" => op.to_s, "pool_id" => @pool_id }) }
+  end
+end
+
+def workpool(agent, name, mode: nil)
+  args = { "op" => "create", "agent" => agent, "name" => name }
+  args["mode"] = mode unless mode.nil?
+  result = __senpi_workpool_call(args)
+  details = result["details"]
+  if details.is_a?(Hash)
+    error = details["error"]
+    raise SenpiBridgeError.new(error["message"], error["code"]) if error.is_a?(Hash)
+    pool_id = details["pool_id"]
+    return SenpiWorkpool.new(pool_id) if !result["hasError"] && pool_id.is_a?(String) && /\Awp_[0-9a-f]{32}\z/.match?(pool_id)
+  end
+  raise SenpiBridgeError.new("Host did not return a workpool identity", "workpool_unavailable")
+end

package/src/kernels/shared/subprocess-kernel.ts

@@ -1,6 +1,7 @@
 import type { HostToKernelMessage, KernelToHostMessage } from "../../bridge/protocol.ts";
 import { decodeBridgeFrame, encodeBridgeFrame, isKernelToHostMessage } from "../../bridge/protocol.ts";
 import type { KernelInterruptHandle } from "../../tool/types.ts";
+import { rejectKernelToolsUnavailable } from "../kernel-tools-unavailable.ts";
 import { applySessionEnvironment } from "../session-env.ts";
 import type { KernelResult, KernelRunInput, SubprocessKernelOptions, ToolCallMessage } from "./subprocess-contract.ts";
 import { type SubprocessLike, SubprocessProcess, type SubprocessSpawn, spawnSubprocess } from "./subprocess-process.ts";
@@ -69,6 +70,18 @@ export class SubprocessKernel {
 		return { stateRetained: Promise.resolve(false) };
 	}
 
+	listKernelToolNames(): readonly string[] {
+		return [];
+	}
+
+	describeKernelTools(_names: readonly string[]): Promise<never> {
+		return rejectKernelToolsUnavailable();
+	}
+
+	invokeKernelTool(_request: unknown, _signal?: AbortSignal): Promise<never> {
+		return rejectKernelToolsUnavailable();
+	}
+
 	nextToolCall(): Promise<ToolCallMessage> {
 		return this.runs.nextToolCall();
 	}

package/src/kernels/shared/subprocess-queue.ts

@@ -96,6 +96,8 @@ export class SubprocessRunQueue {
 			case "ready":
 			case "init-failed":
 			case "closed":
+			case "kernel-tool-describe-reply":
+			case "kernel-tool-invoke-reply":
 				onMessage?.(message);
 				return false;
 			default: {

package/src/prompt/eval-prompt-template.ts

@@ -57,8 +57,10 @@ tool_schema(name?) → dict
 completion(prompt, model?="default", system?=None, schema?=None) → str | dict
     Oneshot, stateless. \`model\`: \`"smol"\` fast | \`"default"\` session | \`"slow"\` most capable. \`schema\` (JSON-Schema) → parsed structured output.
 {{#if spawns}}agent(prompt, agent?="{{spawnDefaultAgent}}", model?=None, label?=None, schema?=None, handle?=False) → str | dict
-    Run a subagent → final output. \`agent\` picks a discovered agent. \`schema\` as in completion(). \`handle\` → workflow node { text, output, handle: \`agent://<id>\`, id, agent } (parsed under \`data\` with \`schema\`).
-{{/if}}parallel(thunks) → list
+    Run a subagent → final output. \`agent\` picks a discovered agent. \`schema\` as in completion(). \`handle\` → workflow node { text, output, handle: \`agent://<id>\`, id, run_epoch, agent } (parsed under \`data\` with \`schema\`).
+{{/if}}workpool(agent, name, mode?) → { pool_id, push(items), close(), inspect(), cancel() }
+    Thin host-tool adapter; agent is a plain-data spec. The host owns scheduling and keyed yields; explicitly close for automatic aggregate delivery. Requires the host workpool tool; omitted mode uses its default.
+parallel(thunks) → list
     Thunks through a bounded pool (as wide as a \`task\` batch), input order kept; a throwing thunk propagates.
 pipeline(items, ...stages) → list
     Map items through one-arg stages with a barrier between stages; each stage receives the previous stage's result.

package/src/tool/cell-handler.ts

@@ -1,4 +1,9 @@
-import { type AgentToolResult, type ExtensionContext, sanitizeTerminalLabel } from "@code-yeongyu/senpi";
+import {
+	type AgentToolResult,
+	type ExtensionContext,
+	kernelToolsStorage,
+	sanitizeTerminalLabel,
+} from "@code-yeongyu/senpi";
 import type { KernelToHostMessage } from "../bridge/protocol.ts";
 import { RESERVED_SCHEMA_TOOL } from "../bridge/reserved.ts";
 import type { AgentExecuteTool } from "../bridges/agent-bridge.ts";
@@ -8,6 +13,7 @@ import { appendSchemaHint } from "../bridges/schema-hint.ts";
 import type { CompletionRequest, CompletionResult } from "../completion/handler.ts";
 import { handleCompletionToolCall } from "../completion/tool-bridge.ts";
 import type { ResolvedCodemodeSettings } from "../config/settings.ts";
+import type { KernelToolsCapability } from "../kernels/js/kernel-tools-types.ts";
 import {
 	boundToolCallArgs,
 	capCodePoints,
@@ -39,6 +45,8 @@ export interface CellBridgeRuntime {
 	readonly ctx: ExtensionContext;
 	readonly artifactPath?: string;
 	readonly imageResizer?: EvalImageResizer;
+	/** This cell's live kernel-tool capability; only a JS kernel has one (#1754). */
+	readonly kernelTools?: KernelToolsCapability;
 }
 
 export class CellHandler {
@@ -81,7 +89,7 @@ export class CellHandler {
 				this.#resultBuilder.display(message);
 				return;
 			case "tool-call": {
-				const pending = this.#handleToolCall(message);
+				const pending = this.#dispatchToolCall(message);
 				this.#state.pendingBridgeCalls.push(pending);
 				await pending;
 				return;
@@ -90,6 +98,8 @@ export class CellHandler {
 			case "init-failed":
 			case "result":
 			case "closed":
+			case "kernel-tool-describe-reply":
+			case "kernel-tool-invoke-reply":
 				return;
 			default:
 				throw new TypeError(`Unhandled kernel message: ${String(message)}`);
@@ -112,6 +122,19 @@ export class CellHandler {
 		return this.#resultBuilder.liveResult();
 	}
 
+	/**
+	 * The worker's message loop fires outside the async context `run-eval-cell.ts` enters around the
+	 * awaited run chain, so the capability has to be entered here — around the whole dispatch, including
+	 * the reserved agent()/output() bridges where a host task tool resolves the parent's kernel tools —
+	 * for exactly the duration of each host tool call this cell makes (#1754). Without a capability
+	 * (py/rb/jl) the store stays empty and `ctx.kernelTools` remains undefined.
+	 */
+	async #dispatchToolCall(message: Extract<KernelToHostMessage, { type: "tool-call" }>): Promise<void> {
+		const kernelTools = this.#runtime.kernelTools;
+		if (kernelTools === undefined) return await this.#handleToolCall(message);
+		return await kernelToolsStorage.run(kernelTools, async () => await this.#handleToolCall(message));
+	}
+
 	async #handleToolCall(message: Extract<KernelToHostMessage, { type: "tool-call" }>): Promise<void> {
 		const startedAt = Date.now();
 		const metric = createToolCallMetric(message.toolName, startedAt);
@@ -223,7 +246,12 @@ export class CellHandler {
 				type: "tool-reply",
 				callId: message.callId,
 				ok: false,
-				error: { message: text },
+				error: {
+					message: text,
+					...(error instanceof Error && "code" in error && typeof error.code === "string"
+						? { code: error.code }
+						: {}),
+				},
 			});
 		}
 		this.#resultBuilder.emitUpdate(false);

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

@@ -1,7 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
-import type { AgentToolResult, ExtensionContext } from "@code-yeongyu/senpi";
+import { type AgentToolResult, type ExtensionContext, kernelToolsStorage } from "@code-yeongyu/senpi";
 import { DEFAULT_FOREGROUND_WINDOW_SECONDS, defaultCodemodeSettings } from "../config/settings.ts";
+import type { KernelToolsCapability } from "../kernels/js/kernel-tools-types.ts";
 import { TIMEOUT_PAUSE_OP, TIMEOUT_RESUME_OP } from "../timeouts/bridge-timeout.ts";
 import { abortError, CellExecution, defaultTimeoutFactory } from "./cell-execution.ts";
 import { CellHandler, type CellState } from "./cell-handler.ts";
@@ -11,7 +12,7 @@ import { buildEvalExecutionEventPayload, type EvalExecutionSettleOutcome } from
 import { evalTimeoutBehavior } from "./eval-request.ts";
 import type { CreateEvalToolOptions, EvalCellInvocation } from "./eval-tool-options.ts";
 import { describeTimeoutState } from "./interrupt-note.ts";
-import type { EvalToolDetails } from "./types.ts";
+import type { EvalKernel, EvalToolDetails } from "./types.ts";
 
 export async function runEvalCell(
 	options: CreateEvalToolOptions,
@@ -166,34 +167,42 @@ async function executeCell(
 				void pending.catch((error: unknown) => execution.cancel(error));
 			}),
 		);
-		execution.setKernel(kernel);
-		const activeHandler = new CellHandler(kernel, state, {
-			executeTool: options.executeTool,
-			...(options.listTools === undefined ? {} : { listTools: options.listTools }),
-			settings: options.settings ?? defaultCodemodeSettings,
-			...(options.complete === undefined ? {} : { complete: options.complete }),
-			ctx: bridgeContext,
-			...(options.artifactsDir === undefined
-				? {}
-				: { artifactPath: join(options.artifactsDir, `eval-${randomUUID()}.log`) }),
-			...(options.imageResizer === undefined ? {} : { imageResizer: options.imageResizer }),
-		});
-		handler = activeHandler;
-		cellManager.markRunning(
-			cell,
-			kernel,
-			() => activeHandler.liveResult(),
-			(error) => execution.cancel(error),
-		);
-		// Includes a steer already queued at execute start or received while acquiring the kernel.
-		onReady();
-		if ("setContext" in options.kernelManager && typeof options.kernelManager.setContext === "function") {
-			options.kernelManager.setContext(bridgeContext);
-		}
-		if (invocation.input.reset) await execution.wait(kernel.reset());
-		const result = await execution.wait(kernel.run({ cellId: invocation.cellId, code: invocation.input.code }));
-		if (result.ok && state.pendingBridgeCalls.length > 0) await execution.wait(Promise.all(state.pendingBridgeCalls));
-		return await handler.finalize(result);
+		// Computed before the handler so the cell's capability can be entered per host tool call from the
+		// worker's message loop, which runs outside the `kernelToolsStorage.run` context below (#1754).
+		const kernelTools = jsKernelTools(kernel, invocation.input.language);
+		const runBound = async (): Promise<AgentToolResult<EvalToolDetails>> => {
+			execution.setKernel(kernel);
+			const activeHandler = new CellHandler(kernel, state, {
+				executeTool: options.executeTool,
+				...(options.listTools === undefined ? {} : { listTools: options.listTools }),
+				settings: options.settings ?? defaultCodemodeSettings,
+				...(options.complete === undefined ? {} : { complete: options.complete }),
+				ctx: bridgeContext,
+				...(options.artifactsDir === undefined
+					? {}
+					: { artifactPath: join(options.artifactsDir, `eval-${randomUUID()}.log`) }),
+				...(options.imageResizer === undefined ? {} : { imageResizer: options.imageResizer }),
+				...(kernelTools === undefined ? {} : { kernelTools }),
+			});
+			handler = activeHandler;
+			cellManager.markRunning(
+				cell,
+				kernel,
+				() => activeHandler.liveResult(),
+				(error) => execution.cancel(error),
+			);
+			// Includes a steer already queued at execute start or received while acquiring the kernel.
+			onReady();
+			if ("setContext" in options.kernelManager && typeof options.kernelManager.setContext === "function") {
+				options.kernelManager.setContext(bridgeContext);
+			}
+			if (invocation.input.reset) await execution.wait(kernel.reset());
+			const result = await execution.wait(kernel.run({ cellId: invocation.cellId, code: invocation.input.code }));
+			if (result.ok && state.pendingBridgeCalls.length > 0)
+				await execution.wait(Promise.all(state.pendingBridgeCalls));
+			return await handler.finalize(result);
+		};
+		return kernelTools ? await kernelToolsStorage.run(kernelTools, runBound) : await runBound();
 	} catch (error) {
 		if (handler && error instanceof Error && error.name === "CodemodeSessionDisposedError")
 			return await handler.finalizeCancellation(error);
@@ -206,3 +215,16 @@ async function executeCell(
 		if (handler) await handler.flushOutput();
 	}
 }
+
+function jsKernelTools(kernel: EvalKernel, language: string): KernelToolsCapability | undefined {
+	if (language !== "js") return undefined;
+	if (!("describeKernelTools" in kernel) || typeof kernel.describeKernelTools !== "function") return undefined;
+	const js = kernel as EvalKernel & {
+		describeKernelTools: KernelToolsCapability["describe"];
+		invokeKernelTool: KernelToolsCapability["invoke"];
+	};
+	return {
+		describe: (names) => js.describeKernelTools(names),
+		invoke: (request, signal) => js.invokeKernelTool(request, signal),
+	};
+}

package/src/tool/types.ts

@@ -132,6 +132,8 @@ export interface EvalKernel {
 	deliverToolReply(message: Extract<HostToKernelMessage, { type: "tool-reply" }>): void;
 	reset(): Promise<void>;
 	close(): Promise<void>;
+	/** Names this kernel has registered; JS collides with other languages in the same session. */
+	listKernelToolNames?(): readonly string[];
 }
 
 export interface EvalKernelManager {