pi-usereq 0.49.0 → 0.51.0

package/pi.dev-src/pi-mono/coding-agent/test/suite/agent-session-model-extension.test.ts

@@ -1,325 +0,0 @@
-import type { AgentTool, ThinkingLevel } from "@mariozechner/pi-agent-core";
-import { fauxAssistantMessage, fauxToolCall, type Model } from "@mariozechner/pi-ai";
-import { Type } from "typebox";
-import { afterEach, describe, expect, it } from "vitest";
-import type { ExtensionAPI } from "../../src/index.js";
-import { createHarness, getAssistantTexts, type Harness } from "./harness.js";
-
-describe("AgentSession model and extension characterization", () => {
-	const harnesses: Harness[] = [];
-
-	afterEach(() => {
-		while (harnesses.length > 0) {
-			harnesses.pop()?.cleanup();
-		}
-	});
-
-	it("setModel saves the model and emits model_select", async () => {
-		const modelEvents: string[] = [];
-		const harness = await createHarness({
-			models: [
-				{ id: "faux-1", name: "One", reasoning: true },
-				{ id: "faux-2", name: "Two", reasoning: true },
-			],
-			extensionFactories: [
-				(pi) => {
-					pi.on("model_select", async (event) => {
-						modelEvents.push(`${event.previousModel?.id ?? "none"}->${event.model.id}:${event.source}`);
-					});
-				},
-			],
-		});
-		harnesses.push(harness);
-		const nextModel = harness.getModel("faux-2")!;
-
-		await harness.session.setModel(nextModel);
-
-		expect(harness.session.model?.id).toBe("faux-2");
-		expect(modelEvents).toEqual(["faux-1->faux-2:set"]);
-		expect(
-			harness.sessionManager
-				.getEntries()
-				.filter((entry) => entry.type === "model_change")
-				.map((entry) => `${entry.provider}/${entry.modelId}`),
-		).toEqual([`${nextModel.provider}/${nextModel.id}`]);
-	});
-
-	it("cycles through scoped models and preserves the scoped thinking preference", async () => {
-		const harness = await createHarness({
-			models: [
-				{ id: "faux-1", name: "One", reasoning: true },
-				{ id: "faux-2", name: "Two", reasoning: false },
-			],
-		});
-		harnesses.push(harness);
-		const modelOne = harness.getModel("faux-1")!;
-		const modelTwo = harness.getModel("faux-2")!;
-		harness.session.setScopedModels([{ model: modelOne, thinkingLevel: "high" }, { model: modelTwo }] as Array<{
-			model: Model<string>;
-			thinkingLevel?: ThinkingLevel;
-		}>);
-		harness.session.setThinkingLevel("high");
-
-		await harness.session.cycleModel();
-		expect(harness.session.model?.id).toBe("faux-2");
-		expect(harness.session.thinkingLevel).toBe("off");
-
-		await harness.session.cycleModel();
-		expect(harness.session.model?.id).toBe("faux-1");
-		expect(harness.session.thinkingLevel).toBe("high");
-	});
-
-	it("clamps thinking levels to model capabilities and cycles available levels", async () => {
-		const harness = await createHarness({ models: [{ id: "faux-1", reasoning: false }] });
-		harnesses.push(harness);
-
-		harness.session.setThinkingLevel("high");
-		expect(harness.session.thinkingLevel).toBe("off");
-		expect(harness.session.cycleThinkingLevel()).toBeUndefined();
-	});
-
-	it("throws when setModel is called without configured auth", async () => {
-		const harness = await createHarness({
-			models: [
-				{ id: "faux-1", name: "One", reasoning: true },
-				{ id: "faux-2", name: "Two", reasoning: true },
-			],
-			withConfiguredAuth: false,
-		});
-		harnesses.push(harness);
-
-		await expect(harness.session.setModel(harness.getModel("faux-2")!)).rejects.toThrow(
-			`No API key for ${harness.getModel().provider}/faux-2`,
-		);
-	});
-
-	it("allows extension tool_call handlers to block tool execution", async () => {
-		const echoTool: AgentTool = {
-			name: "echo",
-			label: "Echo",
-			description: "Echo text back",
-			parameters: Type.Object({ text: Type.String() }),
-			execute: async () => {
-				throw new Error("tool should have been blocked");
-			},
-		};
-		const harness = await createHarness({
-			tools: [echoTool],
-			extensionFactories: [
-				(pi) => {
-					pi.on("tool_call", async () => ({ block: true, reason: "Blocked by test" }));
-				},
-			],
-		});
-		harnesses.push(harness);
-		harness.setResponses([
-			fauxAssistantMessage([fauxToolCall("echo", { text: "hello" })], { stopReason: "toolUse" }),
-			(context) => {
-				const toolResult = context.messages.find((message) => message.role === "toolResult");
-				const errorText =
-					toolResult?.role === "toolResult"
-						? toolResult.content
-								.filter((part): part is { type: "text"; text: string } => part.type === "text")
-								.map((part) => part.text)
-								.join("\n")
-						: "";
-				return fauxAssistantMessage(errorText);
-			},
-		]);
-
-		await harness.session.prompt("hi");
-
-		expect(getAssistantTexts(harness)).toContain("Blocked by test");
-		expect(
-			harness.session.messages.find((message) => message.role === "toolResult" && message.isError),
-		).toBeDefined();
-	});
-
-	it("allows extension tool_result handlers to modify tool results", async () => {
-		const echoTool: AgentTool = {
-			name: "echo",
-			label: "Echo",
-			description: "Echo text back",
-			parameters: Type.Object({ text: Type.String() }),
-			execute: async (_toolCallId, params) => {
-				const text = typeof params === "object" && params !== null && "text" in params ? String(params.text) : "";
-				return { content: [{ type: "text", text }], details: { text } };
-			},
-		};
-		const harness = await createHarness({
-			tools: [echoTool],
-			extensionFactories: [
-				(pi) => {
-					pi.on("tool_result", async () => ({
-						content: [{ type: "text", text: "patched result" }],
-						details: { patched: true },
-					}));
-				},
-			],
-		});
-		harnesses.push(harness);
-		harness.setResponses([
-			fauxAssistantMessage([fauxToolCall("echo", { text: "hello" })], { stopReason: "toolUse" }),
-			(context) => {
-				const toolResult = context.messages.find((message) => message.role === "toolResult");
-				const text =
-					toolResult?.role === "toolResult"
-						? toolResult.content
-								.filter((part): part is { type: "text"; text: string } => part.type === "text")
-								.map((part) => part.text)
-								.join("\n")
-						: "";
-				return fauxAssistantMessage(text);
-			},
-		]);
-
-		await harness.session.prompt("hi");
-
-		expect(getAssistantTexts(harness)).toContain("patched result");
-		expect(
-			harness.session.messages.find((message) => message.role === "toolResult" && message.details?.patched === true),
-		).toBeDefined();
-	});
-
-	it("allows extension context handlers to modify messages before the LLM call", async () => {
-		const harness = await createHarness({
-			extensionFactories: [
-				(pi) => {
-					pi.on("context", async (event) => ({
-						messages: event.messages.map((message) =>
-							message.role === "user"
-								? { ...message, content: [{ type: "text", text: "rewritten" }], timestamp: message.timestamp }
-								: message,
-						),
-					}));
-				},
-			],
-		});
-		harnesses.push(harness);
-		let providerUserText = "";
-		harness.setResponses([
-			(context) => {
-				const user = context.messages.find((message) => message.role === "user");
-				providerUserText =
-					user && typeof user.content !== "string"
-						? user.content
-								.filter((part): part is { type: "text"; text: string } => part.type === "text")
-								.map((part) => part.text)
-								.join("\n")
-						: "";
-				return fauxAssistantMessage("done");
-			},
-		]);
-
-		await harness.session.prompt("original");
-
-		expect(providerUserText).toBe("rewritten");
-		const storedUserMessage = harness.session.messages.find((message) => message.role === "user");
-		expect(storedUserMessage?.role).toBe("user");
-		if (storedUserMessage?.role === "user") {
-			expect(storedUserMessage.content).toEqual([{ type: "text", text: "original" }]);
-		}
-	});
-
-	it("allows extension input handlers to transform or handle input", async () => {
-		let extensionApi: ExtensionAPI | undefined;
-		const transformedHarness = await createHarness({
-			extensionFactories: [
-				(pi) => {
-					extensionApi = pi;
-					pi.on("input", async (event) => {
-						if (event.text === "ping") {
-							return { action: "handled" };
-						}
-						return { action: "transform", text: `transformed:${event.text}` };
-					});
-				},
-			],
-		});
-		harnesses.push(transformedHarness);
-		let providerUserText = "";
-		transformedHarness.setResponses([
-			(context) => {
-				const user = context.messages.find((message) => message.role === "user");
-				providerUserText =
-					user && typeof user.content !== "string"
-						? user.content
-								.filter((part): part is { type: "text"; text: string } => part.type === "text")
-								.map((part) => part.text)
-								.join("\n")
-						: "";
-				return fauxAssistantMessage("done");
-			},
-		]);
-
-		await transformedHarness.session.prompt("hello");
-		await transformedHarness.session.prompt("ping");
-
-		expect(providerUserText).toBe("transformed:hello");
-		expect(transformedHarness.session.messages.filter((message) => message.role === "user")).toHaveLength(1);
-		expect(extensionApi).toBeDefined();
-	});
-
-	it("allows before_agent_start handlers to inject custom messages and modify the system prompt", async () => {
-		const harness = await createHarness({
-			extensionFactories: [
-				(pi) => {
-					pi.on("before_agent_start", async (event) => ({
-						message: {
-							customType: "before-start",
-							content: "injected",
-							display: true,
-							details: { injected: true },
-						},
-						systemPrompt: `${event.systemPrompt}\n\nextra instructions`,
-					}));
-				},
-			],
-		});
-		harnesses.push(harness);
-		let providerSystemPrompt = "";
-		let sawInjectedUserMessage = false;
-		harness.setResponses([
-			(context) => {
-				providerSystemPrompt = context.systemPrompt ?? "";
-				sawInjectedUserMessage = context.messages.some(
-					(message) =>
-						message.role === "user" &&
-						typeof message.content !== "string" &&
-						message.content.some((part) => part.type === "text" && part.text === "injected"),
-				);
-				return fauxAssistantMessage("done");
-			},
-		]);
-
-		await harness.session.prompt("hello");
-
-		expect(providerSystemPrompt).toContain("extra instructions");
-		expect(sawInjectedUserMessage).toBe(true);
-		expect(
-			harness.session.messages.some((message) => message.role === "custom" && message.customType === "before-start"),
-		).toBe(true);
-	});
-
-	it("bindExtensions emits session_start and reload emits session_shutdown then session_start", async () => {
-		const lifecycleEvents: string[] = [];
-		const harness = await createHarness({
-			extensionFactories: [
-				(pi) => {
-					pi.on("session_start", async (event) => {
-						lifecycleEvents.push(`start:${event.reason}`);
-					});
-					pi.on("session_shutdown", async (event) => {
-						lifecycleEvents.push(`shutdown:${event.reason}`);
-					});
-				},
-			],
-		});
-		harnesses.push(harness);
-
-		await harness.session.bindExtensions({ shutdownHandler: () => {} });
-		await harness.session.reload();
-
-		expect(lifecycleEvents).toEqual(["start:startup", "shutdown:reload", "start:reload"]);
-	});
-});

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

