qlogicagent 2.13.3 → 2.13.5

package/dist/protocol/wire/web-capability.d.ts

@@ -0,0 +1,54 @@
+export declare const WEB_CAPABILITY_ID_VALUES: readonly ["web_search", "web_fetch", "deep_research", "browser_execution"];
+export type WebCapabilityId = (typeof WEB_CAPABILITY_ID_VALUES)[number];
+export declare const WEB_CAPABILITY_FAMILY_VALUES: readonly ["web-intelligence", "browser-execution"];
+export type WebCapabilityFamily = (typeof WEB_CAPABILITY_FAMILY_VALUES)[number];
+export declare const WEB_TASK_MODE_VALUES: readonly ["discovery", "read-url", "multi-source-research", "interactive-browser"];
+export type WebTaskMode = (typeof WEB_TASK_MODE_VALUES)[number];
+export declare const WEB_EXECUTION_MODE_VALUES: readonly ["stateless", "render-backend", "interactive-session"];
+export type WebExecutionMode = (typeof WEB_EXECUTION_MODE_VALUES)[number];
+export declare const WEB_STATEFULNESS_VALUES: readonly ["stateless", "stateless-single-step", "stateful-session-required"];
+export type WebStatefulness = (typeof WEB_STATEFULNESS_VALUES)[number];
+export declare const WEB_APPROVAL_DEFAULT_VALUES: readonly ["required", "conditional", "none"];
+export type WebApprovalDefault = (typeof WEB_APPROVAL_DEFAULT_VALUES)[number];
+export declare const WEB_POLICY_RISK_CLASS_VALUES: readonly ["browser-read", "browser-authenticated-read", "browser-state-changing"];
+export type WebPolicyRiskClass = (typeof WEB_POLICY_RISK_CLASS_VALUES)[number];
+export declare const TOOL_RISK_LEVEL_VALUES: readonly ["read", "write", "system", "external_egress"];
+export type ToolRiskLevel = (typeof TOOL_RISK_LEVEL_VALUES)[number];
+export declare const WEB_ACTION_SCOPE_VALUES: readonly ["read-page", "read-authenticated-page", "fill-form", "submit-form", "download-file", "reuse-session"];
+export type WebActionScope = (typeof WEB_ACTION_SCOPE_VALUES)[number];
+export declare const WEB_DEGRADATION_TARGET_VALUES: readonly ["web_search", "web_fetch", "deep_research", "blocked"];
+export type WebDegradationTarget = (typeof WEB_DEGRADATION_TARGET_VALUES)[number];
+export declare const WEB_ESCALATION_REASON_VALUES: readonly ["requires-interaction", "requires-login-state", "requires-rendered-dom", "requires-persistent-session", "requires-state-changing-action"];
+export type WebEscalationReason = (typeof WEB_ESCALATION_REASON_VALUES)[number];
+export declare const WEB_RETRY_POLICY_VALUES: readonly ["none", "same-capability-once", "degrade-only"];
+export type WebRetryPolicy = (typeof WEB_RETRY_POLICY_VALUES)[number];
+export interface WebCapabilityDescriptorContract {
+    capabilityId?: WebCapabilityId;
+    capabilityFamily?: WebCapabilityFamily;
+    taskMode?: WebTaskMode;
+    executionMode?: WebExecutionMode;
+    statefulness?: WebStatefulness;
+    approvalDefault?: WebApprovalDefault;
+    policyRiskClass?: WebPolicyRiskClass;
+    riskLevel?: ToolRiskLevel;
+    requiresRuntimeBackend?: boolean;
+    requiresHostBridge?: boolean;
+    supportsRenderBackend?: boolean;
+    supportsLoginState?: boolean;
+    supportsPersistentProfile?: boolean;
+    supportsSharedSessionReuse?: boolean;
+    supportsTransactionality?: "read-only" | "state-changing";
+    allowedActionScopes?: WebActionScope[];
+    degradationTarget?: WebDegradationTarget;
+    upgradeTargets?: WebCapabilityId[];
+    fallbackChain?: Array<"render-backend">;
+    escalationReasons?: WebEscalationReason[];
+    auditRequired?: boolean;
+    requiresUserVisibleStep?: boolean;
+    retryPolicy?: WebRetryPolicy;
+    repairAfterDenied?: boolean;
+    repairAfterUnavailable?: boolean;
+    displayRiskLabel?: string;
+    displayBlockedLabel?: string;
+    displayFallbackLabel?: string;
+}

