@sayknow-cli/coding-agent 0.3.15 → 0.4.0

package/src/tools/subagent.ts

@@ -17,6 +17,10 @@ const MAX_LIST_LIMIT = 50;
 const RECEIPT_PREVIEW_WIDTH = 280;
 const PREVIEW_WIDTH = 2_000;
 const FULL_PREVIEW_WIDTH = 12_000;
+const RECEIPT_PREVIEW_BYTES = 1_024;
+const PREVIEW_BYTES = 8_192;
+const FULL_PREVIEW_BYTES = 49_152;
+
 const STEER_QUEUED_GUIDANCE =
 	"The steer message is queued for the subagent's next steering boundary and has not necessarily taken effect yet.";
 
@@ -80,8 +84,17 @@ export interface SubagentSnapshot {
 	modelFellBack?: boolean;
 }
 
+export type SubagentAwaitOutcome = "completed" | "timed_out" | "interrupted";
+
+const AWAIT_INTERRUPTED_GUIDANCE =
+	"Await interrupted; this subagent continues. Inspect its current state or cancel it only when necessary.";
+
 export interface SubagentToolDetails {
 	subagents: SubagentSnapshot[];
+	/** Await outcome for a live await receipt; omitted when no wait was started. */
+	awaitOutcome?: SubagentAwaitOutcome;
+	/** True only when the parent await was interrupted; the child was not cancelled. */
+	interrupted?: true;
 }
 
 export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentToolDetails> {
@@ -214,6 +227,8 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 				if (!result.ok && result.reason === "context_unavailable") throw new ToolError("context unavailable");
 				if (!result.ok && result.reason === "not_found") {
 					missing.push(this.#missingSnapshot(id, "not_found", "No visible detached subagent matches this id."));
+				} else if (!result.ok) {
+					throw new ToolError(`Failed to resume subagent ${record.subagentId}: ${result.reason ?? "unknown"}.`);
 				} else {
 					records.push(manager.getSubagentRecord(record.subagentId, ownerFilter) ?? record);
 				}
@@ -370,35 +385,50 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		// the viewport (the source of the await-panel repaint storms).
 		emitIfChanged(true);
 
-		let timedOut = false;
+		let awaitOutcome: SubagentAwaitOutcome;
+		const { promise: timeoutPromise, resolve: resolveTimeout } = Promise.withResolvers<SubagentAwaitOutcome>();
+		const timeoutTimer = setTimeout(() => resolveTimeout("timed_out"), timeoutMs);
+		const completionPromise = Promise.all(runningJobs.map(job => job.promise)).then(() => "completed" as const);
+		let onAbort: (() => void) | undefined;
 		try {
-			const completionPromise = Promise.all(runningJobs.map(job => job.promise));
-			const timeoutPromise = Bun.sleep(timeoutMs).then(() => {
-				timedOut = true;
-			});
 			if (signal) {
-				const { promise: abortPromise, resolve: abortResolve } = Promise.withResolvers<void>();
-				const onAbort = () => abortResolve();
-				signal.addEventListener("abort", onAbort, { once: true });
-				try {
-					await Promise.race([completionPromise, timeoutPromise, abortPromise]);
-				} finally {
-					signal.removeEventListener("abort", onAbort);
-				}
+				const { promise: abortPromise, resolve: resolveAbort } = Promise.withResolvers<SubagentAwaitOutcome>();
+				onAbort = () => resolveAbort("interrupted");
+				if (signal.aborted) onAbort();
+				else signal.addEventListener("abort", onAbort, { once: true });
+				awaitOutcome = await Promise.race([completionPromise, timeoutPromise, abortPromise]);
 			} else {
-				await Promise.race([completionPromise, timeoutPromise]);
+				awaitOutcome = await Promise.race([completionPromise, timeoutPromise]);
 			}
 		} finally {
-			manager.unwatchJobs(watchedJobIds);
+			clearTimeout(timeoutTimer);
+			if (signal && onAbort) signal.removeEventListener("abort", onAbort);
 			if (progressTimer) clearInterval(progressTimer);
 		}
+		if (awaitOutcome !== "interrupted") {
+			const terminalWatchedJobIds = watchedJobIds.filter(jobId => {
+				const status = manager.getJob(jobId)?.status;
+				return status === "completed" || status === "failed" || status === "cancelled";
+			});
+			manager.acknowledgeDeliveries(terminalWatchedJobIds);
+		}
+		manager.unwatchJobs(watchedJobIds);
 
-		return await this.#buildRecordResult(manager, records, {
-			title: "Subagent await",
-			notFoundIds,
-			timedOut,
+		const finalRecords = this.#visibleRecordsByIds(
+			manager,
+			records.map(record => record.subagentId),
+			ownerFilter,
+		);
+		const finalNotFoundIds = [...new Set([...notFoundIds, ...records.map(record => record.subagentId)])].filter(
+			id => !finalRecords.some(record => record.subagentId === id),
+		);
+		return await this.#buildRecordResult(manager, finalRecords, {
+			title: awaitOutcome === "interrupted" ? "Subagent await interrupted" : "Subagent await",
+			notFoundIds: finalNotFoundIds,
+			timedOut: awaitOutcome === "timed_out",
 			verbosity: params.verbosity ?? "receipt",
 			attachLiveProgress: true,
+			awaitOutcome,
 		});
 	}
 
