@oh-my-pi/pi-ai 12.0.0 → 12.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "12.0.0",
+	"version": "12.1.1",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -63,7 +63,7 @@
 		"@connectrpc/connect-node": "^2.1.1",
 		"@google/genai": "^1.39.0",
 		"@mistralai/mistralai": "^1.13.0",
-		"@oh-my-pi/pi-utils": "12.0.0",
+		"@oh-my-pi/pi-utils": "12.1.1",
 		"@sinclair/typebox": "^0.34.48",
 		"@smithy/node-http-handler": "^4.4.9",
 		"ajv": "^8.17.1",
@@ -82,17 +82,22 @@
 		"unified",
 		"api"
 	],
-	"author": "Mario Zechner",
+	"author": "Can Bölük",
+	"contributors": ["Mario Zechner"],
 	"license": "MIT",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/can1357/oh-my-pi.git",
 		"directory": "packages/ai"
 	},
-	"engines": {
-		"bun": ">=1.3.7"
-	},
-	"devDependencies": {
-		"@types/bun": "^1.3.9"
-	}
+	"homepage": "https://github.com/can1357/oh-my-pi",
+	"bugs": {
+	"url": "https://github.com/can1357/oh-my-pi/issues"
+},
+"engines": {
+	"bun": ">=1.3.7"
+},
+"devDependencies": {
+	"@types/bun": "^1.3.9"
+}
 }

package/src/providers/azure-openai-responses.ts

