pi-usereq 0.49.0 → 0.51.0

package/pi.dev-src/pi-mono/ai/test/google-shared-convert-tools.test.ts

@@ -1,187 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { convertTools } from "../src/providers/google-shared.js";
-import type { Tool } from "../src/types.js";
-
-function makeTool(parameters: Record<string, unknown>): Tool {
-	return {
-		name: "test_tool",
-		description: "A test tool",
-		parameters: parameters as Tool["parameters"],
-	};
-}
-
-describe("google-shared convertTools", () => {
-	it("strips JSON Schema meta keys from parameters when useParameters=true", () => {
-		const tools = [
-			makeTool({
-				$schema: "http://json-schema.org/draft-07/schema#",
-				$id: "urn:bash-tool",
-				$comment: "A bash tool for demonstration",
-				$defs: {
-					commandDef: { type: "string" },
-				},
-				definitions: {
-					legacyDef: { type: "number" },
-				},
-				type: "object",
-				properties: {
-					command: { type: "string" },
-				},
-				required: ["command"],
-			}),
-		];
-
-		const result = convertTools(tools, true);
-		const decl = result?.[0]?.functionDeclarations?.[0];
-
-		expect(decl).toBeDefined();
-		expect(decl?.parameters).toEqual({
-			type: "object",
-			properties: {
-				command: { type: "string" },
-			},
-			required: ["command"],
-		});
-		expect(decl?.parameters).not.toHaveProperty("$schema");
-		expect(decl?.parameters).not.toHaveProperty("$id");
-		expect(decl?.parameters).not.toHaveProperty("$comment");
-		expect(decl?.parameters).not.toHaveProperty("$defs");
-		expect(decl?.parameters).not.toHaveProperty("definitions");
-	});
-
-	it("recursively strips nested JSON Schema meta keys", () => {
-		const tools = [
-			makeTool({
-				$schema: "http://json-schema.org/draft-07/schema#",
-				type: "object",
-				properties: {
-					deep: {
-						$schema: "http://json-schema.org/draft-07/schema#",
-						$id: "urn:nested",
-						type: "string",
-					},
-				},
-			}),
-		];
-
-		const result = convertTools(tools, true);
-		const decl = result?.[0]?.functionDeclarations?.[0];
-
-		expect(decl).toBeDefined();
-		expect(decl?.parameters).toEqual({
-			type: "object",
-			properties: {
-				deep: {
-					type: "string",
-				},
-			},
-		});
-	});
-
-	it("preserves $ref while stripping meta keys", () => {
-		const tools = [
-			makeTool({
-				$schema: "http://json-schema.org/draft-07/schema#",
-				type: "object",
-				properties: {
-					refProp: {
-						$ref: "#/$defs/someDef",
-						type: "string",
-					},
-				},
-			}),
-		];
-
-		const result = convertTools(tools, true);
-		const decl = result?.[0]?.functionDeclarations?.[0];
-
-		expect(decl).toBeDefined();
-		expect(decl?.parameters).toEqual({
-			type: "object",
-			properties: {
-				refProp: {
-					$ref: "#/$defs/someDef",
-					type: "string",
-				},
-			},
-		});
-	});
-
-	it("does not mutate the original Tool.parameters object", () => {
-		const originalParameters = {
-			$schema: "http://json-schema.org/draft-07/schema#",
-			type: "object",
-			properties: {
-				command: { type: "string" },
-			},
-			required: ["command"],
-		};
-		const tools = [makeTool(originalParameters)];
-
-		convertTools(tools, true);
-
-		expect(originalParameters).toEqual({
-			$schema: "http://json-schema.org/draft-07/schema#",
-			type: "object",
-			properties: {
-				command: { type: "string" },
-			},
-			required: ["command"],
-		});
-	});
-
-	it("preserves $schema in parametersJsonSchema when useParameters=false", () => {
-		const tools = [
-			makeTool({
-				$schema: "http://json-schema.org/draft-07/schema#",
-				type: "object",
-				properties: {
-					command: { type: "string" },
-				},
-				required: ["command"],
-			}),
-		];
-
-		const result = convertTools(tools, false);
-		const decl = result?.[0]?.functionDeclarations?.[0];
-
-		expect(decl).toBeDefined();
-		expect(decl?.parametersJsonSchema).toEqual({
-			$schema: "http://json-schema.org/draft-07/schema#",
-			type: "object",
-			properties: {
-				command: { type: "string" },
-			},
-			required: ["command"],
-		});
-	});
-
-	it("handles tools without $schema gracefully", () => {
-		const tools = [
-			makeTool({
-				type: "object",
-				properties: {
-					path: { type: "string" },
-				},
-				required: ["path"],
-			}),
-		];
-
-		const result = convertTools(tools, true);
-		const decl = result?.[0]?.functionDeclarations?.[0];
-
-		expect(decl).toBeDefined();
-		expect(decl?.parameters).toEqual({
-			type: "object",
-			properties: {
-				path: { type: "string" },
-			},
-			required: ["path"],
-		});
-	});
-
-	it("returns undefined for empty tool list", () => {
-		expect(convertTools([])).toBeUndefined();
-		expect(convertTools([], true)).toBeUndefined();
-	});
-});