package/dist/protocol/wire/web-capability.js

@@ -0,0 +1,52 @@
+export const WEB_CAPABILITY_ID_VALUES = [
+    "web_search",
+    "web_fetch",
+    "deep_research",
+    "browser_execution",
+];
+export const WEB_CAPABILITY_FAMILY_VALUES = ["web-intelligence", "browser-execution"];
+export const WEB_TASK_MODE_VALUES = [
+    "discovery",
+    "read-url",
+    "multi-source-research",
+    "interactive-browser",
+];
+export const WEB_EXECUTION_MODE_VALUES = [
+    "stateless",
+    "render-backend",
+    "interactive-session",
+];
+export const WEB_STATEFULNESS_VALUES = [
+    "stateless",
+    "stateless-single-step",
+    "stateful-session-required",
+];
+export const WEB_APPROVAL_DEFAULT_VALUES = ["required", "conditional", "none"];
+export const WEB_POLICY_RISK_CLASS_VALUES = [
+    "browser-read",
+    "browser-authenticated-read",
+    "browser-state-changing",
+];
+export const TOOL_RISK_LEVEL_VALUES = ["read", "write", "system", "external_egress"];
+export const WEB_ACTION_SCOPE_VALUES = [
+    "read-page",
+    "read-authenticated-page",
+    "fill-form",
+    "submit-form",
+    "download-file",
+    "reuse-session",
+];
+export const WEB_DEGRADATION_TARGET_VALUES = [
+    "web_search",
+    "web_fetch",
+    "deep_research",
+    "blocked",
+];
+export const WEB_ESCALATION_REASON_VALUES = [
+    "requires-interaction",
+    "requires-login-state",
+    "requires-rendered-dom",
+    "requires-persistent-session",
+    "requires-state-changing-action",
+];
+export const WEB_RETRY_POLICY_VALUES = ["none", "same-capability-once", "degrade-only"];

package/dist/runtime/community/community-consent-client.d.ts