@@ -460,12 +460,17 @@ function buildParams(
 	}
 
 	if (model.reasoning) {
+		// Always request encrypted reasoning content so reasoning items can be
+		// replayed in multi-turn conversations when store is false (items aren't
+		// persisted server-side, so we must include the full content).
+		// See: https://github.com/can1357/oh-my-pi/issues/41
+		params.include = ["reasoning.encrypted_content"];
+
 		if (options?.reasoningEffort || options?.reasoningSummary) {
 			params.reasoning = {
 				effort: options?.reasoningEffort || "medium",
 				summary: options?.reasoningSummary || "auto",
 			};
-			params.include = ["reasoning.encrypted_content"];
 		} else {
 			if (model.name.toLowerCase().startsWith("gpt-5")) {
 				// Jesus Christ, see https://community.openai.com/t/need-reasoning-false-option-for-gpt-5/1351588/7

package/src/providers/google-shared.ts

@@ -2,6 +2,8 @@
  * Shared utilities for Google Generative AI and Google Cloud Code Assist providers.
  */
 import { type Content, FinishReason, FunctionCallingConfigMode, type Part } from "@google/genai";
+import type { AnySchema } from "ajv";
+import Ajv2020 from "ajv/dist/2020.js";
 import type { Context, ImageContent, Model, StopReason, TextContent, Tool } from "../types";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode";
 import { transformMessages } from "./transform-messages";
@@ -257,7 +259,6 @@ const UNSUPPORTED_SCHEMA_FIELDS = new Set([
 	"$defs",
 	"$dynamicRef",
 	"$dynamicAnchor",
-	"format",
 	"examples",
 	"prefixItems",
 	"unevaluatedProperties",
@@ -276,65 +277,164 @@ const UNSUPPORTED_SCHEMA_FIELDS = new Set([
 	"format",
 ]);
 
-function sanitizeSchemaImpl(value: unknown, isInsideProperties: boolean): unknown {
-	if (Array.isArray(value)) {
-		return value.map(entry => sanitizeSchemaImpl(entry, isInsideProperties));
+interface SanitizeSchemaOptions {
+	insideProperties: boolean;
+	normalizeTypeArrayToNullable: boolean;
+	stripNullableKeyword: boolean;
+}
+
+type JsonObject = Record<string, unknown>;
+
+function isJsonObject(value: unknown): value is JsonObject {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function areJsonValuesEqual(left: unknown, right: unknown): boolean {
+	if (Object.is(left, right)) {
+		return true;
+	}
+	if (Array.isArray(left) || Array.isArray(right)) {
+		if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+			return false;
+		}
+		for (let i = 0; i < left.length; i += 1) {
+			if (!areJsonValuesEqual(left[i], right[i])) {
+				return false;
+			}
+		}
+		return true;
+	}
+	if (!isJsonObject(left) || !isJsonObject(right)) {
+		return false;
+	}
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) {
+		return false;
+	}
+	for (const key of leftKeys) {
+		if (!(key in right) || !areJsonValuesEqual(left[key], right[key])) {
+			return false;
+		}
+	}
+	return true;
+}
+
+function mergeCompatibleEnumSchemas(existing: unknown, incoming: unknown): JsonObject | null {
+	if (!isJsonObject(existing) || !isJsonObject(incoming)) {
+		return null;
+	}
+	const existingEnum = Array.isArray(existing.enum) ? existing.enum : null;
+	const incomingEnum = Array.isArray(incoming.enum) ? incoming.enum : null;
+	if (!existingEnum || !incomingEnum) {
+		return null;
+	}
+	if (!areJsonValuesEqual(existing.type, incoming.type)) {
+		return null;
+	}
+	const existingKeys = Object.keys(existing).filter(key => key !== "enum");
+	const incomingKeys = Object.keys(incoming).filter(key => key !== "enum");
+	if (existingKeys.length !== incomingKeys.length) {
+		return null;
+	}
+	for (const key of existingKeys) {
+		if (!(key in incoming) || !areJsonValuesEqual(existing[key], incoming[key])) {
+			return null;
+		}
+	}
+
+	const mergedEnum = [...existingEnum];
+	for (const enumValue of incomingEnum) {
+		if (!mergedEnum.some(existingValue => Object.is(existingValue, enumValue))) {
+			mergedEnum.push(enumValue);
+		}
+	}
+	return {
+		...existing,
+		enum: mergedEnum,
+	};
+}
+
+function getAnyOfVariants(schema: unknown): unknown[] {
+	if (isJsonObject(schema) && Array.isArray(schema.anyOf)) {
+		return schema.anyOf;
+	}
+	return [schema];
+}
+
+function mergePropertySchemas(existing: unknown, incoming: unknown): unknown {
+	if (areJsonValuesEqual(existing, incoming)) {
+		return existing;
+	}
+	const mergedEnumSchema = mergeCompatibleEnumSchemas(existing, incoming);
+	if (mergedEnumSchema !== null) {
+		return mergedEnumSchema;
+	}
+
+	const mergedAnyOf = [...getAnyOfVariants(existing)];
+	for (const variant of getAnyOfVariants(incoming)) {
+		if (!mergedAnyOf.some(existingVariant => areJsonValuesEqual(existingVariant, variant))) {
+			mergedAnyOf.push(variant);
+		}
 	}
+	return mergedAnyOf.length === 1 ? mergedAnyOf[0] : { anyOf: mergedAnyOf };
+}
 
+function sanitizeSchemaImpl(value: unknown, options: SanitizeSchemaOptions): unknown {
+	if (Array.isArray(value)) {
+		return value.map(entry => sanitizeSchemaImpl(entry, options));
+	}
 	if (!value || typeof value !== "object") {
 		return value;
 	}
-
 	const obj = value as Record<string, unknown>;
 	const result: Record<string, unknown> = {};
-
-	// Collapse anyOf/oneOf of const values into enum
 	for (const combiner of ["anyOf", "oneOf"] as const) {
 		if (Array.isArray(obj[combiner])) {
 			const variants = obj[combiner] as Record<string, unknown>[];
-
-			// Check if ALL variants have a const field
 			const allHaveConst = variants.every(v => v && typeof v === "object" && "const" in v);
-
 			if (allHaveConst && variants.length > 0) {
-				// Extract all const values into enum
 				result.enum = variants.map(v => v.const);
-
-				// Inherit type from first variant if present
 				const firstType = variants[0]?.type;
 				if (firstType) {
 					result.type = firstType;
 				}
-
 				// 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] = sanitizeSchemaImpl(entry, false);
+						result[key] = sanitizeSchemaImpl(entry, {
+							insideProperties: false,
+							normalizeTypeArrayToNullable: options.normalizeTypeArrayToNullable,
+							stripNullableKeyword: options.stripNullableKeyword,
+						});
 					}
 				}
 				return result;
 			}
 		}
 	}
-
 	// Regular field processing
 	let constValue: unknown;
 	for (const [key, entry] of Object.entries(obj)) {
 		// 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 (!options.insideProperties && UNSUPPORTED_SCHEMA_FIELDS.has(key)) continue;
+		if (options.stripNullableKeyword && key === "nullable") continue;
 		if (key === "const") {
 			constValue = entry;
 			continue;
 		}
 		if (key === "additionalProperties" && entry === false) continue;
 		// When key is "properties", child keys are property names, not schema keywords
-		result[key] = sanitizeSchemaImpl(entry, key === "properties");
+		result[key] = sanitizeSchemaImpl(entry, {
+			insideProperties: key === "properties",
+			normalizeTypeArrayToNullable: options.normalizeTypeArrayToNullable,
+			stripNullableKeyword: options.stripNullableKeyword,
+		});
 	}
-
 	// Normalize array-valued "type" (e.g. ["string", "null"]) to a single type + nullable.
 	// Google's Schema proto expects type to be a single enum string, not an array.
-	if (Array.isArray(result.type)) {
+	if (options.normalizeTypeArrayToNullable && Array.isArray(result.type)) {
 		const types = result.type as string[];
 		const nonNull = types.filter(t => t !== "null");
 		if (types.includes("null")) {
@@ -342,7 +442,6 @@ function sanitizeSchemaImpl(value: unknown, isInsideProperties: boolean): unknow
 		}
 		result.type = nonNull[0] ?? types[0];
 	}
-
 	if (constValue !== undefined) {
 		// Convert const to enum, merging with existing enum if present
 		const existingEnum = Array.isArray(result.enum) ? result.enum : [];
@@ -364,9 +463,135 @@ function sanitizeSchemaImpl(value: unknown, isInsideProperties: boolean): unknow
 
 	return result;
 }
-
 export function sanitizeSchemaForGoogle(value: unknown): unknown {
-	return sanitizeSchemaImpl(value, false);
+	return sanitizeSchemaImpl(value, {
+		insideProperties: false,
+		normalizeTypeArrayToNullable: true,
+		stripNullableKeyword: false,
+	});
+}
+
+export function sanitizeSchemaForCloudCodeAssistClaude(value: unknown): unknown {
+	return sanitizeSchemaImpl(value, {
+		insideProperties: false,
+		normalizeTypeArrayToNullable: false,
+		stripNullableKeyword: true,
+	});
+}
+
+/**
+ * Claude via Cloud Code Assist (`parameters` path) can reject schemas that keep
+ * object variant combiners, so flatten object-only unions into one object shape.
+ */
+function mergeObjectCombinerVariants(schema: JsonObject, combiner: "anyOf" | "oneOf"): JsonObject {
+	const variantsRaw = schema[combiner];
+	if (!Array.isArray(variantsRaw) || variantsRaw.length === 0) {
+		return schema;
+	}
+
+	const variants: JsonObject[] = [];
+	for (const entry of variantsRaw) {
+		if (!isJsonObject(entry)) {
+			return schema;
+		}
+		const variantType = entry.type;
+		if (variantType !== undefined && variantType !== "object") {
+			return schema;
+		}
+		if (entry.properties !== undefined && !isJsonObject(entry.properties)) {
+			return schema;
+		}
+		variants.push(entry);
+	}
+
+	const mergedProperties: JsonObject = {};
+	const ownProperties = isJsonObject(schema.properties) ? schema.properties : {};
+	for (const [name, propertySchema] of Object.entries(ownProperties)) {
+		mergedProperties[name] = propertySchema;
+	}
+
+	for (const variant of variants) {
+		const properties = isJsonObject(variant.properties) ? variant.properties : {};
+		for (const [name, propertySchema] of Object.entries(properties)) {
+			const existingSchema = mergedProperties[name];
+			mergedProperties[name] =
+				existingSchema === undefined ? propertySchema : mergePropertySchemas(existingSchema, propertySchema);
+		}
+	}
+
+	const nextSchema: JsonObject = {};
+	for (const [key, entry] of Object.entries(schema)) {
+		if (key === combiner) continue;
+		nextSchema[key] = entry;
+	}
+
+	nextSchema.type = "object";
+	nextSchema.properties = mergedProperties;
+	return nextSchema;
+}
+
+function normalizeSchemaForCloudCodeAssistClaude(value: unknown): unknown {
+	if (Array.isArray(value)) {
+		return value.map(entry => normalizeSchemaForCloudCodeAssistClaude(entry));
+	}
+	if (!isJsonObject(value)) {
+		return value;
+	}
+
+	const normalized: JsonObject = {};
+	for (const [key, entry] of Object.entries(value)) {
+		normalized[key] = normalizeSchemaForCloudCodeAssistClaude(entry);
+	}
+
+	const mergedAnyOf = mergeObjectCombinerVariants(normalized, "anyOf");
+	return mergeObjectCombinerVariants(mergedAnyOf, "oneOf");
+}
+
+let cloudCodeAssistSchemaValidator: Ajv2020 | null = null;
+function getCloudCodeAssistSchemaValidator(): Ajv2020 {
+	if (cloudCodeAssistSchemaValidator) {
+		return cloudCodeAssistSchemaValidator;
+	}
+
+	cloudCodeAssistSchemaValidator = new Ajv2020({
+		allErrors: true,
+		strict: false,
+		validateSchema: true,
+	});
+	return cloudCodeAssistSchemaValidator;
+}
+
+/**
+ * Keep validation synchronous in this request path.
+ */
+function isValidCloudCodeAssistClaudeSchema(schema: unknown): boolean {
+	try {
+		const result = getCloudCodeAssistSchemaValidator().validateSchema(schema as AnySchema);
+		return typeof result === "boolean" ? result : false;
+	} catch {
+		return false;
+	}
+}
+
+const CLOUD_CODE_ASSIST_CLAUDE_FALLBACK_SCHEMA = {
+	type: "object",
+	properties: {},
+} as const;
+
+/**
+ * Prepare schema for Claude on Cloud Code Assist:
+ * sanitize -> normalize union objects -> validate -> fallback.
+ *
+ * Fallback is per-tool and fail-open to avoid rejecting the entire request when
+ * one tool schema is invalid.
+ */
+export function prepareSchemaForCloudCodeAssistClaude(value: unknown): unknown {
+	const sanitized = sanitizeSchemaForCloudCodeAssistClaude(value);
+	const normalized = normalizeSchemaForCloudCodeAssistClaude(sanitized);
+	if (isValidCloudCodeAssistClaudeSchema(normalized)) {
+		return normalized;
+	}
+	return CLOUD_CODE_ASSIST_CLAUDE_FALLBACK_SCHEMA;
 }
 
 /**
@@ -384,8 +609,10 @@ export function convertTools(
 ): { functionDeclarations: Record<string, unknown>[] }[] | undefined {
 	if (tools.length === 0) return undefined;
 
-	// Claude models on Cloud Code Assist need the legacy `parameters` field;
-	// the API translates it into Anthropic's `input_schema`.
+	/**
+	 * Claude models on Cloud Code Assist need the legacy `parameters` field;
+	 * the API translates it into Anthropic's `input_schema`.
+	 */
 	const useParameters = model.id.startsWith("claude-");
 
 	return [
@@ -394,7 +621,7 @@ export function convertTools(
 				name: tool.name,
 				description: tool.description,
 				...(useParameters
-					? { parameters: sanitizeSchemaForGoogle(tool.parameters) }
+					? { parameters: prepareSchemaForCloudCodeAssistClaude(tool.parameters) }
 					: { parametersJsonSchema: tool.parameters }),
 			})),
 		},

package/src/providers/openai-responses.ts

@@ -454,12 +454,17 @@ function buildParams(model: Model<"openai-responses">, context: Context, options
 	}
 
 	if (model.reasoning) {
+		// Always request encrypted reasoning content so reasoning items can be
+		// replayed in multi-turn conversations when store is false (items aren't
+		// persisted server-side, so we must include the full content).
+		// See: https://github.com/can1357/oh-my-pi/issues/41
+		params.include = ["reasoning.encrypted_content"];
+
 		if (options?.reasoningEffort || options?.reasoningSummary) {
 			params.reasoning = {
 				effort: options?.reasoningEffort || "medium",
 				summary: options?.reasoningSummary || "auto",
 			};
-			params.include = ["reasoning.encrypted_content"];
 		} else {
 			if (model.name.startsWith("gpt-5")) {
 				// Jesus Christ, see https://community.openai.com/t/need-reasoning-false-option-for-gpt-5/1351588/7

package/src/storage.ts

@@ -5,9 +5,8 @@
 
 import { Database, type Statement } from "bun:sqlite";
 import * as fs from "node:fs/promises";
-import * as os from "node:os";
 import * as path from "node:path";
-import { $env } from "@oh-my-pi/pi-utils";
+import { getAgentDir } from "@oh-my-pi/pi-utils/dirs";
 import type { OAuthCredentials } from "./utils/oauth/types";
 
 type AuthCredential = { type: "api_key"; key: string } | ({ type: "oauth" } & OAuthCredentials);
@@ -21,14 +20,6 @@ type AuthRow = {
 	updated_at: number;
 };
 
-/**
- * Get the agent config directory (e.g., ~/.omp/agent/)
- */
-function getAgentDir(): string {
-	const configDir = $env.PI_CODING_AGENT_DIR || path.join(os.homedir(), ".omp", "agent");
-	return configDir;
-}
-
 /**
  * Get path to agent.db
  */

package/src/utils/oauth/anthropic.ts

@@ -7,7 +7,7 @@ import type { OAuthController, OAuthCredentials } from "./types";
 
 const decode = (s: string) => atob(s);
 const CLIENT_ID = decode("OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl");
-const AUTHORIZE_URL = "https://platform.claude.com/oauth/authorize";
+const AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
 const TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
 const CALLBACK_PORT = 54545;
 const CALLBACK_PATH = "/callback";

package/src/utils/oauth/kimi.ts

@@ -7,6 +7,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { $env, abortableSleep, isEnoent } from "@oh-my-pi/pi-utils";
+import { getAgentDir } from "@oh-my-pi/pi-utils/dirs";
 import packageJson from "../../../package.json" with { type: "json" };
 import type { OAuthController, OAuthCredentials } from "./types";
 
@@ -36,11 +37,6 @@ interface TokenResponse {
 	interval?: number;
 }
 
-function getAgentDir(): string {
-	const configDir = $env.PI_CODING_AGENT_DIR || path.join(os.homedir(), ".omp", "agent");
-	return configDir;
-}
-
 function resolveOAuthHost(): string {
 	return $env.KIMI_CODE_OAUTH_HOST || $env.KIMI_OAUTH_HOST || DEFAULT_OAUTH_HOST;
 }