package/pi.dev-src/pi-mono/ai/test/google-shared-gemini3-unsigned-tool-call.test.ts

@@ -1,172 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { convertMessages } from "../src/providers/google-shared.js";
-import type { Context, Model } from "../src/types.js";
-
-const SKIP_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
-
-function makeGemini3Model(id = "gemini-3-pro-preview"): Model<"google-generative-ai"> {
-	return {
-		id,
-		name: "Gemini 3 Pro Preview",
-		api: "google-generative-ai",
-		provider: "google",
-		baseUrl: "https://generativelanguage.googleapis.com",
-		reasoning: true,
-		input: ["text"],
-		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-		contextWindow: 128000,
-		maxTokens: 8192,
-	};
-}
-
-describe("google-shared convertMessages — Gemini 3 unsigned tool calls", () => {
-	it("uses skip_thought_signature_validator for unsigned tool calls on Gemini 3", () => {
-		const model = makeGemini3Model();
-		const now = Date.now();
-		const context: Context = {
-			messages: [
-				{ role: "user", content: "Hi", timestamp: now },
-				{
-					role: "assistant",
-					content: [
-						{
-							type: "toolCall",
-							id: "call_1",
-							name: "bash",
-							arguments: { command: "ls -la" },
-							// No thoughtSignature: simulates Claude via Antigravity.
-						},
-					],
-					api: "google-gemini-cli",
-					provider: "google-antigravity",
-					model: "claude-sonnet-4-20250514",
-					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: now,
-				},
-			],
-		};
-
-		const contents = convertMessages(model, context);
-
-		const modelTurn = contents.find((c) => c.role === "model");
-		expect(modelTurn).toBeTruthy();
-
-		// Should be a structured functionCall, NOT text fallback
-		const fcPart = modelTurn?.parts?.find((p) => p.functionCall !== undefined);
-		expect(fcPart).toBeTruthy();
-		expect(fcPart?.functionCall?.name).toBe("bash");
-		expect(fcPart?.functionCall?.args).toEqual({ command: "ls -la" });
-		expect(fcPart?.thoughtSignature).toBe(SKIP_THOUGHT_SIGNATURE);
-
-		// No text fallback should exist
-		const textParts = modelTurn?.parts?.filter((p) => p.text !== undefined) ?? [];
-		const historicalText = textParts.filter((p) => p.text?.includes("Historical context"));
-		expect(historicalText).toHaveLength(0);
-	});
-
-	it("preserves valid thoughtSignature when present (same provider/model)", () => {
-		const model = makeGemini3Model();
-		const now = Date.now();
-		// Valid base64 signature (16 bytes = 24 chars base64)
-		const validSig = "AAAAAAAAAAAAAAAAAAAAAA==";
-		const context: Context = {
-			messages: [
-				{ role: "user", content: "Hi", timestamp: now },
-				{
-					role: "assistant",
-					content: [
-						{
-							type: "toolCall",
-							id: "call_1",
-							name: "bash",
-							arguments: { command: "echo hi" },
-							thoughtSignature: validSig,
-						},
-					],
-					api: "google-generative-ai",
-					provider: "google",
-					model: "gemini-3-pro-preview",
-					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: now,
-				},
-			],
-		};
-
-		const contents = convertMessages(model, context);
-		const modelTurn = contents.find((c) => c.role === "model");
-		const fcPart = modelTurn?.parts?.find((p) => p.functionCall !== undefined);
-
-		expect(fcPart).toBeTruthy();
-		expect(fcPart?.thoughtSignature).toBe(validSig);
-	});
-
-	it("does not add sentinel for non-Gemini-3 models", () => {
-		const model: Model<"google-generative-ai"> = {
-			id: "gemini-2.5-flash",
-			name: "Gemini 2.5 Flash",
-			api: "google-generative-ai",
-			provider: "google",
-			baseUrl: "https://generativelanguage.googleapis.com",
-			reasoning: true,
-			input: ["text"],
-			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-			contextWindow: 128000,
-			maxTokens: 8192,
-		};
-		const now = Date.now();
-		const context: Context = {
-			messages: [
-				{ role: "user", content: "Hi", timestamp: now },
-				{
-					role: "assistant",
-					content: [
-						{
-							type: "toolCall",
-							id: "call_1",
-							name: "bash",
-							arguments: { command: "ls" },
-							// No thoughtSignature
-						},
-					],
-					api: "google-gemini-cli",
-					provider: "google-antigravity",
-					model: "claude-sonnet-4-20250514",
-					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: now,
-				},
-			],
-		};
-
-		const contents = convertMessages(model, context);
-		const modelTurn = contents.find((c) => c.role === "model");
-		const fcPart = modelTurn?.parts?.find((p) => p.functionCall !== undefined);
-
-		expect(fcPart).toBeTruthy();
-		// No sentinel, no thoughtSignature at all
-		expect(fcPart?.thoughtSignature).toBeUndefined();
-	});
-});

