pi-usereq 0.49.0 → 0.50.0

package/pi.dev-src/pi-mono/ai/test/anthropic-tool-name-normalization.test.ts

@@ -1,205 +0,0 @@
-import { Type } from "typebox";
-import { describe, expect, it } from "vitest";
-import { getModel } from "../src/models.js";
-import { stream } from "../src/stream.js";
-import type { Context, Tool } from "../src/types.js";
-import { resolveApiKey } from "./oauth.js";
-
-const oauthToken = await resolveApiKey("anthropic");
-
-/**
- * Tests for Anthropic OAuth tool name normalization.
- *
- * When using Claude Code OAuth, tool names must match CC's canonical casing.
- * The normalization should:
- * 1. Convert tool names that match CC tools (case-insensitive) to CC casing on outbound
- * 2. Convert tool names back to the original casing on inbound
- *
- * This is a simple case-insensitive lookup, NOT a mapping of different names.
- * e.g., "todowrite" -> "TodoWrite" -> "todowrite" (round-trip works)
- *
- * The old `find -> Glob` mapping was WRONG because:
- * - Outbound: "find" -> "Glob"
- * - Inbound: "Glob" -> ??? (no tool named "glob" in context.tools, only "find")
- * - Result: tool call has name "Glob" but no tool exists with that name
- */
-describe.skipIf(!oauthToken)("Anthropic OAuth tool name normalization", () => {
-	const model = getModel("anthropic", "claude-sonnet-4-20250514");
-
-	it("should normalize user-defined tool matching CC name (todowrite -> TodoWrite -> todowrite)", async () => {
-		// User defines a tool named "todowrite" (lowercase)
-		// CC has "TodoWrite" - this should round-trip correctly
-		const todoTool: Tool = {
-			name: "todowrite",
-			description: "Write a todo item",
-			parameters: Type.Object({
-				task: Type.String({ description: "The task to add" }),
-			}),
-		};
-
-		const context: Context = {
-			systemPrompt: "You are a helpful assistant. Use the todowrite tool when asked to add todos.",
-			messages: [
-				{
-					role: "user",
-					content: "Add a todo: buy milk. Use the todowrite tool.",
-					timestamp: Date.now(),
-				},
-			],
-			tools: [todoTool],
-		};
-
-		const s = stream(model, context, { apiKey: oauthToken });
-		let toolCallName: string | undefined;
-
-		for await (const event of s) {
-			if (event.type === "toolcall_end") {
-				const toolCall = event.partial.content[event.contentIndex];
-				if (toolCall.type === "toolCall") {
-					toolCallName = toolCall.name;
-				}
-			}
-		}
-
-		const response = await s.result();
-		expect(response.stopReason, `Error: ${response.errorMessage}`).toBe("toolUse");
-
-		// The tool call should come back with the ORIGINAL name "todowrite", not "TodoWrite"
-		expect(toolCallName).toBe("todowrite");
-	});
-
-	it("should handle pi's built-in tools (read, write, edit, bash)", async () => {
-		// Pi's tools use lowercase names, CC uses PascalCase
-		const readTool: Tool = {
-			name: "read",
-			description: "Read a file",
-			parameters: Type.Object({
-				path: Type.String({ description: "File path" }),
-			}),
-		};
-
-		const context: Context = {
-			systemPrompt: "You are a helpful assistant. Use the read tool to read files.",
-			messages: [
-				{
-					role: "user",
-					content: "Read the file /tmp/test.txt using the read tool.",
-					timestamp: Date.now(),
-				},
-			],
-			tools: [readTool],
-		};
-
-		const s = stream(model, context, { apiKey: oauthToken });
-		let toolCallName: string | undefined;
-
-		for await (const event of s) {
-			if (event.type === "toolcall_end") {
-				const toolCall = event.partial.content[event.contentIndex];
-				if (toolCall.type === "toolCall") {
-					toolCallName = toolCall.name;
-				}
-			}
-		}
-
-		const response = await s.result();
-		expect(response.stopReason, `Error: ${response.errorMessage}`).toBe("toolUse");
-
-		// The tool call should come back with the ORIGINAL name "read", not "Read"
-		expect(toolCallName).toBe("read");
-	});
-
-	it("should NOT map find to Glob - find is not a CC tool name", async () => {
-		// Pi has a "find" tool, CC has "Glob" - these are DIFFERENT tools
-		// The old code incorrectly mapped find -> Glob, which broke the round-trip
-		// because there's no tool named "glob" in context.tools
-		const findTool: Tool = {
-			name: "find",
-			description: "Find files by pattern",
-			parameters: Type.Object({
-				pattern: Type.String({ description: "Glob pattern" }),
-			}),
-		};
-
-		const context: Context = {
-			systemPrompt: "You are a helpful assistant. Use the find tool to search for files.",
-			messages: [
-				{
-					role: "user",
-					content: "Find all .ts files using the find tool.",
-					timestamp: Date.now(),
-				},
-			],
-			tools: [findTool],
-		};
-
-		const s = stream(model, context, { apiKey: oauthToken });
-		let toolCallName: string | undefined;
-
-		for await (const event of s) {
-			if (event.type === "toolcall_end") {
-				const toolCall = event.partial.content[event.contentIndex];
-				if (toolCall.type === "toolCall") {
-					toolCallName = toolCall.name;
-				}
-			}
-		}
-
-		const response = await s.result();
-		expect(response.stopReason, `Error: ${response.errorMessage}`).toBe("toolUse");
-
-		// With the BROKEN find -> Glob mapping:
-		// - Sent as "Glob" to Anthropic
-		// - Received back as "Glob"
-		// - fromClaudeCodeName("Glob", tools) looks for tool.name.toLowerCase() === "glob"
-		// - No match (tool is named "find"), returns "Glob"
-		// - Test fails: toolCallName is "Glob" instead of "find"
-		//
-		// With the CORRECT implementation (no find->Glob mapping):
-		// - Sent as "find" to Anthropic (no CC tool named "Find")
-		// - Received back as "find"
-		// - Test passes: toolCallName is "find"
-		expect(toolCallName).toBe("find");
-	});
-
-	it("should handle custom tools that don't match any CC tool names", async () => {
-		// A completely custom tool should pass through unchanged
-		const customTool: Tool = {
-			name: "my_custom_tool",
-			description: "A custom tool",
-			parameters: Type.Object({
-				input: Type.String({ description: "Input value" }),
-			}),
-		};
-
-		const context: Context = {
-			systemPrompt: "You are a helpful assistant. Use my_custom_tool when asked.",
-			messages: [
-				{
-					role: "user",
-					content: "Use my_custom_tool with input 'hello'.",
-					timestamp: Date.now(),
-				},
-			],
-			tools: [customTool],
-		};
-
-		const s = stream(model, context, { apiKey: oauthToken });
-		let toolCallName: string | undefined;
-
-		for await (const event of s) {
-			if (event.type === "toolcall_end") {
-				const toolCall = event.partial.content[event.contentIndex];
-				if (toolCall.type === "toolCall") {
-					toolCallName = toolCall.name;
-				}
-			}
-		}
-
-		const response = await s.result();
-		expect(response.stopReason, `Error: ${response.errorMessage}`).toBe("toolUse");
-
-		// Custom tool names should pass through unchanged
-		expect(toolCallName).toBe("my_custom_tool");
-	});
-});

