@oh-my-pi/pi-ai 4.5.0 → 4.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "4.5.0",
+	"version": "4.7.0",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./src/index.ts",

package/src/providers/anthropic.ts

@@ -30,7 +30,7 @@ import { sanitizeSurrogates } from "../utils/sanitize-unicode";
 import { transformMessages } from "./transorm-messages";
 
 // Stealth mode: Mimic Claude Code headers while avoiding tool name collisions.
-export const claudeCodeVersion = "1.0.83";
+export const claudeCodeVersion = "2.1.2";
 export const claudeToolPrefix = "proxy_";
 export const claudeCodeSystemInstruction = "You are Claude Code, Anthropic's official CLI for Claude.";
 export const claudeCodeHeaders = {

package/src/providers/google-gemini-cli.ts

@@ -512,6 +512,10 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 										});
 									} else {
 										currentBlock.text += part.text;
+										currentBlock.textSignature = retainThoughtSignature(
+											currentBlock.textSignature,
+											part.thoughtSignature,
+										);
 										stream.push({
 											type: "text_delta",
 											contentIndex: blockIndex(),

package/src/providers/google-shared.ts

@@ -13,18 +13,19 @@ type GoogleApiType = "google-generative-ai" | "google-gemini-cli" | "google-vert
  * Determines whether a streamed Gemini `Part` should be treated as "thinking".
  *
  * Protocol note (Gemini / Vertex AI thought signatures):
- * - `thoughtSignature` may appear without `thought: true` (including in empty-text parts at the end of streaming).
+ * - `thought: true` is the definitive marker for thinking content (thought summaries).
+ * - `thoughtSignature` is an encrypted representation of the model's internal thought process
+ *   used to preserve reasoning context across multi-turn interactions.
+ * - `thoughtSignature` can appear on ANY part type (text, functionCall, etc.) - it does NOT
+ *   indicate the part itself is thinking content.
+ * - For non-functionCall responses, the signature appears on the last part for context replay.
  * - When persisting/replaying model outputs, signature-bearing parts must be preserved as-is;
  *   do not merge/move signatures across parts.
- * - Our streaming representation uses content blocks, so we classify any non-empty `thoughtSignature`
- *   as thinking to avoid leaking thought content into normal assistant text.
  *
- * Some Google backends send thought content with `thoughtSignature` but omit `thought: true`
- * on subsequent deltas. We treat any non-empty `thoughtSignature` as thinking to avoid
- * leaking thought text into the normal assistant text stream.
+ * See: https://ai.google.dev/gemini-api/docs/thought-signatures
  */
 export function isThinkingPart(part: Pick<Part, "thought" | "thoughtSignature">): boolean {
-	return part.thought === true || (typeof part.thoughtSignature === "string" && part.thoughtSignature.length > 0);
+	return part.thought === true;
 }
 
 /**
@@ -214,9 +215,9 @@ const UNSUPPORTED_SCHEMA_FIELDS = new Set([
 	"format",
 ]);
 
-export function sanitizeSchemaForGoogle(value: unknown): unknown {
+function sanitizeSchemaImpl(value: unknown, isInsideProperties: boolean): unknown {
 	if (Array.isArray(value)) {
-		return value.map((entry) => sanitizeSchemaForGoogle(entry));
+		return value.map((entry) => sanitizeSchemaImpl(entry, isInsideProperties));
 	}
 
 	if (!value || typeof value !== "object") {
@@ -247,7 +248,7 @@ export function sanitizeSchemaForGoogle(value: unknown): unknown {
 				// Copy description and other top-level fields (not the combiner)
 				for (const [key, entry] of Object.entries(obj)) {
 					if (key !== combiner && !(key in result)) {
-						result[key] = sanitizeSchemaForGoogle(entry);
+						result[key] = sanitizeSchemaImpl(entry, false);
 					}
 				}
 				return result;
@@ -258,13 +259,16 @@ export function sanitizeSchemaForGoogle(value: unknown): unknown {
 	// Regular field processing
 	let constValue: unknown;
 	for (const [key, entry] of Object.entries(obj)) {
-		if (UNSUPPORTED_SCHEMA_FIELDS.has(key)) continue;
+		// Only strip unsupported schema keywords when NOT inside "properties" object
+		// Inside "properties", keys are property names (e.g., "pattern") not schema keywords
+		if (!isInsideProperties && UNSUPPORTED_SCHEMA_FIELDS.has(key)) continue;
 		if (key === "const") {
 			constValue = entry;
 			continue;
 		}
 		if (key === "additionalProperties" && entry === false) continue;
-		result[key] = sanitizeSchemaForGoogle(entry);
+		// When key is "properties", child keys are property names, not schema keywords
+		result[key] = sanitizeSchemaImpl(entry, key === "properties");
 	}
 
 	if (constValue !== undefined) {
@@ -289,6 +293,10 @@ export function sanitizeSchemaForGoogle(value: unknown): unknown {
 	return result;
 }
 
+export function sanitizeSchemaForGoogle(value: unknown): unknown {
+	return sanitizeSchemaImpl(value, false);
+}
+
 function sanitizeToolForGoogle(tool: Tool): Tool {
 	return {
 		name: tool.name,

package/src/providers/google-vertex.ts

@@ -143,6 +143,10 @@ export const streamGoogleVertex: StreamFunction<"google-vertex"> = (
 								});
 							} else {
 								currentBlock.text += part.text;
+								currentBlock.textSignature = retainThoughtSignature(
+									currentBlock.textSignature,
+									part.thoughtSignature,
+								);
 								stream.push({
 									type: "text_delta",
 									contentIndex: blockIndex(),