@@ -516,6 +546,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			timedOut?: boolean;
 			verbosity?: SubagentParams["verbosity"];
 			attachLiveProgress?: boolean;
+			awaitOutcome?: SubagentAwaitOutcome;
 		},
 	): Promise<AgentToolResult<SubagentToolDetails>> {
 		const verifiedOutputIds = await this.#verifiedOutputIds(records);
@@ -530,18 +561,34 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		for (const id of options.notFoundIds ?? []) {
 			snapshots.push(this.#missingSnapshot(id, "not_found", "No visible detached subagent matches this id."));
 		}
-		manager.acknowledgeDeliveries(
-			snapshots
-				.filter(
-					s =>
-						s.status !== "running" && s.status !== "paused" && s.status !== "queued" && s.status !== "not_found",
-				)
-				.map(s => s.jobId),
-		);
-		return this.#buildSnapshotResult(snapshots, options.title);
+		if (options.awaitOutcome !== "interrupted") {
+			manager.acknowledgeDeliveries(
+				snapshots
+					.filter(
+						s =>
+							s.status !== "running" &&
+							s.status !== "paused" &&
+							s.status !== "queued" &&
+							s.status !== "not_found",
+					)
+					.map(s => s.jobId),
+			);
+		}
+		if (options.awaitOutcome === "interrupted") {
+			for (const snapshot of snapshots) {
+				if (snapshot.status === "running" || snapshot.status === "paused" || snapshot.status === "queued") {
+					snapshot.guidance = AWAIT_INTERRUPTED_GUIDANCE;
+				}
+			}
+		}
+		return this.#buildSnapshotResult(snapshots, options.title, options.awaitOutcome);
 	}
 
-	#buildSnapshotResult(snapshots: SubagentSnapshot[], title: string): AgentToolResult<SubagentToolDetails> {
+	#buildSnapshotResult(
+		snapshots: SubagentSnapshot[],
+		title: string,
+		awaitOutcome?: SubagentAwaitOutcome,
+	): AgentToolResult<SubagentToolDetails> {
 		const lines = [`## ${title} (${snapshots.length})`, ""];
 		for (const snapshot of snapshots) {
 			lines.push(`### ${snapshot.id} — ${snapshot.status}`);
@@ -571,7 +618,11 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 		}
 		return {
 			content: [{ type: "text", text: lines.join("\n").trimEnd() }],
-			details: { subagents: snapshots },
+			details: {
+				subagents: snapshots,
+				...(awaitOutcome ? { awaitOutcome } : {}),
+				...(awaitOutcome === "interrupted" ? { interrupted: true } : {}),
+			},
 		};
 	}
 