package/pi.dev-src/pi-mono/ai/test/azure-utils.ts

@@ -1,28 +0,0 @@
-/**
- * Utility functions for Azure OpenAI tests
- */
-
-function parseDeploymentNameMap(value: string | undefined): Map<string, string> {
-	const map = new Map<string, string>();
-	if (!value) return map;
-	for (const entry of value.split(",")) {
-		const trimmed = entry.trim();
-		if (!trimmed) continue;
-		const [modelId, deploymentName] = trimmed.split("=", 2);
-		if (!modelId || !deploymentName) continue;
-		map.set(modelId.trim(), deploymentName.trim());
-	}
-	return map;
-}
-
-export function hasAzureOpenAICredentials(): boolean {
-	const hasKey = !!process.env.AZURE_OPENAI_API_KEY;
-	const hasBaseUrl = !!(process.env.AZURE_OPENAI_BASE_URL || process.env.AZURE_OPENAI_RESOURCE_NAME);
-	return hasKey && hasBaseUrl;
-}
-
-export function resolveAzureDeploymentName(modelId: string): string | undefined {
-	const mapValue = process.env.AZURE_OPENAI_DEPLOYMENT_NAME_MAP;
-	if (!mapValue) return undefined;
-	return parseDeploymentNameMap(mapValue).get(modelId);
-}

package/pi.dev-src/pi-mono/ai/test/bedrock-endpoint-resolution.test.ts