@@ -0,0 +1,142 @@
+import type { ConfigPort } from "../ports/index.js";
+import type { CommunityTelemetryEvent } from "./community-telemetry-types.js";
+export interface CommunityConsentView {
+    enabled: boolean;
+    methodSharingEnabled: boolean;
+    signalsEnabled: boolean;
+    encounterEnabled: boolean;
+    remoteSynced: boolean;
+}
+export interface SetCommunityConsentInput {
+    enabled: boolean;
+    methodSharingEnabled?: boolean;
+    signalsEnabled?: boolean;
+    encounterEnabled?: boolean;
+}
+export interface CommunityConsentClient {
+    getConsent(): Promise<CommunityConsentView>;
+    setConsent(input: SetCommunityConsentInput): Promise<CommunityConsentView>;
+    matchRegistry(input: CommunityRegistryMatchInput): Promise<CommunityRegistryMatchResult[]>;
+    publishSkill(input: CommunityPublishSkillInput): Promise<CommunityPublishSkillResult>;
+    publishPet(input: CommunityPublishSkillInput): Promise<CommunityPublishSkillResult>;
+    /** Publish a workflow resource (IT-5): manifest + sanitized-bundle gzip payload. */
+    publishWorkflow(input: CommunityPublishSkillInput): Promise<CommunityPublishSkillResult>;
+    recordSignal(input: CommunityRecordSignalInput): Promise<CommunityRecordSignalResult>;
+    recordTelemetry(input: CommunityRecordTelemetryInput): Promise<CommunityRecordTelemetryResult>;
+    resolveInstall(resourceId: string, version?: string): Promise<CommunityInstallResolution>;
+    listSharedResources(): Promise<CommunitySharedResource[]>;
+    withdrawSharedResource(resourceId: string, reason?: string): Promise<CommunitySharedResource>;
+    withdrawSharedResources(reason?: string): Promise<CommunitySharedResource[]>;
+    listNotices(input?: CommunityListNoticesInput): Promise<CommunityNotice[]>;
+    markNoticeRead(noticeId: number): Promise<CommunityNotice>;
+}
+export interface CommunitySharedResource {
+    id: string;
+    type: string;
+    title: string;
+    summary: string;
+    visibility: string;
+    latestVersion: string | null;
+    withdrawn: boolean;
+    withdrawnAt: string | null;
+}
+export interface CommunityPublishedVersion {
+    version: string;
+    checksum: string;
+    sizeBytes: number;
+}
+export interface CommunityRegistryMatchInput {
+    intent: string;
+    topK?: number;
+    preferOfficial?: boolean;
+}
+export interface CommunityRegistryMatchResult {
+    id: string;
+    type: string;
+    title: string;
+    summary: string;
+    capabilityTags: string[];
+    sourceTier: CommunityInstallSourceTier;
+    trustStage: CommunityInstallTrustStage;
+    resourceRiskTier: CommunityInstallRiskTier;
+    effectiveRiskTier: CommunityInstallRiskTier;
+    latestVersion: string | null;
+    canonical: true;
+}
+export interface CommunityPublishSkillInput {
+    id: string;
+    title: string;
+    summary: string;
+    visibility?: "public" | "private";
+    /** Hub official category key (RESOURCE_CATEGORIES; hub rejects unknown keys). */
+    category?: string;
+    tags?: string[];
+    manifest: Record<string, unknown>;
+    version?: string;
+    packageGzipBase64?: string;
+}
+export interface CommunityPublishSkillResult {
+    resource: CommunitySharedResource;
+    version?: CommunityPublishedVersion;
+}
+export type CommunitySignalEvent = "installed" | "success" | "fail" | "neutral" | "kept" | "uninstalled" | "endorse" | "error";
+export interface CommunityRecordSignalInput {
+    resourceId: string;
+    event: CommunitySignalEvent;
+    attribution?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface CommunityRecordSignalResult {
+    accepted: true;
+}
+export interface CommunityRecordTelemetryInput {
+    event: CommunityTelemetryEvent;
+    metadata?: Record<string, unknown>;
+}
+export interface CommunityRecordTelemetryResult {
+    accepted: true;
+}
+export interface CommunityNotice {
+    id: number;
+    resourceId: string;
+    resourceType: string;
+    title: string;
+    event: "withdrawn";
+    version: string | null;
+    reason: string | null;
+    read: boolean;
+    createdAt: string;
+    readAt: string | null;
+}
+export interface CommunityListNoticesInput {
+    includeRead?: boolean;
+}
+export type CommunityInstallRiskTier = "R0" | "R1" | "R2" | "R3";
+export type CommunityInstallSourceTier = "official" | "community";
+export type CommunityInstallTrustStage = "quarantine" | "trial" | "trusted";
+export type CommunityInstallReviewStatus = "pending" | "approved" | "rejected";
+export interface CommunityInstallResolution {
+    id: string;
+    type: string;
+    kind: string;
+    sourceTier: CommunityInstallSourceTier;
+    trustStage: CommunityInstallTrustStage;
+    reviewStatus: CommunityInstallReviewStatus;
+    resourceRiskTier: CommunityInstallRiskTier;
+    effectiveRiskTier: CommunityInstallRiskTier;
+    requires: string[];
+    dependencies: CommunityInstallResolution[];
+    version: string;
+    checksum: string;
+    sizeBytes: number;
+    downloadUrl: string;
+    manifest: unknown;
+}
+export interface CommunityConsentClientOptions {
+    baseUrl: string;
+    token: string;
+    fetchFn?: typeof fetch;
+}
+export declare function createCommunityConsentClient(options: CommunityConsentClientOptions): CommunityConsentClient;
+export declare function createDefaultCommunityConsentClient(configPort?: ConfigPort): CommunityConsentClient | null;
+export declare function normalizeCommunityConsent(value: unknown, remoteSynced: boolean): CommunityConsentView;

package/dist/runtime/community/community-consent-client.js

@@ -0,0 +1,381 @@
+import { createProcessConfigPort } from "../infra/process-config-port.js";
+import { sanitizeCommunityTelemetryMetadata } from "./community-telemetry-metadata.js";
+export function createCommunityConsentClient(options) {
+    const endpoint = registryConsentEndpoint(options.baseUrl);
+    const fetchFn = options.fetchFn ?? fetch;
+    const token = options.token.trim();
+    return {
+        async getConsent() {
+            return requestConsent(fetchFn, endpoint, token, "GET");
+        },
+        async setConsent(input) {
+            return requestConsent(fetchFn, endpoint, token, "PUT", input);
+        },
+        async matchRegistry(input) {
+            const intent = input.intent.trim();
+            if (!intent)
+                throw new Error("intent is required.");
+            const topK = normalizeRegistryMatchTopK(input.topK);
+            const payload = await requestJson(fetchFn, registryEndpoint(options.baseUrl, "/api/v15/registry/match"), token, "POST", {
+                intent,
+                topK,
+                prefer: input.preferOfficial === false ? "relevance" : "official",
+                canonicalOnly: true,
+            });
+            const matches = isRecord(payload) && Array.isArray(payload.matches) ? payload.matches : [];
+            return matches
+                .map(normalizeRegistryMatchResult)
+                .filter((item) => !!item)
+                .slice(0, topK);
+        },
+        async publishSkill(input) {
+            return publishResource(fetchFn, options.baseUrl, token, "skill", input);
+        },
+        async publishPet(input) {
+            return publishResource(fetchFn, options.baseUrl, token, "pet", input);
+        },
+        async publishWorkflow(input) {
+            return publishResource(fetchFn, options.baseUrl, token, "workflow", input);
+        },
+        async recordSignal(input) {
+            const safeId = encodeURIComponent(input.resourceId.trim());
+            if (!safeId)
+                throw new Error("resourceId is required.");
+            const payload = await requestJson(fetchFn, registryEndpoint(options.baseUrl, `/api/v15/registry/resources/${safeId}/signal`), token, "POST", {
+                event: input.event,
+                attribution: input.attribution?.trim() || undefined,
+                metadata: input.metadata,
+            });
+            if (isRecord(payload) && payload.accepted === true)
+                return { accepted: true };
+            throw new Error("Community hub returned an invalid signal response.");
+        },
+        async recordTelemetry(input) {
+            const metadata = sanitizeCommunityTelemetryMetadata(input.event, input.metadata);
+            const payload = await requestJson(fetchFn, registryEndpoint(options.baseUrl, "/api/v15/registry/telemetry"), token, "POST", {
+                event: input.event,
+                metadata,
+            });
+            if (isRecord(payload) && payload.accepted === true)
+                return { accepted: true };
+            throw new Error("Community hub returned an invalid telemetry response.");
+        },
+        async listSharedResources() {
+            const payload = await requestJson(fetchFn, registryEndpoint(options.baseUrl, "/api/v15/registry/mine"), token, "GET");
+            const resources = isRecord(payload) && Array.isArray(payload.resources) ? payload.resources : [];
+            return resources.map(normalizeSharedResource).filter((item) => !!item);
+        },
+        async withdrawSharedResource(resourceId, reason) {
+            const safeId = encodeURIComponent(resourceId.trim());
+            if (!safeId)
+                throw new Error("resourceId is required.");
+            const payload = await requestJson(fetchFn, registryEndpoint(options.baseUrl, `/api/v15/registry/resources/${safeId}/withdraw`), token, "POST", { reason: reason?.trim() || undefined });
+            const resource = normalizeSharedResource(payload);
+            if (!resource)
+                throw new Error("Community hub returned an invalid resource.");
+            return resource;
+        },
+        async withdrawSharedResources(reason) {
+            const payload = await requestJson(fetchFn, registryEndpoint(options.baseUrl, "/api/v15/registry/community-consent/withdraw-shared"), token, "POST", { reason: reason?.trim() || undefined });
+            const resources = isRecord(payload) && Array.isArray(payload.resources) ? payload.resources : [];
+            return resources.map(normalizeSharedResource).filter((item) => !!item);
+        },
+        async listNotices(input = {}) {
+            const query = input.includeRead ? "?includeRead=true" : "";
+            const payload = await requestJson(fetchFn, registryEndpoint(options.baseUrl, `/api/v15/registry/notices${query}`), token, "GET");
+            const notices = isRecord(payload) && Array.isArray(payload.notices) ? payload.notices : [];
+            return notices.map(normalizeNotice).filter((item) => !!item);
+        },
+        async markNoticeRead(noticeId) {
+            if (!Number.isSafeInteger(noticeId) || noticeId < 1)
+                throw new Error("noticeId is required.");
+            const payload = await requestJson(fetchFn, registryEndpoint(options.baseUrl, `/api/v15/registry/notices/${noticeId}/read`), token, "POST");
+            const notice = normalizeNotice(payload);
+            if (!notice)
+                throw new Error("Community hub returned an invalid notice.");
+            return notice;
+        },
+        async resolveInstall(resourceId, version) {
+            const safeId = encodeURIComponent(resourceId.trim());
+            if (!safeId)
+                throw new Error("resourceId is required.");
+            const requestedVersion = version?.trim();
+            const query = requestedVersion ? `?version=${encodeURIComponent(requestedVersion)}` : "";
+            const payload = await requestJson(fetchFn, registryEndpoint(options.baseUrl, `/api/v15/registry/resources/${safeId}/install${query}`), token, "GET");
+            const install = normalizeInstallResolution(payload);
+            if (!install)
+                throw new Error("Community hub returned an invalid install resolution.");
+            return install;
+        },
+    };
+}
+async function publishResource(fetchFn, baseUrl, token, type, input) {
+    const resource = normalizeSharedResource(await requestJson(fetchFn, registryEndpoint(baseUrl, "/api/v15/registry/resources"), token, "POST", {
+        id: input.id,
+        type,
+        title: input.title,
+        summary: input.summary,
+        visibility: input.visibility ?? "public",
+        ...(input.category ? { category: input.category } : {}),
+        tags: input.tags ?? [],
+        manifest: input.manifest,
+    }));
+    if (!resource)
+        throw new Error("Community hub returned an invalid resource.");
+    if (input.version === undefined && input.packageGzipBase64 === undefined) {
+        return { resource };
+    }
+    if (!input.version?.trim() || !input.packageGzipBase64?.trim()) {
+        throw new Error("version and packageGzipBase64 must be provided together.");
+    }
+    const safeId = encodeURIComponent(input.id.trim());
+    const safeVersion = encodeURIComponent(input.version.trim());
+    const version = normalizePublishedVersion(await requestGzipJson(fetchFn, registryEndpoint(baseUrl, `/api/v15/registry/resources/${safeId}/versions/${safeVersion}`), token, Buffer.from(input.packageGzipBase64, "base64")));
+    if (!version)
+        throw new Error("Community hub returned an invalid version.");
+    return { resource, version };
+}
+export function createDefaultCommunityConsentClient(configPort = createProcessConfigPort()) {
+    const token = configPort.get("QLOGIC_LLMROUTER_ACCESS_TOKEN")?.trim();
+    if (!token)
+        return null;
+    return createCommunityConsentClient({ baseUrl: resolveHubBaseUrl(configPort), token });
+}
+/**
+ * The registry community lives on the Hub service, not on llmrouter.
+ * Auth stays an llmrouter JWT (the Hub validates it via JWKS), but the
+ * HTTP surface is the Hub's domain.
+ */
+function resolveHubBaseUrl(configPort) {
+    return configPort.get("QLOGIC_HUB_BASE_URL")?.trim()
+        || configPort.get("XIAOZHICLAW_HUB_URL")?.trim()
+        || "https://xiaozhi.qlogicagent.com";
+}
+function registryConsentEndpoint(baseUrl) {
+    return registryEndpoint(baseUrl, "/api/v15/registry/community-consent");
+}
+function registryEndpoint(baseUrl, path) {
+    let normalized = baseUrl.trim().replace(/\/+$/, "");
+    if (normalized.endsWith("/v1"))
+        normalized = normalized.slice(0, -3);
+    if (normalized.endsWith("/api"))
+        normalized = normalized.slice(0, -4);
+    return `${normalized}${path}`;
+}
+async function requestConsent(fetchFn, url, token, method, body) {
+    return normalizeCommunityConsent(await requestJson(fetchFn, url, token, method, body), true);
+}
+async function requestJson(fetchFn, url, token, method, body) {
+    let response;
+    const hasBody = body !== undefined;
+    try {
+        response = await fetchFn(url, {
+            method,
+            headers: {
+                accept: "application/json",
+                authorization: `Bearer ${token}`,
+                ...(hasBody ? { "content-type": "application/json" } : {}),
+            },
+            ...(hasBody ? { body: JSON.stringify(body) } : {}),
+            signal: AbortSignal.timeout(10_000),
+        });
+    }
+    catch {
+        throw new Error("Community hub is unavailable.");
+    }
+    if (!response.ok) {
+        throw new Error(`Community hub rejected registry request: ${response.status}`);
+    }
+    return response.json().catch(() => null);
+}
+async function requestGzipJson(fetchFn, url, token, body) {
+    let response;
+    try {
+        response = await fetchFn(url, {
+            method: "PUT",
+            headers: {
+                accept: "application/json",
+                authorization: `Bearer ${token}`,
+                "content-type": "application/gzip",
+            },
+            body,
+            signal: AbortSignal.timeout(10_000),
+        });
+    }
+    catch {
+        throw new Error("Community hub is unavailable.");
+    }
+    if (!response.ok) {
+        throw new Error(`Community hub rejected registry request: ${response.status}`);
+    }
+    return response.json().catch(() => null);
+}
+export function normalizeCommunityConsent(value, remoteSynced) {
+    const record = isRecord(value) ? value : {};
+    const enabled = record.enabled === true;
+    return {
+        enabled,
+        methodSharingEnabled: enabled && record.methodSharingEnabled !== false,
+        signalsEnabled: enabled && record.signalsEnabled !== false,
+        encounterEnabled: enabled && record.encounterEnabled !== false,
+        remoteSynced,
+    };
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeSharedResource(value) {
+    if (!isRecord(value) || typeof value.id !== "string")
+        return null;
+    return {
+        id: value.id,
+        type: typeof value.type === "string" ? value.type : "skill",
+        title: typeof value.title === "string" ? value.title : value.id,
+        summary: typeof value.summary === "string" ? value.summary : "",
+        visibility: typeof value.visibility === "string" ? value.visibility : "private",
+        latestVersion: typeof value.latestVersion === "string" ? value.latestVersion : null,
+        withdrawn: value.withdrawn === true,
+        withdrawnAt: typeof value.withdrawnAt === "string" ? value.withdrawnAt : null,
+    };
+}
+function normalizeRegistryMatchTopK(value) {
+    if (value === undefined)
+        return 3;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > 3) {
+        throw new Error("registry match topK must be an integer between 1 and 3.");
+    }
+    return value;
+}
+function normalizeRegistryMatchResult(value) {
+    if (!isRecord(value) || value.canonical !== true && value.isCanonical !== true)
+        return null;
+    const sourceTier = normalizeSourceTier(value.sourceTier);
+    const trustStage = normalizeTrustStage(value.trustStage);
+    const resourceRiskTier = normalizeRiskTier(value.resourceRiskTier);
+    const effectiveRiskTier = normalizeRiskTier(value.effectiveRiskTier);
+    if (typeof value.id !== "string"
+        || typeof value.title !== "string"
+        || !sourceTier
+        || !trustStage
+        || !resourceRiskTier
+        || !effectiveRiskTier) {
+        return null;
+    }
+    const rawTags = Array.isArray(value.capabilityTags) ? value.capabilityTags : [];
+    return {
+        id: value.id,
+        type: typeof value.type === "string" ? value.type : "skill",
+        title: trimDiscoveryText(value.title, 80),
+        summary: trimDiscoveryText(typeof value.summary === "string" ? value.summary : "", 160),
+        capabilityTags: rawTags
+            .filter((tag) => typeof tag === "string" && tag.trim().length > 0)
+            .slice(0, 6)
+            .map((tag) => trimDiscoveryText(tag, 32)),
+        sourceTier,
+        trustStage,
+        resourceRiskTier,
+        effectiveRiskTier,
+        latestVersion: typeof value.latestVersion === "string" ? value.latestVersion : null,
+        canonical: true,
+    };
+}
+function trimDiscoveryText(value, maxChars) {
+    const clean = value.replace(/\s+/g, " ").trim();
+    return clean.length <= maxChars ? clean : `${clean.slice(0, Math.max(0, maxChars - 1))}…`;
+}
+function normalizePublishedVersion(value) {
+    if (!isRecord(value) || typeof value.version !== "string" || typeof value.checksum !== "string")
+        return null;
+    return {
+        version: value.version,
+        checksum: value.checksum,
+        sizeBytes: typeof value.sizeBytes === "number" ? value.sizeBytes : 0,
+    };
+}
+function normalizeNotice(value) {
+    if (!isRecord(value) || typeof value.id !== "number" || typeof value.resourceId !== "string")
+        return null;
+    return {
+        id: value.id,
+        resourceId: value.resourceId,
+        resourceType: typeof value.resourceType === "string" ? value.resourceType : "skill",
+        title: typeof value.title === "string" ? value.title : value.resourceId,
+        event: "withdrawn",
+        version: typeof value.version === "string" ? value.version : null,
+        reason: typeof value.reason === "string" ? value.reason : null,
+        read: value.read === true,
+        createdAt: typeof value.createdAt === "string" ? value.createdAt : "",
+        readAt: typeof value.readAt === "string" ? value.readAt : null,
+    };
+}
+const INSTALL_RISK_TIERS = new Set(["R0", "R1", "R2", "R3"]);
+const INSTALL_SOURCE_TIERS = new Set(["official", "community"]);
+const INSTALL_TRUST_STAGES = new Set(["quarantine", "trial", "trusted"]);
+const INSTALL_REVIEW_STATUSES = new Set(["pending", "approved", "rejected"]);
+function normalizeRiskTier(value) {
+    return typeof value === "string" && INSTALL_RISK_TIERS.has(value)
+        ? value
+        : null;
+}
+function normalizeSourceTier(value) {
+    return typeof value === "string" && INSTALL_SOURCE_TIERS.has(value)
+        ? value
+        : null;
+}
+function normalizeTrustStage(value) {
+    return typeof value === "string" && INSTALL_TRUST_STAGES.has(value)
+        ? value
+        : null;
+}
+function normalizeReviewStatus(value) {
+    return typeof value === "string" && INSTALL_REVIEW_STATUSES.has(value)
+        ? value
+        : null;
+}
+function normalizeInstallResolution(value) {
+    if (!isRecord(value))
+        return null;
+    const sourceTier = normalizeSourceTier(value.sourceTier);
+    const trustStage = normalizeTrustStage(value.trustStage);
+    const reviewStatus = normalizeReviewStatus(value.reviewStatus);
+    const resourceRiskTier = normalizeRiskTier(value.resourceRiskTier);
+    const effectiveRiskTier = normalizeRiskTier(value.effectiveRiskTier);
+    if (typeof value.id !== "string"
+        || typeof value.type !== "string"
+        || typeof value.kind !== "string"
+        || !sourceTier
+        || !trustStage
+        || !reviewStatus
+        || !resourceRiskTier
+        || !effectiveRiskTier
+        || typeof value.version !== "string"
+        || typeof value.checksum !== "string"
+        || typeof value.sizeBytes !== "number"
+        || typeof value.downloadUrl !== "string") {
+        return null;
+    }
+    const rawRequires = Array.isArray(value.requires) ? value.requires : null;
+    const rawDependencies = Array.isArray(value.dependencies) ? value.dependencies : null;
+    if (!rawRequires || !rawDependencies || rawRequires.some((item) => typeof item !== "string"))
+        return null;
+    const dependencies = rawDependencies.map(normalizeInstallResolution);
+    if (dependencies.some((item) => !item))
+        return null;
+    return {
+        id: value.id,
+        type: value.type,
+        kind: value.kind,
+        sourceTier,
+        trustStage,
+        reviewStatus,
+        resourceRiskTier,
+        effectiveRiskTier,
+        requires: rawRequires,
+        dependencies: dependencies,
+        version: value.version,
+        checksum: value.checksum,
+        sizeBytes: value.sizeBytes,
+        downloadUrl: value.downloadUrl,
+        manifest: value.manifest,
+    };
+}

package/dist/runtime/community/community-consent-client.test.d.ts

@@ -0,0 +1 @@
+export {};