pi-usereq 0.49.0 → 0.50.0

package/pi.dev-src/pi-mono/coding-agent/test/agent-session-dynamic-provider.test.ts

@@ -1,117 +0,0 @@
-import { existsSync, mkdirSync, 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 { AuthStorage } from "../src/core/auth-storage.js";
-import { DefaultResourceLoader } from "../src/core/resource-loader.js";
-import type { ExtensionFactory } from "../src/core/sdk.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("AgentSession dynamic provider registration", () => {
-	let tempDir: string;
-	let agentDir: string;
-
-	beforeEach(() => {
-		tempDir = join(tmpdir(), `pi-dynamic-provider-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-		agentDir = join(tempDir, "agent");
-		mkdirSync(agentDir, { recursive: true });
-	});
-
-	afterEach(() => {
-		if (tempDir && existsSync(tempDir)) {
-			rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	async function createSession(extensionFactories: ExtensionFactory[]) {
-		const settingsManager = SettingsManager.create(tempDir, agentDir);
-		const sessionManager = SessionManager.inMemory();
-		const authStorage = AuthStorage.create(join(agentDir, "auth.json"));
-		authStorage.setRuntimeApiKey("anthropic", "test-key");
-		const resourceLoader = new DefaultResourceLoader({
-			cwd: tempDir,
-			agentDir,
-			settingsManager,
-			extensionFactories,
-		});
-		await resourceLoader.reload();
-
-		const { session } = await createAgentSession({
-			cwd: tempDir,
-			agentDir,
-			model: getModel("anthropic", "claude-sonnet-4-5")!,
-			settingsManager,
-			sessionManager,
-			authStorage,
-			resourceLoader,
-		});
-
-		return session;
-	}
-
-	async function capturePromptBaseUrl(
-		session: Awaited<ReturnType<typeof createSession>>,
-	): Promise<string | undefined> {
-		let baseUrl: string | undefined;
-		session.agent.streamFn = async (model) => {
-			baseUrl = model.baseUrl;
-			throw new Error("stop");
-		};
-		await session.prompt("hello");
-		return baseUrl;
-	}
-
-	it("applies top-level registerProvider overrides to the active model", async () => {
-		const session = await createSession([
-			(pi) => {
-				pi.registerProvider("anthropic", { baseUrl: "http://localhost:8080/top-level" });
-			},
-		]);
-
-		expect(session.model?.baseUrl).toBe("http://localhost:8080/top-level");
-		expect(await capturePromptBaseUrl(session)).toBe("http://localhost:8080/top-level");
-
-		session.dispose();
-	});
-
-	it("applies session_start registerProvider overrides to the active model", async () => {
-		const session = await createSession([
-			(pi) => {
-				pi.on("session_start", () => {
-					pi.registerProvider("anthropic", { baseUrl: "http://localhost:8080/session-start" });
-				});
-			},
-		]);
-
-		await session.bindExtensions({});
-
-		expect(session.model?.baseUrl).toBe("http://localhost:8080/session-start");
-		expect(await capturePromptBaseUrl(session)).toBe("http://localhost:8080/session-start");
-
-		session.dispose();
-	});
-
-	it("applies command-time registerProvider overrides without reload", async () => {
-		const session = await createSession([
-			(pi) => {
-				pi.registerCommand("use-proxy", {
-					description: "Use proxy",
-					handler: async () => {
-						pi.registerProvider("anthropic", { baseUrl: "http://localhost:8080/command" });
-					},
-				});
-			},
-		]);
-
-		await session.bindExtensions({});
-		await session.prompt("/use-proxy");
-
-		expect(session.model?.baseUrl).toBe("http://localhost:8080/command");
-		expect(await capturePromptBaseUrl(session)).toBe("http://localhost:8080/command");
-
-		session.dispose();
-	});
-});

package/pi.dev-src/pi-mono/coding-agent/test/agent-session-dynamic-tools.test.ts

@@ -1,182 +0,0 @@
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { getModel } from "@mariozechner/pi-ai";
-import { Type } from "typebox";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { DefaultResourceLoader } 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";
-
-describe("AgentSession dynamic tool registration", () => {
-	let tempDir: string;
-	let agentDir: string;
-
-	beforeEach(() => {
-		tempDir = join(tmpdir(), `pi-dynamic-tool-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-		agentDir = join(tempDir, "agent");
-		mkdirSync(agentDir, { recursive: true });
-	});
-
-	afterEach(() => {
-		if (tempDir && existsSync(tempDir)) {
-			rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it("refreshes tool registry when tools are registered after initialization", async () => {
-		const settingsManager = SettingsManager.create(tempDir, agentDir);
-		const sessionManager = SessionManager.inMemory();
-
-		const resourceLoader = new DefaultResourceLoader({
-			cwd: tempDir,
-			agentDir,
-			settingsManager,
-			extensionFactories: [
-				(pi) => {
-					pi.on("session_start", () => {
-						pi.registerTool({
-							name: "dynamic_tool",
-							label: "Dynamic Tool",
-							description: "Tool registered from session_start",
-							promptSnippet: "Run dynamic test behavior",
-							promptGuidelines: ["Use dynamic_tool when the user asks for dynamic behavior tests."],
-							parameters: Type.Object({}),
-							execute: async () => ({
-								content: [{ type: "text", text: "ok" }],
-								details: {},
-							}),
-						});
-					});
-				},
-			],
-		});
-		await resourceLoader.reload();
-
-		const { session } = await createAgentSession({
-			cwd: tempDir,
-			agentDir,
-			model: getModel("anthropic", "claude-sonnet-4-5")!,
-			settingsManager,
-			sessionManager,
-			resourceLoader,
-		});
-
-		expect(session.getAllTools().map((tool) => tool.name)).not.toContain("dynamic_tool");
-
-		await session.bindExtensions({});
-
-		const allTools = session.getAllTools();
-		const dynamicTool = allTools.find((tool) => tool.name === "dynamic_tool");
-		const readTool = allTools.find((tool) => tool.name === "read");
-
-		expect(allTools.map((tool) => tool.name)).toContain("dynamic_tool");
-		expect(dynamicTool?.sourceInfo).toMatchObject({
-			path: "<inline:1>",
-			source: "inline",
-			scope: "temporary",
-			origin: "top-level",
-		});
-		expect(readTool?.sourceInfo).toMatchObject({
-			path: "<builtin:read>",
-			source: "builtin",
-			scope: "temporary",
-			origin: "top-level",
-		});
-		expect(session.getActiveToolNames()).toContain("dynamic_tool");
-		expect(session.systemPrompt).toContain("- dynamic_tool: Run dynamic test behavior");
-		expect(session.systemPrompt).toContain("- Use dynamic_tool when the user asks for dynamic behavior tests.");
-
-		session.dispose();
-	});
-
-	it("returns source metadata for SDK custom tools", async () => {
-		const settingsManager = SettingsManager.create(tempDir, agentDir);
-		const sessionManager = SessionManager.inMemory();
-		const resourceLoader = new DefaultResourceLoader({
-			cwd: tempDir,
-			agentDir,
-			settingsManager,
-		});
-		await resourceLoader.reload();
-
-		const { session } = await createAgentSession({
-			cwd: tempDir,
-			agentDir,
-			model: getModel("anthropic", "claude-sonnet-4-5")!,
-			settingsManager,
-			sessionManager,
-			resourceLoader,
-			customTools: [
-				{
-					name: "sdk_tool",
-					label: "SDK Tool",
-					description: "Tool registered through createAgentSession",
-					parameters: Type.Object({}),
-					execute: async () => ({
-						content: [{ type: "text", text: "ok" }],
-						details: {},
-					}),
-				},
-			],
-		});
-
-		const sdkTool = session.getAllTools().find((tool) => tool.name === "sdk_tool");
-		expect(sdkTool?.sourceInfo).toMatchObject({
-			path: "<sdk:sdk_tool>",
-			source: "sdk",
-			scope: "temporary",
-			origin: "top-level",
-		});
-		expect(session.getActiveToolNames()).toContain("sdk_tool");
-
-		session.dispose();
-	});
-
-	it("keeps custom tools active but omits them from available tools when promptSnippet is not provided", async () => {
-		const settingsManager = SettingsManager.create(tempDir, agentDir);
-		const sessionManager = SessionManager.inMemory();
-
-		const resourceLoader = new DefaultResourceLoader({
-			cwd: tempDir,
-			agentDir,
-			settingsManager,
-			extensionFactories: [
-				(pi) => {
-					pi.on("session_start", () => {
-						pi.registerTool({
-							name: "hidden_tool",
-							label: "Hidden Tool",
-							description: "Description should not appear in available tools",
-							parameters: Type.Object({}),
-							execute: async () => ({
-								content: [{ type: "text", text: "ok" }],
-								details: {},
-							}),
-						});
-					});
-				},
-			],
-		});
-		await resourceLoader.reload();
-
-		const { session } = await createAgentSession({
-			cwd: tempDir,
-			agentDir,
-			model: getModel("anthropic", "claude-sonnet-4-5")!,
-			settingsManager,
-			sessionManager,
-			resourceLoader,
-		});
-
-		await session.bindExtensions({});
-
-		expect(session.getAllTools().map((tool) => tool.name)).toContain("hidden_tool");
-		expect(session.getActiveToolNames()).toContain("hidden_tool");
-		expect(session.systemPrompt).not.toContain("hidden_tool");
-		expect(session.systemPrompt).not.toContain("Description should not appear in available tools");
-
-		session.dispose();
-	});
-});

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

@@ -1,318 +0,0 @@
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { Agent, type AgentEvent, type AgentTool } from "@mariozechner/pi-agent-core";
-import { type AssistantMessage, type AssistantMessageEvent, EventStream, getModel } from "@mariozechner/pi-ai";
-import { Type } from "typebox";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { AgentSession } from "../src/core/agent-session.js";
-import { AuthStorage } from "../src/core/auth-storage.js";
-import { ModelRegistry } from "../src/core/model-registry.js";
-import { SessionManager } from "../src/core/session-manager.js";
-import { SettingsManager } from "../src/core/settings-manager.js";
-import { createTestResourceLoader } from "./utilities.js";
-
-class MockAssistantStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
-	constructor() {
-		super(
-			(event) => event.type === "done" || event.type === "error",
-			(event) => {
-				if (event.type === "done") return event.message;
-				if (event.type === "error") return event.error;
-				throw new Error("Unexpected event type");
-			},
-		);
-	}
-}
-
-function createAssistantMessage(text: string, overrides?: Partial<AssistantMessage>): AssistantMessage {
-	return {
-		role: "assistant",
-		content: [{ type: "text", text }],
-		api: "anthropic-messages",
-		provider: "anthropic",
-		model: "mock",
-		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(),
-		...overrides,
-	};
-}
-
-type SessionWithExtensionEmitHook = {
-	_emitExtensionEvent: (event: AgentEvent) => Promise<void>;
-};
-
-describe("AgentSession retry", () => {
-	let session: AgentSession;
-	let tempDir: string;
-
-	beforeEach(() => {
-		tempDir = join(tmpdir(), `pi-retry-test-${Date.now()}`);
-		mkdirSync(tempDir, { recursive: true });
-	});
-
-	afterEach(() => {
-		if (session) {
-			session.dispose();
-		}
-		if (tempDir && existsSync(tempDir)) {
-			rmSync(tempDir, { recursive: true });
-		}
-	});
-
-	function createSession(options?: { failCount?: number; maxRetries?: number; delayAssistantMessageEndMs?: number }) {
-		const failCount = options?.failCount ?? 1;
-		const maxRetries = options?.maxRetries ?? 3;
-		const delayAssistantMessageEndMs = options?.delayAssistantMessageEndMs ?? 0;
-		let callCount = 0;
-
-		const model = getModel("anthropic", "claude-sonnet-4-5")!;
-		const agent = new Agent({
-			getApiKey: () => "test-key",
-			initialState: { model, systemPrompt: "Test", tools: [] },
-			streamFn: () => {
-				callCount++;
-				const stream = new MockAssistantStream();
-				queueMicrotask(() => {
-					if (callCount <= failCount) {
-						const msg = createAssistantMessage("", {
-							stopReason: "error",
-							errorMessage: "overloaded_error",
-						});
-						stream.push({ type: "start", partial: msg });
-						stream.push({ type: "error", reason: "error", error: msg });
-					} else {
-						const msg = createAssistantMessage("Success");
-						stream.push({ type: "start", partial: msg });
-						stream.push({ type: "done", reason: "stop", message: msg });
-					}
-				});
-				return stream;
-			},
-		});
-
-		const sessionManager = SessionManager.inMemory();
-		const settingsManager = SettingsManager.create(tempDir, tempDir);
-		const authStorage = AuthStorage.create(join(tempDir, "auth.json"));
-		const modelRegistry = ModelRegistry.create(authStorage, tempDir);
-		authStorage.setRuntimeApiKey("anthropic", "test-key");
-		settingsManager.applyOverrides({ retry: { enabled: true, maxRetries, baseDelayMs: 1 } });
-
-		session = new AgentSession({
-			agent,
-			sessionManager,
-			settingsManager,
-			cwd: tempDir,
-			modelRegistry,
-			resourceLoader: createTestResourceLoader(),
-		});
-
-		if (delayAssistantMessageEndMs > 0) {
-			const sessionWithHook = session as unknown as SessionWithExtensionEmitHook;
-			const original = sessionWithHook._emitExtensionEvent.bind(sessionWithHook);
-			sessionWithHook._emitExtensionEvent = async (event: AgentEvent) => {
-				if (event.type === "message_end" && event.message.role === "assistant") {
-					await new Promise((resolve) => setTimeout(resolve, delayAssistantMessageEndMs));
-				}
-				await original(event);
-			};
-		}
-
-		return { session, getCallCount: () => callCount };
-	}
-
-	it("retries after a transient error and succeeds", async () => {
-		const created = createSession({ failCount: 1 });
-		const events: string[] = [];
-		created.session.subscribe((event) => {
-			if (event.type === "auto_retry_start") events.push(`start:${event.attempt}`);
-			if (event.type === "auto_retry_end") events.push(`end:success=${event.success}`);
-		});
-
-		await created.session.prompt("Test");
-
-		expect(created.getCallCount()).toBe(2);
-		expect(events).toEqual(["start:1", "end:success=true"]);
-		expect(created.session.isRetrying).toBe(false);
-	});
-
-	it("exhausts max retries and emits failure", async () => {
-		const created = createSession({ failCount: 99, maxRetries: 2 });
-		const events: string[] = [];
-		created.session.subscribe((event) => {
-			if (event.type === "auto_retry_start") events.push(`start:${event.attempt}`);
-			if (event.type === "auto_retry_end") events.push(`end:success=${event.success}`);
-		});
-
-		await created.session.prompt("Test");
-
-		expect(created.getCallCount()).toBe(3);
-		expect(events).toContain("start:1");
-		expect(events).toContain("start:2");
-		expect(events).toContain("end:success=false");
-		expect(created.session.isRetrying).toBe(false);
-	});
-
-	it("prompt waits for retry completion even when assistant message_end handling is delayed", async () => {
-		const created = createSession({ failCount: 1, delayAssistantMessageEndMs: 40 });
-
-		await created.session.prompt("Test");
-
-		expect(created.getCallCount()).toBe(2);
-		expect(created.session.isRetrying).toBe(false);
-	});
-
-	it("retries provider network_error failures", async () => {
-		const created = createSession({ failCount: 0 });
-		let callCount = 0;
-		const streamFn = () => {
-			callCount++;
-			const stream = new MockAssistantStream();
-			queueMicrotask(() => {
-				if (callCount === 1) {
-					const msg = createAssistantMessage("", {
-						stopReason: "error",
-						errorMessage: "Provider finish_reason: network_error",
-					});
-					stream.push({ type: "start", partial: msg });
-					stream.push({ type: "error", reason: "error", error: msg });
-					return;
-				}
-
-				const msg = createAssistantMessage("Recovered after retry");
-				stream.push({ type: "start", partial: msg });
-				stream.push({ type: "done", reason: "stop", message: msg });
-			});
-			return stream;
-		};
-		created.session.dispose();
-
-		const model = getModel("anthropic", "claude-sonnet-4-5")!;
-		const agent = new Agent({
-			getApiKey: () => "test-key",
-			initialState: { model, systemPrompt: "Test", tools: [] },
-			streamFn,
-		});
-		const sessionManager = SessionManager.inMemory();
-		const settingsManager = SettingsManager.create(tempDir, tempDir);
-		const authStorage = AuthStorage.create(join(tempDir, "auth.json"));
-		const modelRegistry = ModelRegistry.create(authStorage, tempDir);
-		authStorage.setRuntimeApiKey("anthropic", "test-key");
-		settingsManager.applyOverrides({ retry: { enabled: true, maxRetries: 3, baseDelayMs: 1 } });
-		session = new AgentSession({
-			agent,
-			sessionManager,
-			settingsManager,
-			cwd: tempDir,
-			modelRegistry,
-			resourceLoader: createTestResourceLoader(),
-		});
-
-		const events: string[] = [];
-		session.subscribe((event) => {
-			if (event.type === "auto_retry_start") events.push(`start:${event.attempt}`);
-			if (event.type === "auto_retry_end") events.push(`end:success=${event.success}`);
-		});
-
-		await session.prompt("Test");
-
-		expect(callCount).toBe(2);
-		expect(events).toEqual(["start:1", "end:success=true"]);
-	});
-
-	it("prompt waits for full agent loop when retry produces tool calls", async () => {
-		// Regression: when auto-retry fires and the retry response includes tool_use,
-		// session.prompt() must wait for the entire tool loop to finish before returning.
-		// Previously, _resolveRetry() on the first successful message_end would unblock
-		// waitForRetry() while the agent was still executing tools.
-		let callCount = 0;
-		const toolExecuted = { value: false };
-
-		const echoTool: AgentTool = {
-			name: "echo",
-			label: "Echo",
-			description: "Echo text back",
-			parameters: Type.Object({ text: Type.String() }),
-			execute: async () => {
-				toolExecuted.value = true;
-				return { content: [{ type: "text", text: "echoed" }], details: undefined };
-			},
-		};
-
-		const model = getModel("anthropic", "claude-sonnet-4-5")!;
-		const agent = new Agent({
-			getApiKey: () => "test-key",
-			initialState: { model, systemPrompt: "Test", tools: [] },
-			streamFn: () => {
-				callCount++;
-				const stream = new MockAssistantStream();
-				queueMicrotask(() => {
-					if (callCount === 1) {
-						// First call: overloaded error
-						const msg = createAssistantMessage("", {
-							stopReason: "error",
-							errorMessage: "overloaded_error",
-						});
-						stream.push({ type: "start", partial: msg });
-						stream.push({ type: "error", reason: "error", error: msg });
-					} else if (callCount === 2) {
-						// Second call (retry): text + tool_use
-						const msg: AssistantMessage = {
-							...createAssistantMessage("Looking that up now."),
-							stopReason: "toolUse",
-							content: [
-								{ type: "text", text: "Looking that up now." },
-								{ type: "toolCall", id: "call_1", name: "echo", arguments: { text: "hello" } },
-							],
-						};
-						stream.push({ type: "start", partial: msg });
-						stream.push({ type: "done", reason: "toolUse", message: msg });
-					} else {
-						// Third call (after tool result): final response
-						const msg = createAssistantMessage("Final answer.");
-						stream.push({ type: "start", partial: msg });
-						stream.push({ type: "done", reason: "stop", message: msg });
-					}
-				});
-				return stream;
-			},
-		});
-
-		const sessionManager = SessionManager.inMemory();
-		const settingsManager = SettingsManager.create(tempDir, tempDir);
-		const authStorage = AuthStorage.create(join(tempDir, "auth.json"));
-		const modelRegistry = ModelRegistry.create(authStorage, tempDir);
-		authStorage.setRuntimeApiKey("anthropic", "test-key");
-		settingsManager.applyOverrides({ retry: { enabled: true, maxRetries: 3, baseDelayMs: 1 } });
-
-		session = new AgentSession({
-			agent,
-			sessionManager,
-			settingsManager,
-			cwd: tempDir,
-			modelRegistry,
-			resourceLoader: createTestResourceLoader(),
-			baseToolsOverride: { echo: echoTool },
-		});
-
-		await session.prompt("Test");
-
-		// All three LLM calls must have completed
-		expect(callCount).toBe(3);
-		// Tool must have been executed
-		expect(toolExecuted.value).toBe(true);
-		// Agent must not be streaming after prompt returns
-		expect(session.isStreaming).toBe(false);
-		// A follow-up prompt must work (no "Agent is already processing" error)
-		await session.prompt("Follow-up");
-		expect(callCount).toBe(4);
-	});
-});