@@ -1,131 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const bedrockMock = vi.hoisted(() => ({
-	constructorCalls: [] as Array<Record<string, unknown>>,
-}));
-
-vi.mock("@aws-sdk/client-bedrock-runtime", () => {
-	class BedrockRuntimeServiceException extends Error {}
-
-	class BedrockRuntimeClient {
-		constructor(config: Record<string, unknown>) {
-			bedrockMock.constructorCalls.push(config);
-		}
-
-		send(): Promise<never> {
-			return Promise.reject(new Error("mock send"));
-		}
-	}
-
-	class ConverseStreamCommand {
-		readonly input: unknown;
-
-		constructor(input: unknown) {
-			this.input = input;
-		}
-	}
-
-	return {
-		BedrockRuntimeClient,
-		BedrockRuntimeServiceException,
-		ConverseStreamCommand,
-		StopReason: {
-			END_TURN: "end_turn",
-			STOP_SEQUENCE: "stop_sequence",
-			MAX_TOKENS: "max_tokens",
-			MODEL_CONTEXT_WINDOW_EXCEEDED: "model_context_window_exceeded",
-			TOOL_USE: "tool_use",
-		},
-		CachePointType: { DEFAULT: "default" },
-		CacheTTL: { ONE_HOUR: "ONE_HOUR" },
-		ConversationRole: { ASSISTANT: "assistant", USER: "user" },
-		ImageFormat: { JPEG: "jpeg", PNG: "png", GIF: "gif", WEBP: "webp" },
-		ToolResultStatus: { ERROR: "error", SUCCESS: "success" },
-	};
-});
-
-import { getModel } from "../src/models.js";
-import { streamBedrock } from "../src/providers/amazon-bedrock.js";
-import type { Context, Model } from "../src/types.js";
-
-const context: Context = {
-	messages: [{ role: "user", content: "hello", timestamp: Date.now() }],
-};
-
-const originalAwsRegion = process.env.AWS_REGION;
-const originalAwsDefaultRegion = process.env.AWS_DEFAULT_REGION;
-const originalAwsProfile = process.env.AWS_PROFILE;
-
-beforeEach(() => {
-	bedrockMock.constructorCalls.length = 0;
-	delete process.env.AWS_REGION;
-	delete process.env.AWS_DEFAULT_REGION;
-	delete process.env.AWS_PROFILE;
-});
-
-afterEach(() => {
-	if (originalAwsRegion === undefined) {
-		delete process.env.AWS_REGION;
-	} else {
-		process.env.AWS_REGION = originalAwsRegion;
-	}
-
-	if (originalAwsDefaultRegion === undefined) {
-		delete process.env.AWS_DEFAULT_REGION;
-	} else {
-		process.env.AWS_DEFAULT_REGION = originalAwsDefaultRegion;
-	}
-
-	if (originalAwsProfile === undefined) {
-		delete process.env.AWS_PROFILE;
-	} else {
-		process.env.AWS_PROFILE = originalAwsProfile;
-	}
-});
-
-async function captureClientConfig(model: Model<"bedrock-converse-stream">): Promise<Record<string, unknown>> {
-	await streamBedrock(model, context, { cacheRetention: "none" }).result();
-	expect(bedrockMock.constructorCalls).toHaveLength(1);
-	return bedrockMock.constructorCalls[0];
-}
-
-describe("bedrock endpoint resolution", () => {
-	it("assigns eu-central-1 runtime URLs to built-in EU inference profiles", () => {
-		const model = getModel("amazon-bedrock", "eu.anthropic.claude-sonnet-4-5-20250929-v1:0");
-
-		expect(model.baseUrl).toBe("https://bedrock-runtime.eu-central-1.amazonaws.com");
-	});
-
-	it("does not pin standard AWS endpoints when AWS_REGION is configured", async () => {
-		process.env.AWS_REGION = "us-east-2";
-		const model = getModel("amazon-bedrock", "us.anthropic.claude-opus-4-7");
-
-		const config = await captureClientConfig(model);
-
-		expect(config.region).toBe("us-east-2");
-		expect(config.endpoint).toBeUndefined();
-	});
-
-	it("derives region from a built-in EU endpoint when no region or profile is configured", async () => {
-		const model = getModel("amazon-bedrock", "eu.anthropic.claude-sonnet-4-5-20250929-v1:0");
-
-		const config = await captureClientConfig(model);
-
-		expect(config.endpoint).toBe("https://bedrock-runtime.eu-central-1.amazonaws.com");
-		expect(config.region).toBe("eu-central-1");
-	});
-
-	it("still passes custom Bedrock endpoints through to the SDK client", async () => {
-		process.env.AWS_REGION = "us-west-2";
-		const baseModel = getModel("amazon-bedrock", "us.anthropic.claude-opus-4-7");
-		const model: Model<"bedrock-converse-stream"> = {
-			...baseModel,
-			baseUrl: "https://bedrock-vpc.example.com",
-		};
-
-		const config = await captureClientConfig(model);
-
-		expect(config.endpoint).toBe("https://bedrock-vpc.example.com");
-		expect(config.region).toBe("us-west-2");
-	});
-});