package/pi.dev-src/pi-mono/ai/test/google-shared-image-tool-result-routing.test.ts

@@ -1,124 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { convertMessages } from "../src/providers/google-shared.js";
-import type { Context, Model } from "../src/types.js";
-
-function makeModel<TApi extends "google-generative-ai" | "google-gemini-cli">(
-	api: TApi,
-	provider: Model<TApi>["provider"],
-	id: string,
-): Model<TApi> {
-	return {
-		id,
-		name: id,
-		api,
-		provider,
-		baseUrl: "https://example.com",
-		reasoning: true,
-		input: ["text", "image"],
-		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-		contextWindow: 128000,
-		maxTokens: 8192,
-	};
-}
-
-function makeContext(model: { api: string; provider: string; id: string }): Context {
-	const now = Date.now();
-	return {
-		messages: [
-			{ role: "user", content: "read the files", timestamp: now },
-			{
-				role: "assistant",
-				content: [
-					{ type: "toolCall", id: "call_a", name: "read", arguments: { path: "a.txt" } },
-					{ type: "toolCall", id: "call_img", name: "read", arguments: { path: "image.png" } },
-					{ type: "toolCall", id: "call_b", name: "read", arguments: { path: "b.txt" } },
-				],
-				api: model.api,
-				provider: model.provider,
-				model: model.id,
-				usage: {
-					input: 0,
-					output: 0,
-					cacheRead: 0,
-					cacheWrite: 0,
-					totalTokens: 0,
-					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-				},
-				stopReason: "toolUse",
-				timestamp: now,
-			},
-			{
-				role: "toolResult",
-				toolCallId: "call_a",
-				toolName: "read",
-				content: [{ type: "text", text: "alpha text" }],
-				isError: false,
-				timestamp: now,
-			},
-			{
-				role: "toolResult",
-				toolCallId: "call_img",
-				toolName: "read",
-				content: [{ type: "image", data: "abc", mimeType: "image/png" }],
-				isError: false,
-				timestamp: now,
-			},
-			{
-				role: "toolResult",
-				toolCallId: "call_b",
-				toolName: "read",
-				content: [{ type: "text", text: "beta text" }],
-				isError: false,
-				timestamp: now,
-			},
-		],
-	};
-}
-
-describe("google-shared image tool result routing", () => {
-	it("keeps separate synthetic image turn for Gemini 2.x Google API models", () => {
-		const model = makeModel("google-generative-ai", "google", "gemini-2.5-flash");
-		const contents = convertMessages(model, makeContext(model));
-
-		expect(contents).toHaveLength(5);
-		expect(contents[2].parts?.every((part) => part.functionResponse)).toBe(true);
-		expect(contents[3].parts?.[0]?.text).toBe("Tool result image:");
-		expect(contents[3].parts?.[1]?.inlineData).toBeTruthy();
-		expect(contents[4].parts?.[0]?.functionResponse).toBeTruthy();
-	});
-
-	it("nests image tool results for Gemini 3 Google API models", () => {
-		const model = makeModel("google-generative-ai", "google", "gemini-3-pro-preview");
-		const contents = convertMessages(model, makeContext(model));
-
-		expect(contents).toHaveLength(3);
-		const toolResultTurn = contents[2];
-		expect(toolResultTurn.parts).toHaveLength(3);
-		const imageResponse = toolResultTurn.parts?.[1]?.functionResponse;
-		expect(imageResponse).toBeTruthy();
-		expect(imageResponse?.parts).toHaveLength(1);
-		expect(imageResponse?.parts?.[0]?.inlineData).toBeTruthy();
-	});
-
-	it("nests image tool results for non-Gemini models on Antigravity / Cloud Code Assist", () => {
-		const model = makeModel("google-gemini-cli", "google-antigravity", "claude-sonnet-4-6");
-		const contents = convertMessages(model, makeContext(model));
-
-		expect(contents).toHaveLength(3);
-		const toolResultTurn = contents[2];
-		expect(toolResultTurn.parts).toHaveLength(3);
-		const imageResponse = toolResultTurn.parts?.[1]?.functionResponse;
-		expect(imageResponse).toBeTruthy();
-		expect(imageResponse?.parts).toHaveLength(1);
-		expect(imageResponse?.parts?.[0]?.inlineData).toBeTruthy();
-	});
-
-	it("keeps separate synthetic image turn for Gemini 2.x Cloud Code Assist models", () => {
-		const model = makeModel("google-gemini-cli", "google-gemini-cli", "gemini-2.5-flash");
-		const contents = convertMessages(model, makeContext(model));
-
-		expect(contents).toHaveLength(5);
-		expect(contents[3].parts?.[0]?.text).toBe("Tool result image:");
-		expect(contents[3].parts?.[1]?.inlineData).toBeTruthy();
-	});
-});