@@ -738,7 +789,40 @@ function isSubagentJob(job: AsyncJob): boolean {
 }
 
 function sanitizeText(text: string, width: number): string {
-	return truncateToWidth(replaceTabs(text), width, Ellipsis.Unicode);
+	return capCodePointsAndBytes(
+		truncateToWidth(replaceTabs(text), width, Ellipsis.Unicode),
+		width,
+		previewByteCap(width),
+	);
+}
+
+function previewByteCap(width: number): number {
+	return width === FULL_PREVIEW_WIDTH
+		? FULL_PREVIEW_BYTES
+		: width === PREVIEW_WIDTH
+			? PREVIEW_BYTES
+			: RECEIPT_PREVIEW_BYTES;
+}
+
+export function capCodePointsAndBytes(text: string, maxCodePoints: number, maxBytes: number): string {
+	const ellipsis = "…";
+	const collapsed = text.replace(/…{2,}$/u, ellipsis);
+	const codePoints = [...collapsed];
+	if (codePoints.length <= maxCodePoints && Buffer.byteLength(collapsed) <= maxBytes) return collapsed;
+
+	const source = collapsed.endsWith(ellipsis) ? collapsed.slice(0, -ellipsis.length) : collapsed;
+	const ellipsisBytes = Buffer.byteLength(ellipsis);
+	let preview = "";
+	let previewBytes = 0;
+	let previewCodePoints = 0;
+	for (const codePoint of source) {
+		const codePointBytes = Buffer.byteLength(codePoint);
+		if (previewCodePoints + 1 + 1 > maxCodePoints || previewBytes + codePointBytes + ellipsisBytes > maxBytes) break;
+		preview += codePoint;
+		previewBytes += codePointBytes;
+		previewCodePoints++;
+	}
+	return `${preview}${ellipsis}`;
 }
 
 function previewJobOutput(
@@ -754,7 +838,11 @@ function previewJobOutput(
 	const width =
 		verbosity === "full" ? FULL_PREVIEW_WIDTH : verbosity === "preview" ? PREVIEW_WIDTH : RECEIPT_PREVIEW_WIDTH;
 	const normalized = replaceTabs(source.text);
-	const preview = truncateToWidth(normalized, width, Ellipsis.Unicode);
+	const preview = capCodePointsAndBytes(
+		truncateToWidth(normalized, width, Ellipsis.Unicode),
+		width,
+		previewByteCap(width),
+	);
 	return { type: source.type, preview, truncated: preview !== normalized };
 }
 
@@ -778,8 +866,15 @@ function previewJobOutput(
  * countdown ticking is sacrificed by design; every real transition still changes
  * the signature.
  */
-export function subagentAwaitRenderedStateSignature(subagents: readonly SubagentSnapshot[]): string {
-	return JSON.stringify(subagents.map(canonicalizeSnapshotForSignature));
+export function subagentAwaitRenderedStateSignature(
+	subagents: readonly SubagentSnapshot[],
+	receipt?: Pick<SubagentToolDetails, "awaitOutcome" | "interrupted">,
+): string {
+	return JSON.stringify({
+		awaitOutcome: receipt?.awaitOutcome ?? null,
+		interrupted: receipt?.interrupted === true,
+		subagents: subagents.map(canonicalizeSnapshotForSignature),
+	});
 }
 
 function canonicalizeSnapshotForSignature(snapshot: SubagentSnapshot): unknown {

package/src/tools/telegram-send.ts

@@ -2,8 +2,8 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
 import { z } from "zod/v4";
-import { getTelegramFileSink } from "../notifications/attachment-registry";
-import { getNotificationConfig, isGloballyConfigured } from "../notifications/config";
+import { getTelegramFileSink } from "../sdk/bus/attachment-registry";
+import { getNotificationConfig, isGloballyConfigured } from "../sdk/bus/config";
 import type { ToolSession } from "./index";
 
 const TELEGRAM_SEND_MAX_FILE_BYTES = 50 * 1024 * 1024;

package/src/utils/event-bus.ts

@@ -1,7 +1,7 @@
 import { logger } from "@sayknow-cli/utils";
 
 export class EventBus {
-	readonly #listeners = new Map<string, Set<(data: unknown) => void>>();
+	readonly #listeners = new Map<string, Set<(data: unknown) => void | PromiseLike<void>>>();
 
 	emit(channel: string, data: unknown): void {
 		const handlers = this.#listeners.get(channel);
@@ -12,13 +12,18 @@ export class EventBus {
 		}
 	}
 
-	on(channel: string, handler: (data: unknown) => void): () => void {
+	on(channel: string, handler: (data: unknown) => void | PromiseLike<void>): () => void {
 		if (!this.#listeners.has(channel)) {
 			this.#listeners.set(channel, new Set());
 		}
-		const safeHandler = async (data: unknown) => {
+		const safeHandler = (data: unknown): void => {
 			try {
-				await handler(data);
+				const result = handler(data);
+				if (result && typeof result.then === "function") {
+					Promise.resolve(result).catch(err => {
+						logger.error("Event handler error", { channel, error: String(err) });
+					});
+				}
 			} catch (err) {
 				logger.error("Event handler error", { channel, error: String(err) });
 			}

package/src/utils/file-mentions.ts

@@ -160,11 +160,11 @@ async function resolveMentionPath(
 }
 
 /**
- * Default inline cap for auto-read file mentions, deliberately below the
- * read-tool cap (`DEFAULT_MAX_BYTES`, 50KB) so an incidental `@path` mention
- * injects a smaller snippet than an explicit `read`. Overridable per call.
+ * Default inline cap for auto-read file mentions, aligned with the read-tool's
+ * 10 KiB bare-read receipt so an incidental `@path` mention injects a bounded
+ * snippet. Overridable per call.
  */
-export const DEFAULT_FILE_MENTION_INLINE_BYTES = 20 * 1024;
+export const DEFAULT_FILE_MENTION_INLINE_BYTES = 10 * 1024;
 
 function buildTextOutput(textContent: string, maxInlineBytes?: number): { output: string; lineCount: number } {
 	const cap = maxInlineBytes && maxInlineBytes > 0 ? maxInlineBytes : DEFAULT_FILE_MENTION_INLINE_BYTES;

package/src/utils/image-loading.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs/promises";
 import type { ImageContent } from "@sayknow-cli/ai";
 import { formatBytes, readImageMetadata, SUPPORTED_IMAGE_MIME_TYPES } from "@sayknow-cli/utils";
 import { resolveReadPath } from "../tools/path-utils";
-import { formatDimensionNote, resizeImage } from "./image-resize";
+import { formatDimensionNote, resizeImageBuffer } from "./image-resize";
 
 export const MAX_IMAGE_INPUT_BYTES = 20 * 1024 * 1024;
 export const SUPPORTED_INPUT_IMAGE_MIME_TYPES = SUPPORTED_IMAGE_MIME_TYPES;
@@ -14,6 +14,26 @@ export interface LoadImageInputOptions {
 	maxBytes?: number;
 	resolvedPath?: string;
 	detectedMimeType?: string;
+	signal?: AbortSignal;
+}
+
+export interface LoadImageInputBytesOptions {
+	inputBuffer: Buffer;
+	resolvedPath: string;
+	mimeType: string;
+	autoResize: boolean;
+	maxBytes?: number;
+	maxOutputBytes?: number;
+	signal?: AbortSignal;
+}
+
+export interface TransformedImageInput {
+	resolvedPath: string;
+	mimeType: string;
+	buffer: Uint8Array;
+	textNote: string;
+	dimensionNote?: string;
+	bytes: number;
 }
 
 export interface LoadedImageInput {
@@ -38,9 +58,7 @@ export class ImageInputTooLargeError extends Error {
 }
 
 export async function ensureSupportedImageInput(image: ImageContent): Promise<ImageContent | null> {
-	if (SUPPORTED_INPUT_IMAGE_MIME_TYPES.has(image.mimeType)) {
-		return image;
-	}
+	if (SUPPORTED_INPUT_IMAGE_MIME_TYPES.has(image.mimeType)) return image;
 	try {
 		const bytes = Buffer.from(image.data, "base64");
 		const data = await new Bun.Image(bytes).png().toBase64();
@@ -50,53 +68,86 @@ export async function ensureSupportedImageInput(image: ImageContent): Promise<Im
 	}
 }
 
-export async function loadImageInput(options: LoadImageInputOptions): Promise<LoadedImageInput | null> {
+/** Transform trusted source bytes without materializing a base64 payload. */
+export async function transformImageInputBytes(options: LoadImageInputBytesOptions): Promise<TransformedImageInput> {
 	const maxBytes = options.maxBytes ?? MAX_IMAGE_INPUT_BYTES;
-	const resolvedPath = options.resolvedPath ?? resolveReadPath(options.path, options.cwd);
-	const metadata = options.detectedMimeType
-		? { mimeType: options.detectedMimeType }
-		: await readImageMetadata(resolvedPath);
-	const mimeType = metadata?.mimeType;
-	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);
+	options.signal?.throwIfAborted();
+	if (options.inputBuffer.byteLength > maxBytes) {
+		throw new ImageInputTooLargeError(options.inputBuffer.byteLength, maxBytes);
 	}
 
-	let outputData = Buffer.from(inputBuffer).toBase64();
-	let outputMimeType = mimeType;
-	let outputBytes = inputBuffer.byteLength;
+	let outputBuffer: Uint8Array = options.inputBuffer;
+	let outputMimeType = options.mimeType;
 	let dimensionNote: string | undefined;
 
 	if (options.autoResize) {
+		options.signal?.throwIfAborted();
 		try {
-			const resized = await resizeImage({ type: "image", data: outputData, mimeType });
-			outputData = resized.data;
+			const resized = await resizeImageBuffer(
+				options.inputBuffer,
+				options.mimeType,
+				options.maxOutputBytes === undefined ? undefined : { maxBytes: options.maxOutputBytes },
+			);
+			options.signal?.throwIfAborted();
+			outputBuffer = resized.buffer;
 			outputMimeType = resized.mimeType;
-			outputBytes = resized.buffer.byteLength;
 			dimensionNote = formatDimensionNote(resized);
 		} catch {
-			// keep original image when resize fails
+			options.signal?.throwIfAborted();
+			// Keep the original image when optional resize fails.
 		}
 	}
 
+	options.signal?.throwIfAborted();
 	let textNote = `Read image file [${outputMimeType}]`;
-	if (dimensionNote) {
-		textNote += `\n${dimensionNote}`;
-	}
-
+	if (dimensionNote) textNote += `\n${dimensionNote}`;
 	return {
-		resolvedPath,
+		resolvedPath: options.resolvedPath,
 		mimeType: outputMimeType,
-		data: outputData,
+		buffer: outputBuffer,
 		textNote,
 		dimensionNote,
-		bytes: outputBytes,
+		bytes: outputBuffer.byteLength,
+	};
+}
+
+export function materializeImageInput(transformed: TransformedImageInput): LoadedImageInput {
+	return {
+		resolvedPath: transformed.resolvedPath,
+		mimeType: transformed.mimeType,
+		data: Buffer.from(transformed.buffer).toBase64(),
+		textNote: transformed.textNote,
+		dimensionNote: transformed.dimensionNote,
+		bytes: transformed.bytes,
 	};
 }
+
+/** Build a model image payload from bytes already read through a trusted descriptor. */
+export async function loadImageInputBytes(options: LoadImageInputBytesOptions): Promise<LoadedImageInput> {
+	return materializeImageInput(await transformImageInputBytes(options));
+}
+
+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);
+	options.signal?.throwIfAborted();
+	const metadata = options.detectedMimeType
+		? { mimeType: options.detectedMimeType }
+		: await readImageMetadata(resolvedPath);
+	const mimeType = metadata?.mimeType;
+	if (!mimeType) return null;
+
+	options.signal?.throwIfAborted();
+	const stat = await Bun.file(resolvedPath).stat();
+	if (stat.size > maxBytes) throw new ImageInputTooLargeError(stat.size, maxBytes);
+
+	const inputBuffer = await fs.readFile(resolvedPath, { signal: options.signal });
+	return loadImageInputBytes({
+		inputBuffer,
+		resolvedPath,
+		mimeType,
+		autoResize: options.autoResize,
+		maxBytes,
+		signal: options.signal,
+	});
+}

package/src/utils/image-resize.ts

@@ -21,14 +21,14 @@ export interface ResizedImage {
 
 // 500KB target — aggressive compression; Anthropic's 5MB per-image cap is rarely the
 // binding constraint once images are downsized to 1568px (Anthropic's internal threshold).
-const DEFAULT_MAX_BYTES = 500 * 1024;
+export const DEFAULT_IMAGE_RESIZE_MAX_BYTES = 500 * 1024;
 
 const DEFAULT_OPTIONS: Required<Omit<ImageResizeOptions, "excludeWebP">> = {
 	// Anthropic's "internal recommended size" — Anthropic model internally caps images at
 	// 1568px on the longest edge before vision processing.
 	maxWidth: 1568,
 	maxHeight: 1568,
-	maxBytes: DEFAULT_MAX_BYTES,
+	maxBytes: DEFAULT_IMAGE_RESIZE_MAX_BYTES,
 	jpegQuality: 80,
 };
 
@@ -72,14 +72,17 @@ Buffer.prototype.toBase64 = function (this: Buffer) {
  * Backed by `Bun.Image`: a chainable native pipeline that runs decode/transform/encode
  * off the JS thread when the terminal (`.bytes()`) is awaited.
  */
-export async function resizeImage(img: ImageContent, options?: ImageResizeOptions): Promise<ResizedImage> {
+export async function resizeImageBuffer(
+	inputBuffer: Buffer,
+	inputMimeType: string,
+	options?: ImageResizeOptions,
+): Promise<ResizedImage> {
 	const excludeWebP = options?.excludeWebP ?? isWebPExcluded();
 	const opts = { ...DEFAULT_OPTIONS, ...options, excludeWebP };
-	const inputBuffer = Buffer.from(img.data, "base64");
 
 	try {
 		const { width: originalWidth, height: originalHeight, format } = await new Bun.Image(inputBuffer).metadata();
-		const sourceMime = img.mimeType ?? `image/${format}`;
+		const sourceMime = inputMimeType ?? `image/${format}`;
 
 		// Fast path: already within dimensions AND well under budget.
 		// Threshold is 1/4 of budget — if already that compact, don't re-encode.
@@ -102,7 +105,7 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 				height: originalHeight,
 				wasResized: false,
 				get data() {
-					return img.data;
+					return inputBuffer.toBase64();
 				},
 			};
 		}
@@ -272,24 +275,28 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 		// When the caller demanded WebP exclusion AND the original is WebP,
 		// returning the original buffer would silently violate that contract,
 		// so surface an explicit error instead.
-		if (excludeWebP && (img.mimeType === "image/webp" || !img.mimeType)) {
+		if (excludeWebP && (inputMimeType === "image/webp" || !inputMimeType)) {
 			throw new Error("resizeImage: failed to decode image and cannot honor excludeWebP for a WebP source");
 		}
 		return {
 			buffer: inputBuffer,
-			mimeType: img.mimeType,
+			mimeType: inputMimeType,
 			originalWidth: 0,
 			originalHeight: 0,
 			width: 0,
 			height: 0,
 			wasResized: false,
 			get data() {
-				return img.data;
+				return inputBuffer.toBase64();
 			},
 		};
 	}
 }
 
+export function resizeImage(img: ImageContent, options?: ImageResizeOptions): Promise<ResizedImage> {
+	return resizeImageBuffer(Buffer.from(img.data, "base64"), img.mimeType, options);
+}
+
 /**
  * Format a dimension note for resized images.
  * This helps the model understand the coordinate mapping.