package/pi.dev-src/pi-mono/ai/test/bedrock-models.test.ts

@@ -1,66 +0,0 @@
-/**
- * A test suite to ensure all configured Amazon Bedrock models are usable.
- *
- * This is here to make sure we got correct model identifiers from models.dev and other sources.
- * Because Amazon Bedrock requires cross-region inference in some models,
- * plain model identifiers are not always usable and it requires tweaking of model identifiers to use cross-region inference.
- * See https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html#inference-profiles-support-system for more details.
- *
- * This test suite is not enabled by default unless AWS credentials and `BEDROCK_EXTENSIVE_MODEL_TEST` environment variables are set.
- * This test suite takes ~2 minutes to run. Because not all models are available in all regions,
- * it's recommended to use `us-west-2` region for best coverage for running this test suite.
- *
- * You can run this test suite with:
- * ```bash
- * $ AWS_REGION=us-west-2 BEDROCK_EXTENSIVE_MODEL_TEST=1 AWS_PROFILE=... npm test -- ./test/bedrock-models.test.ts
- * ```
- */
-
-import { describe, expect, it } from "vitest";
-import { getModels } from "../src/models.js";
-import { complete } from "../src/stream.js";
-import type { Context } from "../src/types.js";
-import { hasBedrockCredentials } from "./bedrock-utils.js";
-
-describe("Amazon Bedrock Models", () => {
-	const models = getModels("amazon-bedrock");
-
-	it("should get all available Bedrock models", () => {
-		expect(models.length).toBeGreaterThan(0);
-		console.log(`Found ${models.length} Bedrock models`);
-	});
-
-	if (hasBedrockCredentials() && process.env.BEDROCK_EXTENSIVE_MODEL_TEST) {
-		for (const model of models) {
-			it(`should make a simple request with ${model.id}`, { timeout: 10_000 }, async () => {
-				const context: Context = {
-					systemPrompt: "You are a helpful assistant. Be extremely concise.",
-					messages: [
-						{
-							role: "user",
-							content: "Reply with exactly: 'OK'",
-							timestamp: Date.now(),
-						},
-					],
-				};
-
-				const response = await complete(model, context);
-
-				expect(response.role).toBe("assistant");
-				expect(response.content).toBeTruthy();
-				expect(response.content.length).toBeGreaterThan(0);
-				expect(response.usage.input + response.usage.cacheRead).toBeGreaterThan(0);
-				expect(response.usage.output).toBeGreaterThan(0);
-				expect(response.errorMessage).toBeFalsy();
-
-				const textContent = response.content
-					.filter((b) => b.type === "text")
-					.map((b) => (b.type === "text" ? b.text : ""))
-					.join("")
-					.trim();
-				expect(textContent).toBeTruthy();
-				console.log(`${model.id}: ${textContent.substring(0, 100)}`);
-			});
-		}
-	}
-});

package/pi.dev-src/pi-mono/ai/test/bedrock-thinking-payload.test.ts

