@oh-my-pi/pi-coding-agent 15.3.2 → 15.4.2

package/src/eval/js/worker-core.ts

@@ -3,6 +3,7 @@ import { JsRuntime, type RuntimeHooks } from "./shared/runtime";
 import type { RunErrorPayload, SessionSnapshot, ToolReply, Transport, WorkerInbound } from "./worker-protocol";
 
 interface PendingTool {
+	runId: string;
 	resolve(value: unknown): void;
 	reject(error: Error): void;
 }
@@ -36,8 +37,7 @@ function errorFromPayload(payload: RunErrorPayload): Error {
 export class WorkerCore {
 	#transport: Transport;
 	#runtime: JsRuntime | null = null;
-	#queue: Promise<void> = Promise.resolve();
-	#active: ActiveRun | null = null;
+	#runs = new Map<string, ActiveRun>();
 	#unsubscribe: () => void;
 
 	constructor(transport: Transport) {
@@ -52,7 +52,7 @@ export class WorkerCore {
 				this.#ensureRuntime(msg.snapshot);
 				return;
 			case "run":
-				this.#enqueueRun(msg.runId, msg.code, msg.filename, msg.snapshot);
+				void this.#runOne(msg.runId, msg.code, msg.filename, msg.snapshot);
 				return;
 			case "tool-reply":
 				this.#deliverToolReply(msg.id, msg.reply);
@@ -71,73 +71,58 @@ export class WorkerCore {
 		this.#runtime = new JsRuntime({
 			initialCwd: snapshot.cwd,
 			sessionId: snapshot.sessionId,
-			getHooks: () => this.#hooksForCurrentRun(),
 		});
 		return this.#runtime;
 	}
 
-	#hooksForCurrentRun(): RuntimeHooks | null {
-		const active = this.#active;
-		if (!active) return null;
-		const runId = active.runId;
-		return {
+	async #runOne(runId: string, code: string, filename: string, snapshot: SessionSnapshot): Promise<void> {
+		const runtime = this.#ensureRuntime(snapshot);
+		runtime.setCwd(snapshot.cwd);
+		const active: ActiveRun = { runId, pendingTools: new Map() };
+		this.#runs.set(runId, active);
+		const hooks: RuntimeHooks = {
 			onText: chunk => this.#transport.send({ type: "text", runId, chunk }),
 			onDisplay: output => this.#transport.send({ type: "display", runId, output }),
 			callTool: (name, args) => this.#callTool(active, name, args),
 		};
-	}
-
-	#enqueueRun(runId: string, code: string, filename: string, snapshot: SessionSnapshot): void {
-		const previous = this.#queue;
-		const next = (async () => {
-			await previous.catch(() => undefined);
-			await this.#runOne(runId, code, filename, snapshot);
-		})();
-		this.#queue = next.catch(() => undefined);
-	}
-
-	async #runOne(runId: string, code: string, filename: string, snapshot: SessionSnapshot): Promise<void> {
-		const runtime = this.#ensureRuntime(snapshot);
-		runtime.setCwd(snapshot.cwd);
-		this.#active = { runId, pendingTools: new Map() };
 		try {
-			const value = await runtime.run(code, filename);
-			runtime.displayValue(value);
+			const value = await runtime.run(code, filename, hooks, { runId, cwd: snapshot.cwd });
+			runtime.displayValue(value, hooks);
 			this.#transport.send({ type: "result", runId, ok: true });
 		} catch (error) {
 			this.#transport.send({ type: "result", runId, ok: false, error: errorPayload(error) });
 		} finally {
-			this.#active = null;
+			this.#runs.delete(runId);
 		}
 	}
 
 	async #callTool(active: ActiveRun, name: string, args: unknown): Promise<unknown> {
 		const id = `tc-${active.runId}-${crypto.randomUUID()}`;
 		const { promise, resolve, reject } = Promise.withResolvers<unknown>();
-		active.pendingTools.set(id, { resolve, reject });
+		active.pendingTools.set(id, { runId: active.runId, resolve, reject });
 		this.#transport.send({ type: "tool-call", id, runId: active.runId, name, args });
 		return await promise;
 	}
 
 	#deliverToolReply(id: string, reply: ToolReply): void {
