pi-usereq 0.48.0 → 0.50.0

package/pi.dev-src/pi-mono/coding-agent/test/sdk-codex-cache-probe-tool-loop.ts

@@ -1,364 +0,0 @@
-#!/usr/bin/env tsx
-/**
- * Manual SDK probe for OpenAI Codex prompt caching through the tool loop.
- *
- * Runs append-only multi-turn prompting through createAgentSession(), forcing one
- * deterministic custom tool call per top-level user turn. Logs per-subrequest
- * assistant usage so cache-read monotonicity can be inspected inside a tool loop.
- */
-
-import { mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import process from "node:process";
-import { type AssistantMessage, getModel, Type } from "@mariozechner/pi-ai";
-import { AuthStorage } from "../src/core/auth-storage.js";
-import { createExtensionRuntime } from "../src/core/extensions/loader.js";
-import type { ToolDefinition } from "../src/core/extensions/types.js";
-import { ModelRegistry } from "../src/core/model-registry.js";
-import type { ResourceLoader } from "../src/core/resource-loader.js";
-import { createAgentSession } from "../src/core/sdk.js";
-import { SessionManager } from "../src/core/session-manager.js";
-import { SettingsManager } from "../src/core/settings-manager.js";
-
-type Transport = "sse" | "websocket" | "auto";
-
-interface Args {
-	turns: number;
-	sessionPath: string;
-	transport: Transport;
-	maxTokens: number;
-}
-
-interface SubrequestRecord {
-	turn: number;
-	subrequest: number;
-	elapsedMs: number;
-	usage: AssistantMessage["usage"];
-	stopReason: AssistantMessage["stopReason"];
-	text: string;
-}
-
-const DEFAULT_TURNS = 20;
-const MIN_TURNS = 20;
-const MAX_TURNS = 50;
-const DEFAULT_MAX_TOKENS = 64;
-
-function parseArgs(argv: string[]): Args {
-	let turns = DEFAULT_TURNS;
-	let sessionPath = resolve(join(tmpdir(), `pi-sdk-codex-cache-probe-tool-loop-${Date.now()}.jsonl`));
-	let transport: Transport = "sse";
-	let maxTokens = DEFAULT_MAX_TOKENS;
-
-	for (let i = 0; i < argv.length; i++) {
-		const arg = argv[i];
-		switch (arg) {
-			case "--turns": {
-				const value = argv[++i];
-				if (!value) throw new Error("Missing value for --turns");
-				turns = Number.parseInt(value, 10);
-				break;
-			}
-			case "--session": {
-				const value = argv[++i];
-				if (!value) throw new Error("Missing value for --session");
-				sessionPath = resolve(value);
-				break;
-			}
-			case "--transport": {
-				const value = argv[++i];
-				if (value !== "sse" && value !== "websocket" && value !== "auto") {
-					throw new Error(`Invalid --transport value: ${value}`);
-				}
-				transport = value;
-				break;
-			}
-			case "--max-tokens": {
-				const value = argv[++i];
-				if (!value) throw new Error("Missing value for --max-tokens");
-				maxTokens = Number.parseInt(value, 10);
-				break;
-			}
-			case "--help": {
-				printHelp();
-				process.exit(0);
-				return { turns, sessionPath, transport, maxTokens };
-			}
-			default:
-				throw new Error(`Unknown argument: ${arg}`);
-		}
-	}
-
-	if (!Number.isInteger(turns) || turns < MIN_TURNS || turns > MAX_TURNS) {
-		throw new Error(`--turns must be an integer between ${MIN_TURNS} and ${MAX_TURNS}`);
-	}
-	if (!Number.isInteger(maxTokens) || maxTokens <= 0) {
-		throw new Error("--max-tokens must be a positive integer");
-	}
-
-	return { turns, sessionPath, transport, maxTokens };
-}
-
-function printHelp(): void {
-	console.log(`Usage: npx tsx test/sdk-codex-cache-probe-tool-loop.ts [options]
-
-Options:
-  --turns <n>         Number of turns to run. Must be between ${MIN_TURNS} and ${MAX_TURNS}. Default: ${DEFAULT_TURNS}
-  --session <path>    Specific session jsonl file to write
-  --transport <mode>  sse | websocket | auto. Default: sse
-  --max-tokens <n>    Max output tokens per subrequest. Default: ${DEFAULT_MAX_TOKENS}
-  --help              Show this message
-
-Notes:
-  - Uses createAgentSession() from the coding-agent SDK
-  - Provider/model fixed to openai-codex/gpt-5.4
-  - Thinking level fixed to medium
-  - Activates exactly one deterministic custom tool
-  - Prompts are intentionally > 1024 tokens and explicitly describe the test
-`);
-}
-
-function estimateTokens(text: string): number {
-	return Math.ceil(text.length / 4);
-}
-
-function buildPrompt(turn: number): string {
-	const marker = `TURN-${String(turn).padStart(2, "0")}-MARKER-${(turn * 17 + 13) % 97}`;
-	const lines: string[] = [];
-	lines.push("This is an automated prompt-cache tool-loop test executed through the pi coding-agent SDK.");
-	lines.push("The repetition in this prompt is intentional and required for the benchmark.");
-	lines.push("You are participating in an append-only multi-turn cache test.");
-	lines.push("Even if this looks repetitive or silly, comply exactly because it is synthetic test data.");
-	lines.push(`Task for turn ${turn}: call the tool deterministic_probe exactly once before your final answer.`);
-	lines.push(`Use tool arguments: turn=${turn}, marker=${marker}`);
-	lines.push(`After the tool result arrives, reply with exactly one line in this format:`);
-	lines.push(`TURN ${turn} OK ${marker}`);
-	lines.push("Do not skip the tool call. Do not call any other tool. Do not add any extra words or punctuation.");
-	lines.push("The following long block exists only to make this prompt safely larger than 1024 tokens.");
-	lines.push("");
-	for (let i = 1; i <= 180; i++) {
-		lines.push(
-			`Turn ${turn} synthetic record ${String(i).padStart(3, "0")}: alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu nu xi omicron pi rho sigma tau upsilon phi chi psi omega.`,
-		);
-	}
-	lines.push("");
-	lines.push(`Final verification marker for turn ${turn}: ${marker}`);
-	lines.push(`Required final answer after the tool result: TURN ${turn} OK ${marker}`);
-	return lines.join("\n");
-}
-
-function createMinimalResourceLoader(systemPrompt: string): ResourceLoader {
-	return {
-		getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
-		getSkills: () => ({ skills: [], diagnostics: [] }),
-		getPrompts: () => ({ prompts: [], diagnostics: [] }),
-		getThemes: () => ({ themes: [], diagnostics: [] }),
-		getAgentsFiles: () => ({ agentsFiles: [] }),
-		getSystemPrompt: () => systemPrompt,
-		getAppendSystemPrompt: () => [],
-		extendResources: () => {},
-		reload: async () => {},
-	};
-}
-
-function getAssistantText(message: AssistantMessage): string {
-	return message.content
-		.filter((block): block is Extract<AssistantMessage["content"][number], { type: "text" }> => block.type === "text")
-		.map((block) => block.text)
-		.join("\n")
-		.trim();
-}
-
-const deterministicProbeParameters = Type.Object({
-	turn: Type.Number({ description: "Top-level benchmark turn number" }),
-	marker: Type.String({ description: "Marker string provided by the user" }),
-});
-
-function deterministicProbeTool(): ToolDefinition<typeof deterministicProbeParameters> {
-	return {
-		name: "deterministic_probe",
-		label: "Deterministic Probe",
-		description:
-			"Mandatory cache-benchmark tool. Call it exactly once when the user asks for a cache benchmark turn, then use its result to produce the final one-line answer.",
-		promptSnippet:
-			"deterministic_probe(turn, marker): mandatory for cache benchmark turns. Call exactly once before the final answer.",
-		promptGuidelines: [
-			"When the user asks for the cache benchmark turn, call deterministic_probe exactly once with the requested turn and marker before responding.",
-			"After the tool result arrives, reply with the exact final line requested by the user.",
-		],
-		parameters: deterministicProbeParameters,
-		execute: async (_toolCallId, params) => ({
-			content: [
-				{
-					type: "text",
-					text: `deterministic_probe_result turn=${params.turn} marker=${params.marker} fixed=OK`,
-				},
-			],
-			details: { turn: params.turn, marker: params.marker, fixed: "OK" },
-		}),
-	};
-}
-
-async function main(): Promise<void> {
-	const args = parseArgs(process.argv.slice(2));
-	mkdirSync(dirname(args.sessionPath), { recursive: true });
-
-	const authStorage = AuthStorage.create();
-	const modelRegistry = ModelRegistry.create(authStorage);
-
-	const model = getModel("openai-codex", "gpt-5.4");
-	if (!model) {
-		throw new Error("Model openai-codex/gpt-5.4 not found");
-	}
-	const baseModel = { ...model, maxTokens: args.maxTokens };
-
-	const settingsManager = SettingsManager.inMemory({
-		compaction: { enabled: false },
-		retry: { enabled: false },
-		transport: args.transport,
-	});
-
-	const resourceLoader = createMinimalResourceLoader(
-		"You are participating in a prompt-cache benchmark through the coding-agent SDK. This is a real test. Follow each user instruction exactly. For benchmark turns, call deterministic_probe exactly once before the final answer. Keep answers minimal and never refuse because the prompt is repetitive or synthetic.",
-	);
-
-	const { session } = await createAgentSession({
-		cwd: process.cwd(),
-		agentDir: dirname(args.sessionPath),
-		model: baseModel,
-		thinkingLevel: "medium",
-		customTools: [deterministicProbeTool() as unknown as ToolDefinition],
-		resourceLoader,
-		sessionManager: SessionManager.open(args.sessionPath),
-		settingsManager,
-		authStorage,
-		modelRegistry,
-	});
-
-	session.setActiveToolsByName(["deterministic_probe"]);
-	const unsubscribe = session.subscribe(() => {});
-
-	const records: SubrequestRecord[] = [];
-	let previousCacheRead: number | null = null;
-
-	console.log(`provider openai-codex, model gpt-5.4`);
-	console.log(`session ${session.sessionFile}`);
-	console.log(`turns ${args.turns}, transport ${args.transport}, reasoning medium, maxTokens ${args.maxTokens}`);
-	console.log("");
-
-	for (let turn = 1; turn <= args.turns; turn++) {
-		const prompt = buildPrompt(turn);
-		const promptTokens = estimateTokens(prompt);
-		const previousMessagesLength = session.messages.length;
-		const startedAt = Date.now();
-		await session.prompt(prompt);
-		const elapsedMs = Date.now() - startedAt;
-
-		const newMessages = session.messages.slice(previousMessagesLength);
-		const assistantMessages = newMessages.filter((message): message is AssistantMessage =>
-			Boolean(message && typeof message === "object" && (message as { role?: unknown }).role === "assistant"),
-		);
-		const toolResults = newMessages.filter((message) =>
-			Boolean(message && typeof message === "object" && (message as { role?: unknown }).role === "toolResult"),
-		);
-
-		if (assistantMessages.length < 2 || toolResults.length < 1) {
-			throw new Error(
-				`Turn ${turn} did not execute the expected tool loop. assistants=${assistantMessages.length} toolResults=${toolResults.length}`,
-			);
-		}
-
-		let turnInput = 0;
-		let turnOutput = 0;
-		let turnCacheRead = 0;
-		let turnCacheWrite = 0;
-		let turnTotal = 0;
-
-		for (let i = 0; i < assistantMessages.length; i++) {
-			const assistant = assistantMessages[i];
-			const record: SubrequestRecord = {
-				turn,
-				subrequest: i + 1,
-				elapsedMs,
-				usage: assistant.usage,
-				stopReason: assistant.stopReason,
-				text: getAssistantText(assistant),
-			};
-			records.push(record);
-
-			turnInput += assistant.usage.input;
-			turnOutput += assistant.usage.output;
-			turnCacheRead += assistant.usage.cacheRead;
-			turnCacheWrite += assistant.usage.cacheWrite;
-			turnTotal += assistant.usage.totalTokens;
-
-			const monotonic =
-				previousCacheRead === null ? "n/a" : assistant.usage.cacheRead >= previousCacheRead ? "yes" : "NO";
-			console.log(
-				[
-					`turn ${String(turn).padStart(2, "0")}.${i + 1}`,
-					`elapsed ${(elapsedMs / 1000).toFixed(1)}s`,
-					`prompt~${promptTokens}`,
-					`stop ${assistant.stopReason}`,
-					`in ${assistant.usage.input}`,
-					`out ${assistant.usage.output}`,
-					`cache ${assistant.usage.cacheRead}/${assistant.usage.cacheWrite}`,
-					`total ${assistant.usage.totalTokens}`,
-					`cache>=prev ${monotonic}`,
-				].join(" | "),
-			);
-
-			if (assistant.stopReason === "error" || assistant.stopReason === "aborted") {
-				throw new Error(
-					`Turn ${turn}.${i + 1} ended with stopReason=${assistant.stopReason}: ${assistant.errorMessage || "unknown error"}`,
-				);
-			}
-			previousCacheRead = assistant.usage.cacheRead;
-		}
-
-		console.log(
-			[
-				`turn ${String(turn).padStart(2, "0")} agg`,
-				`assistants ${assistantMessages.length}`,
-				`toolResults ${toolResults.length}`,
-				`in ${turnInput}`,
-				`out ${turnOutput}`,
-				`cache ${turnCacheRead}/${turnCacheWrite}`,
-				`total ${turnTotal}`,
-			].join(" | "),
-		);
-	}
-
-	const violations = records
-		.map((record, index) => {
-			if (index === 0) return null;
-			const previous = records[index - 1];
-			if (record.usage.cacheRead >= previous.usage.cacheRead) return null;
-			return {
-				turn: record.turn,
-				subrequest: record.subrequest,
-				previous: previous.usage.cacheRead,
-				current: record.usage.cacheRead,
-			};
-		})
-		.filter((value): value is NonNullable<typeof value> => value !== null);
-
-	console.log("");
-	console.log(`subrequest cache read monotonic: ${violations.length === 0 ? "yes" : "NO"}`);
-	if (violations.length > 0) {
-		console.log("violations:");
-		for (const violation of violations) {
-			console.log(`  turn ${violation.turn}.${violation.subrequest}: ${violation.previous} -> ${violation.current}`);
-		}
-	}
-	console.log(`session file: ${session.sessionFile}`);
-
-	unsubscribe();
-	session.dispose();
-}
-
-main().catch((error: unknown) => {
-	const message = error instanceof Error ? error.message : String(error);
-	console.error(message);
-	process.exitCode = 1;
-});

package/pi.dev-src/pi-mono/coding-agent/test/sdk-openrouter-attribution.test.ts

@@ -1,181 +0,0 @@
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-	type Api,
-	type AssistantMessage,
-	createAssistantMessageEventStream,
-	type Model,
-	type SimpleStreamOptions,
-} from "@mariozechner/pi-ai";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { AuthStorage } from "../src/core/auth-storage.js";
-import { ModelRegistry } from "../src/core/model-registry.js";
-import { createAgentSession } from "../src/core/sdk.js";
-import { SessionManager } from "../src/core/session-manager.js";
-import { SettingsManager } from "../src/core/settings-manager.js";
-
-describe("createAgentSession OpenRouter attribution headers", () => {
-	let tempDir: string;
-	let cwd: string;
-	let agentDir: string;
-	let originalTelemetryEnv: string | undefined;
-
-	beforeEach(() => {
-		tempDir = join(tmpdir(), `pi-sdk-openrouter-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-		cwd = join(tempDir, "project");
-		agentDir = join(tempDir, "agent");
-		mkdirSync(cwd, { recursive: true });
-		mkdirSync(agentDir, { recursive: true });
-		originalTelemetryEnv = process.env.PI_TELEMETRY;
-		delete process.env.PI_TELEMETRY;
-	});
-
-	afterEach(() => {
-		if (originalTelemetryEnv === undefined) {
-			delete process.env.PI_TELEMETRY;
-		} else {
-			process.env.PI_TELEMETRY = originalTelemetryEnv;
-		}
-		if (tempDir && existsSync(tempDir)) {
-			rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	function createModel(provider: string, baseUrl: string): Model<Api> {
-		return {
-			id: `${provider}-test-model`,
-			name: `${provider} Test Model`,
-			api: "openai-completions",
-			provider,
-			baseUrl,
-			reasoning: false,
-			input: ["text"],
-			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-			contextWindow: 128000,
-			maxTokens: 4096,
-		};
-	}
-
-	function createDoneStream() {
-		const stream = createAssistantMessageEventStream();
-		const message: AssistantMessage = {
-			role: "assistant",
-			content: [{ type: "text", text: "ok" }],
-			api: "openai-completions",
-			provider: "capture-provider",
-			model: "capture-model",
-			usage: {
-				input: 0,
-				output: 0,
-				cacheRead: 0,
-				cacheWrite: 0,
-				totalTokens: 0,
-				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-			},
-			stopReason: "stop",
-			timestamp: Date.now(),
-		};
-		stream.end(message);
-		return stream;
-	}
-
-	async function captureHeaders(
-		model: Model<Api>,
-		options: {
-			telemetryEnabled?: boolean;
-			providerHeaders?: Record<string, string>;
-			requestHeaders?: Record<string, string>;
-		} = {},
-	): Promise<Record<string, string> | undefined> {
-		const settingsManager = SettingsManager.create(cwd, agentDir);
-		if (options.telemetryEnabled === false) {
-			settingsManager.setEnableInstallTelemetry(false);
-		}
-
-		const authStorage = AuthStorage.create(join(agentDir, "auth.json"));
-		authStorage.setRuntimeApiKey(model.provider, "test-api-key");
-		const modelRegistry = ModelRegistry.create(authStorage, join(agentDir, "models.json"));
-		const registeredProviders = ["capture-provider"];
-		let capturedOptions: SimpleStreamOptions | undefined;
-
-		modelRegistry.registerProvider("capture-provider", {
-			api: "openai-completions",
-			streamSimple: (_model, _context, providerOptions) => {
-				capturedOptions = providerOptions;
-				return createDoneStream();
-			},
-		});
-
-		if (options.providerHeaders) {
-			modelRegistry.registerProvider(model.provider, { headers: options.providerHeaders });
-			registeredProviders.push(model.provider);
-		}
-
-		const { session } = await createAgentSession({
-			cwd,
-			agentDir,
-			model,
-			authStorage,
-			modelRegistry,
-			settingsManager,
-			sessionManager: SessionManager.inMemory(cwd),
-		});
-
-		try {
-			await session.agent.streamFn(
-				model,
-				{ messages: [] },
-				options.requestHeaders ? { headers: options.requestHeaders } : undefined,
-			);
-			return capturedOptions?.headers;
-		} finally {
-			session.dispose();
-			for (const provider of registeredProviders.reverse()) {
-				modelRegistry.unregisterProvider(provider);
-			}
-		}
-	}
-
-	it("adds default attribution headers for OpenRouter models", async () => {
-		const headers = await captureHeaders(createModel("openrouter", "https://openrouter.ai/api/v1"));
-
-		expect(headers?.["HTTP-Referer"]).toBe("https://pi.dev");
-		expect(headers?.["X-OpenRouter-Title"]).toBe("pi");
-		expect(headers?.["X-OpenRouter-Categories"]).toBe("cli-agent");
-	});
-
-	it("does not add attribution headers when telemetry is disabled", async () => {
-		const headers = await captureHeaders(createModel("openrouter", "https://openrouter.ai/api/v1"), {
-			telemetryEnabled: false,
-		});
-
-		expect(headers?.["HTTP-Referer"]).toBeUndefined();
-		expect(headers?.["X-OpenRouter-Title"]).toBeUndefined();
-		expect(headers?.["X-OpenRouter-Categories"]).toBeUndefined();
-	});
-
-	it("adds attribution headers for custom providers routed through OpenRouter", async () => {
-		const headers = await captureHeaders(createModel("custom-openrouter", "https://openrouter.ai/api/v1"));
-
-		expect(headers?.["HTTP-Referer"]).toBe("https://pi.dev");
-		expect(headers?.["X-OpenRouter-Title"]).toBe("pi");
-		expect(headers?.["X-OpenRouter-Categories"]).toBe("cli-agent");
-	});
-
-	it("lets provider and request headers override the defaults", async () => {
-		const headers = await captureHeaders(createModel("openrouter", "https://openrouter.ai/api/v1"), {
-			providerHeaders: {
-				"HTTP-Referer": "https://provider.example",
-				"X-OpenRouter-Categories": "provider-category",
-			},
-			requestHeaders: {
-				"X-OpenRouter-Title": "request-title",
-			},
-		});
-
-		expect(headers?.["HTTP-Referer"]).toBe("https://provider.example");
-		expect(headers?.["X-OpenRouter-Title"]).toBe("request-title");
-		expect(headers?.["X-OpenRouter-Categories"]).toBe("provider-category");
-	});
-});

package/pi.dev-src/pi-mono/coding-agent/test/sdk-session-manager.test.ts

@@ -1,95 +0,0 @@
-import { existsSync, mkdirSync, realpathSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { getModel } from "@mariozechner/pi-ai";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { createAgentSession } from "../src/core/sdk.js";
-import { SessionManager } from "../src/core/session-manager.js";
-
-describe("createAgentSession session manager defaults", () => {
-	let tempDir: string;
-	let cwd: string;
-	let agentDir: string;
-
-	beforeEach(() => {
-		tempDir = join(tmpdir(), `pi-sdk-session-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-		cwd = join(tempDir, "project");
-		agentDir = join(tempDir, "agent");
-		mkdirSync(cwd, { recursive: true });
-		mkdirSync(agentDir, { recursive: true });
-	});
-
-	afterEach(() => {
-		if (tempDir && existsSync(tempDir)) {
-			rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it("uses agentDir for the default persisted session path", async () => {
-		const model = getModel("anthropic", "claude-sonnet-4-5");
-		expect(model).toBeTruthy();
-
-		const { session } = await createAgentSession({
-			cwd,
-			agentDir,
-			model: model!,
-		});
-
-		const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-		const expectedSessionDir = join(agentDir, "sessions", safePath);
-		const sessionDir = session.sessionManager.getSessionDir();
-		const sessionFile = session.sessionManager.getSessionFile();
-
-		expect(sessionDir).toBe(expectedSessionDir);
-		expect(sessionFile?.startsWith(`${expectedSessionDir}/`)).toBe(true);
-
-		session.dispose();
-	});
-
-	it("keeps an explicit sessionManager override", async () => {
-		const model = getModel("anthropic", "claude-sonnet-4-5");
-		expect(model).toBeTruthy();
-
-		const sessionManager = SessionManager.inMemory(cwd);
-		const { session } = await createAgentSession({
-			cwd,
-			agentDir,
-			model: model!,
-			sessionManager,
-		});
-
-		expect(session.sessionManager).toBe(sessionManager);
-		expect(session.sessionManager.isPersisted()).toBe(false);
-
-		session.dispose();
-	});
-
-	it("derives cwd from an explicit sessionManager when cwd is omitted", async () => {
-		const model = getModel("anthropic", "claude-sonnet-4-5");
-		expect(model).toBeTruthy();
-
-		const sessionCwd = join(tempDir, "session-project");
-		mkdirSync(sessionCwd, { recursive: true });
-		const sessionManager = SessionManager.inMemory(sessionCwd);
-		const { session } = await createAgentSession({
-			agentDir,
-			model: model!,
-			sessionManager,
-		});
-
-		expect(session.sessionManager).toBe(sessionManager);
-		expect(session.systemPrompt).toContain(`Current working directory: ${sessionCwd}`);
-
-		const bashTool = session.agent.state.tools.find((tool) => tool.name === "bash");
-		expect(bashTool).toBeTruthy();
-		const result = await bashTool!.execute("test", { command: "pwd" });
-		const output = result.content
-			.filter((item): item is { type: "text"; text: string } => item.type === "text")
-			.map((item) => item.text)
-			.join("");
-
-		expect(realpathSync(output.trim())).toBe(realpathSync(sessionCwd));
-
-		session.dispose();
-	});
-});