@luckypiggy/zhihu-ai-cli 0.1.0-test.1

package/dist/http.js

@@ -0,0 +1,1875 @@
+import { lstatSync, readFileSync } from "node:fs";
+import { isIP } from "node:net";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { isAbsolute } from "node:path";
+import { CLI_VERSION, P1_CAPABILITY_SCOPES } from "./contracts.js";
+const INTEGRATION_PATH = "/api/zhihu/integrations/v1";
+const DEFAULT_MAX_RESPONSE_BYTES = 1024 * 1024;
+const MAX_REQUEST_BYTES = 128 * 1024;
+const MAX_CA_BUNDLE_BYTES = 4 * 1024 * 1024;
+const CLI_USER_AGENT = `zhihu-ai-cli/${CLI_VERSION}`;
+const INFO_CAPABILITIES = [
+    "info",
+    "capabilities",
+    "employees",
+    "assets",
+    "incidents",
+    "inspections",
+    "metrics",
+    "alarms",
+];
+function semver(value) {
+    if (typeof value !== "string" || !/^\d+\.\d+\.\d+$/.test(value))
+        return null;
+    const parts = value.split(".").map(Number);
+    if (parts.some((part) => !Number.isSafeInteger(part) || part < 0))
+        return null;
+    return parts;
+}
+function compareSemver(left, right) {
+    for (let index = 0; index < 3; index += 1) {
+        if (left[index] !== right[index])
+            return left[index] - right[index];
+    }
+    return 0;
+}
+/** Validate the exact, unauthenticated integration discovery contract. */
+export function validateIntegrationInfo(value, requireReady = false) {
+    const object = validateResponseObject(value, "Info");
+    const expectedKeys = new Set(["service", "protocol_version", "minimum_cli_version", "status", "capabilities", "auth"]);
+    if (Object.keys(object).length !== expectedKeys.size || Object.keys(object).some((key) => !expectedKeys.has(key))) {
+        throw new HttpError("PROTOCOL_ERROR", "Info response is invalid");
+    }
+    if (object.service !== "zhihu-pilot" || object.protocol_version !== "1.0") {
+        throw new HttpError("VERSION_INCOMPATIBLE", "The configured Pilot does not support this CLI version");
+    }
+    const minimum = semver(object.minimum_cli_version);
+    const current = semver(CLI_VERSION);
+    if (!minimum || !current || compareSemver(minimum, current) > 0) {
+        throw new HttpError("VERSION_INCOMPATIBLE", "The configured Pilot requires a newer CLI version");
+    }
+    if (object.status !== "ready" && object.status !== "configuration_required") {
+        throw new HttpError("PROTOCOL_ERROR", "Info response is invalid");
+    }
+    if (!Array.isArray(object.capabilities) || object.capabilities.length === 0) {
+        throw new HttpError("PROTOCOL_ERROR", "Info capabilities are invalid");
+    }
+    const capabilities = object.capabilities;
+    let previous = -1;
+    const seen = new Set();
+    for (const capability of capabilities) {
+        if (typeof capability !== "string" || !INFO_CAPABILITIES.includes(capability)) {
+            throw new HttpError("PROTOCOL_ERROR", "Info capabilities are invalid");
+        }
+        const index = INFO_CAPABILITIES.indexOf(capability);
+        if (index <= previous || seen.has(capability))
+            throw new HttpError("PROTOCOL_ERROR", "Info capabilities are invalid");
+        seen.add(capability);
+        previous = index;
+    }
+    if (!seen.has("info"))
+        throw new HttpError("PROTOCOL_ERROR", "Info capabilities are invalid");
+    const auth = validateResponseObject(object.auth, "Info auth");
+    const authKeys = new Set(["mode", "configured", "pkce_methods"]);
+    if (Object.keys(auth).length !== authKeys.size || Object.keys(auth).some((key) => !authKeys.has(key))) {
+        throw new HttpError("PROTOCOL_ERROR", "Info auth is invalid");
+    }
+    if (auth.mode !== "pilot_oauth_bff" || typeof auth.configured !== "boolean"
+        || !Array.isArray(auth.pkce_methods) || auth.pkce_methods.length !== 1 || auth.pkce_methods[0] !== "S256") {
+        throw new HttpError("PROTOCOL_ERROR", "Info auth is invalid");
+    }
+    const baseCapabilities = INFO_CAPABILITIES.slice(0, 4);
+    const baseMatch = capabilities.length >= baseCapabilities.length
+        && baseCapabilities.every((capability, index) => capabilities[index] === capability);
+    const hasMetrics = seen.has("metrics");
+    const hasAlarms = seen.has("alarms");
+    const hasIncidents = seen.has("incidents");
+    const hasInspections = seen.has("inspections");
+    // The backend advertises a monotonic capability set.  The base four are
+    // always present; metrics and alarms may be enabled independently.  The
+    // incident/inspection pair is available only when both data sources exist,
+    // and the pair itself is all-or-nothing.
+    const optionalCombinationValid = baseMatch && (capabilities.length === 4
+        || (capabilities.length === 5 && hasMetrics && !hasAlarms && !hasIncidents && !hasInspections)
+        || (capabilities.length === 5 && hasAlarms && !hasMetrics && !hasIncidents && !hasInspections)
+        || (capabilities.length === 8 && hasMetrics && hasAlarms && hasIncidents && hasInspections));
+    if (object.status === "ready" && (auth.configured !== true || !optionalCombinationValid)) {
+        throw new HttpError("PROTOCOL_ERROR", "Info readiness is inconsistent");
+    }
+    if (object.status === "configuration_required" && (auth.configured !== false
+        || capabilities.length !== 1 || capabilities[0] !== "info")) {
+        throw new HttpError("PROTOCOL_ERROR", "Info readiness is inconsistent");
+    }
+    if (requireReady && (object.status !== "ready" || auth.configured !== true || !optionalCombinationValid)) {
+        if (object.status === "configuration_required" && auth.configured === false) {
+            throw new HttpError("SERVICE_CONFIGURATION_REQUIRED", "Pilot is not configured for CLI OAuth yet. Ask a Pilot administrator to complete the server-side CLI OAuth configuration before installing.");
+        }
+        throw new HttpError("VERSION_INCOMPATIBLE", "The configured Pilot is not ready for CLI installation");
+    }
+    return {
+        service: object.service,
+        protocol_version: object.protocol_version,
+        minimum_cli_version: object.minimum_cli_version,
+        status: object.status,
+        capabilities: capabilities,
+        auth: {
+            mode: auth.mode,
+            configured: auth.configured,
+            pkce_methods: ["S256"],
+        },
+    };
+}
+export class HttpError extends Error {
+    code;
+    status;
+    retryable;
+    constructor(code, message, options = {}) {
+        super(message);
+        this.name = "HttpError";
+        this.code = code;
+        this.status = options.status;
+        this.retryable = options.retryable ?? false;
+    }
+}
+// Retryability is a client-side contract derived from the stable error code,
+// never from a provider/server message or a caller-controlled envelope field.
+// Keep this list aligned with the public integration error contract.
+const RETRYABLE_ERROR_CODES = new Set([
+    "RATE_LIMITED",
+    "RATE_LIMITER_UNAVAILABLE",
+    "CONVERSATION_BUSY",
+    "CONVERSATION_CAPACITY_REACHED",
+    "DATA_SOURCE_UNAVAILABLE",
+    "TIMEOUT",
+]);
+const NON_RETRYABLE_ERROR_CODES = new Set([
+    "AUTH_RELOGIN_REQUIRED",
+    "CAPABILITY_SCOPE_REQUIRED",
+    "CAPABILITY_NOT_AVAILABLE",
+    "FORBIDDEN",
+    "INVALID_ARGUMENT",
+    "EMPLOYEE_NOT_FOUND",
+    "EMPLOYEE_NOT_CHATABLE",
+    "CONVERSATION_NOT_FOUND",
+    "MODEL_NOT_FOUND",
+    "ASSET_NOT_FOUND",
+    "ALARM_NOT_FOUND",
+    "INCIDENT_ASSET_IDENTITY_UNAVAILABLE",
+    "UPSTREAM_PROTOCOL_ERROR",
+    "UPSTREAM_RESPONSE_TOO_LARGE",
+    "USER_CANCELLED",
+    "PROTOCOL_ERROR",
+]);
+function retryableForCode(code, fallback) {
+    if (RETRYABLE_ERROR_CODES.has(code))
+        return true;
+    if (NON_RETRYABLE_ERROR_CODES.has(code))
+        return false;
+    return fallback;
+}
+function stableCode(status) {
+    if (status === 401)
+        return { code: "AUTH_RELOGIN_REQUIRED", retryable: false };
+    if (status === 403)
+        return { code: "FORBIDDEN", retryable: false };
+    if (status === 429)
+        return { code: "RATE_LIMITED", retryable: true };
+    if (status >= 500)
+        return { code: "SERVER_ERROR", retryable: true };
+    return { code: "PROTOCOL_ERROR", retryable: false };
+}
+function responseError(status, body) {
+    const fallback = stableCode(status);
+    const messages = {
+        AUTH_RELOGIN_REQUIRED: "Your Zhihu session has expired. Run `zhihu auth login`.",
+        CAPABILITY_NOT_AVAILABLE: "This capability is not available on the configured Pilot.",
+        CAPABILITY_SCOPE_REQUIRED: "This CLI session is not allowed to use this capability.",
+        FORBIDDEN: "The server denied this operation.",
+        RATE_LIMITED: "The server is rate limiting requests; try again later.",
+        RATE_LIMITER_UNAVAILABLE: "The capability service is temporarily unavailable; try again later.",
+        SERVER_ERROR: "The server could not complete the request.",
+        PROTOCOL_ERROR: "The server returned an invalid response.",
+        EMPLOYEE_NOT_FOUND: "The requested digital employee was not found.",
+        EMPLOYEE_NOT_CHATABLE: "This digital employee is not available for read-only chat.",
+        ASSET_NOT_FOUND: "The requested asset was not found.",
+        ALARM_NOT_FOUND: "The requested alarm was not found.",
+        INCIDENT_ASSET_IDENTITY_UNAVAILABLE: "The alarm and asset identity could not be verified.",
+        CONVERSATION_NOT_FOUND: "The conversation is unavailable for this session.",
+        CONVERSATION_BUSY: "This conversation already has an active request.",
+        CONVERSATION_CAPACITY_REACHED: "Too many active conversations; try again later.",
+        DATA_SOURCE_UNAVAILABLE: "The requested data source is unavailable.",
+        INVALID_ARGUMENT: "The request arguments are invalid.",
+        MODEL_NOT_FOUND: "The requested asset model was not found.",
+        UPSTREAM_PROTOCOL_ERROR: "The data source returned an invalid response.",
+        UPSTREAM_RESPONSE_TOO_LARGE: "The data source returned too much data.",
+        METRIC_DATA_NOT_FOUND: "No metric data was found for the requested asset and window.",
+        ASSET_METRIC_IDENTITY_UNAVAILABLE: "The asset has no monitorable IP address for metric lookup.",
+        TIMEOUT: "The request timed out.",
+        USER_CANCELLED: "The request was cancelled.",
+    };
+    try {
+        const parsed = JSON.parse(body);
+        const error = parsed.error && typeof parsed.error === "object" ? parsed.error : undefined;
+        const detailCode = typeof parsed.detail === "string" && /^[A-Z][A-Z0-9_]{2,63}$/.test(parsed.detail)
+            ? parsed.detail
+            : undefined;
+        const code = typeof error?.code === "string" && /^[A-Z][A-Z0-9_]{2,63}$/.test(error.code)
+            ? error.code
+            : typeof parsed.error_code === "string" && /^[A-Z][A-Z0-9_]{2,63}$/.test(parsed.error_code)
+                ? parsed.error_code
+                : detailCode ?? fallback.code;
+        // Never reflect provider/server detail: it may contain a token, cookie,
+        // stack trace or customer topology. The stable code is enough for CLI UX.
+        const message = messages[code] ?? "The server rejected the request.";
+        const retryable = retryableForCode(code, fallback.retryable);
+        return new HttpError(code, message, { status, retryable });
+    }
+    catch {
+        return new HttpError(fallback.code, "Request failed", { status, retryable: fallback.retryable });
+    }
+}
+function validateResponseObject(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new HttpError("PROTOCOL_ERROR", `${label} response is invalid`);
+    }
+    return value;
+}
+function validateCredentialField(value, field) {
+    if (typeof value !== "string" || value.length === 0 || value.length > 4096) {
+        throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+    }
+    return value;
+}
+function validateStringList(value, field) {
+    if (!Array.isArray(value) || value.length > P1_CAPABILITY_SCOPES.length || value.some((item) => (typeof item !== "string" || item.length === 0 || item.length > 128))) {
+        throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+    }
+    const items = [...value];
+    const seen = new Set();
+    let previousIndex = -1;
+    for (const item of items) {
+        const index = P1_CAPABILITY_SCOPES.indexOf(item);
+        if (index < 0 || seen.has(item) || index <= previousIndex) {
+            throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+        }
+        seen.add(item);
+        previousIndex = index;
+    }
+    return items;
+}
+function validateIdentityId(value, field, allowEmpty = false) {
+    if (typeof value !== "string") {
+        throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+    }
+    if (allowEmpty && value === "")
+        return value;
+    if (!/^[A-Za-z0-9_-]{1,128}$/.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+    }
+    return value;
+}
+function validateGeneratedAt(value) {
+    if (typeof value !== "string"
+        || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?Z$/.test(value)
+        || !Number.isFinite(Date.parse(value))) {
+        throw new HttpError("PROTOCOL_ERROR", "Capabilities metadata is invalid");
+    }
+    return value;
+}
+function validateEmployeeText(value, field) {
+    if (typeof value !== "string" || value.length === 0 || value.length > 4096) {
+        throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+    }
+    return value;
+}
+function validateEmployeeList(value) {
+    if (!Array.isArray(value) || value.length > 64) {
+        throw new HttpError("PROTOCOL_ERROR", "Employees response is invalid");
+    }
+    const seen = new Set();
+    return value.map((raw, index) => {
+        const item = validateResponseObject(raw, `Employee ${index}`);
+        const expected = new Set([
+            "id",
+            "name",
+            "name_en",
+            "description",
+            "description_en",
+            "readonly",
+            "chat_available",
+        ]);
+        if (Object.keys(item).some((key) => !expected.has(key)) || expected.size !== Object.keys(item).length) {
+            throw new HttpError("PROTOCOL_ERROR", "Employees response is invalid");
+        }
+        const id = validateIdentityId(item.id, "employee id");
+        if (seen.has(id))
+            throw new HttpError("PROTOCOL_ERROR", "Employees response is invalid");
+        seen.add(id);
+        if (typeof item.readonly !== "boolean" || typeof item.chat_available !== "boolean") {
+            throw new HttpError("PROTOCOL_ERROR", "Employees response is invalid");
+        }
+        if (item.chat_available && !item.readonly) {
+            throw new HttpError("PROTOCOL_ERROR", "Employees response is invalid");
+        }
+        return {
+            id,
+            name: validateEmployeeText(item.name, "employee name"),
+            name_en: validateEmployeeText(item.name_en, "employee name_en"),
+            description: validateEmployeeText(item.description, "employee description"),
+            description_en: validateEmployeeText(item.description_en, "employee description_en"),
+            readonly: item.readonly,
+            chat_available: item.chat_available,
+        };
+    });
+}
+const ASSET_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+const ASSET_IP_PATTERN = /^[0-9a-fA-F:.]{1,128}$/;
+function validateNullableAssetText(value, field) {
+    if (value === null)
+        return null;
+    if (typeof value !== "string" || value.length === 0 || value.length > 1024 || /[\u0000-\u001f]/.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+    }
+    if (/^(?:https?|tcp|udp):\/\//i.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+    }
+    return value;
+}
+function validateNullableAssetId(value, field) {
+    if (value === null)
+        return null;
+    if (typeof value !== "string" || !ASSET_ID_PATTERN.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+    }
+    return value;
+}
+function validateAssetId(value) {
+    if (typeof value !== "string" || !ASSET_ID_PATTERN.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", "asset id response is invalid");
+    }
+    return value;
+}
+function validateAssetRequestId(value) {
+    if (typeof value !== "string" || !ASSET_ID_PATTERN.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", "asset id is invalid");
+    }
+    if (/^\d+$/.test(value)) {
+        const normalized = value.replace(/^0+/, "") || "0";
+        let numeric;
+        try {
+            numeric = BigInt(normalized);
+        }
+        catch {
+            throw new HttpError("PROTOCOL_ERROR", "asset id is invalid");
+        }
+        if (numeric < 1n || numeric > 9223372036854775807n) {
+            throw new HttpError("PROTOCOL_ERROR", "asset id is invalid");
+        }
+        return numeric.toString();
+    }
+    return value;
+}
+function validateNullableAssetIp(value) {
+    if (value === null)
+        return null;
+    if (typeof value !== "string" || !ASSET_IP_PATTERN.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", "asset ip response is invalid");
+    }
+    return value;
+}
+function validateMetricAsset(value) {
+    if (typeof value !== "string" || value.length < 1 || value.length > 128 || /[\u0000-\u001f]/.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", "metric asset is invalid");
+    }
+    if (isIP(value) > 0)
+        return value;
+    return validateAssetRequestId(value);
+}
+function canonicalIp(value) {
+    if (typeof value !== "string")
+        return null;
+    const kind = isIP(value);
+    if (kind === 4)
+        return value;
+    if (kind !== 6 || value.includes("%"))
+        return null;
+    let input = value.toLowerCase();
+    if (input.includes(".")) {
+        const separator = input.lastIndexOf(":");
+        if (separator < 0)
+            return null;
+        const octets = input.slice(separator + 1).split(".");
+        if (octets.length !== 4 || octets.some((octet) => !/^\d+$/.test(octet) || Number(octet) > 255))
+            return null;
+        const high = ((Number(octets[0]) << 8) | Number(octets[1])).toString(16);
+        const low = ((Number(octets[2]) << 8) | Number(octets[3])).toString(16);
+        input = `${input.slice(0, separator)}:${high}:${low}`;
+    }
+    const sections = input.split("::");
+    if (sections.length > 2)
+        return null;
+    const left = sections[0] ? sections[0].split(":") : [];
+    const right = sections.length === 2 && sections[1] ? sections[1].split(":") : [];
+    const validSection = (section) => /^[0-9a-f]{1,4}$/.test(section);
+    if (left.some((section) => !validSection(section)) || right.some((section) => !validSection(section)))
+        return null;
+    const missing = 8 - left.length - right.length;
+    if ((sections.length === 1 && missing !== 0) || (sections.length === 2 && missing < 1))
+        return null;
+    const full = [...left, ...Array.from({ length: Math.max(0, missing) }, () => "0"), ...right]
+        .map((section) => section.replace(/^0+(?=[0-9a-f])/, ""));
+    if (full.length !== 8)
+        return null;
+    let bestStart = -1;
+    let bestLength = 0;
+    for (let index = 0; index < full.length;) {
+        if (full[index] !== "0") {
+            index += 1;
+            continue;
+        }
+        let end = index;
+        while (end < full.length && full[end] === "0")
+            end += 1;
+        if (end - index > bestLength && end - index >= 2) {
+            bestStart = index;
+            bestLength = end - index;
+        }
+        index = end;
+    }
+    if (bestStart < 0)
+        return full.join(":");
+    const before = full.slice(0, bestStart).join(":");
+    const after = full.slice(bestStart + bestLength).join(":");
+    return `${before}::${after}`;
+}
+const METRIC_NAMES = new Set(["online", "cpu", "memory", "load", "disk", "io", "snmp"]);
+const METRIC_LABELS = new Set(["host_ip", "instance", "monitorIp", "ip", "agent_hostname"]);
+function validateMetricSeries(raw, index, maxPoints) {
+    const item = validateResponseObject(raw, `Metric series ${index}`);
+    const expected = new Set(["dimension", "unit", "current", "min", "max", "average", "sample_count", "points"]);
+    if (Object.keys(item).length !== expected.size || Object.keys(item).some((key) => !expected.has(key))) {
+        throw new HttpError("PROTOCOL_ERROR", "Metrics response is invalid");
+    }
+    const text = (value, field, max = 256, allowEmpty = false) => {
+        if (typeof value !== "string" || (!allowEmpty && value.length < 1) || value.length > max || /[\u0000-\u001f]/.test(value)) {
+            throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+        }
+        return value;
+    };
+    const number = (value, field) => {
+        if (typeof value !== "number" || !Number.isFinite(value))
+            throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+        return value;
+    };
+    if (!Number.isSafeInteger(item.sample_count) || item.sample_count < 1 || item.sample_count > maxPoints) {
+        throw new HttpError("PROTOCOL_ERROR", "Metric sample count is invalid");
+    }
+    if (!Array.isArray(item.points) || item.points.length !== item.sample_count || item.points.length > maxPoints) {
+        throw new HttpError("PROTOCOL_ERROR", "Metric points are invalid");
+    }
+    const points = item.points.map((point, pointIndex) => {
+        const record = validateResponseObject(point, `Metric point ${pointIndex}`);
+        if (Object.keys(record).length !== 2 || !Object.hasOwn(record, "timestamp") || !Object.hasOwn(record, "value")) {
+            throw new HttpError("PROTOCOL_ERROR", "Metric point response is invalid");
+        }
+        const timestamp = number(record.timestamp, "Metric timestamp");
+        if (timestamp < 0)
+            throw new HttpError("PROTOCOL_ERROR", "Metric timestamp is invalid");
+        return { timestamp, value: number(record.value, "Metric value") };
+    });
+    for (let index = 1; index < points.length; index += 1) {
+        if (points[index].timestamp <= points[index - 1].timestamp) {
+            throw new HttpError("PROTOCOL_ERROR", "Metric timestamps are not strictly increasing");
+        }
+    }
+    const current = number(item.current, "Metric current");
+    const min = number(item.min, "Metric min");
+    const max = number(item.max, "Metric max");
+    const average = number(item.average, "Metric average");
+    if (min > max || average < min || average > max || current < min || current > max || current !== points[points.length - 1].value) {
+        throw new HttpError("PROTOCOL_ERROR", "Metric summary is inconsistent");
+    }
+    return {
+        dimension: text(item.dimension, "Metric dimension"),
+        unit: text(item.unit, "Metric unit", 32, true),
+        current,
+        min,
+        max,
+        average,
+        sample_count: item.sample_count,
+        points,
+    };
+}
+function validateAssetRecord(raw, index, seen = new Set()) {
+    const item = validateResponseObject(raw, `Asset ${index}`);
+    const expected = new Set([
+        "id", "name", "ip", "model_id", "model_name", "model_code", "managed", "monitorable",
+    ]);
+    if (Object.keys(item).some((key) => !expected.has(key)) || Object.keys(item).length !== expected.size) {
+        throw new HttpError("PROTOCOL_ERROR", "Assets response is invalid");
+    }
+    const id = validateAssetId(item.id);
+    if (seen.has(id))
+        throw new HttpError("PROTOCOL_ERROR", "Assets response is invalid");
+    seen.add(id);
+    if ((item.managed !== null && typeof item.managed !== "boolean")
+        || (item.monitorable !== null && typeof item.monitorable !== "boolean")) {
+        throw new HttpError("PROTOCOL_ERROR", "Assets response is invalid");
+    }
+    return {
+        id,
+        name: validateNullableAssetText(item.name, "asset name"),
+        ip: validateNullableAssetIp(item.ip),
+        model_id: validateNullableAssetId(item.model_id, "asset model id"),
+        model_name: validateNullableAssetText(item.model_name, "asset model name"),
+        model_code: validateNullableAssetText(item.model_code, "asset model code"),
+        managed: item.managed,
+        monitorable: item.monitorable,
+    };
+}
+function validateAssetItems(value, pageSize) {
+    if (!Array.isArray(value) || value.length > pageSize) {
+        throw new HttpError("PROTOCOL_ERROR", "Assets response is invalid");
+    }
+    const seen = new Set();
+    return value.map((raw, index) => validateAssetRecord(raw, index, seen));
+}
+const ALARM_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+const ALARM_QUERY_STATUSES = new Set(["all", "firing", "resolved"]);
+const ALARM_STATUSES = new Set(["firing", "resolved", "unknown"]);
+const ALARM_SEVERITIES = new Set(["early_warning", "normal", "severe", "critical", "unknown"]);
+const ALARM_SEVERITY_BY_CODE = new Map([
+    [1, "early_warning"],
+    [2, "normal"],
+    [3, "severe"],
+    [4, "critical"],
+]);
+function validateAlarmRequestId(value) {
+    if (typeof value !== "string" || !ALARM_ID_PATTERN.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", "alarm id is invalid");
+    }
+    if (!/^\d+$/.test(value))
+        return value;
+    const normalized = value.replace(/^0+/, "") || "0";
+    let numeric;
+    try {
+        numeric = BigInt(normalized);
+    }
+    catch {
+        throw new HttpError("PROTOCOL_ERROR", "alarm id is invalid");
+    }
+    if (numeric < 1n || numeric > 9223372036854775807n) {
+        throw new HttpError("PROTOCOL_ERROR", "alarm id is invalid");
+    }
+    return numeric.toString();
+}
+function validateAlarmNullableText(value, field, maxLength = 1024) {
+    if (value === null)
+        return null;
+    if (typeof value !== "string" || value.length === 0 || value.length > maxLength || /[\u0000-\u001f]/.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+    }
+    if (/^(?:https?|tcp|udp):\/\//i.test(value))
+        return null;
+    return value;
+}
+function validateAlarmIp(value) {
+    if (value === null)
+        return null;
+    if (typeof value !== "string" || value.length === 0 || value.length > 128) {
+        throw new HttpError("PROTOCOL_ERROR", "alarm ip response is invalid");
+    }
+    const canonical = canonicalIp(value);
+    if (canonical === null)
+        throw new HttpError("PROTOCOL_ERROR", "alarm ip response is invalid");
+    return canonical;
+}
+function validateAlarmDuration(value) {
+    if (value === null)
+        return null;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value) || value < 0 || value > 365 * 24 * 60 * 60) {
+            throw new HttpError("PROTOCOL_ERROR", "alarm duration response is invalid");
+        }
+        return value;
+    }
+    if (typeof value !== "string" || value.length === 0 || value.length > 128 || /[\u0000-\u001f]/.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", "alarm duration response is invalid");
+    }
+    return value;
+}
+function validateAlarmContent(value, field) {
+    if (value === null)
+        return null;
+    if (typeof value !== "string" || value.length === 0 || value.length > 16 * 1024) {
+        throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+    }
+    if (/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+    }
+    if (/(?:https?:\/\/|tcp:\/\/|udp:\/\/|authorization|bearer\s|token\s*=|password\s*=|secret\s*=|stack\s*trace|traceback|\/(?:api|var|data|etc)\/)/i.test(value)) {
+        return null;
+    }
+    return value;
+}
+function validateAlarmRecord(raw, index, detail, seen) {
+    const item = validateResponseObject(raw, `Alarm ${index}`);
+    const expected = new Set([
+        "id", "title", "status", "severity", "severity_code", "asset_id", "asset_name", "asset_ip",
+        "model_name", "started_at", "duration", "count", "source",
+        ...(detail ? ["content", "description"] : []),
+    ]);
+    if (Object.keys(item).length !== expected.size || Object.keys(item).some((key) => !expected.has(key))) {
+        throw new HttpError("PROTOCOL_ERROR", "Alarms response is invalid");
+    }
+    const id = validateAlarmRequestId(item.id);
+    if (seen?.has(id))
+        throw new HttpError("PROTOCOL_ERROR", "Alarms response is invalid");
+    seen?.add(id);
+    if (typeof item.status !== "string" || !ALARM_STATUSES.has(item.status)) {
+        throw new HttpError("PROTOCOL_ERROR", "Alarm status response is invalid");
+    }
+    if (typeof item.severity !== "string" || !ALARM_SEVERITIES.has(item.severity)) {
+        throw new HttpError("PROTOCOL_ERROR", "Alarm severity response is invalid");
+    }
+    const severityCode = item.severity_code;
+    if (severityCode !== null && (typeof severityCode !== "number" || !Number.isSafeInteger(severityCode) || severityCode < 0 || severityCode > 100)) {
+        throw new HttpError("PROTOCOL_ERROR", "Alarm severity code response is invalid");
+    }
+    const expectedSeverity = severityCode === null ? "unknown" : (ALARM_SEVERITY_BY_CODE.get(severityCode) ?? "unknown");
+    if (item.severity !== expectedSeverity) {
+        throw new HttpError("PROTOCOL_ERROR", "Alarm severity response is inconsistent");
+    }
+    const count = item.count;
+    if (count !== null && (typeof count !== "number" || !Number.isSafeInteger(count) || count < 0 || count > 1_000_000_000)) {
+        throw new HttpError("PROTOCOL_ERROR", "Alarm count response is invalid");
+    }
+    const output = {
+        id,
+        title: validateAlarmNullableText(item.title, "alarm title"),
+        status: item.status,
+        severity: item.severity,
+        severity_code: severityCode,
+        asset_id: item.asset_id === null ? null : validateAlarmRequestId(item.asset_id),
+        asset_name: validateAlarmNullableText(item.asset_name, "alarm asset name"),
+        asset_ip: validateAlarmIp(item.asset_ip),
+        model_name: validateAlarmNullableText(item.model_name, "alarm model name"),
+        started_at: validateAlarmNullableText(item.started_at, "alarm start time", 128),
+        duration: validateAlarmDuration(item.duration),
+        count: count,
+        source: validateAlarmNullableText(item.source, "alarm source", 256),
+    };
+    if (!detail)
+        return output;
+    return {
+        ...output,
+        content: validateAlarmContent(item.content, "alarm content"),
+        description: validateAlarmContent(item.description, "alarm description"),
+    };
+}
+const INCIDENT_CATEGORIES = new Set(["cpu", "memory", "load", "disk", "io", "online", "unknown"]);
+const INCIDENT_CONCLUSIONS = new Set(["active_anomaly", "recovered", "not_reproduced", "insufficient_evidence", "unsupported_alarm"]);
+const INCIDENT_CONFIDENCES = new Set(["high", "medium", "low"]);
+const INCIDENT_ASSOCIATIONS = new Set(["exact_asset_id", "exact_alarm_ip", "unavailable"]);
+const INCIDENT_WINDOWS = new Set(["event", "recent"]);
+const INCIDENT_METRICS = new Set(["cpu", "memory", "load", "disk", "io", "online"]);
+const INCIDENT_FINDINGS = new Set([
+    "ALARM_CATEGORY_UNKNOWN",
+    "TARGET_UNAVAILABLE",
+    "ASSET_IP_UNAVAILABLE",
+    "EVENT_TIME_UNAVAILABLE",
+    "RECENT_METRIC_ANOMALY",
+    "HISTORICAL_METRIC_ANOMALY",
+    "NO_RECENT_DATA",
+    "NO_EVENT_DATA",
+    "ALARM_RESOLVED",
+]);
+const INCIDENT_ACTIONS = new Set([
+    "VERIFY_ALARM_RULE",
+    "REVIEW_ASSET_MONITORING",
+    "RECHECK_METRICS",
+    "CONTINUE_OBSERVATION",
+    "NO_ACTION",
+]);
+function validateIncidentTarget(value, alarm) {
+    const item = validateResponseObject(value, "Incident target");
+    const expected = new Set(["association", "asset_id", "name", "ip"]);
+    if (Object.keys(item).length !== expected.size || Object.keys(item).some((key) => !expected.has(key))) {
+        throw new HttpError("PROTOCOL_ERROR", "Incident target is invalid");
+    }
+    if (typeof item.association !== "string" || !INCIDENT_ASSOCIATIONS.has(item.association)) {
+        throw new HttpError("PROTOCOL_ERROR", "Incident target association is invalid");
+    }
+    const association = item.association;
+    const assetId = item.asset_id === null ? null : validateAlarmRequestId(item.asset_id);
+    const name = item.name === null ? null : validateAlarmNullableText(item.name, "incident target name");
+    const ip = item.ip === null ? null : validateAlarmIp(item.ip);
+    if (association === "exact_asset_id") {
+        if (assetId === null || alarm.asset_id !== assetId)
+            throw new HttpError("PROTOCOL_ERROR", "Incident target identity is invalid");
+        if (ip !== null && alarm.asset_ip !== null && ip !== alarm.asset_ip)
+            throw new HttpError("PROTOCOL_ERROR", "Incident target identity is invalid");
+    }
+    else if (association === "exact_alarm_ip") {
+        if (assetId !== null || ip === null || alarm.asset_id !== null || alarm.asset_ip !== ip)
+            throw new HttpError("PROTOCOL_ERROR", "Incident target identity is invalid");
+    }
+    else if (assetId !== null || name !== null || ip !== null || alarm.asset_id !== null || alarm.asset_ip !== null) {
+        throw new HttpError("PROTOCOL_ERROR", "Incident target identity is invalid");
+    }
+    return { association, asset_id: assetId, name, ip };
+}
+function validateIncidentEvidence(value, index) {
+    const item = validateResponseObject(value, `Incident evidence ${index}`);
+    const expected = new Set(["window", "metric", "status", "series", "truncated"]);
+    if (Object.keys(item).length !== expected.size || Object.keys(item).some((key) => !expected.has(key))) {
+        throw new HttpError("PROTOCOL_ERROR", "Incident evidence is invalid");
+    }
+    if (typeof item.window !== "string" || !INCIDENT_WINDOWS.has(item.window)) {
+        throw new HttpError("PROTOCOL_ERROR", "Incident evidence window is invalid");
+    }
+    if (typeof item.metric !== "string" || !INCIDENT_METRICS.has(item.metric)) {
+        throw new HttpError("PROTOCOL_ERROR", "Incident evidence metric is invalid");
+    }
+    if (typeof item.status !== "string" || !["available", "no_data"].includes(item.status)) {
+        throw new HttpError("PROTOCOL_ERROR", "Incident evidence status is invalid");
+    }
+    if (typeof item.truncated !== "boolean" || !Array.isArray(item.series) || item.series.length > 20) {
+        throw new HttpError("PROTOCOL_ERROR", "Incident evidence is invalid");
+    }
+    let pointCount = 0;
+    const series = item.series.map((raw, seriesIndex) => {
+        const parsed = validateMetricSeries(raw, seriesIndex, 60);
+        pointCount += parsed.points.length;
+        if (pointCount > 60)
+            throw new HttpError("PROTOCOL_ERROR", "Incident evidence points are invalid");
+        return parsed;
+    });
+    if (item.status === "available" && series.length === 0)
+        throw new HttpError("PROTOCOL_ERROR", "Incident evidence is invalid");
+    if (item.status === "no_data" && series.length !== 0)
+        throw new HttpError("PROTOCOL_ERROR", "Incident evidence is invalid");
+    return {
+        window: item.window,
+        metric: item.metric,
+        status: item.status,
+        series,
+        truncated: item.truncated,
+    };
+}
+function validateIncidentData(value, requestedAlarmId) {
+    const data = validateResponseObject(value, "Incident data");
+    const expected = new Set(["alarm", "target", "category", "conclusion", "confidence", "evidence", "findings", "actions"]);
+    if (Object.keys(data).length !== expected.size || Object.keys(data).some((key) => !expected.has(key))) {
+        throw new HttpError("PROTOCOL_ERROR", "Incident response is invalid");
+    }
+    const alarm = validateAlarmRecord(data.alarm, 0, true);
+    if (alarm.id !== requestedAlarmId)
+        throw new HttpError("PROTOCOL_ERROR", "Incident alarm identity is invalid");
+    const target = validateIncidentTarget(data.target, alarm);
+    if (typeof data.category !== "string" || !INCIDENT_CATEGORIES.has(data.category)) {
+        throw new HttpError("PROTOCOL_ERROR", "Incident category is invalid");
+    }
+    const category = data.category;
+    if (typeof data.conclusion !== "string" || !INCIDENT_CONCLUSIONS.has(data.conclusion)) {
+        throw new HttpError("PROTOCOL_ERROR", "Incident conclusion is invalid");
+    }
+    if (typeof data.confidence !== "string" || !INCIDENT_CONFIDENCES.has(data.confidence)) {
+        throw new HttpError("PROTOCOL_ERROR", "Incident confidence is invalid");
+    }
+    if (!Array.isArray(data.evidence) || data.evidence.length > 2)
+        throw new HttpError("PROTOCOL_ERROR", "Incident evidence is invalid");
+    const evidence = data.evidence.map((raw, index) => validateIncidentEvidence(raw, index));
+    if (new Set(evidence.map((item) => item.window)).size !== evidence.length)
+        throw new HttpError("PROTOCOL_ERROR", "Incident evidence is invalid");
+    if ((category === "unknown" && evidence.length > 0)
+        || (category !== "unknown" && evidence.some((item) => item.metric !== category))) {
+        throw new HttpError("PROTOCOL_ERROR", "Incident evidence identity is invalid");
+    }
+    if (!Array.isArray(data.findings) || data.findings.length > 8 || data.findings.some((item) => typeof item !== "string" || !INCIDENT_FINDINGS.has(item))) {
+        throw new HttpError("PROTOCOL_ERROR", "Incident findings are invalid");
+    }
+    if (new Set(data.findings).size !== data.findings.length)
+        throw new HttpError("PROTOCOL_ERROR", "Incident findings are invalid");
+    if (!Array.isArray(data.actions) || data.actions.length > 8 || data.actions.some((item) => typeof item !== "string" || !INCIDENT_ACTIONS.has(item))) {
+        throw new HttpError("PROTOCOL_ERROR", "Incident actions are invalid");
+    }
+    if (new Set(data.actions).size !== data.actions.length)
+        throw new HttpError("PROTOCOL_ERROR", "Incident actions are invalid");
+    return {
+        alarm,
+        target,
+        category,
+        conclusion: data.conclusion,
+        confidence: data.confidence,
+        evidence,
+        findings: [...data.findings],
+        actions: [...data.actions],
+    };
+}
+const INSPECTION_GRADES = new Set(["healthy", "warning", "critical", "insufficient"]);
+const INSPECTION_MONITORING = new Set(["covered", "missing", "unknown"]);
+const INSPECTION_FINDINGS = new Set([
+    "NO_ASSETS",
+    "MONITORING_MISSING",
+    "IDENTITY_UNKNOWN",
+    "ACTIVE_ALARMS",
+    "CRITICAL_ALARM",
+    "UNMATCHED_ALARMS",
+    "RESULT_TRUNCATED",
+    "MONITORING_UNAVAILABLE",
+]);
+const INSPECTION_ACTIONS = new Set([
+    "REVIEW_ACTIVE_ALARMS",
+    "REVIEW_ASSET_MONITORING",
+    "REVIEW_ASSET_IDENTITY",
+    "RECHECK_INSPECTION",
+    "INVESTIGATE_CRITICAL_ALARMS",
+    "NO_ACTION",
+]);
+function inspectionSafeCount(value, field) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value > 10_000_000) {
+        throw new HttpError("PROTOCOL_ERROR", `${field} is invalid`);
+    }
+    return value;
+}
+function validateInspectionScope(value) {
+    const item = validateResponseObject(value, "Inspection scope");
+    const expected = new Set(["model", "window_minutes", "asset_limit", "alarm_limit"]);
+    if (Object.keys(item).length !== expected.size || Object.keys(item).some((key) => !expected.has(key))) {
+        throw new HttpError("PROTOCOL_ERROR", "Inspection scope is invalid");
+    }
+    if (item.model !== null && (typeof item.model !== "string" || item.model.length < 1 || item.model.length > 128 || /[\u0000-\u001f]/.test(item.model) || item.model.trim() !== item.model)) {
+        throw new HttpError("PROTOCOL_ERROR", "Inspection scope model is invalid");
+    }
+    if (typeof item.window_minutes !== "number" || !Number.isSafeInteger(item.window_minutes) || item.window_minutes < 5 || item.window_minutes > 1440) {
+        throw new HttpError("PROTOCOL_ERROR", "Inspection scope window is invalid");
+    }
+    if (item.asset_limit !== 100 || item.alarm_limit !== 100) {
+        throw new HttpError("PROTOCOL_ERROR", "Inspection scope limits are invalid");
+    }
+    return {
+        model: item.model,
+        window_minutes: item.window_minutes,
+        asset_limit: item.asset_limit,
+        alarm_limit: item.alarm_limit,
+    };
+}
+function validateInspectionData(value) {
+    const data = validateResponseObject(value, "Inspection data");
+    const expected = new Set(["scope", "summary", "grade", "items", "unmatched_alarm_count", "truncated", "findings", "actions"]);
+    if (Object.keys(data).length !== expected.size || Object.keys(data).some((key) => !expected.has(key))) {
+        throw new HttpError("PROTOCOL_ERROR", "Inspection response is invalid");
+    }
+    const scope = validateInspectionScope(data.scope);
+    const summaryRaw = validateResponseObject(data.summary, "Inspection summary");
+    const summaryKeys = new Set([
+        "assets_total",
+        "assets_examined",
+        "monitoring_covered",
+        "monitoring_missing",
+        "identity_unknown",
+        "active_alarms",
+        "affected_assets",
+    ]);
+    if (Object.keys(summaryRaw).length !== summaryKeys.size || Object.keys(summaryRaw).some((key) => !summaryKeys.has(key))) {
+        throw new HttpError("PROTOCOL_ERROR", "Inspection summary is invalid");
+    }
+    const summary = {
+        assets_total: inspectionSafeCount(summaryRaw.assets_total, "Inspection assets total"),
+        assets_examined: inspectionSafeCount(summaryRaw.assets_examined, "Inspection assets examined"),
+        monitoring_covered: inspectionSafeCount(summaryRaw.monitoring_covered, "Inspection covered count"),
+        monitoring_missing: inspectionSafeCount(summaryRaw.monitoring_missing, "Inspection missing count"),
+        identity_unknown: inspectionSafeCount(summaryRaw.identity_unknown, "Inspection unknown count"),
+        active_alarms: inspectionSafeCount(summaryRaw.active_alarms, "Inspection alarm count"),
+        affected_assets: inspectionSafeCount(summaryRaw.affected_assets, "Inspection affected count"),
+    };
+    if (summary.assets_examined > summary.assets_total
+        || summary.assets_examined > scope.asset_limit
+        || summary.monitoring_covered + summary.monitoring_missing + summary.identity_unknown !== summary.assets_examined
+        || summary.affected_assets > summary.assets_examined
+        || summary.active_alarms + (typeof data.unmatched_alarm_count === "number" && Number.isSafeInteger(data.unmatched_alarm_count) && data.unmatched_alarm_count >= 0 ? data.unmatched_alarm_count : 10_000_001) > scope.alarm_limit) {
+        throw new HttpError("PROTOCOL_ERROR", "Inspection summary counts are inconsistent");
+    }
+    if (typeof data.grade !== "string" || !INSPECTION_GRADES.has(data.grade)) {
+        throw new HttpError("PROTOCOL_ERROR", "Inspection grade is invalid");
+    }
+    if (!Array.isArray(data.items) || data.items.length > 100) {
+        throw new HttpError("PROTOCOL_ERROR", "Inspection items are invalid");
+    }
+    const items = [];
+    const seenIds = new Set();
+    const seenIps = new Set();
+    let itemAlarmCount = 0;
+    let itemAffected = 0;
+    for (let index = 0; index < data.items.length; index += 1) {
+        const raw = validateResponseObject(data.items[index], `Inspection item ${index}`);
+        const itemKeys = new Set(["asset", "monitoring", "active_alarm_count", "max_severity"]);
+        if (Object.keys(raw).length !== itemKeys.size || Object.keys(raw).some((key) => !itemKeys.has(key))) {
+            throw new HttpError("PROTOCOL_ERROR", "Inspection item is invalid");
+        }
+        const asset = validateAssetRecord(raw.asset, index);
+        if (seenIds.has(asset.id))
+            throw new HttpError("PROTOCOL_ERROR", "Inspection item identity is invalid");
+        seenIds.add(asset.id);
+        if (asset.ip !== null) {
+            const canonical = canonicalIp(asset.ip);
+            if (canonical === null || seenIps.has(canonical))
+                throw new HttpError("PROTOCOL_ERROR", "Inspection item identity is invalid");
+            seenIps.add(canonical);
+            asset.ip = canonical;
+        }
+        if (typeof raw.monitoring !== "string" || !INSPECTION_MONITORING.has(raw.monitoring)) {
+            throw new HttpError("PROTOCOL_ERROR", "Inspection monitoring status is invalid");
+        }
+        const activeAlarmCount = inspectionSafeCount(raw.active_alarm_count, "Inspection item alarm count");
+        if (typeof raw.max_severity !== "string" || !ALARM_SEVERITIES.has(raw.max_severity)) {
+            throw new HttpError("PROTOCOL_ERROR", "Inspection item severity is invalid");
+        }
+        if (activeAlarmCount === 0 && raw.max_severity !== "unknown") {
+            throw new HttpError("PROTOCOL_ERROR", "Inspection item severity is inconsistent");
+        }
+        if (raw.monitoring === "covered" && activeAlarmCount === 0) {
+            throw new HttpError("PROTOCOL_ERROR", "Normal inspection items must be omitted");
+        }
+        if ((raw.monitoring === "covered" || raw.monitoring === "missing") && asset.ip === null) {
+            throw new HttpError("PROTOCOL_ERROR", "Inspection monitoring identity is invalid");
+        }
+        if (raw.monitoring === "unknown" && asset.ip !== null) {
+            throw new HttpError("PROTOCOL_ERROR", "Inspection monitoring identity is invalid");
+        }
+        itemAlarmCount += activeAlarmCount;
+        if (activeAlarmCount > 0)
+            itemAffected += 1;
+        items.push({
+            asset,
+            monitoring: raw.monitoring,
+            active_alarm_count: activeAlarmCount,
+            max_severity: raw.max_severity,
+        });
+    }
+    const truncated = data.truncated;
+    if (typeof truncated !== "boolean")
+        throw new HttpError("PROTOCOL_ERROR", "Inspection truncation is invalid");
+    const itemMissing = items.filter((item) => item.monitoring === "missing").length;
+    const itemUnknown = items.filter((item) => item.monitoring === "unknown").length;
+    if (itemAlarmCount !== summary.active_alarms
+        || itemAffected !== summary.affected_assets
+        || itemMissing !== summary.monitoring_missing
+        || itemUnknown !== summary.identity_unknown) {
+        throw new HttpError("PROTOCOL_ERROR", "Inspection item counts are inconsistent");
+    }
+    const unmatched = inspectionSafeCount(data.unmatched_alarm_count, "Inspection unmatched alarm count");
+    if (summary.active_alarms + unmatched > scope.alarm_limit) {
+        throw new HttpError("PROTOCOL_ERROR", "Inspection alarm counts are inconsistent");
+    }
+    if (summary.assets_total > summary.assets_examined && !truncated) {
+        throw new HttpError("PROTOCOL_ERROR", "Inspection truncation is inconsistent");
+    }
+    const parseCodes = (value, field, allowed) => {
+        if (!Array.isArray(value) || value.length > 8 || value.some((entry) => typeof entry !== "string" || !allowed.has(entry))) {
+            throw new HttpError("PROTOCOL_ERROR", `${field} are invalid`);
+        }
+        const values = [...value];
+        if (new Set(values).size !== values.length)
+            throw new HttpError("PROTOCOL_ERROR", `${field} are invalid`);
+        return values;
+    };
+    const findings = parseCodes(data.findings, "Inspection findings", INSPECTION_FINDINGS);
+    const actions = parseCodes(data.actions, "Inspection actions", INSPECTION_ACTIONS);
+    const hasCriticalItem = items.some((item) => item.max_severity === "critical");
+    if ((data.grade === "healthy" && (truncated || summary.assets_examined < 1 || summary.monitoring_covered < 1 || summary.monitoring_missing > 0 || summary.identity_unknown > 0 || summary.active_alarms > 0 || summary.assets_total !== summary.assets_examined))
+        || (data.grade === "critical" && !hasCriticalItem)
+        || (hasCriticalItem && data.grade !== "critical")) {
+        throw new HttpError("PROTOCOL_ERROR", "Inspection grade is inconsistent");
+    }
+    return {
+        scope,
+        summary,
+        grade: data.grade,
+        items,
+        unmatched_alarm_count: unmatched,
+        truncated,
+        findings,
+        actions,
+    };
+}
+const CHAT_ID_PATTERN = /^[A-Za-z0-9_-]{1,96}$/;
+const EMPLOYEE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+const CHAT_ERROR_CODES = new Set([
+    "AUTH_RELOGIN_REQUIRED",
+    "CAPABILITY_SCOPE_REQUIRED",
+    "CAPABILITY_NOT_AVAILABLE",
+    "EMPLOYEE_NOT_FOUND",
+    "EMPLOYEE_NOT_CHATABLE",
+    "CONVERSATION_NOT_FOUND",
+    "CONVERSATION_BUSY",
+    "CONVERSATION_CAPACITY_REACHED",
+    "DATA_SOURCE_UNAVAILABLE",
+    "TIMEOUT",
+    "USER_CANCELLED",
+    "PROTOCOL_ERROR",
+]);
+function validateChatId(value, field) {
+    if (typeof value !== "string" || !CHAT_ID_PATTERN.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", `${field} is invalid`);
+    }
+    return value;
+}
+function validateEmployeeId(value) {
+    if (typeof value !== "string" || !EMPLOYEE_ID_PATTERN.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", "employee id is invalid");
+    }
+    return value;
+}
+/**
+ * Incremental SSE parser for the public employee-chat protocol.
+ *
+ * It deliberately returns a tiny allowlisted event shape.  Provider payloads,
+ * internal IDs, tool calls and error text never become part of a thrown error
+ * or callback value.
+ */
+export class EmployeeChatSseParser {
+    decoder = new TextDecoder("utf-8", { fatal: true });
+    buffer = "";
+    totalBytes = 0;
+    terminal = false;
+    terminalErrorCode;
+    conversationId;
+    text = "";
+    maxTotalBytes;
+    maxEventBytes;
+    constructor(initialConversationId, options = {}) {
+        if (initialConversationId !== undefined)
+            validateChatId(initialConversationId, "conversation id");
+        this.conversationId = initialConversationId;
+        this.maxTotalBytes = options.maxTotalBytes ?? 4 * 1024 * 1024;
+        this.maxEventBytes = options.maxEventBytes ?? 64 * 1024;
+        if (!Number.isSafeInteger(this.maxTotalBytes) || this.maxTotalBytes < 1) {
+            throw new HttpError("PROTOCOL_ERROR", "SSE limits are invalid");
+        }
+        if (!Number.isSafeInteger(this.maxEventBytes) || this.maxEventBytes < 1 || this.maxEventBytes > this.maxTotalBytes) {
+            throw new HttpError("PROTOCOL_ERROR", "SSE limits are invalid");
+        }
+    }
+    push(chunk) {
+        const bytes = typeof chunk === "string" ? Buffer.byteLength(chunk, "utf8") : chunk.byteLength;
+        if (this.terminal && bytes > 0)
+            throw new HttpError("PROTOCOL_ERROR", "SSE stream has already terminated");
+        this.totalBytes += bytes;
+        if (this.totalBytes > this.maxTotalBytes) {
+            throw new HttpError("RESPONSE_TOO_LARGE", "Chat stream is too large");
+        }
+        try {
+            this.buffer += typeof chunk === "string" ? chunk : this.decoder.decode(chunk, { stream: true });
+        }
+        catch {
+            throw new HttpError("PROTOCOL_ERROR", "Chat stream encoding is invalid");
+        }
+        const events = [];
+        for (;;) {
+            const boundary = this.findBoundary(this.buffer);
+            if (!boundary) {
+                if (Buffer.byteLength(this.buffer, "utf8") > this.maxEventBytes) {
+                    throw new HttpError("RESPONSE_TOO_LARGE", "Chat event is too large");
+                }
+                break;
+            }
+            const frame = this.buffer.slice(0, boundary.index);
+            this.buffer = this.buffer.slice(boundary.index + boundary.length);
+            if (Buffer.byteLength(frame, "utf8") > this.maxEventBytes) {
+                throw new HttpError("RESPONSE_TOO_LARGE", "Chat event is too large");
+            }
+            const event = this.decodeFrame(frame);
+            if (event) {
+                events.push(event);
+                if (this.terminal) {
+                    if (this.buffer.length > 0)
+                        throw new HttpError("PROTOCOL_ERROR", "SSE data followed a terminal event");
+                    break;
+                }
+            }
+        }
+        return events;
+    }
+    finish() {
+        try {
+            this.buffer += this.decoder.decode();
+        }
+        catch {
+            throw new HttpError("PROTOCOL_ERROR", "Chat stream encoding is invalid");
+        }
+        if (this.buffer !== "") {
+            throw new HttpError("PROTOCOL_ERROR", "Chat stream did not terminate an event");
+        }
+        if (!this.terminal || !this.conversationId) {
+            throw new HttpError("PROTOCOL_ERROR", "Chat stream did not terminate");
+        }
+        return [];
+    }
+    result() {
+        if (this.terminalErrorCode) {
+            throw new HttpError(this.terminalErrorCode, "The server rejected the chat request.", {
+                status: 200,
+                retryable: retryableForCode(this.terminalErrorCode, false),
+            });
+        }
+        if (!this.terminal || !this.conversationId) {
+            throw new HttpError("PROTOCOL_ERROR", "Chat stream did not terminate");
+        }
+        return { conversation_id: this.conversationId, text: this.text };
+    }
+    findBoundary(value) {
+        const candidates = ["\r\n\r\n", "\n\n", "\r\r"]
+            .map((separator) => ({ index: value.indexOf(separator), length: separator.length }))
+            .filter((item) => item.index >= 0);
+        return candidates.length ? candidates.sort((left, right) => left.index - right.index)[0] : undefined;
+    }
+    decodeFrame(frame) {
+        let eventName = "message";
+        const dataLines = [];
+        for (const rawLine of frame.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n")) {
+            if (!rawLine || rawLine.startsWith(":"))
+                continue;
+            if (rawLine.startsWith("event:"))
+                eventName = rawLine.slice(6).trim();
+            else if (rawLine.startsWith("data:"))
+                dataLines.push(rawLine.slice(5).replace(/^ /, ""));
+        }
+        if (!dataLines.length)
+            return undefined;
+        const rawData = dataLines.join("\n");
+        if (rawData.trim() === "[DONE]") {
+            this.terminal = true;
+            if (!this.conversationId)
+                throw new HttpError("PROTOCOL_ERROR", "Chat conversation is missing");
+            return { type: "done", conversation_id: this.conversationId };
+        }
+        let payload;
+        try {
+            payload = JSON.parse(rawData);
+        }
+        catch {
+            throw new HttpError("PROTOCOL_ERROR", "Chat stream payload is invalid");
+        }
+        if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+            throw new HttpError("PROTOCOL_ERROR", "Chat stream payload is invalid");
+        }
+        const record = payload;
+        if (!["conversation", "delta", "done", "error", "message", ""].includes(eventName))
+            return undefined;
+        if (eventName === "conversation") {
+            const conversationId = validateChatId(record.conversation_id, "conversation id");
+            if (this.conversationId && this.conversationId !== conversationId) {
+                throw new HttpError("PROTOCOL_ERROR", "Chat conversation changed");
+            }
+            this.conversationId = conversationId;
+            return { type: "conversation", conversation_id: conversationId };
+        }
+        if (eventName === "delta") {
+            if (typeof record.text !== "string" || record.text.length === 0) {
+                throw new HttpError("PROTOCOL_ERROR", "Chat delta is invalid");
+            }
+            this.text += record.text;
+            if (Buffer.byteLength(this.text, "utf8") > this.maxTotalBytes) {
+                throw new HttpError("RESPONSE_TOO_LARGE", "Chat text is too large");
+            }
+            return { type: "delta", text: record.text };
+        }
+        if (eventName === "error") {
+            const code = typeof record.code === "string" && /^[A-Z][A-Z0-9_]{2,63}$/.test(record.code)
+                ? record.code
+                : "PROTOCOL_ERROR";
+            this.terminal = true;
+            this.terminalErrorCode = CHAT_ERROR_CODES.has(code) ? code : "PROTOCOL_ERROR";
+            return { type: "error", code: this.terminalErrorCode };
+        }
+        if (eventName === "done") {
+            const conversationId = record.conversation_id === undefined
+                ? this.conversationId
+                : validateChatId(record.conversation_id, "conversation id");
+            if (!conversationId || (this.conversationId && this.conversationId !== conversationId)) {
+                throw new HttpError("PROTOCOL_ERROR", "Chat conversation is invalid");
+            }
+            this.conversationId = conversationId;
+            this.terminal = true;
+            return { type: "done", conversation_id: conversationId };
+        }
+        // A message/unknown payload is intentionally ignored; only the public
+        // event names above can affect the result.
+        return undefined;
+    }
+}
+function validateExpires(value) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > 365 * 24 * 3600) {
+        throw new HttpError("PROTOCOL_ERROR", "Token expiry response is invalid");
+    }
+    return value;
+}
+function joinPath(basePath, suffix) {
+    const normalized = basePath.replace(/\/+$/, "");
+    return `${normalized}${INTEGRATION_PATH}${suffix}` || "/";
+}
+function isLoopbackHostname(hostname) {
+    const value = hostname.toLowerCase();
+    return value === "localhost" || value === "127.0.0.1" || value === "[::1]" || value === "::1";
+}
+export function integrationUrl(baseUrl, suffix) {
+    let parsed;
+    try {
+        parsed = new URL(baseUrl);
+    }
+    catch {
+        throw new HttpError("CONFIG_INVALID", "Profile base_url is invalid");
+    }
+    if (!/^https?:$/.test(parsed.protocol) || parsed.username || parsed.password || parsed.search || parsed.hash) {
+        throw new HttpError("CONFIG_INVALID", "Profile base_url must be an HTTP(S) URL without credentials");
+    }
+    if (parsed.protocol === "http:" && !isLoopbackHostname(parsed.hostname)) {
+        throw new HttpError("CONFIG_INVALID", "Profile base_url must use HTTPS");
+    }
+    if (!/^\/[A-Za-z0-9._~!$&'()*+,;=:@%/-]*$/.test(suffix) || suffix.includes("//")) {
+        throw new HttpError("PROTOCOL_ERROR", "Integration path is invalid");
+    }
+    parsed.pathname = joinPath(parsed.pathname, suffix);
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed;
+}
+function requestOptions(url, profile, headers) {
+    const options = {
+        protocol: url.protocol,
+        hostname: url.hostname,
+        port: url.port || undefined,
+        path: `${url.pathname}${url.search}`,
+        method: headers["content-length"] ? "POST" : "GET",
+        headers,
+    };
+    if (url.protocol === "https:") {
+        options.rejectUnauthorized = true;
+        if (profile.ca_bundle) {
+            try {
+                if (!isAbsolute(profile.ca_bundle))
+                    throw new Error("CA path must be absolute");
+                const stat = lstatSync(profile.ca_bundle);
+                if (stat.isSymbolicLink() || !stat.isFile())
+                    throw new Error("CA bundle must be a regular file");
+                const size = stat.size;
+                if (!Number.isSafeInteger(size) || size <= 0 || size > MAX_CA_BUNDLE_BYTES)
+                    throw new Error("CA bundle too large");
+                options.ca = readFileSync(profile.ca_bundle);
+            }
+            catch {
+                throw new HttpError("CONFIG_INVALID", "Profile CA bundle cannot be read");
+            }
+        }
+    }
+    return options;
+}
+function collectResponse(response, maxBytes) {
+    return new Promise((resolve, reject) => {
+        let total = 0;
+        const chunks = [];
+        let settled = false;
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            response.destroy();
+            reject(error);
+        };
+        response.on("data", (chunk) => {
+            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            total += buffer.length;
+            if (total > maxBytes) {
+                fail(new HttpError("RESPONSE_TOO_LARGE", "Server response is too large"));
+                return;
+            }
+            chunks.push(buffer);
+        });
+        response.on("end", () => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(Buffer.concat(chunks).toString("utf8"));
+        });
+        response.on("error", (error) => fail(new HttpError("NETWORK_ERROR", "Network request failed", { retryable: true })));
+    });
+}
+export class IntegrationHttpClient {
+    baseUrl;
+    profile;
+    maxResponseBytes;
+    constructor(profile, options = {}) {
+        if (!profile.base_url)
+            throw new HttpError("CONFIG_INVALID", "Profile base_url is required");
+        // Validate once at construction so every route remains fixed to this origin.
+        integrationUrl(profile.base_url, "/info");
+        this.baseUrl = profile.base_url;
+        this.profile = profile;
+        this.maxResponseBytes = options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
+    }
+    async requestJson(method, suffix, body, accessToken, options = {}) {
+        const url = integrationUrl(this.baseUrl, suffix);
+        const encoded = body === undefined ? "" : JSON.stringify(body);
+        if (Buffer.byteLength(encoded, "utf8") > MAX_REQUEST_BYTES) {
+            throw new HttpError("PROTOCOL_ERROR", "Request is too large");
+        }
+        const headers = {
+            accept: "application/json",
+            "cache-control": "no-store",
+            pragma: "no-cache",
+            connection: "close",
+            "user-agent": CLI_USER_AGENT,
+            "x-zhihu-cli-version": CLI_VERSION,
+        };
+        if (body !== undefined) {
+            headers["content-type"] = "application/json";
+            headers["content-length"] = String(Buffer.byteLength(encoded, "utf8"));
+        }
+        if (accessToken)
+            headers.authorization = `Bearer ${accessToken}`;
+        const requestConfig = requestOptions(url, this.profile, headers);
+        requestConfig.method = method;
+        const raw = await this.send(requestConfig, encoded);
+        if (raw.status >= 300 && raw.status < 400) {
+            throw new HttpError("REDIRECT_NOT_ALLOWED", "Server redirects are not allowed", { status: raw.status });
+        }
+        if (raw.status < 200 || raw.status >= 300)
+            throw responseError(raw.status, raw.body);
+        if (!raw.body.trim() && options.allowEmpty)
+            return undefined;
+        try {
+            return JSON.parse(raw.body);
+        }
+        catch {
+            throw new HttpError("PROTOCOL_ERROR", "Server response is not valid JSON", { status: raw.status });
+        }
+    }
+    send(options, body) {
+        return new Promise((resolve, reject) => {
+            const protocol = options.protocol === "https:" ? httpsRequest : httpRequest;
+            let request;
+            try {
+                request = protocol(options, async (response) => {
+                    try {
+                        const responseBody = await collectResponse(response, this.maxResponseBytes);
+                        resolve({ status: response.statusCode ?? 0, headers: response.headers, body: responseBody });
+                    }
+                    catch (error) {
+                        reject(error instanceof HttpError ? error : new HttpError("NETWORK_ERROR", "Network request failed", { retryable: true }));
+                    }
+                });
+            }
+            catch {
+                reject(new HttpError("NETWORK_ERROR", "Network request failed", { retryable: true }));
+                return;
+            }
+            const timeout = Math.max(1, this.profile.timeout_seconds) * 1000;
+            request.setTimeout(timeout, () => {
+                request.destroy();
+                reject(new HttpError("TIMEOUT", "Network request timed out", { retryable: true }));
+            });
+            request.once("error", (error) => {
+                if (error.code === "ETIMEDOUT")
+                    reject(new HttpError("TIMEOUT", "Network request timed out", { retryable: true }));
+                else
+                    reject(new HttpError("NETWORK_ERROR", "Network request failed", { retryable: true }));
+            });
+            if (body)
+                request.write(body);
+            request.end();
+        });
+    }
+    async info(options = {}) {
+        const value = await this.requestJson("GET", "/info");
+        if (options.requireReady)
+            return validateIntegrationInfo(value, true);
+        // Keep the low-level discovery call backwards compatible for existing
+        // clients/tests; installation and doctor opt into the strict contract.
+        return validateResponseObject(value, "Info");
+    }
+    async capabilities(accessToken) {
+        const envelope = validateResponseObject(await this.requestJson("GET", "/capabilities", undefined, accessToken), "Capabilities");
+        if (envelope.ok !== true) {
+            throw new HttpError("PROTOCOL_ERROR", "Capabilities response is invalid");
+        }
+        const data = validateResponseObject(envelope.data, "Capabilities data");
+        const userId = validateIdentityId(data.user_id, "user_id");
+        const tenantId = validateIdentityId(data.tenant_id, "tenant_id", true);
+        const scopes = validateStringList(data.scopes, "scopes");
+        const capabilities = validateStringList(data.capabilities, "capabilities");
+        if (scopes.length !== capabilities.length || scopes.some((scope, index) => capabilities[index] !== scope)) {
+            throw new HttpError("PROTOCOL_ERROR", "Capabilities response is invalid");
+        }
+        const meta = validateResponseObject(envelope.meta, "Capabilities metadata");
+        if (typeof meta.request_id !== "string" || !/^req_[A-Za-z0-9_-]{8,128}$/.test(meta.request_id)
+            || meta.capability !== "capabilities.list"
+            || meta.schema_version !== "1.0"
+            || validateGeneratedAt(meta.generated_at) !== meta.generated_at) {
+            throw new HttpError("PROTOCOL_ERROR", "Capabilities metadata is invalid");
+        }
+        return { user_id: userId, tenant_id: tenantId, scopes, capabilities };
+    }
+    async employees(accessToken) {
+        const envelope = validateResponseObject(await this.requestJson("GET", "/employees", undefined, accessToken), "Employees");
+        if (envelope.ok !== true) {
+            throw new HttpError("PROTOCOL_ERROR", "Employees response is invalid");
+        }
+        const data = validateResponseObject(envelope.data, "Employees data");
+        const employees = validateEmployeeList(data.employees);
+        const meta = validateResponseObject(envelope.meta, "Employees metadata");
+        if (typeof meta.request_id !== "string" || !/^req_[A-Za-z0-9_-]{8,128}$/.test(meta.request_id)
+            || meta.capability !== "employees.list"
+            || meta.schema_version !== "1.0"
+            || validateGeneratedAt(meta.generated_at) !== meta.generated_at) {
+            throw new HttpError("PROTOCOL_ERROR", "Employees metadata is invalid");
+        }
+        return { employees };
+    }
+    async assetsSearch(input, accessToken) {
+        if (!Number.isSafeInteger(input.page) || input.page < 1 || input.page > 10000
+            || !Number.isSafeInteger(input.page_size) || input.page_size < 1 || input.page_size > 100) {
+            throw new HttpError("PROTOCOL_ERROR", "Assets request pagination is invalid");
+        }
+        for (const value of [input.keyword, input.model]) {
+            if (value !== undefined && (typeof value !== "string" || value.length > 256 || /[\u0000-\u001f]/.test(value))) {
+                throw new HttpError("PROTOCOL_ERROR", "Assets request is invalid");
+            }
+        }
+        if (input.model !== undefined && input.model.length > 128) {
+            throw new HttpError("PROTOCOL_ERROR", "Assets model is invalid");
+        }
+        const envelope = validateResponseObject(await this.requestJson("POST", "/assets/search", {
+            ...(input.keyword !== undefined ? { keyword: input.keyword } : {}),
+            ...(input.model !== undefined ? { model: input.model } : {}),
+            page: input.page,
+            page_size: input.page_size,
+        }, accessToken), "Assets");
+        if (envelope.ok !== true)
+            throw new HttpError("PROTOCOL_ERROR", "Assets response is invalid");
+        const data = validateResponseObject(envelope.data, "Assets data");
+        const page = data.page;
+        const pageSize = data.page_size;
+        const total = data.total;
+        if (page !== input.page || pageSize !== input.page_size
+            || !Number.isSafeInteger(page) || !Number.isSafeInteger(pageSize)
+            || !Number.isSafeInteger(total) || page < 1 || page > 10000
+            || pageSize < 1 || pageSize > 100 || total < 0) {
+            throw new HttpError("PROTOCOL_ERROR", "Assets pagination is invalid");
+        }
+        const items = validateAssetItems(data.items, pageSize);
+        if (total < items.length)
+            throw new HttpError("PROTOCOL_ERROR", "Assets pagination is invalid");
+        const meta = validateResponseObject(envelope.meta, "Assets metadata");
+        if (typeof meta.request_id !== "string" || !/^req_[A-Za-z0-9_-]{8,128}$/.test(meta.request_id)
+            || meta.capability !== "assets.search"
+            || meta.schema_version !== "1.0"
+            || validateGeneratedAt(meta.generated_at) !== meta.generated_at) {
+            throw new HttpError("PROTOCOL_ERROR", "Assets metadata is invalid");
+        }
+        return { page, page_size: pageSize, total, items };
+    }
+    async assetGet(assetId, accessToken) {
+        const normalizedId = validateAssetRequestId(assetId);
+        const envelope = validateResponseObject(await this.requestJson("GET", `/assets/${assetId}`, undefined, accessToken), "Asset");
+        if (envelope.ok !== true)
+            throw new HttpError("PROTOCOL_ERROR", "Asset response is invalid");
+        const data = validateResponseObject(envelope.data, "Asset data");
+        if (Object.keys(data).length !== 1 || !Object.hasOwn(data, "asset")) {
+            throw new HttpError("PROTOCOL_ERROR", "Asset data response is invalid");
+        }
+        const asset = validateAssetRecord(data.asset, 0);
+        if (asset.id !== normalizedId) {
+            throw new HttpError("PROTOCOL_ERROR", "Asset response identity is invalid");
+        }
+        const meta = validateResponseObject(envelope.meta, "Asset metadata");
+        if (typeof meta.request_id !== "string" || !/^req_[A-Za-z0-9_-]{8,128}$/.test(meta.request_id)
+            || meta.capability !== "assets.get"
+            || meta.schema_version !== "1.0"
+            || validateGeneratedAt(meta.generated_at) !== meta.generated_at) {
+            throw new HttpError("PROTOCOL_ERROR", "Asset metadata is invalid");
+        }
+        return { asset };
+    }
+    async alarmsSearch(input, accessToken) {
+        if (!ALARM_QUERY_STATUSES.has(input.status)
+            || !Number.isSafeInteger(input.page) || input.page < 1 || input.page > 10000
+            || !Number.isSafeInteger(input.page_size) || input.page_size < 1 || input.page_size > 100) {
+            throw new HttpError("PROTOCOL_ERROR", "Alarms request is invalid");
+        }
+        const envelope = validateResponseObject(await this.requestJson("POST", "/alarms/search", {
+            status: input.status,
+            page: input.page,
+            page_size: input.page_size,
+        }, accessToken), "Alarms");
+        if (envelope.ok !== true)
+            throw new HttpError("PROTOCOL_ERROR", "Alarms response is invalid");
+        const data = validateResponseObject(envelope.data, "Alarms data");
+        const expected = new Set(["page", "page_size", "total", "items"]);
+        if (Object.keys(data).length !== expected.size || Object.keys(data).some((key) => !expected.has(key))) {
+            throw new HttpError("PROTOCOL_ERROR", "Alarms data response is invalid");
+        }
+        const responsePage = data.page;
+        const responsePageSize = data.page_size;
+        const responseTotal = data.total;
+        if (typeof responsePage !== "number" || typeof responsePageSize !== "number" || typeof responseTotal !== "number"
+            || responsePage !== input.page || responsePageSize !== input.page_size
+            || !Number.isSafeInteger(responsePage) || !Number.isSafeInteger(responsePageSize)
+            || !Number.isSafeInteger(responseTotal) || responsePage < 1 || responsePage > 10000
+            || responsePageSize < 1 || responsePageSize > 100 || responseTotal < 0 || responseTotal > 10_000_000) {
+            throw new HttpError("PROTOCOL_ERROR", "Alarms pagination is invalid");
+        }
+        if (!Array.isArray(data.items) || data.items.length > responsePageSize || data.items.length > 100) {
+            throw new HttpError("PROTOCOL_ERROR", "Alarms response is invalid");
+        }
+        const seen = new Set();
+        const items = data.items.map((item, index) => validateAlarmRecord(item, index, false, seen));
+        if (responseTotal < items.length)
+            throw new HttpError("PROTOCOL_ERROR", "Alarms pagination is invalid");
+        if (input.status !== "all" && items.some((item) => item.status !== input.status)) {
+            throw new HttpError("PROTOCOL_ERROR", "Alarms status filter response is invalid");
+        }
+        const meta = validateResponseObject(envelope.meta, "Alarms metadata");
+        if (typeof meta.request_id !== "string" || !/^req_[A-Za-z0-9_-]{8,128}$/.test(meta.request_id)
+            || meta.capability !== "alarms.search"
+            || meta.schema_version !== "1.0"
+            || validateGeneratedAt(meta.generated_at) !== meta.generated_at) {
+            throw new HttpError("PROTOCOL_ERROR", "Alarms metadata is invalid");
+        }
+        return { page: responsePage, page_size: responsePageSize, total: responseTotal, items };
+    }
+    async alarmGet(alarmId, accessToken) {
+        const normalizedId = validateAlarmRequestId(alarmId);
+        const envelope = validateResponseObject(await this.requestJson("GET", `/alarms/${normalizedId}`, undefined, accessToken), "Alarm");
+        if (envelope.ok !== true)
+            throw new HttpError("PROTOCOL_ERROR", "Alarm response is invalid");
+        const data = validateResponseObject(envelope.data, "Alarm data");
+        if (Object.keys(data).length !== 1 || !Object.hasOwn(data, "alarm")) {
+            throw new HttpError("PROTOCOL_ERROR", "Alarm data response is invalid");
+        }
+        const alarm = validateAlarmRecord(data.alarm, 0, true);
+        if (alarm.id !== normalizedId)
+            throw new HttpError("PROTOCOL_ERROR", "Alarm response identity is invalid");
+        const meta = validateResponseObject(envelope.meta, "Alarm metadata");
+        if (typeof meta.request_id !== "string" || !/^req_[A-Za-z0-9_-]{8,128}$/.test(meta.request_id)
+            || meta.capability !== "alarms.get"
+            || meta.schema_version !== "1.0"
+            || validateGeneratedAt(meta.generated_at) !== meta.generated_at) {
+            throw new HttpError("PROTOCOL_ERROR", "Alarm metadata is invalid");
+        }
+        return { alarm };
+    }
+    async alarmsGet(alarmId, accessToken) {
+        return this.alarmGet(alarmId, accessToken);
+    }
+    async incidentsDiagnose(alarmId, accessToken) {
+        const normalizedId = validateAlarmRequestId(alarmId);
+        const envelope = validateResponseObject(await this.requestJson("POST", "/incidents/diagnose", { alarm_id: normalizedId }, accessToken), "Incident");
+        const envelopeKeys = new Set(["ok", "data", "meta"]);
+        if (Object.keys(envelope).length !== envelopeKeys.size || Object.keys(envelope).some((key) => !envelopeKeys.has(key))) {
+            throw new HttpError("PROTOCOL_ERROR", "Incident response is invalid");
+        }
+        if (envelope.ok !== true)
+            throw new HttpError("PROTOCOL_ERROR", "Incident response is invalid");
+        const data = validateIncidentData(envelope.data, normalizedId);
+        const meta = validateResponseObject(envelope.meta, "Incident metadata");
+        if (typeof meta.request_id !== "string" || !/^req_[A-Za-z0-9_-]{8,128}$/.test(meta.request_id)
+            || meta.capability !== "incidents.diagnose"
+            || meta.schema_version !== "1.0"
+            || validateGeneratedAt(meta.generated_at) !== meta.generated_at) {
+            throw new HttpError("PROTOCOL_ERROR", "Incident metadata is invalid");
+        }
+        return data;
+    }
+    async inspectionsRun(input, accessToken) {
+        if (!Number.isSafeInteger(input.window_minutes) || input.window_minutes < 5 || input.window_minutes > 1440) {
+            throw new HttpError("PROTOCOL_ERROR", "Inspection window is invalid");
+        }
+        if (input.model !== undefined && input.model !== null
+            && (typeof input.model !== "string" || input.model.length < 1 || input.model.length > 128
+                || input.model.trim() !== input.model || /[\u0000-\u001f]/.test(input.model))) {
+            throw new HttpError("PROTOCOL_ERROR", "Inspection model is invalid");
+        }
+        const envelope = validateResponseObject(await this.requestJson("POST", "/inspections/run", {
+            ...(input.model !== undefined && input.model !== null ? { model: input.model } : {}),
+            window_minutes: input.window_minutes,
+        }, accessToken), "Inspection");
+        const envelopeKeys = new Set(["ok", "data", "meta"]);
+        if (Object.keys(envelope).length !== envelopeKeys.size || Object.keys(envelope).some((key) => !envelopeKeys.has(key))) {
+            throw new HttpError("PROTOCOL_ERROR", "Inspection response is invalid");
+        }
+        if (envelope.ok !== true)
+            throw new HttpError("PROTOCOL_ERROR", "Inspection response is invalid");
+        const data = validateInspectionData(envelope.data);
+        if (data.scope.window_minutes !== input.window_minutes
+            || (input.model ?? null) !== data.scope.model) {
+            throw new HttpError("PROTOCOL_ERROR", "Inspection scope identity is invalid");
+        }
+        const meta = validateResponseObject(envelope.meta, "Inspection metadata");
+        if (typeof meta.request_id !== "string" || !/^req_[A-Za-z0-9_-]{8,128}$/.test(meta.request_id)
+            || meta.capability !== "inspections.run"
+            || meta.schema_version !== "1.0"
+            || validateGeneratedAt(meta.generated_at) !== meta.generated_at) {
+            throw new HttpError("PROTOCOL_ERROR", "Inspection metadata is invalid");
+        }
+        return data;
+    }
+    async inspectionRun(input, accessToken) {
+        return this.inspectionsRun(input, accessToken);
+    }
+    async metricsQuery(input, accessToken) {
+        const asset = validateMetricAsset(input.asset);
+        if (!METRIC_NAMES.has(input.metric)
+            || !Number.isSafeInteger(input.window_minutes) || input.window_minutes < 5 || input.window_minutes > 1440
+            || !Number.isSafeInteger(input.max_points) || input.max_points < 1 || input.max_points > 120) {
+            throw new HttpError("PROTOCOL_ERROR", "Metrics request is invalid");
+        }
+        const envelope = validateResponseObject(await this.requestJson("POST", "/metrics/query", {
+            asset,
+            metric: input.metric,
+            window_minutes: input.window_minutes,
+            max_points: input.max_points,
+        }, accessToken), "Metrics");
+        if (envelope.ok !== true)
+            throw new HttpError("PROTOCOL_ERROR", "Metrics response is invalid");
+        const data = validateResponseObject(envelope.data, "Metrics data");
+        const expectedData = new Set(["target", "metric", "window_minutes", "matched_label", "series", "truncated"]);
+        if (Object.keys(data).length !== expectedData.size || Object.keys(data).some((key) => !expectedData.has(key))) {
+            throw new HttpError("PROTOCOL_ERROR", "Metrics data response is invalid");
+        }
+        const target = validateResponseObject(data.target, "Metrics target");
+        if (Object.keys(target).length !== 3 || !Object.hasOwn(target, "asset_id") || !Object.hasOwn(target, "name") || !Object.hasOwn(target, "ip")) {
+            throw new HttpError("PROTOCOL_ERROR", "Metrics target is invalid");
+        }
+        if (typeof target.asset_id !== "string" || target.asset_id.length < 1 || target.asset_id.length > 128) {
+            throw new HttpError("PROTOCOL_ERROR", "Metrics target id is invalid");
+        }
+        const targetId = isIP(input.asset) > 0
+            ? input.asset
+            : validateAssetRequestId(input.asset);
+        if (target.asset_id !== targetId) {
+            throw new HttpError("PROTOCOL_ERROR", "Metrics response identity is invalid");
+        }
+        const targetName = target.name === null ? null : validateNullableAssetText(target.name, "metric asset name");
+        const responseIp = canonicalIp(target.ip);
+        if (responseIp === null)
+            throw new HttpError("PROTOCOL_ERROR", "Metric asset ip is invalid");
+        const requestedIp = canonicalIp(input.asset);
+        if (requestedIp !== null && responseIp !== requestedIp) {
+            throw new HttpError("PROTOCOL_ERROR", "Metrics response target ip is invalid");
+        }
+        if (data.metric !== input.metric || data.window_minutes !== input.window_minutes || typeof data.truncated !== "boolean") {
+            throw new HttpError("PROTOCOL_ERROR", "Metrics response identity is invalid");
+        }
+        const matchedLabel = data.matched_label === null ? null : data.matched_label;
+        if (matchedLabel !== null && (typeof matchedLabel !== "string" || !METRIC_LABELS.has(matchedLabel))) {
+            throw new HttpError("PROTOCOL_ERROR", "Metrics matched label is invalid");
+        }
+        if (!Array.isArray(data.series) || data.series.length < 1 || data.series.length > 20) {
+            throw new HttpError("PROTOCOL_ERROR", "Metrics series are invalid");
+        }
+        const series = data.series.map((item, index) => validateMetricSeries(item, index, input.max_points));
+        const meta = validateResponseObject(envelope.meta, "Metrics metadata");
+        if (typeof meta.request_id !== "string" || !/^req_[A-Za-z0-9_-]{8,128}$/.test(meta.request_id)
+            || meta.capability !== "metrics.query"
+            || meta.schema_version !== "1.0"
+            || validateGeneratedAt(meta.generated_at) !== meta.generated_at) {
+            throw new HttpError("PROTOCOL_ERROR", "Metrics metadata is invalid");
+        }
+        return {
+            target: { asset_id: targetId, name: targetName, ip: responseIp },
+            metric: input.metric,
+            window_minutes: input.window_minutes,
+            matched_label: matchedLabel,
+            series,
+            truncated: data.truncated,
+        };
+    }
+    async employeeChat(employeeId, message, conversationId, accessToken, options = {}) {
+        validateEmployeeId(employeeId);
+        if (typeof message !== "string" || message.trim().length === 0 || message.length > 10000 || message.includes("\u0000")) {
+            throw new HttpError("PROTOCOL_ERROR", "message is invalid");
+        }
+        if (conversationId !== undefined)
+            validateChatId(conversationId, "conversation id");
+        const body = JSON.stringify({ message: message.trim(), ...(conversationId ? { conversation_id: conversationId } : {}) });
+        if (Buffer.byteLength(body, "utf8") > MAX_REQUEST_BYTES) {
+            throw new HttpError("PROTOCOL_ERROR", "Request is too large");
+        }
+        const url = integrationUrl(this.baseUrl, `/employees/${employeeId}/chat`);
+        const headers = {
+            accept: "text/event-stream",
+            "cache-control": "no-store",
+            pragma: "no-cache",
+            connection: "close",
+            "content-type": "application/json",
+            "content-length": String(Buffer.byteLength(body, "utf8")),
+            "user-agent": CLI_USER_AGENT,
+            "x-zhihu-cli-version": CLI_VERSION,
+            authorization: `Bearer ${accessToken}`,
+        };
+        const requestConfig = requestOptions(url, this.profile, headers);
+        requestConfig.method = "POST";
+        const parser = new EmployeeChatSseParser(conversationId, {
+            maxTotalBytes: this.maxResponseBytes,
+            maxEventBytes: Math.min(options.maxEventBytes ?? 64 * 1024, this.maxResponseBytes),
+        });
+        return new Promise((resolve, reject) => {
+            let request;
+            let settled = false;
+            let abortListener;
+            const cleanup = () => {
+                if (abortListener && options.signal)
+                    options.signal.removeEventListener("abort", abortListener);
+                abortListener = undefined;
+            };
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                if (request)
+                    request.destroy();
+                reject(error instanceof HttpError ? error : new HttpError("NETWORK_ERROR", "Network request failed", { retryable: true }));
+            };
+            const emit = (event) => {
+                try {
+                    options.onEvent?.(event);
+                }
+                catch {
+                    fail(new HttpError("PROTOCOL_ERROR", "Unable to consume chat stream"));
+                    return;
+                }
+                if (event.type === "error") {
+                    const message = event.code === "PROTOCOL_ERROR" ? "The server returned an invalid chat stream." : "The server rejected the chat request.";
+                    fail(new HttpError(event.code, message, {
+                        status: 200,
+                        retryable: retryableForCode(event.code, false),
+                    }));
+                }
+            };
+            const handleChunk = (chunk) => {
+                if (settled)
+                    return;
+                try {
+                    for (const event of parser.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)))
+                        emit(event);
+                }
+                catch (error) {
+                    fail(error);
+                }
+            };
+            const protocol = requestConfig.protocol === "https:" ? httpsRequest : httpRequest;
+            try {
+                request = protocol(requestConfig, (response) => {
+                    if (settled)
+                        return;
+                    const statusCode = response.statusCode ?? 0;
+                    if (statusCode < 200 || statusCode >= 300) {
+                        collectResponse(response, this.maxResponseBytes).then((responseBody) => fail(responseError(statusCode, responseBody)), (error) => fail(error));
+                        return;
+                    }
+                    const contentType = String(response.headers["content-type"] ?? "").toLowerCase();
+                    if (!contentType.includes("text/event-stream")) {
+                        fail(new HttpError("PROTOCOL_ERROR", "Chat response is not an SSE stream", { status: statusCode }));
+                        return;
+                    }
+                    response.on("data", handleChunk);
+                    response.on("end", () => {
+                        if (settled)
+                            return;
+                        try {
+                            for (const event of parser.finish())
+                                emit(event);
+                            if (!settled) {
+                                const result = parser.result();
+                                settled = true;
+                                cleanup();
+                                resolve(result);
+                            }
+                        }
+                        catch (error) {
+                            fail(error);
+                        }
+                    });
+                    response.on("error", () => fail(new HttpError("NETWORK_ERROR", "Network request failed", { retryable: true })));
+                });
+            }
+            catch {
+                fail(new HttpError("NETWORK_ERROR", "Network request failed", { retryable: true }));
+                return;
+            }
+            const timeout = Math.max(1, this.profile.timeout_seconds) * 1000;
+            request.setTimeout(timeout, () => {
+                fail(new HttpError("TIMEOUT", "The request timed out.", { retryable: true }));
+            });
+            request.once("error", (error) => {
+                if (settled)
+                    return;
+                if (error.code === "ETIMEDOUT")
+                    fail(new HttpError("TIMEOUT", "The request timed out.", { retryable: true }));
+                else
+                    fail(new HttpError("NETWORK_ERROR", "Network request failed", { retryable: true }));
+            });
+            abortListener = () => {
+                fail(new HttpError("USER_CANCELLED", "The request was cancelled."));
+            };
+            if (options.signal?.aborted) {
+                abortListener();
+                return;
+            }
+            options.signal?.addEventListener("abort", abortListener, { once: true });
+            request.write(body);
+            request.end();
+        });
+    }
+    async chat(employeeId, message, conversationId, accessToken, options = {}) {
+        return this.employeeChat(employeeId, message, conversationId, accessToken, options);
+    }
+    async start(codeChallenge) {
+        const result = validateResponseObject(await this.requestJson("POST", "/auth/start", {
+            code_challenge: codeChallenge,
+            code_challenge_method: "S256",
+        }), "Auth start");
+        return {
+            transaction_id: validateCredentialField(result.transaction_id, "transaction_id"),
+            polling_secret: validateCredentialField(result.polling_secret, "polling_secret"),
+            authorization_url: validateCredentialField(result.authorization_url, "authorization_url"),
+            expires_in: validateExpires(result.expires_in),
+        };
+    }
+    async poll(transactionId, pollingSecret, codeVerifier) {
+        const result = validateResponseObject(await this.requestJson("POST", "/auth/poll", {
+            transaction_id: transactionId,
+            polling_secret: pollingSecret,
+            code_verifier: codeVerifier,
+        }), "Auth poll");
+        const status = validateCredentialField(result.status, "status");
+        const output = { status };
+        if (typeof result.error_code === "string")
+            output.error_code = result.error_code;
+        if (result.access_token !== undefined)
+            output.access_token = validateCredentialField(result.access_token, "access_token");
+        if (result.refresh_credential !== undefined)
+            output.refresh_credential = validateCredentialField(result.refresh_credential, "refresh_credential");
+        if (result.expires_in !== undefined)
+            output.expires_in = validateExpires(result.expires_in);
+        return output;
+    }
+    async refresh(refreshCredential) {
+        const result = validateResponseObject(await this.requestJson("POST", "/auth/refresh", {
+            refresh_credential: refreshCredential,
+        }), "Auth refresh");
+        return {
+            access_token: validateCredentialField(result.access_token, "access_token"),
+            refresh_credential: validateCredentialField(result.refresh_credential, "refresh_credential"),
+            expires_in: validateExpires(result.expires_in),
+        };
+    }
+    async logout(refreshCredential) {
+        await this.requestJson("POST", "/auth/logout", { refresh_credential: refreshCredential }, undefined, { allowEmpty: true });
+    }
+}
+export { IntegrationHttpClient as HttpClient };