-		const active = this.#active;
-		if (!active) return;
-		const pending = active.pendingTools.get(id);
-		if (!pending) return;
-		active.pendingTools.delete(id);
-		if (reply.ok) pending.resolve(reply.value);
-		else pending.reject(errorFromPayload(reply.error));
+		for (const active of this.#runs.values()) {
+			const pending = active.pendingTools.get(id);
+			if (!pending) continue;
+			active.pendingTools.delete(id);
+			if (reply.ok) pending.resolve(reply.value);
+			else pending.reject(errorFromPayload(reply.error));
+			return;
+		}
 	}
 
 	#close(): void {
-		const active = this.#active;
-		if (active) {
+		for (const active of this.#runs.values()) {
 			for (const pending of active.pendingTools.values()) {
 				pending.reject(new ToolError("JS worker closed"));
 			}
 			active.pendingTools.clear();
 		}
-		this.#active = null;
+		this.#runs.clear();
 		this.#runtime = null;
 		this.#transport.send({ type: "closed" });
 		this.#unsubscribe();

package/src/eval/py/executor.ts

@@ -1,14 +1,17 @@
+import * as path from "node:path";
+
 import { getProjectDir, logger } from "@oh-my-pi/pi-utils";
 import { Settings } from "../../config/settings";
 import { OutputSink } from "../../session/streaming-output";
 import type { ToolSession } from "../../tools";
 import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../../tools/output-meta";
 import type { JsStatusEvent } from "../js/shared/types";
-import type { KernelDisplayOutput } from "./display";
 import {
 	checkPythonKernelAvailability,
+	type KernelDisplayOutput,
 	type KernelExecuteOptions,
 	type KernelExecuteResult,
+	type KernelRuntimeEnv,
 	PythonKernel,
 } from "./kernel";
 import { ensurePyToolBridge, registerPyToolBridge } from "./tool-bridge";
@@ -92,20 +95,32 @@ export interface PythonResult {
 // ---------------------------------------------------------------------------
 // Session bookkeeping
 //
-// One PythonKernel subprocess per session id. Sessions are reused until they
-// die or are explicitly disposed. Multiple agent owners can register against
-// the same session id; the kernel stays alive until the last owner detaches.
+// One PythonKernel subprocess per (session id, cwd) tuple. The runner mutates
+// process-global cwd/sys.path during execution, so cross-directory work MUST
+// never share a live kernel. Multiple agent owners can still register against
+// the same tuple; the kernel stays alive until the last owner detaches.
 // ---------------------------------------------------------------------------
 
 interface PythonSession {
+	sessionKey: string;
 	sessionId: string;
+	cwd: string;
 	kernel: PythonKernel;
 	ownerIds: Set<string>;
 	hasFallbackOwner: boolean;
-	queue: Promise<void>;
 }
 
 const sessions = new Map<string, PythonSession>();
+const startingSessions = new Map<string, Promise<PythonSession>>();
+const resettingSessions = new Set<string>();
+
+function normalizeSessionCwd(cwd: string): string {
+	return path.resolve(cwd);
+}
+
+function buildSessionKey(sessionId: string, cwd: string): string {
+	return `${sessionId}\0${normalizeSessionCwd(cwd)}`;
+}
 
 // ---------------------------------------------------------------------------
 // Cancellation plumbing
@@ -240,19 +255,40 @@ function createCancelledPythonResult(timedOut: boolean, timeoutMs?: number): Pyt
 // Kernel start helpers
 // ---------------------------------------------------------------------------
 
+const MANAGED_KERNEL_ENV_KEYS = [
+	"PI_SESSION_FILE",
+	"PI_ARTIFACTS_DIR",
+	"PI_TOOL_BRIDGE_URL",
+	"PI_TOOL_BRIDGE_TOKEN",
+	"PI_TOOL_BRIDGE_SESSION",
+] as const;
+
+function buildKernelEnvPatch(options: {
+	sessionFile?: string;
+	artifactsDir?: string;
+	bridgeSessionId?: string;
+	bridge?: { url: string; token: string };
+}): KernelRuntimeEnv {
+	return {
+		PI_SESSION_FILE: options.sessionFile ?? null,
+		PI_ARTIFACTS_DIR: options.artifactsDir ?? null,
+		PI_TOOL_BRIDGE_URL: options.bridge?.url ?? null,
+		PI_TOOL_BRIDGE_TOKEN: options.bridge?.token ?? null,
+		PI_TOOL_BRIDGE_SESSION: options.bridge && options.bridgeSessionId ? options.bridgeSessionId : null,
+	};
+}
+
 function buildKernelEnv(options: {
 	sessionFile?: string;
 	artifactsDir?: string;
 	bridgeSessionId?: string;
 	bridge?: { url: string; token: string };
 }): Record<string, string> | undefined {
+	const patch = buildKernelEnvPatch(options);
 	const env: Record<string, string> = {};
-	if (options.sessionFile) env.PI_SESSION_FILE = options.sessionFile;
-	if (options.artifactsDir) env.PI_ARTIFACTS_DIR = options.artifactsDir;
-	if (options.bridge && options.bridgeSessionId) {
-		env.PI_TOOL_BRIDGE_URL = options.bridge.url;
-		env.PI_TOOL_BRIDGE_TOKEN = options.bridge.token;
-		env.PI_TOOL_BRIDGE_SESSION = options.bridgeSessionId;
+	for (const key of MANAGED_KERNEL_ENV_KEYS) {
+		const value = patch[key];
+		if (value !== null) env[key] = value;
 	}
 	return Object.keys(env).length > 0 ? env : undefined;
 }
@@ -282,23 +318,44 @@ function attachOwner(session: PythonSession, sessionId: string, ownerId: string
 	}
 }
 
-async function acquireSession(sessionId: string, cwd: string, options: PythonExecutorOptions): Promise<PythonSession> {
-	const existing = sessions.get(sessionId);
+async function acquireSession(
+	sessionKey: string,
+	sessionId: string,
+	cwd: string,
+	options: PythonExecutorOptions,
+): Promise<PythonSession> {
+	const existing = sessions.get(sessionKey);
 	if (existing) {
 		attachOwner(existing, sessionId, options.kernelOwnerId);
 		return existing;
 	}
-	const kernel = await startKernel(cwd, options);
-	const session: PythonSession = {
-		sessionId,
-		kernel,
-		ownerIds: new Set(),
-		hasFallbackOwner: false,
-		queue: Promise.resolve(),
-	};
-	attachOwner(session, sessionId, options.kernelOwnerId);
-	sessions.set(sessionId, session);
-	return session;
+	const starting = startingSessions.get(sessionKey);
+	if (starting) {
+		const session = await starting;
+		attachOwner(session, sessionId, options.kernelOwnerId);
+		return session;
+	}
+	const startup = (async () => {
+		const kernel = await startKernel(cwd, options);
+		const session: PythonSession = {
+			sessionKey,
+			sessionId,
+			cwd,
+			kernel,
+			ownerIds: new Set(),
+			hasFallbackOwner: false,
+		};
+		sessions.set(sessionKey, session);
+		return session;
+	})();
+	startingSessions.set(sessionKey, startup);
+	try {
+		const session = await startup;
+		attachOwner(session, sessionId, options.kernelOwnerId);
+		return session;
+	} finally {
+		if (startingSessions.get(sessionKey) === startup) startingSessions.delete(sessionKey);
+	}
 }
 
 async function replaceSessionKernel(
@@ -311,52 +368,40 @@ async function replaceSessionKernel(
 	await old
 		.shutdown(remaining !== undefined ? { timeoutMs: Math.max(0, remaining) } : undefined)
 		.catch(() => undefined);
-	if (sessions.get(session.sessionId) !== session) {
+	if (sessions.get(session.sessionKey) !== session) {
 		throw new PythonExecutionCancelledError(false);
 	}
 	requireRemainingTimeoutMs(options.deadlineMs);
 	const next = await startKernel(cwd, options);
-	if (sessions.get(session.sessionId) !== session) {
+	if (sessions.get(session.sessionKey) !== session) {
 		await next.shutdown().catch(() => undefined);
 		throw new PythonExecutionCancelledError(false);
 	}
 	session.kernel = next;
 }
 
-async function resetSession(sessionId: string): Promise<void> {
-	const existing = sessions.get(sessionId);
+async function resetSession(sessionKey: string): Promise<void> {
+	const existing = sessions.get(sessionKey) ?? (await startingSessions.get(sessionKey)?.catch(() => undefined));
 	if (!existing) return;
-	sessions.delete(sessionId);
+	sessions.delete(sessionKey);
 	await existing.kernel.shutdown().catch(() => undefined);
 }
 
-async function runQueued<T>(
-	session: PythonSession,
-	options: Pick<PythonExecutorOptions, "signal" | "deadlineMs">,
-	work: () => Promise<T>,
-): Promise<T> {
-	const previous = session.queue;
-	const { promise: ourSlot, resolve: releaseSlot } = Promise.withResolvers<void>();
-	// Keep the queue chained even if WE bail out: future runs must still wait
-	// for `previous` to finish before they touch the kernel.
-	session.queue = previous.catch(() => undefined).then(() => ourSlot);
-	try {
-		await waitForPromiseWithCancellation(
-			previous.catch(() => undefined),
-			options,
-		);
-		return await work();
-	} finally {
-		releaseSlot();
-	}
-}
-
 // ---------------------------------------------------------------------------
 // Public dispose entry points
 // ---------------------------------------------------------------------------
 
 export async function disposeAllKernelSessions(): Promise<void> {
+	const pending = [...startingSessions.values()];
+	startingSessions.clear();
+	const started = await Promise.allSettled(pending);
 	const all = [...sessions.entries()];
+	for (const result of started) {
+		if (result.status !== "fulfilled") continue;
+		if (!all.some(([, session]) => session === result.value)) {
+			all.push([result.value.sessionKey, result.value]);
+		}
+	}
 	for (const [id, session] of all) {
 		if (sessions.get(id) === session) sessions.delete(id);
 	}
@@ -366,7 +411,12 @@ export async function disposeAllKernelSessions(): Promise<void> {
 		const result = results[i];
 		if (result.status === "fulfilled" && result.value?.confirmed !== false) continue;
 		const reason = result.status === "rejected" ? result.reason : "not confirmed";
-		logger.warn("Python kernel shutdown not confirmed", { sessionId: id, reason });
+		logger.warn("Python kernel shutdown not confirmed", {
+			sessionId: session.sessionId,
+			sessionKey: id,
+			cwd: session.cwd,
+			reason,
+		});
 		if (!sessions.has(id)) sessions.set(id, session);
 	}
 }
@@ -382,7 +432,7 @@ export async function disposeKernelSessionsByOwner(ownerId: string): Promise<voi
 		session.ownerIds.delete(ownerId);
 	}
 	for (const session of toShutdown) {
-		if (sessions.get(session.sessionId) === session) sessions.delete(session.sessionId);
+		if (sessions.get(session.sessionKey) === session) sessions.delete(session.sessionKey);
 	}
 	const results = await Promise.allSettled(toShutdown.map(session => session.kernel.shutdown()));
 	for (let i = 0; i < toShutdown.length; i += 1) {
@@ -393,8 +443,13 @@ export async function disposeKernelSessionsByOwner(ownerId: string): Promise<voi
 			continue;
 		}
 		const reason = result.status === "rejected" ? result.reason : "not confirmed";
-		logger.warn("Python kernel shutdown not confirmed", { sessionId: session.sessionId, reason });
-		if (!sessions.has(session.sessionId)) sessions.set(session.sessionId, session);
+		logger.warn("Python kernel shutdown not confirmed", {
+			sessionId: session.sessionId,
+			sessionKey: session.sessionKey,
+			cwd: session.cwd,
+			reason,
+		});
+		if (!sessions.has(session.sessionKey)) sessions.set(session.sessionKey, session);
 	}
 }
 
@@ -424,9 +479,10 @@ async function executeWithKernel(
 		((event: JsStatusEvent) => {
 			displayOutputs.push({ type: "status", event });
 		});
+	const runId = `py-${crypto.randomUUID()}`;
 	const unregisterBridge =
 		options?.toolSession && options?.bridgeSessionId
-			? registerPyToolBridge(options.bridgeSessionId, {
+			? registerPyToolBridge(options.bridgeSessionId, runId, {
 					toolSession: options.toolSession,
 					signal: options.signal,
 					emitStatus,
@@ -436,6 +492,9 @@ async function executeWithKernel(
 	try {
 		executionTimeoutMs = requireRemainingTimeoutMs(deadlineMs);
 		const result = await kernel.execute(code, {
+			cwd: options?.cwd,
+			env: buildKernelEnvPatch(options ?? {}),
+			id: runId,
 			signal: options?.signal,
 			timeoutMs: executionTimeoutMs,
 			onChunk: text => sink.push(text),
@@ -516,7 +575,7 @@ async function executePerCall(code: string, cwd: string, options: PythonExecutor
 	}
 	const kernel = await startKernel(cwd, options);
 	try {
-		return await executeWithKernel(kernel, code, options);
+		return await executeWithKernel(kernel, code, { ...options, cwd: undefined });
 	} finally {
 		await kernel.shutdown().catch(() => undefined);
 	}
@@ -524,42 +583,53 @@ async function executePerCall(code: string, cwd: string, options: PythonExecutor
 
 async function executeOnSession(code: string, cwd: string, options: PythonExecutorOptions): Promise<PythonResult> {
 	const sessionId = options.sessionId ?? `session:${cwd}`;
+	const sessionKey = buildSessionKey(sessionId, cwd);
 	if (options.bridge && !options.bridgeSessionId) {
 		options.bridgeSessionId = sessionId;
 	}
 	if (options.reset) {
-		await resetSession(sessionId);
-	}
-	const session = await acquireSession(sessionId, cwd, options);
-	return await runQueued(session, options, async () => {
-		if (options.signal?.aborted) {
-			throw new PythonExecutionCancelledError(isTimedOutCancellation(options.signal.reason, options.signal));
+		if (resettingSessions.has(sessionKey)) {
+			throw new Error("Python kernel reset already in progress");
+		}
+		resettingSessions.add(sessionKey);
+		try {
+			await resetSession(sessionKey);
+		} finally {
+			resettingSessions.delete(sessionKey);
 		}
-		if (sessions.get(session.sessionId) !== session) {
+	} else if (resettingSessions.has(sessionKey)) {
+		throw new Error("Python kernel reset in progress");
+	}
+	const session = await acquireSession(sessionKey, sessionId, cwd, options);
+	if (options.signal?.aborted) {
+		throw new PythonExecutionCancelledError(isTimedOutCancellation(options.signal.reason, options.signal));
+	}
+	if (sessions.get(session.sessionKey) !== session) {
+		throw new PythonExecutionCancelledError(false);
+	}
+	if (!session.kernel.isAlive()) {
+		await replaceSessionKernel(session, cwd, options);
+		if (sessions.get(session.sessionKey) !== session) {
 			throw new PythonExecutionCancelledError(false);
 		}
-		if (!session.kernel.isAlive()) {
-			await replaceSessionKernel(session, cwd, options);
-			if (sessions.get(session.sessionId) !== session) {
-				throw new PythonExecutionCancelledError(false);
-			}
+	}
+	const runOptions = { ...options, cwd: undefined };
+	try {
+		return await executeWithKernel(session.kernel, code, runOptions);
+	} catch (err) {
+		if (isCancellationError(err) || options.signal?.aborted) throw err;
+		if (session.kernel.isAlive()) throw err;
+		if (sessions.get(session.sessionKey) !== session) {
+			throw new PythonExecutionCancelledError(false);
 		}
-		try {
-			return await executeWithKernel(session.kernel, code, options);
-		} catch (err) {
-			if (isCancellationError(err) || options.signal?.aborted) throw err;
-			if (session.kernel.isAlive()) throw err;
-			if (sessions.get(session.sessionId) !== session) {
-				throw new PythonExecutionCancelledError(false);
-			}
-			// Kernel died during execute. Replace it and retry once on a fresh one.
-			await replaceSessionKernel(session, cwd, options);
-			if (sessions.get(session.sessionId) !== session) {
-				throw new PythonExecutionCancelledError(false);
-			}
-			return await executeWithKernel(session.kernel, code, options);
+		// Shared kernels are keyed by cwd, so a dead kernel can be recreated in place
+		// without risking cross-directory state bleed.
+		await replaceSessionKernel(session, cwd, options);
+		if (sessions.get(session.sessionKey) !== session) {
+			throw new PythonExecutionCancelledError(false);
 		}
-	});
+		return await executeWithKernel(session.kernel, code, runOptions);
+	}
 }
 
 export async function executePythonWithKernel(
@@ -571,10 +641,11 @@ export async function executePythonWithKernel(
 }
 
 export async function executePython(code: string, options?: PythonExecutorOptions): Promise<PythonResult> {
-	const cwd = options?.cwd ?? getProjectDir();
+	const cwd = normalizeSessionCwd(options?.cwd ?? getProjectDir());
 	const deadlineMs = getExecutionDeadlineMs(options);
 	const executionOptions: PythonExecutorOptions = {
 		...(options ?? {}),
+		cwd,
 		deadlineMs,
 	};
 

package/src/eval/py/kernel.ts

@@ -51,7 +51,14 @@ const STARTUP_TIMEOUT_MS = 10_000;
 // kernel's state, so we only kill as a last-resort recovery path.
 const INTERRUPT_ESCALATION_MS = 5_000;
 
+export type KernelRuntimeEnv = Record<string, string | null>;
+
 export interface KernelExecuteOptions {
+	id?: string;
+	/** Runtime working directory applied immediately before this request executes. */
+	cwd?: string;
+	/** Managed runtime environment variables applied immediately before this request executes. */
+	env?: KernelRuntimeEnv;
 	signal?: AbortSignal;
 	onChunk?: (text: string) => Promise<void> | void;
 	onDisplay?: (output: KernelDisplayOutput) => Promise<void> | void;
@@ -260,7 +267,7 @@ export class PythonKernel {
 			throw new Error("Python kernel is not running");
 		}
 
-		const msgId = Snowflake.next();
+		const msgId = options?.id ?? Snowflake.next();
 		const { promise, resolve } = Promise.withResolvers<KernelExecuteResult>();
 		const pending: PendingExecution = {
 			resolve,
@@ -345,6 +352,8 @@ export class PythonKernel {
 		const payload = JSON.stringify({
 			id: msgId,
 			code,
+			cwd: options?.cwd,
+			env: options?.env,
 			silent: options?.silent ?? false,
 			storeHistory: options?.storeHistory ?? !(options?.silent ?? false),
 		});

package/src/eval/py/prelude.py

@@ -377,13 +377,20 @@ if "__omp_prelude_loaded__" not in globals():
         return current
 
 
+    def _tool_proxy_from_env() -> tuple[str, str, str]:
+        base = os.environ.get("PI_TOOL_BRIDGE_URL")
+        token = os.environ.get("PI_TOOL_BRIDGE_TOKEN")
+        session = os.environ.get("PI_TOOL_BRIDGE_SESSION")
+        if not base or not token or not session:
+            raise RuntimeError("tool bridge is unavailable in this kernel")
+        return (base.rstrip("/"), token, session)
+
     class _ToolCallable:
         """Invokes one host-side tool via the loopback HTTP bridge."""
 
-        __slots__ = ("_proxy", "_name")
+        __slots__ = ("_name",)
 
-        def __init__(self, proxy: "_ToolProxy", name: str):
-            self._proxy = proxy
+        def __init__(self, name: str):
             self._name = name
 
         def __repr__(self) -> str:
@@ -402,16 +409,19 @@ if "__omp_prelude_loaded__" not in globals():
             merged.update(kwargs)
             if "_i" not in merged:
                 merged["_i"] = "py prelude"
+            base, token, session = _tool_proxy_from_env()
+            _run_id_getter = globals().get("__omp_current_run_id__")
+            _run_id = _run_id_getter() if callable(_run_id_getter) else globals().get("__omp_run_id__")
             payload = json.dumps(
-                {"session": self._proxy._session, "name": self._name, "args": merged}
+                {"session": session, "run": _run_id, "name": self._name, "args": merged}
             ).encode("utf-8")
             req = urllib.request.Request(
-                f"{self._proxy._base}/v1/tool",
+                f"{base}/v1/tool",
                 data=payload,
                 method="POST",
                 headers={
                     "Content-Type": "application/json",
-                    "Authorization": f"Bearer {self._proxy._token}",
+                    "Authorization": f"Bearer {token}",
                 },
             )
             try:
@@ -433,30 +443,18 @@ if "__omp_prelude_loaded__" not in globals():
     class _ToolProxy:
         """`tool.<name>(args)` proxy mirroring the JS runtime bridge."""
 
-        __slots__ = ("_base", "_token", "_session")
-
-        def __init__(self, base: str, token: str, session: str):
-            self._base = base.rstrip("/")
-            self._token = token
-            self._session = session
+        __slots__ = ()
 
         def __getattr__(self, name: str) -> _ToolCallable:
             if name.startswith("_"):
                 raise AttributeError(name)
-            return _ToolCallable(self, name)
+            return _ToolCallable(name)
 
         def __getitem__(self, name: str) -> _ToolCallable:
-            return _ToolCallable(self, name)
+            return _ToolCallable(name)
 
         def __repr__(self) -> str:
-            return f"<tool proxy session={self._session}>"
+            session = os.environ.get("PI_TOOL_BRIDGE_SESSION")
+            return f"<tool proxy session={session}>" if session else "<tool proxy unavailable>"
 
-    if all(
-        _k in os.environ
-        for _k in ("PI_TOOL_BRIDGE_URL", "PI_TOOL_BRIDGE_TOKEN", "PI_TOOL_BRIDGE_SESSION")
-    ):
-        tool = _ToolProxy(
-            os.environ["PI_TOOL_BRIDGE_URL"],
-            os.environ["PI_TOOL_BRIDGE_TOKEN"],
-            os.environ["PI_TOOL_BRIDGE_SESSION"],
-        )
+    tool = _ToolProxy()