@@ -1,323 +0,0 @@
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import { fauxAssistantMessage, fauxToolCall, type Model } from "@mariozechner/pi-ai";
-import { Type } from "typebox";
-import { afterEach, describe, expect, it } from "vitest";
-import type { PromptTemplate } from "../../src/core/prompt-templates.js";
-import { createSyntheticSourceInfo } from "../../src/core/source-info.js";
-import { createTestResourceLoader } from "../utilities.js";
-import { createHarness, getMessageText, type Harness } from "./harness.js";
-
-describe("AgentSession prompt characterization", () => {
-	const harnesses: Harness[] = [];
-	const tempDirs: string[] = [];
-
-	afterEach(() => {
-		while (harnesses.length > 0) {
-			harnesses.pop()?.cleanup();
-		}
-		while (tempDirs.length > 0) {
-			const tempDir = tempDirs.pop();
-			if (tempDir) {
-				rmSync(tempDir, { recursive: true, force: true });
-			}
-		}
-	});
-
-	it("prompts while idle and records a single text response", async () => {
-		const harness = await createHarness();
-		harnesses.push(harness);
-
-		harness.setResponses([fauxAssistantMessage("hello")]);
-
-		await harness.session.prompt("hi");
-
-		expect(harness.session.messages.map((message) => message.role)).toEqual(["user", "assistant"]);
-		expect(getMessageText(harness.session.messages[0]!)).toBe("hi");
-		expect(harness.getPendingResponseCount()).toBe(0);
-	});
-
-	it("handles a tool call turn and waits for the follow-up LLM response", async () => {
-		const toolRuns: string[] = [];
-		const echoTool: AgentTool = {
-			name: "echo",
-			label: "Echo",
-			description: "Echo text back",
-			parameters: Type.Object({ text: Type.String() }),
-			execute: async (_toolCallId, params) => {
-				const text = typeof params === "object" && params !== null && "text" in params ? String(params.text) : "";
-				toolRuns.push(text);
-				return {
-					content: [{ type: "text", text: `echo:${text}` }],
-					details: { text },
-				};
-			},
-		};
-		const harness = await createHarness({ tools: [echoTool] });
-		harnesses.push(harness);
-
-		harness.setResponses([
-			fauxAssistantMessage(fauxToolCall("echo", { text: "hello" }), { stopReason: "toolUse" }),
-			fauxAssistantMessage("done"),
-		]);
-
-		await harness.session.prompt("start");
-
-		expect(toolRuns).toEqual(["hello"]);
-		expect(harness.session.messages.map((message) => message.role)).toEqual([
-			"user",
-			"assistant",
-			"toolResult",
-			"assistant",
-		]);
-		expect(harness.session.messages[2]?.role).toBe("toolResult");
-		expect(harness.session.messages[3]?.role).toBe("assistant");
-	});
-
-	it("executes multiple tool calls from one response and continues with a single follow-up response", async () => {
-		const toolRuns: string[] = [];
-		const makeTool = (name: string, delayMs: number): AgentTool => ({
-			name,
-			label: name,
-			description: `${name} tool`,
-			parameters: Type.Object({ value: Type.String() }),
-			execute: async (_toolCallId, params) => {
-				const value =
-					typeof params === "object" && params !== null && "value" in params ? String(params.value) : "";
-				await new Promise((resolve) => setTimeout(resolve, delayMs));
-				toolRuns.push(`${name}:${value}`);
-				return {
-					content: [{ type: "text", text: `${name}:${value}` }],
-					details: { value },
-				};
-			},
-		});
-		const harness = await createHarness({ tools: [makeTool("slow", 25), makeTool("fast", 0)] });
-		harnesses.push(harness);
-
-		harness.setResponses([
-			fauxAssistantMessage([fauxToolCall("slow", { value: "a" }), fauxToolCall("fast", { value: "b" })], {
-				stopReason: "toolUse",
-			}),
-			(context) => {
-				const toolResults = context.messages.filter((message) => message.role === "toolResult");
-				return fauxAssistantMessage(`tool results: ${toolResults.length}`);
-			},
-		]);
-
-		await harness.session.prompt("run tools");
-
-		expect(toolRuns.sort()).toEqual(["fast:b", "slow:a"]);
-		expect(harness.session.messages.filter((message) => message.role === "toolResult")).toHaveLength(2);
-		expect(harness.session.messages[harness.session.messages.length - 1]?.role).toBe("assistant");
-	});
-
-	it("preserves image attachments in the provider context", async () => {
-		const harness = await createHarness();
-		harnesses.push(harness);
-		let sawImage = false;
-
-		harness.setResponses([
-			(context) => {
-				const user = context.messages.find((message) => message.role === "user");
-				sawImage =
-					user?.role === "user" &&
-					typeof user.content !== "string" &&
-					user.content.some((part) => part.type === "image");
-				return fauxAssistantMessage("ok");
-			},
-		]);
-
-		await harness.session.prompt("describe", {
-			images: [
-				{
-					type: "image",
-					mimeType: "image/png",
-					data: "ZmFrZQ==",
-				},
-			],
-		});
-
-		expect(sawImage).toBe(true);
-	});
-
-	it("expands skill commands before sending the prompt", async () => {
-		const tempDir = join(tmpdir(), `pi-skill-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-		mkdirSync(tempDir, { recursive: true });
-		tempDirs.push(tempDir);
-		const skillPath = join(tempDir, "test-skill.md");
-		writeFileSync(skillPath, "# Test Skill\n\nUse the skill body.");
-
-		const resourceLoader = {
-			...createTestResourceLoader(),
-			getSkills: () => ({
-				skills: [
-					{
-						name: "test",
-						description: "Test skill",
-						filePath: skillPath,
-						disableModelInvocation: false,
-						baseDir: tempDir,
-						sourceInfo: createSyntheticSourceInfo(skillPath, {
-							source: "local",
-							scope: "project",
-							origin: "top-level",
-							baseDir: tempDir,
-						}),
-					},
-				],
-				diagnostics: [],
-			}),
-		};
-		const harness = await createHarness({ resourceLoader });
-		harnesses.push(harness);
-		let expandedPrompt = "";
-
-		harness.setResponses([
-			(context) => {
-				const user = context.messages.find((message) => message.role === "user");
-				expandedPrompt = user ? getMessageText(user) : "";
-				return fauxAssistantMessage("ok");
-			},
-		]);
-
-		await harness.session.prompt("/skill:test explain this");
-
-		expect(expandedPrompt).toContain('<skill name="test" location="');
-		expect(expandedPrompt).toContain("Use the skill body.");
-		expect(expandedPrompt).toContain("explain this");
-	});
-
-	it("expands prompt templates before sending the prompt", async () => {
-		const template: PromptTemplate = {
-			name: "review",
-			description: "Review template",
-			content: "Review this code: $1",
-			filePath: "/virtual/review.md",
-			sourceInfo: createSyntheticSourceInfo("/virtual/review.md", {
-				source: "local",
-				scope: "temporary",
-				origin: "top-level",
-			}),
-		};
-		const resourceLoader = {
-			...createTestResourceLoader(),
-			getPrompts: () => ({ prompts: [template], diagnostics: [] }),
-		};
-		const harness = await createHarness({ resourceLoader });
-		harnesses.push(harness);
-		let expandedPrompt = "";
-
-		harness.setResponses([
-			(context) => {
-				const user = context.messages.find((message) => message.role === "user");
-				expandedPrompt = user ? getMessageText(user) : "";
-				return fauxAssistantMessage("ok");
-			},
-		]);
-
-		await harness.session.prompt("/review src/index.ts");
-
-		expect(expandedPrompt).toBe("Review this code: src/index.ts");
-	});
-
-	it("dispatches extension commands without consuming a provider response", async () => {
-		const commandRuns: string[] = [];
-		const harness = await createHarness({
-			extensionFactories: [
-				(pi) => {
-					pi.registerCommand("testcmd", {
-						description: "Test command",
-						handler: async (args) => {
-							commandRuns.push(args);
-						},
-					});
-				},
-			],
-		});
-		harnesses.push(harness);
-		harness.setResponses([fauxAssistantMessage("should stay queued")]);
-
-		await harness.session.prompt("/testcmd hello world");
-
-		expect(commandRuns).toEqual(["hello world"]);
-		expect(harness.session.messages).toEqual([]);
-		expect(harness.getPendingResponseCount()).toBe(1);
-	});
-
-	it("sendUserMessage while idle triggers a turn", async () => {
-		const harness = await createHarness();
-		harnesses.push(harness);
-
-		harness.setResponses([fauxAssistantMessage("response")]);
-
-		await harness.session.sendUserMessage("from extension");
-
-		expect(harness.session.messages.map((message) => message.role)).toEqual(["user", "assistant"]);
-		expect(getMessageText(harness.session.messages[0]!)).toBe("from extension");
-	});
-
-	it("throws when prompted during streaming without a streamingBehavior", async () => {
-		let releaseToolExecution: (() => void) | undefined;
-		const toolRelease = new Promise<void>((resolve) => {
-			releaseToolExecution = resolve;
-		});
-		const waitTool: AgentTool = {
-			name: "wait",
-			label: "Wait",
-			description: "Wait for release",
-			parameters: Type.Object({}),
-			execute: async () => {
-				await toolRelease;
-				return {
-					content: [{ type: "text", text: "released" }],
-					details: {},
-				};
-			},
-		};
-		const harness = await createHarness({ tools: [waitTool] });
-		harnesses.push(harness);
-		harness.setResponses([
-			fauxAssistantMessage(fauxToolCall("wait", {}), { stopReason: "toolUse" }),
-			fauxAssistantMessage("done"),
-		]);
-
-		const sawToolStart = new Promise<void>((resolve) => {
-			const unsubscribe = harness.session.subscribe((event) => {
-				if (event.type === "tool_execution_start") {
-					unsubscribe();
-					resolve();
-				}
-			});
-		});
-
-		const promptPromise = harness.session.prompt("start");
-		await sawToolStart;
-
-		await expect(harness.session.prompt("second")).rejects.toThrow(
-			"Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message.",
-		);
-
-		releaseToolExecution?.();
-		await promptPromise;
-	});
-
-	it("throws when prompting without a model", async () => {
-		const harness = await createHarness();
-		harnesses.push(harness);
-		harness.session.agent.state.model = undefined as unknown as Model<any>;
-
-		await expect(harness.session.prompt("hi")).rejects.toThrow("No model selected.");
-	});
-
-	it("throws when prompting without configured auth", async () => {
-		const harness = await createHarness({ withConfiguredAuth: false });
-		harnesses.push(harness);
-
-		await expect(harness.session.prompt("hi")).rejects.toThrow(
-			`No API key found for ${harness.getModel().provider}.`,
-		);
-	});
-});