package/pi.dev-src/pi-mono/ai/test/google-thinking-disable.test.ts

@@ -1,183 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getModel } from "../src/models.js";
-import { streamSimple } from "../src/stream.js";
-import type { Api, Context, Model, SimpleStreamOptions } from "../src/types.js";
-import { resolveApiKey } from "./oauth.js";
-
-type SimpleOptionsWithExtras = SimpleStreamOptions & Record<string, unknown>;
-
-interface RunResult {
-	thinkingEventCount: number;
-	thinkingCharCount: number;
-	text: string;
-	outputTokens: number;
-	contentTypes: string[];
-}
-
-interface DisableExpectations {
-	requestOptions?: SimpleOptionsWithExtras;
-	minPongs?: number;
-	maxOutputTokens?: number;
-}
-
-const oauthTokens = await Promise.all([resolveApiKey("google-gemini-cli"), resolveApiKey("google-antigravity")]);
-const [geminiCliToken, antigravityToken] = oauthTokens;
-
-function makeContext(): Context {
-	return {
-		systemPrompt: "You are a precise assistant. Follow the requested output format exactly.",
-		messages: [
-			{
-				role: "user",
-				content:
-					"Before replying, carefully solve 36863 * 5279 internally. Then reply with the word pong repeated exactly 40 times, separated by single spaces. Do not add any other text.",
-				timestamp: Date.now(),
-			},
-		],
-	};
-}
-
-function countPongs(text: string): number {
-	return text.match(/\bpong\b/gi)?.length ?? 0;
-}
-
-async function runWithoutReasoning<TApi extends Api>(
-	model: Model<TApi>,
-	options: SimpleOptionsWithExtras = {},
-): Promise<RunResult> {
-	const s = streamSimple(model, makeContext(), {
-		maxTokens: 160,
-		temperature: 0,
-		...options,
-	});
-
-	let thinkingEventCount = 0;
-	let thinkingCharCount = 0;
-
-	for await (const event of s) {
-		if (event.type === "thinking_start" || event.type === "thinking_end") {
-			thinkingEventCount += 1;
-		}
-		if (event.type === "thinking_delta") {
-			thinkingEventCount += 1;
-			thinkingCharCount += event.delta.length;
-		}
-	}
-
-	const response = await s.result();
-	expect(response.stopReason, response.errorMessage).toBe("stop");
-
-	const text = response.content
-		.filter((block) => block.type === "text")
-		.map((block) => block.text)
-		.join("")
-		.trim();
-
-	return {
-		thinkingEventCount,
-		thinkingCharCount,
-		text,
-		outputTokens: response.usage.output,
-		contentTypes: response.content.map((block) => block.type),
-	};
-}
-
-async function expectThinkingDisabledE2E<TApi extends Api>(model: Model<TApi>, expectations: DisableExpectations = {}) {
-	const result = await runWithoutReasoning(model, expectations.requestOptions);
-
-	expect(result.thinkingEventCount).toBe(0);
-	expect(result.thinkingCharCount).toBe(0);
-	expect(result.contentTypes).not.toContain("thinking");
-	expect(countPongs(result.text)).toBeGreaterThanOrEqual(expectations.minPongs ?? 35);
-	if (expectations.maxOutputTokens !== undefined) {
-		expect(result.outputTokens).toBeLessThan(expectations.maxOutputTokens);
-	}
-}
-
-describe.skipIf(!process.env.ANTHROPIC_API_KEY)("Anthropic thinking disable E2E", () => {
-	it("disables thinking for budget-based reasoning models", { retry: 2, timeout: 30000 }, async () => {
-		await expectThinkingDisabledE2E(getModel("anthropic", "claude-sonnet-4-5"), {
-			requestOptions: { maxTokens: 320, temperature: 0 },
-		});
-	});
-
-	it("disables thinking for adaptive reasoning models", { retry: 2, timeout: 30000 }, async () => {
-		await expectThinkingDisabledE2E(getModel("anthropic", "claude-sonnet-4-6"), {
-			requestOptions: { maxTokens: 320, temperature: 0 },
-		});
-	});
-});
-
-describe.skipIf(!process.env.GEMINI_API_KEY)("Google thinking disable E2E", () => {
-	it("disables thinking for Gemini 2.5", { retry: 2, timeout: 30000 }, async () => {
-		await expectThinkingDisabledE2E(getModel("google", "gemini-2.5-flash"));
-	});
-
-	it("disables thinking for Gemini 3.x", { retry: 2, timeout: 30000 }, async () => {
-		await expectThinkingDisabledE2E(getModel("google", "gemini-3-flash-preview"));
-	});
-
-	it("does not error when thinking is off for Gemini 3.1 Pro", { retry: 2, timeout: 30000 }, async () => {
-		await expectThinkingDisabledE2E(getModel("google", "gemini-3.1-pro-preview"), {
-			requestOptions: { maxTokens: 512 },
-			minPongs: 20,
-		});
-	});
-});
-
-describe("Google Vertex thinking disable E2E", () => {
-	const vertexProject = process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT;
-	const vertexLocation = process.env.GOOGLE_CLOUD_LOCATION;
-	const vertexApiKey = process.env.GOOGLE_CLOUD_API_KEY;
-	const vertexOptions = vertexApiKey
-		? ({ apiKey: vertexApiKey } satisfies SimpleOptionsWithExtras)
-		: vertexProject && vertexLocation
-			? ({ project: vertexProject, location: vertexLocation } satisfies SimpleOptionsWithExtras)
-			: undefined;
-
-	it.skipIf(!vertexOptions)("disables thinking for Gemini 2.5", { retry: 2, timeout: 30000 }, async () => {
-		await expectThinkingDisabledE2E(getModel("google-vertex", "gemini-2.5-flash"), {
-			requestOptions: vertexOptions,
-		});
-	});
-
-	it.skipIf(!vertexOptions)("disables thinking for Gemini 3.x", { retry: 2, timeout: 30000 }, async () => {
-		await expectThinkingDisabledE2E(getModel("google-vertex", "gemini-3-flash-preview"), {
-			requestOptions: vertexOptions,
-		});
-	});
-});
-
-describe("Google Gemini CLI thinking disable E2E", () => {
-	it.skipIf(!geminiCliToken)("disables thinking for Gemini 2.5", { retry: 2, timeout: 30000 }, async () => {
-		await expectThinkingDisabledE2E(getModel("google-gemini-cli", "gemini-2.5-flash"), {
-			requestOptions: { apiKey: geminiCliToken! },
-			maxOutputTokens: 100,
-		});
-	});
-});
-
-describe("Google Antigravity thinking disable E2E", () => {
-	it.skipIf(!antigravityToken)("disables thinking for Gemini 3.x", { retry: 2, timeout: 30000 }, async () => {
-		await expectThinkingDisabledE2E(getModel("google-antigravity", "gemini-3-flash"), {
-			requestOptions: { apiKey: antigravityToken! },
-			maxOutputTokens: 100,
-		});
-	});
-});
-
-describe.skipIf(!process.env.OPENAI_API_KEY)("OpenAI thinking disable E2E", () => {
-	it("disables thinking for Responses reasoning models", { retry: 2, timeout: 30000 }, async () => {
-		await expectThinkingDisabledE2E(getModel("openai", "gpt-5.4-mini"), {
-			requestOptions: { temperature: undefined },
-		});
-	});
-});
-
-describe.skipIf(!process.env.OPENROUTER_API_KEY)("OpenRouter thinking disable E2E", () => {
-	it("disables thinking for Qwen 3.5 reasoning models", { retry: 2, timeout: 30000 }, async () => {
-		await expectThinkingDisabledE2E(getModel("openrouter", "qwen/qwen3.5-plus-02-15"), {
-			maxOutputTokens: 100,
-		});
-	});
-});

