@luckypiggy/zhihu-ai-cli 0.1.0-test.1 → 0.2.1-test.4

package/dist/http.js

@@ -4,6 +4,7 @@ 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";
+import { cliCommand } from "./release.js";
 const INTEGRATION_PATH = "/api/zhihu/integrations/v1";
 const DEFAULT_MAX_RESPONSE_BYTES = 1024 * 1024;
 const MAX_REQUEST_BYTES = 128 * 1024;
@@ -18,24 +19,85 @@ const INFO_CAPABILITIES = [
     "inspections",
     "metrics",
     "alarms",
+    "a2a",
 ];
-function semver(value) {
-    if (typeof value !== "string" || !/^\d+\.\d+\.\d+$/.test(value))
+const SEMVER_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
+function parseNumericCore(value) {
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : null;
+}
+/** Parse SemVer without accepting loose prefixes, missing parts or bad zeros. */
+export function parseSemVer(value) {
+    if (typeof value !== "string")
         return null;
-    const parts = value.split(".").map(Number);
-    if (parts.some((part) => !Number.isSafeInteger(part) || part < 0))
+    const match = SEMVER_PATTERN.exec(value);
+    if (!match)
+        return null;
+    const major = parseNumericCore(match[1]);
+    const minor = parseNumericCore(match[2]);
+    const patch = parseNumericCore(match[3]);
+    if (major === null || minor === null || patch === null)
+        return null;
+    const prerelease = match[4]?.split(".") ?? [];
+    if (prerelease.some((identifier) => /^\d+$/.test(identifier) && identifier.length > 1 && identifier.startsWith("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;
+    return {
+        major,
+        minor,
+        patch,
+        prerelease,
+        build: match[5]?.split(".") ?? [],
+    };
 }
+function asSemVer(value) {
+    return typeof value === "string" ? parseSemVer(value) : value;
+}
+function comparePrereleaseIdentifier(left, right) {
+    const leftNumeric = /^\d+$/.test(left);
+    const rightNumeric = /^\d+$/.test(right);
+    if (leftNumeric && rightNumeric) {
+        if (left.length !== right.length)
+            return left.length < right.length ? -1 : 1;
+        return left === right ? 0 : left < right ? -1 : 1;
+    }
+    if (leftNumeric !== rightNumeric)
+        return leftNumeric ? -1 : 1;
+    return left === right ? 0 : left < right ? -1 : 1;
+}
+/** Compare SemVer precedence; build metadata does not affect the result. */
+export function compareSemVer(left, right) {
+    const parsedLeft = asSemVer(left);
+    const parsedRight = asSemVer(right);
+    if (!parsedLeft || !parsedRight)
+        throw new TypeError("Invalid SemVer value");
+    for (const key of ["major", "minor", "patch"]) {
+        if (parsedLeft[key] !== parsedRight[key])
+            return parsedLeft[key] < parsedRight[key] ? -1 : 1;
+    }
+    const leftPrerelease = parsedLeft.prerelease;
+    const rightPrerelease = parsedRight.prerelease;
+    if (leftPrerelease.length === 0 && rightPrerelease.length === 0)
+        return 0;
+    if (leftPrerelease.length === 0)
+        return 1;
+    if (rightPrerelease.length === 0)
+        return -1;
+    const count = Math.min(leftPrerelease.length, rightPrerelease.length);
+    for (let index = 0; index < count; index += 1) {
+        const comparison = comparePrereleaseIdentifier(leftPrerelease[index], rightPrerelease[index]);
+        if (comparison !== 0)
+            return comparison;
+    }
+    if (leftPrerelease.length === rightPrerelease.length)
+        return 0;
+    return leftPrerelease.length < rightPrerelease.length ? -1 : 1;
+}
+// Preserve the spelling used by older internal tests while exposing the
+// standards-correct SemVer comparator to release validation tooling.
+export const compareSemver = compareSemVer;
 /** Validate the exact, unauthenticated integration discovery contract. */
-export function validateIntegrationInfo(value, requireReady = false) {
+export function validateIntegrationInfo(value, requireReady = false, cliVersion = CLI_VERSION) {
     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))) {
@@ -44,9 +106,9 @@ export function validateIntegrationInfo(value, requireReady = false) {
     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) {
+    const minimum = parseSemVer(object.minimum_cli_version);
+    const current = parseSemVer(cliVersion);
+    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") {
@@ -75,8 +137,14 @@ export function validateIntegrationInfo(value, requireReady = false) {
     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") {
+    const terminalAuth = auth.mode === "pilot_terminal_password"
+        && Array.isArray(auth.pkce_methods)
+        && auth.pkce_methods.length === 0;
+    const legacyAuth = auth.mode === "pilot_oauth_bff"
+        && Array.isArray(auth.pkce_methods)
+        && auth.pkce_methods.length === 1
+        && auth.pkce_methods[0] === "S256";
+    if (typeof auth.configured !== "boolean" || (!terminalAuth && !legacyAuth)) {
         throw new HttpError("PROTOCOL_ERROR", "Info auth is invalid");
     }
     const baseCapabilities = INFO_CAPABILITIES.slice(0, 4);
@@ -86,14 +154,21 @@ export function validateIntegrationInfo(value, requireReady = false) {
     const hasAlarms = seen.has("alarms");
     const hasIncidents = seen.has("incidents");
     const hasInspections = seen.has("inspections");
+    const hasA2A = seen.has("a2a");
+    if (hasA2A && capabilities[capabilities.length - 1] !== "a2a") {
+        throw new HttpError("PROTOCOL_ERROR", "Info capabilities are invalid");
+    }
+    const coreCapabilities = hasA2A ? capabilities.slice(0, -1) : capabilities;
+    const coreSet = new Set(coreCapabilities);
     // 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));
+    // and the pair itself is all-or-nothing. A2A is a final, independent
+    // marker so older discovery suffix ordering remains valid.
+    const optionalCombinationValid = baseMatch && coreSet.has("info") && (coreCapabilities.length === 4
+        || (coreCapabilities.length === 5 && hasMetrics && !hasAlarms && !hasIncidents && !hasInspections)
+        || (coreCapabilities.length === 5 && hasAlarms && !hasMetrics && !hasIncidents && !hasInspections)
+        || (coreCapabilities.length === 8 && hasMetrics && hasAlarms && hasIncidents && hasInspections));
     if (object.status === "ready" && (auth.configured !== true || !optionalCombinationValid)) {
         throw new HttpError("PROTOCOL_ERROR", "Info readiness is inconsistent");
     }
@@ -107,6 +182,9 @@ export function validateIntegrationInfo(value, requireReady = false) {
         }
         throw new HttpError("VERSION_INCOMPATIBLE", "The configured Pilot is not ready for CLI installation");
     }
+    if (requireReady && !terminalAuth) {
+        throw new HttpError("TERMINAL_LOGIN_REQUIRED", "This Pilot still exposes browser OAuth. Upgrade or enable terminal password login before installing this CLI.");
+    }
     return {
         service: object.service,
         protocol_version: object.protocol_version,
@@ -116,7 +194,7 @@ export function validateIntegrationInfo(value, requireReady = false) {
         auth: {
             mode: auth.mode,
             configured: auth.configured,
-            pkce_methods: ["S256"],
+            pkce_methods: [...auth.pkce_methods],
         },
     };
 }
@@ -142,9 +220,17 @@ const RETRYABLE_ERROR_CODES = new Set([
     "CONVERSATION_CAPACITY_REACHED",
     "DATA_SOURCE_UNAVAILABLE",
     "TIMEOUT",
+    "A2A_TIMEOUT",
+    "A2A_RUNTIME_ERROR",
+    "A2A_TASK_START_FAILED",
+    "A2A_DUPLICATE",
 ]);
 const NON_RETRYABLE_ERROR_CODES = new Set([
     "AUTH_RELOGIN_REQUIRED",
+    "AUTH_LOGIN_FAILED",
+    "AUTH_ACCOUNT_LOCKED",
+    "AUTH_CAPTCHA_REQUIRED",
+    "TERMINAL_LOGIN_REQUIRED",
     "CAPABILITY_SCOPE_REQUIRED",
     "CAPABILITY_NOT_AVAILABLE",
     "FORBIDDEN",
@@ -160,6 +246,14 @@ const NON_RETRYABLE_ERROR_CODES = new Set([
     "UPSTREAM_RESPONSE_TOO_LARGE",
     "USER_CANCELLED",
     "PROTOCOL_ERROR",
+    "A2A_DISABLED",
+    "A2A_CAPABILITY_NOT_FOUND",
+    "A2A_CAPABILITY_DISABLED",
+    "A2A_TASK_NOT_FOUND",
+    "A2A_FORBIDDEN",
+    "A2A_CANCELLED",
+    "A2A_EMPTY_RESPONSE",
+    "A2A_EXECUTION_INDETERMINATE",
 ]);
 function retryableForCode(code, fallback) {
     if (RETRYABLE_ERROR_CODES.has(code))
@@ -173,6 +267,8 @@ function stableCode(status) {
         return { code: "AUTH_RELOGIN_REQUIRED", retryable: false };
     if (status === 403)
         return { code: "FORBIDDEN", retryable: false };
+    if (status === 423)
+        return { code: "AUTH_ACCOUNT_LOCKED", retryable: false };
     if (status === 429)
         return { code: "RATE_LIMITED", retryable: true };
     if (status >= 500)
@@ -182,7 +278,11 @@ function stableCode(status) {
 function responseError(status, body) {
     const fallback = stableCode(status);
     const messages = {
-        AUTH_RELOGIN_REQUIRED: "Your Zhihu session has expired. Run `zhihu auth login`.",
+        AUTH_RELOGIN_REQUIRED: `Your Zhihu session has expired. Run \`${cliCommand("auth", "login")}\`.`,
+        AUTH_LOGIN_FAILED: "Zhihu login was rejected. Check the username and password and try again.",
+        AUTH_ACCOUNT_LOCKED: "Zhihu login is temporarily locked. Try again later or contact an administrator.",
+        AUTH_CAPTCHA_REQUIRED: "Zhihu login requires captcha verification. Complete the challenge and try again.",
+        TERMINAL_LOGIN_REQUIRED: "This Pilot requires terminal password login; browser OAuth is not supported by this CLI.",
         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.",
@@ -207,6 +307,18 @@ function responseError(status, body) {
         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.",
+        A2A_DISABLED: "A2A routing is not enabled on the configured Pilot.",
+        A2A_CAPABILITY_NOT_FOUND: "The requested A2A capability was not found.",
+        A2A_CAPABILITY_DISABLED: "The requested A2A capability is not enabled.",
+        A2A_TASK_NOT_FOUND: "The requested A2A task was not found.",
+        A2A_FORBIDDEN: "You are not allowed to access this A2A task.",
+        A2A_TIMEOUT: "The A2A delegation timed out.",
+        A2A_CANCELLED: "The A2A delegation was cancelled.",
+        A2A_RUNTIME_ERROR: "The A2A target employee failed to complete the request.",
+        A2A_EMPTY_RESPONSE: "The A2A target employee returned no usable result.",
+        A2A_EXECUTION_INDETERMINATE: "The A2A execution state is unknown; verify the task before retrying.",
+        A2A_DUPLICATE: "The A2A request is already running.",
+        A2A_TASK_START_FAILED: "The A2A task could not be started.",
     };
     try {
         const parsed = JSON.parse(body);
@@ -323,6 +435,163 @@ function validateEmployeeList(value) {
         };
     });
 }
+const A2A_CAPABILITY_IDS = new Set([
+    "resource_query",
+    "incident_analysis",
+    "inspection_summary",
+    "knowledge_qa",
+]);
+const A2A_WRITE_IDS = new Set(["asset_onboarding", "asset_discovery"]);
+const A2A_TASK_STATUSES = new Set([
+    "running",
+    "completed",
+    "failed",
+    "timed_out",
+    "cancelled",
+]);
+function validateA2AText(value, field, maxLength = 4096) {
+    if (typeof value !== "string"
+        || value.length === 0
+        || value.length > maxLength
+        || /[\u0000-\u001f\u007f]/.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+    }
+    return value;
+}
+function validateA2AResultText(value, field) {
+    if (typeof value !== "string"
+        || value.length > 64 * 1024
+        // Natural-language conclusions may be multiline.  Keep tabs/newlines
+        // while rejecting NUL, other C0 controls and DEL/escape characters that
+        // could corrupt a terminal or a JSON consumer's display.
+        || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(value)) {
+        throw new HttpError("PROTOCOL_ERROR", `${field} response is invalid`);
+    }
+    return value;
+}
+function validateA2ACapabilityRecord(value, index) {
+    const item = validateResponseObject(value, `A2A capability ${index}`);
+    const expected = new Set(["id", "name", "risk_level", "enabled"]);
+    if (Object.keys(item).length !== expected.size || Object.keys(item).some((key) => !expected.has(key))) {
+        throw new HttpError("PROTOCOL_ERROR", "A2A capabilities response is invalid");
+    }
+    if (typeof item.id !== "string" || (!A2A_CAPABILITY_IDS.has(item.id) && !A2A_WRITE_IDS.has(item.id))) {
+        throw new HttpError("PROTOCOL_ERROR", "A2A capability id is invalid");
+    }
+    if (typeof item.risk_level !== "string" || !["readonly", "write"].includes(item.risk_level)) {
+        throw new HttpError("PROTOCOL_ERROR", "A2A capability risk is invalid");
+    }
+    if (typeof item.enabled !== "boolean")
+        throw new HttpError("PROTOCOL_ERROR", "A2A capability state is invalid");
+    if ((A2A_WRITE_IDS.has(item.id) && (item.risk_level !== "write" || item.enabled))
+        || (!A2A_WRITE_IDS.has(item.id) && (item.risk_level !== "readonly" || !item.enabled))) {
+        throw new HttpError("PROTOCOL_ERROR", "A2A capability state is invalid");
+    }
+    return {
+        id: item.id,
+        name: validateA2AText(item.name, "A2A capability name"),
+        risk_level: item.risk_level,
+        enabled: item.enabled,
+    };
+}
+function validateA2ACapabilitiesData(value) {
+    const data = validateResponseObject(value, "A2A capabilities data");
+    const expected = new Set(["capabilities", "disabled_write"]);
+    if (Object.keys(data).length !== expected.size || Object.keys(data).some((key) => !expected.has(key))) {
+        throw new HttpError("PROTOCOL_ERROR", "A2A capabilities response is invalid");
+    }
+    if (!Array.isArray(data.capabilities) || data.capabilities.length > A2A_CAPABILITY_IDS.size) {
+        throw new HttpError("PROTOCOL_ERROR", "A2A capabilities response is invalid");
+    }
+    if (!Array.isArray(data.disabled_write) || data.disabled_write.length > A2A_WRITE_IDS.size) {
+        throw new HttpError("PROTOCOL_ERROR", "A2A capabilities response is invalid");
+    }
+    const capabilities = data.capabilities.map((item, index) => validateA2ACapabilityRecord(item, index));
+    const disabledWrite = data.disabled_write.map((item, index) => validateA2ACapabilityRecord(item, index));
+    const seen = new Set();
+    for (const item of capabilities) {
+        if (item.risk_level !== "readonly" || seen.has(item.id))
+            throw new HttpError("PROTOCOL_ERROR", "A2A capabilities response is invalid");
+        seen.add(item.id);
+    }
+    const writeSeen = new Set();
+    for (const item of disabledWrite) {
+        if (item.risk_level !== "write" || item.enabled || writeSeen.has(item.id))
+            throw new HttpError("PROTOCOL_ERROR", "A2A capabilities response is invalid");
+        writeSeen.add(item.id);
+    }
+    return { capabilities, disabled_write: disabledWrite };
+}
+function validateA2AEnvelope(value, label) {
+    const envelope = validateResponseObject(value, label);
+    const expected = new Set(["ok", "data", "meta"]);
+    if (Object.keys(envelope).length !== expected.size || Object.keys(envelope).some((key) => !expected.has(key)) || envelope.ok !== true) {
+        throw new HttpError("PROTOCOL_ERROR", `${label} response is invalid`);
+    }
+    const meta = validateResponseObject(envelope.meta, `${label} metadata`);
+    if (typeof meta.request_id !== "string" || !/^req_[A-Za-z0-9_-]{8,128}$/.test(meta.request_id)
+        || typeof meta.capability !== "string" || !/^a2a\.[a-z.]+$/.test(meta.capability)
+        || meta.schema_version !== "1.0"
+        || validateGeneratedAt(meta.generated_at) !== meta.generated_at) {
+        throw new HttpError("PROTOCOL_ERROR", `${label} metadata is invalid`);
+    }
+    return envelope;
+}
+function validateA2ATaskId(value) {
+    return validateA2AText(value, "A2A task id", 128).match(/^[A-Za-z0-9:_-]+$/)
+        ? value
+        : (() => { throw new HttpError("PROTOCOL_ERROR", "A2A task id is invalid"); })();
+}
+function validateA2AResult(value) {
+    const data = validateResponseObject(value, "A2A delegation data");
+    const expected = new Set(["accepted", "capability", "target", "task", "trace", "status", "result"]);
+    if (Object.keys(data).length !== expected.size || Object.keys(data).some((key) => !expected.has(key))) {
+        throw new HttpError("PROTOCOL_ERROR", "A2A delegation response is invalid");
+    }
+    if (data.accepted !== true || typeof data.capability !== "string" || !A2A_CAPABILITY_IDS.has(data.capability)) {
+        throw new HttpError("PROTOCOL_ERROR", "A2A delegation response is invalid");
+    }
+    if (data.status !== "success")
+        throw new HttpError("PROTOCOL_ERROR", "A2A delegation status is invalid");
+    return {
+        accepted: true,
+        capability: data.capability,
+        target: validateIdentityId(data.target, "A2A target"),
+        task: validateA2ATaskId(data.task),
+        trace: validateA2AText(data.trace, "A2A trace", 256),
+        status: "success",
+        result: validateA2AResultText(data.result, "A2A result"),
+    };
+}
+function validateA2ATask(value) {
+    const data = validateResponseObject(value, "A2A task data");
+    const expected = new Set(["task", "capability", "target", "trace", "status", "result", "created_at", "finished_at"]);
+    if (Object.keys(data).length !== expected.size || Object.keys(data).some((key) => !expected.has(key))) {
+        throw new HttpError("PROTOCOL_ERROR", "A2A task response is invalid");
+    }
+    if (typeof data.capability !== "string" || !A2A_CAPABILITY_IDS.has(data.capability)) {
+        throw new HttpError("PROTOCOL_ERROR", "A2A task capability is invalid");
+    }
+    if (typeof data.status !== "string" || !A2A_TASK_STATUSES.has(data.status)) {
+        throw new HttpError("PROTOCOL_ERROR", "A2A task status is invalid");
+    }
+    if (typeof data.created_at !== "number" || !Number.isFinite(data.created_at) || data.created_at <= 0
+        || (data.finished_at !== null && (typeof data.finished_at !== "number" || !Number.isFinite(data.finished_at) || data.finished_at <= 0))) {
+        throw new HttpError("PROTOCOL_ERROR", "A2A task timestamps are invalid");
+    }
+    if (data.status === "completed" && data.finished_at === null)
+        throw new HttpError("PROTOCOL_ERROR", "A2A task timestamps are invalid");
+    return {
+        task: validateA2ATaskId(data.task),
+        capability: data.capability,
+        target: validateIdentityId(data.target, "A2A target"),
+        trace: validateA2AText(data.trace, "A2A trace", 256),
+        status: data.status,
+        result: validateA2AResultText(data.result, "A2A result"),
+        created_at: data.created_at,
+        finished_at: data.finished_at,
+    };
+}
 const ASSET_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
 const ASSET_IP_PATTERN = /^[0-9a-fA-F:.]{1,128}$/;
 function validateNullableAssetText(value, field) {
@@ -1332,7 +1601,8 @@ export class IntegrationHttpClient {
             headers.authorization = `Bearer ${accessToken}`;
         const requestConfig = requestOptions(url, this.profile, headers);
         requestConfig.method = method;
-        const raw = await this.send(requestConfig, encoded);
+        const timeoutSeconds = options.timeoutSeconds ?? this.profile.timeout_seconds;
+        const raw = await this.send(requestConfig, encoded, options.signal, timeoutSeconds);
         if (raw.status >= 300 && raw.status < 400) {
             throw new HttpError("REDIRECT_NOT_ALLOWED", "Server redirects are not allowed", { status: raw.status });
         }
@@ -1347,51 +1617,130 @@ export class IntegrationHttpClient {
             throw new HttpError("PROTOCOL_ERROR", "Server response is not valid JSON", { status: raw.status });
         }
     }
-    send(options, body) {
+    send(options, body, signal, timeoutSeconds) {
         return new Promise((resolve, reject) => {
             const protocol = options.protocol === "https:" ? httpsRequest : httpRequest;
             let request;
+            let settled = false;
+            let abortListener;
+            const cleanup = () => {
+                if (abortListener && signal)
+                    signal.removeEventListener("abort", abortListener);
+                abortListener = undefined;
+            };
+            const succeed = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(value);
+            };
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                request?.destroy();
+                reject(error);
+            };
             try {
                 request = protocol(options, async (response) => {
                     try {
                         const responseBody = await collectResponse(response, this.maxResponseBytes);
-                        resolve({ status: response.statusCode ?? 0, headers: response.headers, body: responseBody });
+                        succeed({ 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 }));
+                        fail(error instanceof HttpError ? error : new HttpError("NETWORK_ERROR", "Network request failed", { retryable: true }));
                     }
                 });
             }
             catch {
-                reject(new HttpError("NETWORK_ERROR", "Network request failed", { retryable: true }));
+                fail(new HttpError("NETWORK_ERROR", "Network request failed", { retryable: true }));
                 return;
             }
-            const timeout = Math.max(1, this.profile.timeout_seconds) * 1000;
+            const timeout = Math.max(1, timeoutSeconds ?? this.profile.timeout_seconds) * 1000;
             request.setTimeout(timeout, () => {
-                request.destroy();
-                reject(new HttpError("TIMEOUT", "Network request timed out", { retryable: true }));
+                fail(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 }));
+                    fail(new HttpError("TIMEOUT", "Network request timed out", { retryable: true }));
                 else
-                    reject(new HttpError("NETWORK_ERROR", "Network request failed", { retryable: true }));
+                    fail(new HttpError("NETWORK_ERROR", "Network request failed", { retryable: true }));
             });
+            abortListener = () => fail(new HttpError("USER_CANCELLED", "The request was cancelled."));
+            if (signal?.aborted) {
+                abortListener();
+                return;
+            }
+            signal?.addEventListener("abort", abortListener, { once: true });
             if (body)
                 request.write(body);
             request.end();
         });
     }
     async info(options = {}) {
-        const value = await this.requestJson("GET", "/info");
+        const value = await this.requestJson("GET", "/info", undefined, undefined, { signal: options.signal });
         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");
+    /**
+     * Authenticate through the Pilot terminal-login contract. Credentials are
+     * accepted for this call only and are sent in the JSON body; they are never
+     * placed in a URL, header, error, or log value.
+     */
+    async terminalLogin(username, password, tenantId, captchaVerification, options = {}) {
+        if (typeof username !== "string" || username.length === 0 || username.length > 256 || /[\u0000-\u001f\u007f]/.test(username)) {
+            throw new HttpError("INVALID_ARGUMENT", "Username is invalid");
+        }
+        if (typeof password !== "string" || password.length === 0 || password.length > 4096 || /[\u0000-\u001f\u007f]/.test(password)) {
+            throw new HttpError("INVALID_ARGUMENT", "Password is invalid");
+        }
+        if (tenantId !== undefined && (typeof tenantId !== "string" || tenantId.length === 0 || tenantId.length > 128 || !/^[A-Za-z0-9_-]+$/.test(tenantId))) {
+            throw new HttpError("INVALID_ARGUMENT", "Tenant id is invalid");
+        }
+        if (captchaVerification !== undefined && (typeof captchaVerification !== "string" || captchaVerification.length === 0 || captchaVerification.length > 4096 || /[\u0000-\u001f\u007f]/.test(captchaVerification))) {
+            throw new HttpError("INVALID_ARGUMENT", "Captcha verification is invalid");
+        }
+        const body = {
+            username,
+            password,
+            ...(tenantId === undefined ? {} : { tenant_id: tenantId }),
+            ...(captchaVerification === undefined ? {} : { captcha_verification: captchaVerification }),
+        };
+        let result;
+        try {
+            result = validateResponseObject(await this.requestJson("POST", "/auth/login", body, undefined, { signal: options.signal }), "Terminal login");
+        }
+        catch (error) {
+            if (!(error instanceof HttpError))
+                throw error;
+            // Keep terminal-login failures stable and non-sensitive. The generic
+            // response parser intentionally ignores provider messages.
+            if (error.code === "PROTOCOL_ERROR" && error.status === 400) {
+                throw new HttpError("AUTH_LOGIN_FAILED", "Zhihu login was rejected. Check the username and password and try again.", { status: error.status });
+            }
+            if (error.code === "AUTH_RELOGIN_REQUIRED" && error.status === 401) {
+                throw new HttpError("AUTH_LOGIN_FAILED", "Zhihu login was rejected. Check the username and password and try again.", { status: error.status });
+            }
+            throw error;
+        }
+        const expectedKeys = new Set(["access_token", "refresh_credential", "expires_in"]);
+        const keys = Object.keys(result);
+        if (keys.length !== expectedKeys.size || keys.some((key) => !expectedKeys.has(key))) {
+            throw new HttpError("PROTOCOL_ERROR", "Terminal login response is invalid");
+        }
+        return {
+            access_token: validateCredentialField(result.access_token, "access_token"),
+            refresh_credential: validateCredentialField(result.refresh_credential, "refresh_credential"),
+            expires_in: validateExpires(result.expires_in),
+        };
+    }
+    async capabilities(accessToken, options = {}) {
+        const envelope = validateResponseObject(await this.requestJson("GET", "/capabilities", undefined, accessToken, { signal: options.signal }), "Capabilities");
         if (envelope.ok !== true) {
             throw new HttpError("PROTOCOL_ERROR", "Capabilities response is invalid");
         }
@@ -1412,6 +1761,33 @@ export class IntegrationHttpClient {
         }
         return { user_id: userId, tenant_id: tenantId, scopes, capabilities };
     }
+    async a2aCapabilities(accessToken, options = {}) {
+        const envelope = validateA2AEnvelope(await this.requestJson("GET", "/a2a/capabilities", undefined, accessToken, { signal: options.signal }), "A2A capabilities");
+        return validateA2ACapabilitiesData(envelope.data);
+    }
+    async a2aDelegate(capabilityId, question, accessToken, options = {}) {
+        if (!A2A_CAPABILITY_IDS.has(capabilityId)) {
+            throw new HttpError("INVALID_ARGUMENT", "A2A capability is invalid");
+        }
+        if (typeof question !== "string" || question.trim().length === 0 || Array.from(question).length > 8000
+            || Buffer.byteLength(question, "utf8") > 16 * 1024
+            || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/.test(question)) {
+            throw new HttpError("INVALID_ARGUMENT", "A2A question is invalid");
+        }
+        const envelope = validateA2AEnvelope(await this.requestJson("POST", "/a2a/delegations", {
+            capability_id: capabilityId,
+            question: question.trim(),
+        }, accessToken, {
+            signal: options.signal,
+            timeoutSeconds: Math.max(200, this.profile.timeout_seconds),
+        }), "A2A delegation");
+        return validateA2AResult(envelope.data);
+    }
+    async a2aTask(taskId, accessToken, options = {}) {
+        const normalized = validateA2ATaskId(taskId);
+        const envelope = validateA2AEnvelope(await this.requestJson("GET", `/a2a/tasks/${encodeURIComponent(normalized)}`, undefined, accessToken, { signal: options.signal }), "A2A task");
+        return validateA2ATask(envelope.data);
+    }
     async employees(accessToken) {
         const envelope = validateResponseObject(await this.requestJson("GET", "/employees", undefined, accessToken), "Employees");
         if (envelope.ok !== true) {
@@ -1828,36 +2204,6 @@ export class IntegrationHttpClient {
     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,