@oh-my-pi/pi-coding-agent 13.9.11 → 13.9.13

package/src/tools/read.ts

@@ -23,7 +23,12 @@ import {
 import { renderCodeCell, renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
-import { formatDimensionNote, resizeImage } from "../utils/image-resize";
+import {
+	ImageInputTooLargeError,
+	loadImageInput,
+	MAX_IMAGE_INPUT_BYTES,
+	readImageMetadata,
+} from "../utils/image-input";
 import { detectSupportedImageMimeTypeFromFile } from "../utils/mime";
 import { ensureTool } from "../utils/tools-manager";
 import { applyListLimit } from "./list-limit";
@@ -253,7 +258,7 @@ async function streamLinesFromFile(
 }
 
 // Maximum image file size (20MB) - larger images will be rejected to prevent OOM during serialization
-const MAX_IMAGE_SIZE = 20 * 1024 * 1024;
+const MAX_IMAGE_SIZE = MAX_IMAGE_INPUT_BYTES;
 const GLOB_TIMEOUT_MS = 5000;
 
 function isNotFoundError(error: unknown): boolean {
@@ -366,6 +371,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 
 	readonly #autoResizeImages: boolean;
 	readonly #defaultLimit: number;
+	readonly #inspectImageEnabled: boolean;
 
 	constructor(private readonly session: ToolSession) {
 		const displayMode = resolveFileDisplayMode(session);
@@ -374,6 +380,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			1,
 			Math.min(session.settings.get("read.defaultLimit") ?? DEFAULT_MAX_LINES, DEFAULT_MAX_LINES),
 		);
+		this.#inspectImageEnabled = session.settings.get("inspect_image.enabled");
 		this.description = renderPromptTemplate(readDescription, {
 			DEFAULT_LIMIT: String(this.#defaultLimit),
 			DEFAULT_MAX_LINES: String(DEFAULT_MAX_LINES),
@@ -455,57 +462,63 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			| undefined;
 
 		if (mimeType) {
-			if (fileSize > MAX_IMAGE_SIZE) {
-				const sizeStr = formatBytes(fileSize);
-				const maxStr = formatBytes(MAX_IMAGE_SIZE);
-				throw new ToolError(`Image file too large: ${sizeStr} exceeds ${maxStr} limit.`);
+			if (this.#inspectImageEnabled) {
+				const metadata = await readImageMetadata({
+					path: readPath,
+					cwd: this.session.cwd,
+					resolvedPath: absolutePath,
+					detectedMimeType: mimeType,
+				});
+				const outputMime = metadata?.mimeType ?? mimeType;
+				const outputBytes = metadata?.bytes ?? fileSize;
+				const metadataLines = [
+					"Image metadata:",
+					`- MIME: ${outputMime}`,
+					`- Bytes: ${outputBytes} (${formatBytes(outputBytes)})`,
+					metadata?.width !== undefined && metadata.height !== undefined
+						? `- Dimensions: ${metadata.width}x${metadata.height}`
+						: "- Dimensions: unknown",
+					metadata?.channels !== undefined ? `- Channels: ${metadata.channels}` : "- Channels: unknown",
+					metadata?.hasAlpha === true
+						? "- Alpha: yes"
+						: metadata?.hasAlpha === false
+							? "- Alpha: no"
+							: "- Alpha: unknown",
+					"",
+					`If you want to analyze the image, call inspect_image with path="${readPath}" and a question describing what to inspect and the desired output format.`,
+				];
+				content = [{ type: "text", text: metadataLines.join("\n") }];
+				details = {};
+				sourcePath = absolutePath;
 			} else {
-				// Read as image (binary)
-				const file = Bun.file(absolutePath);
-				const buffer = await file.arrayBuffer();
-
-				// Check actual buffer size after reading to prevent OOM during serialization
-				if (buffer.byteLength > MAX_IMAGE_SIZE) {
-					const sizeStr = formatBytes(buffer.byteLength);
+				if (fileSize > MAX_IMAGE_SIZE) {
+					const sizeStr = formatBytes(fileSize);
 					const maxStr = formatBytes(MAX_IMAGE_SIZE);
 					throw new ToolError(`Image file too large: ${sizeStr} exceeds ${maxStr} limit.`);
-				} else {
-					const base64 = new Uint8Array(buffer).toBase64();
-
-					if (this.#autoResizeImages) {
-						// Resize image if needed - catch errors from Photon
-						try {
-							const resized = await resizeImage({ type: "image", data: base64, mimeType });
-							const dimensionNote = formatDimensionNote(resized);
-
-							let textNote = `Read image file [${resized.mimeType}]`;
-							if (dimensionNote) {
-								textNote += `\n${dimensionNote}`;
-							}
-
-							content = [
-								{ type: "text", text: textNote },
-								{ type: "image", data: resized.data, mimeType: resized.mimeType },
-							];
-							details = {};
-							sourcePath = absolutePath;
-						} catch {
-							// Fall back to original image on resize failure
-							content = [
-								{ type: "text", text: `Read image file [${mimeType}]` },
-								{ type: "image", data: base64, mimeType },
-							];
-							details = {};
-							sourcePath = absolutePath;
-						}
-					} else {
-						content = [
-							{ type: "text", text: `Read image file [${mimeType}]` },
-							{ type: "image", data: base64, mimeType },
-						];
-						details = {};
-						sourcePath = absolutePath;
+				}
+				try {
+					const imageInput = await loadImageInput({
+						path: readPath,
+						cwd: this.session.cwd,
+						autoResize: this.#autoResizeImages,
+						maxBytes: MAX_IMAGE_SIZE,
+						resolvedPath: absolutePath,
+						detectedMimeType: mimeType,
+					});
+					if (!imageInput) {
+						throw new ToolError(`Read image file [${mimeType}] failed: unsupported image format.`);
+					}
+					content = [
+						{ type: "text", text: imageInput.textNote },
+						{ type: "image", data: imageInput.data, mimeType: imageInput.mimeType },
+					];
+					details = {};
+					sourcePath = imageInput.resolvedPath;
+				} catch (error) {
+					if (error instanceof ImageInputTooLargeError) {
+						throw new ToolError(error.message);
 					}
+					throw error;
 				}
 			}
 		} else if (CONVERTIBLE_EXTENSIONS.has(ext)) {

package/src/tools/renderers.ts

@@ -18,6 +18,7 @@ import { calculatorToolRenderer } from "./calculator";
 import { fetchToolRenderer } from "./fetch";
 import { findToolRenderer } from "./find";
 import { grepToolRenderer } from "./grep";
+import { inspectImageToolRenderer } from "./inspect-image-renderer";
 import { notebookToolRenderer } from "./notebook";
 import { pythonToolRenderer } from "./python";
 import { readToolRenderer } from "./read";
@@ -51,6 +52,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	grep: grepToolRenderer as ToolRenderer,
 	lsp: lspToolRenderer as ToolRenderer,
 	notebook: notebookToolRenderer as ToolRenderer,
+	inspect_image: inspectImageToolRenderer as ToolRenderer,
 	read: readToolRenderer as ToolRenderer,
 	resolve: resolveToolRenderer as ToolRenderer,
 	ssh: sshToolRenderer as ToolRenderer,

package/src/utils/image-input.ts

@@ -0,0 +1,264 @@
+import * as fs from "node:fs/promises";
+import { formatBytes } from "@oh-my-pi/pi-utils";
+import { resolveReadPath } from "../tools/path-utils";
+import { formatDimensionNote, resizeImage } from "./image-resize";
+import { detectSupportedImageMimeTypeFromFile } from "./mime";
+
+export const MAX_IMAGE_INPUT_BYTES = 20 * 1024 * 1024;
+const MAX_IMAGE_METADATA_HEADER_BYTES = 256 * 1024;
+
+export interface ImageMetadata {
+	mimeType: string;
+	bytes: number;
+	width?: number;
+	height?: number;
+	channels?: number;
+	hasAlpha?: boolean;
+}
+
+export interface LoadedImageInput {
+	resolvedPath: string;
+	mimeType: string;
+	data: string;
+	textNote: string;
+	dimensionNote?: string;
+	bytes: number;
+}
+
+export interface ReadImageMetadataOptions {
+	path: string;
+	cwd: string;
+	resolvedPath?: string;
+	detectedMimeType?: string;
+}
+
+export interface LoadImageInputOptions extends ReadImageMetadataOptions {
+	autoResize: boolean;
+	maxBytes?: number;
+}
+
+export class ImageInputTooLargeError extends Error {
+	readonly bytes: number;
+	readonly maxBytes: number;
+
+	constructor(bytes: number, maxBytes: number) {
+		super(`Image file too large: ${formatBytes(bytes)} exceeds ${formatBytes(maxBytes)} limit.`);
+		this.name = "ImageInputTooLargeError";
+		this.bytes = bytes;
+		this.maxBytes = maxBytes;
+	}
+}
+
+interface ParsedImageHeaderMetadata {
+	width?: number;
+	height?: number;
+	channels?: number;
+	hasAlpha?: boolean;
+}
+
+function parsePngMetadata(header: Buffer): ParsedImageHeaderMetadata {
+	if (header.length < 26) return {};
+	if (
+		header[0] !== 0x89 ||
+		header[1] !== 0x50 ||
+		header[2] !== 0x4e ||
+		header[3] !== 0x47 ||
+		header[4] !== 0x0d ||
+		header[5] !== 0x0a ||
+		header[6] !== 0x1a ||
+		header[7] !== 0x0a
+	) {
+		return {};
+	}
+	if (header.slice(12, 16).toString("ascii") !== "IHDR") return {};
+	const width = header.readUInt32BE(16);
+	const height = header.readUInt32BE(20);
+	const colorType = header[25];
+	if (colorType === 0) return { width, height, channels: 1, hasAlpha: false };
+	if (colorType === 2) return { width, height, channels: 3, hasAlpha: false };
+	if (colorType === 3) return { width, height, channels: 3 };
+	if (colorType === 4) return { width, height, channels: 2, hasAlpha: true };
+	if (colorType === 6) return { width, height, channels: 4, hasAlpha: true };
+	return { width, height };
+}
+
+function parseJpegMetadata(header: Buffer): ParsedImageHeaderMetadata {
+	if (header.length < 4) return {};
+	if (header[0] !== 0xff || header[1] !== 0xd8) return {};
+
+	let offset = 2;
+	while (offset + 9 < header.length) {
+		if (header[offset] !== 0xff) {
+			offset += 1;
+			continue;
+		}
+
+		let markerOffset = offset + 1;
+		while (markerOffset < header.length && header[markerOffset] === 0xff) {
+			markerOffset += 1;
+		}
+		if (markerOffset >= header.length) break;
+
+		const marker = header[markerOffset];
+		const segmentOffset = markerOffset + 1;
+
+		if (marker === 0xd8 || marker === 0xd9 || marker === 0x01) {
+			offset = segmentOffset;
+			continue;
+		}
+		if (marker >= 0xd0 && marker <= 0xd7) {
+			offset = segmentOffset;
+			continue;
+		}
+		if (segmentOffset + 1 >= header.length) break;
+
+		const segmentLength = header.readUInt16BE(segmentOffset);
+		if (segmentLength < 2) break;
+
+		const isStartOfFrame = marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc;
+		if (isStartOfFrame) {
+			if (segmentOffset + 7 >= header.length) break;
+			const height = header.readUInt16BE(segmentOffset + 3);
+			const width = header.readUInt16BE(segmentOffset + 5);
+			const channels = header[segmentOffset + 7];
+			return {
+				width,
+				height,
+				channels: Number.isFinite(channels) ? channels : undefined,
+				hasAlpha: false,
+			};
+		}
+
+		offset = segmentOffset + segmentLength;
+	}
+
+	return {};
+}
+
+function parseGifMetadata(header: Buffer): ParsedImageHeaderMetadata {
+	if (header.length < 10) return {};
+	const signature = header.slice(0, 6).toString("ascii");
+	if (signature !== "GIF87a" && signature !== "GIF89a") return {};
+	return {
+		width: header.readUInt16LE(6),
+		height: header.readUInt16LE(8),
+		channels: 3,
+	};
+}
+
+function parseWebpMetadata(header: Buffer): ParsedImageHeaderMetadata {
+	if (header.length < 30) return {};
+	if (header.slice(0, 4).toString("ascii") !== "RIFF") return {};
+	if (header.slice(8, 12).toString("ascii") !== "WEBP") return {};
+
+	const chunkType = header.slice(12, 16).toString("ascii");
+	if (chunkType === "VP8X") {
+		const hasAlpha = (header[20] & 0x10) !== 0;
+		const width = (header[24] | (header[25] << 8) | (header[26] << 16)) + 1;
+		const height = (header[27] | (header[28] << 8) | (header[29] << 16)) + 1;
+		return { width, height, channels: hasAlpha ? 4 : 3, hasAlpha };
+	}
+	if (chunkType === "VP8L") {
+		if (header.length < 25) return {};
+		const bits = header.readUInt32LE(21);
+		const width = (bits & 0x3fff) + 1;
+		const height = ((bits >> 14) & 0x3fff) + 1;
+		const hasAlpha = ((bits >> 28) & 0x1) === 1;
+		return { width, height, channels: hasAlpha ? 4 : 3, hasAlpha };
+	}
+	if (chunkType === "VP8 ") {
+		const width = header.readUInt16LE(26) & 0x3fff;
+		const height = header.readUInt16LE(28) & 0x3fff;
+		return { width, height, channels: 3, hasAlpha: false };
+	}
+	return {};
+}
+
+function parseImageHeaderMetadata(header: Buffer, mimeType: string): ParsedImageHeaderMetadata {
+	if (mimeType === "image/png") return parsePngMetadata(header);
+	if (mimeType === "image/jpeg") return parseJpegMetadata(header);
+	if (mimeType === "image/gif") return parseGifMetadata(header);
+	if (mimeType === "image/webp") return parseWebpMetadata(header);
+	return {};
+}
+
+async function readHeader(filePath: string, maxBytes: number): Promise<Buffer> {
+	if (maxBytes <= 0) return Buffer.alloc(0);
+	const fileHandle = await fs.open(filePath, "r");
+	try {
+		const buffer = Buffer.allocUnsafe(maxBytes);
+		const { bytesRead } = await fileHandle.read(buffer, 0, maxBytes, 0);
+		return buffer.subarray(0, bytesRead);
+	} finally {
+		await fileHandle.close();
+	}
+}
+
+export async function readImageMetadata(options: ReadImageMetadataOptions): Promise<ImageMetadata | null> {
+	const resolvedPath = options.resolvedPath ?? resolveReadPath(options.path, options.cwd);
+	const mimeType = options.detectedMimeType ?? (await detectSupportedImageMimeTypeFromFile(resolvedPath));
+	if (!mimeType) return null;
+
+	const stats = await Bun.file(resolvedPath).stat();
+	const bytes = stats.size;
+	const headerBytes = Math.max(0, Math.min(bytes, MAX_IMAGE_METADATA_HEADER_BYTES));
+	const header = await readHeader(resolvedPath, headerBytes);
+	const parsed = parseImageHeaderMetadata(header, mimeType);
+
+	return {
+		mimeType,
+		bytes,
+		width: parsed.width,
+		height: parsed.height,
+		channels: parsed.channels,
+		hasAlpha: parsed.hasAlpha,
+	};
+}
+
+export async function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null> {
+	const maxBytes = options.maxBytes ?? MAX_IMAGE_INPUT_BYTES;
+	const resolvedPath = options.resolvedPath ?? resolveReadPath(options.path, options.cwd);
+	const mimeType = options.detectedMimeType ?? (await detectSupportedImageMimeTypeFromFile(resolvedPath));
+	if (!mimeType) return null;
+
+	const stat = await Bun.file(resolvedPath).stat();
+	if (stat.size > maxBytes) {
+		throw new ImageInputTooLargeError(stat.size, maxBytes);
+	}
+
+	const inputBuffer = await fs.readFile(resolvedPath);
+	if (inputBuffer.byteLength > maxBytes) {
+		throw new ImageInputTooLargeError(inputBuffer.byteLength, maxBytes);
+	}
+
+	let outputData = new Uint8Array(inputBuffer).toBase64();
+	let outputMimeType = mimeType;
+	let outputBytes = inputBuffer.byteLength;
+	let dimensionNote: string | undefined;
+
+	if (options.autoResize) {
+		try {
+			const resized = await resizeImage({ type: "image", data: outputData, mimeType });
+			outputData = resized.data;
+			outputMimeType = resized.mimeType;
+			outputBytes = resized.buffer.byteLength;
+			dimensionNote = formatDimensionNote(resized);
+		} catch {
+			// keep original image when resize fails
+		}
+	}
+
+	let textNote = `Read image file [${outputMimeType}]`;
+	if (dimensionNote) {
+		textNote += `\n${dimensionNote}`;
+	}
+
+	return {
+		resolvedPath,
+		mimeType: outputMimeType,
+		data: outputData,
+		textNote,
+		dimensionNote,
+		bytes: outputBytes,
+	};
+}

package/src/web/kagi.ts

@@ -1,18 +1,8 @@
 import { getEnvApiKey } from "@oh-my-pi/pi-ai";
 import { findCredential } from "./search/providers/utils";
 
-const KAGI_SUMMARIZE_URL = "https://kagi.com/api/v0/summarize";
 const KAGI_SEARCH_URL = "https://kagi.com/api/v0/search";
 
-interface KagiSummarizeResponse {
-	data?: {
-		output?: string;
-	};
-	error?: Array<{
-		msg?: string;
-	}>;
-}
-
 interface KagiSearchResultObject {
 	t: 0;
 	url: string;
@@ -105,14 +95,6 @@ function parseKagiErrorResponse(statusCode: number, responseText: string): KagiA
 	}
 }
 
-export interface KagiSummarizeOptions {
-	engine?: string;
-	summaryType?: string;
-	targetLanguage?: string;
-	cache?: boolean;
-	signal?: AbortSignal;
-}
-
 export interface KagiSearchOptions {
 	limit?: number;
 	signal?: AbortSignal;
@@ -142,30 +124,6 @@ function getAuthHeaders(apiKey: string): Record<string, string> {
 	};
 }
 
-export async function summarizeUrlWithKagi(url: string, options: KagiSummarizeOptions = {}): Promise<string | null> {
-	const apiKey = await findKagiApiKey();
-	if (!apiKey) return null;
-
-	const requestUrl = new URL(KAGI_SUMMARIZE_URL);
-	requestUrl.searchParams.set("url", url);
-	requestUrl.searchParams.set("summary_type", options.summaryType ?? "summary");
-	if (options.engine) requestUrl.searchParams.set("engine", options.engine);
-	if (options.targetLanguage) requestUrl.searchParams.set("target_language", options.targetLanguage);
-	if (options.cache !== undefined) requestUrl.searchParams.set("cache", String(options.cache));
-
-	const response = await fetch(requestUrl, {
-		headers: getAuthHeaders(apiKey),
-		signal: options.signal,
-	});
-	if (!response.ok) return null;
-
-	const payload = (await response.json()) as KagiSummarizeResponse;
-	if (payload.error && payload.error.length > 0) return null;
-
-	const output = payload.data?.output?.trim();
-	return output && output.length > 0 ? output : null;
-}
-
 export async function searchWithKagi(query: string, options: KagiSearchOptions = {}): Promise<KagiSearchResult> {
 	const apiKey = await findKagiApiKey();
 	if (!apiKey) {

package/src/web/scrapers/youtube.ts

@@ -4,7 +4,6 @@ import * as path from "node:path";
 import { ptree, Snowflake } from "@oh-my-pi/pi-utils";
 import { throwIfAborted } from "../../tools/tool-errors";
 import { ensureTool } from "../../utils/tools-manager";
-import { summarizeUrlWithKagi } from "../kagi";
 import type { RenderResult, SpecialHandler } from "./types";
 import { buildResult, formatMediaDuration, formatNumber } from "./types";
 
@@ -110,22 +109,6 @@ export const handleYouTube: SpecialHandler = async (
 	const notes: string[] = [];
 	const videoUrl = `https://www.youtube.com/watch?v=${yt.videoId}`;
 
-	// Prefer Kagi Universal Summarizer when credentials are available
-	try {
-		const kagiSummary = await summarizeUrlWithKagi(videoUrl, { signal });
-		if (kagiSummary && kagiSummary.length > 100) {
-			return buildResult(kagiSummary, {
-				url,
-				finalUrl: videoUrl,
-				method: "kagi",
-				fetchedAt,
-				notes: ["Used Kagi Universal Summarizer for YouTube"],
-			});
-		}
-	} catch {
-		throwIfAborted(signal);
-	}
-
 	// Ensure yt-dlp is available (auto-download if missing)
 	const ytdlp = await ensureTool("yt-dlp", { signal, silent: true });
 	if (!ytdlp) {

package/src/web/search/index.ts

@@ -1,7 +1,7 @@
 /**
  * Unified Web Search Tool
  *
- * Single tool supporting Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, Codex, Z.AI, and Synthetic
+ * Single tool supporting Anthropic, Perplexity, Exa, Brave, Jina, Kimi, Gemini, Codex, Tavily, Kagi, Z.AI, and Synthetic
  * providers with provider-specific parameters exposed conditionally.
  *
  * When EXA_API_KEY is available, additional specialized tools are exposed:
@@ -45,6 +45,7 @@ export const webSearchSchema = Type.Object({
 				"perplexity",
 				"gemini",
 				"codex",
+				"tavily",
 				"kagi",
 				"synthetic",
 			],
@@ -77,6 +78,7 @@ export type SearchParams = {
 		| "perplexity"
 		| "gemini"
 		| "codex"
+		| "tavily"
 		| "kagi"
 		| "synthetic";
 	recency?: "day" | "week" | "month" | "year";

package/src/web/search/provider.ts

@@ -9,6 +9,7 @@ import { KagiProvider } from "./providers/kagi";
 import { KimiProvider } from "./providers/kimi";
 import { PerplexityProvider } from "./providers/perplexity";
 import { SyntheticProvider } from "./providers/synthetic";
+import { TavilyProvider } from "./providers/tavily";
 import { ZaiProvider } from "./providers/zai";
 import type { SearchProviderId } from "./types";
 
@@ -25,11 +26,13 @@ const SEARCH_PROVIDERS: Record<SearchProviderId, SearchProvider> = {
 	anthropic: new AnthropicProvider(),
 	gemini: new GeminiProvider(),
 	codex: new CodexProvider(),
+	tavily: new TavilyProvider(),
 	kagi: new KagiProvider(),
 	synthetic: new SyntheticProvider(),
 } as const;
 
 export const SEARCH_PROVIDER_ORDER: SearchProviderId[] = [
+	"tavily",
 	"perplexity",
 	"brave",
 	"jina",
@@ -55,7 +58,7 @@ export function setPreferredSearchProvider(provider: SearchProviderId | "auto"):
 	preferredProvId = provider;
 }
 
-/** Determine which providers are configured (priority: Perplexity → Brave → Jina → Kimi → Anthropic → Gemini → Codex → Z.AI → Exa → Synthetic) */
+/** Determine which providers are configured (priority: Perplexity → Brave → Jina → Kimi → Anthropic → Gemini → Codex → Z.AI → Exa → Tavily → Kagi → Synthetic) */
 export async function resolveProviderChain(
 	preferredProvider: SearchProviderId | "auto" = preferredProvId,
 ): Promise<SearchProvider[]> {

package/src/web/search/providers/exa.ts

@@ -7,6 +7,7 @@
  * them into a combined `answer` string on the SearchResponse.
  */
 import { getEnvApiKey } from "@oh-my-pi/pi-ai";
+import { settings } from "../../../config/settings";
 import { callExaTool, findApiKey, isSearchResponse } from "../../../exa/mcp-client";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
@@ -244,6 +245,13 @@ export class ExaProvider extends SearchProvider {
 	readonly label = "Exa";
 
 	isAvailable(): boolean {
+		try {
+			if (settings.get("exa.enabled") === false || settings.get("exa.enableSearch") === false) {
+				return false;
+			}
+		} catch {
+			// Settings not initialized; fall through to public MCP availability
+		}
 		return true;
 	}