package/pi.dev-src/pi-mono/ai/test/google-thinking-signature.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { isThinkingPart, retainThoughtSignature } from "../src/providers/google-shared.js";
-
-describe("Google thinking detection (thoughtSignature)", () => {
-	it("treats part.thought === true as thinking", () => {
-		expect(isThinkingPart({ thought: true, thoughtSignature: undefined })).toBe(true);
-		expect(isThinkingPart({ thought: true, thoughtSignature: "opaque-signature" })).toBe(true);
-	});
-
-	it("does not treat thoughtSignature alone as thinking", () => {
-		// Per Google docs, thoughtSignature is for context replay and can appear on any part type.
-		// Only thought === true indicates thinking content.
-		// See: https://ai.google.dev/gemini-api/docs/thought-signatures
-		expect(isThinkingPart({ thought: undefined, thoughtSignature: "opaque-signature" })).toBe(false);
-		expect(isThinkingPart({ thought: false, thoughtSignature: "opaque-signature" })).toBe(false);
-	});
-
-	it("does not treat empty/missing signatures as thinking if thought is not set", () => {
-		expect(isThinkingPart({ thought: undefined, thoughtSignature: undefined })).toBe(false);
-		expect(isThinkingPart({ thought: false, thoughtSignature: "" })).toBe(false);
-	});
-
-	it("preserves the existing signature when subsequent deltas omit thoughtSignature", () => {
-		const first = retainThoughtSignature(undefined, "sig-1");
-		expect(first).toBe("sig-1");
-
-		const second = retainThoughtSignature(first, undefined);
-		expect(second).toBe("sig-1");
-
-		const third = retainThoughtSignature(second, "");
-		expect(third).toBe("sig-1");
-	});
-
-	it("updates the signature when a new non-empty signature arrives", () => {
-		const updated = retainThoughtSignature("sig-1", "sig-2");
-		expect(updated).toBe("sig-2");
-	});
-});