@@ -1,107 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getModel } from "../src/models.js";
-import { type BedrockOptions, streamBedrock } from "../src/providers/amazon-bedrock.js";
-import type { Context, Model } from "../src/types.js";
-
-interface BedrockThinkingPayload {
-	additionalModelRequestFields?: {
-		thinking?: { type: string; budget_tokens?: number; display?: string };
-		output_config?: { effort?: string };
-		anthropic_beta?: string[];
-	};
-}
-
-function makeContext(): Context {
-	return {
-		messages: [{ role: "user", content: "Hello", timestamp: Date.now() }],
-	};
-}
-
-async function capturePayload(
-	model: Model<"bedrock-converse-stream">,
-	options?: BedrockOptions,
-): Promise<BedrockThinkingPayload> {
-	let capturedPayload: BedrockThinkingPayload | undefined;
-	const s = streamBedrock(model, makeContext(), {
-		...options,
-		reasoning: options?.reasoning ?? "high",
-		signal: AbortSignal.abort(),
-		onPayload: (payload) => {
-			capturedPayload = payload as BedrockThinkingPayload;
-			return payload;
-		},
-	});
-
-	for await (const event of s) {
-		if (event.type === "error") {
-			break;
-		}
-	}
-
-	if (!capturedPayload) {
-		throw new Error("Expected Bedrock payload to be captured before request abort");
-	}
-
-	return capturedPayload;
-}
-
-describe("Bedrock thinking payload", () => {
-	it("uses adaptive thinking for Claude Opus 4.7 when reasoning is enabled", async () => {
-		const baseModel = getModel("amazon-bedrock", "global.anthropic.claude-opus-4-6-v1");
-		const model: Model<"bedrock-converse-stream"> = {
-			...baseModel,
-			id: "global.anthropic.claude-opus-4-7-v1",
-			name: "Claude Opus 4.7 (Global)",
-		};
-
-		const payload = await capturePayload(model);
-
-		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "adaptive", display: "summarized" });
-		expect(payload.additionalModelRequestFields?.output_config).toEqual({ effort: "high" });
-		expect(payload.additionalModelRequestFields?.anthropic_beta).toBeUndefined();
-	});
-
-	it("maps xhigh reasoning to effort=xhigh for Claude Opus 4.7", async () => {
-		const baseModel = getModel("amazon-bedrock", "global.anthropic.claude-opus-4-6-v1");
-		const model: Model<"bedrock-converse-stream"> = {
-			...baseModel,
-			id: "global.anthropic.claude-opus-4-7-v1",
-			name: "Claude Opus 4.7 (Global)",
-		};
-
-		const payload = await capturePayload(model, { reasoning: "xhigh" });
-
-		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "adaptive", display: "summarized" });
-		expect(payload.additionalModelRequestFields?.output_config).toEqual({ effort: "xhigh" });
-		expect(payload.additionalModelRequestFields?.anthropic_beta).toBeUndefined();
-	});
-
-	it("omits display for GovCloud model ids on non-adaptive Claude thinking", async () => {
-		const baseModel = getModel("amazon-bedrock", "us.anthropic.claude-sonnet-4-5-20250929-v1:0");
-		const model: Model<"bedrock-converse-stream"> = {
-			...baseModel,
-			id: "us-gov.anthropic.claude-sonnet-4-5-20250929-v1:0",
-			name: "Claude Sonnet 4.5 (GovCloud)",
-		};
-
-		const payload = await capturePayload(model);
-
-		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "enabled", budget_tokens: 16384 });
-		expect(payload.additionalModelRequestFields?.anthropic_beta).toEqual(["interleaved-thinking-2025-05-14"]);
-	});
-
-	it("omits display for GovCloud regions on adaptive Claude thinking", async () => {
-		const baseModel = getModel("amazon-bedrock", "global.anthropic.claude-opus-4-6-v1");
-		const model: Model<"bedrock-converse-stream"> = {
-			...baseModel,
-			id: "global.anthropic.claude-opus-4-7-v1",
-			name: "Claude Opus 4.7 (Global)",
-		};
-
-		const payload = await capturePayload(model, { region: "us-gov-west-1" });
-
-		expect(payload.additionalModelRequestFields?.thinking).toEqual({ type: "adaptive" });
-		expect(payload.additionalModelRequestFields?.output_config).toEqual({ effort: "high" });
-		expect(payload.additionalModelRequestFields?.anthropic_beta).toBeUndefined();
-	});
-});

package/pi.dev-src/pi-mono/ai/test/bedrock-utils.ts

@@ -1,18 +0,0 @@
-/**
- * Utility functions for Amazon Bedrock tests
- */
-
-/**
- * Check if any valid AWS credentials are configured for Bedrock.
- * Returns true if any of the following are set:
- * - AWS_PROFILE (named profile from ~/.aws/credentials)
- * - AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY (IAM keys)
- * - AWS_BEARER_TOKEN_BEDROCK (Bedrock API key)
- */
-export function hasBedrockCredentials(): boolean {
-	return !!(
-		process.env.AWS_PROFILE ||
-		(process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY) ||
-		process.env.AWS_BEARER_TOKEN_BEDROCK
-	);
-}