pi-usereq 0.7.0 → 0.11.0

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

@@ -0,0 +1,187 @@
+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

@@ -0,0 +1,172 @@
+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

@@ -0,0 +1,124 @@
+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

@@ -0,0 +1,183 @@
+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

@@ -0,0 +1,38 @@
+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");
+	});
+});