@xenosystem/agent-interface-ui 0.1.3

package/dist/stores/acpAgentStore.js

@@ -0,0 +1,825 @@
+import { getAgentPlatformBridge } from '../platformBridge';
+import { create } from 'zustand';
+export function normalizeAcpAgentView(value) {
+    const record = asRecord(value);
+    const id = readString(record, 'id');
+    const name = readString(record, 'name');
+    if (!id || !name)
+        return null;
+    return {
+        id,
+        name,
+        command: readString(record, 'command') || 'redacted-command',
+        args: readStringArray(record.args),
+        cwd: readOptionalString(record, 'cwd'),
+        envKeys: readStringArray(record.envKeys),
+        enabled: record.enabled === true,
+        trustLevel: record.trustLevel === 'workspace' ? 'workspace' : 'restricted',
+        endpointKind: normalizeAcpEndpointKind(record.endpointKind),
+        certification: normalizeAcpCertification(record.certification),
+        providerReview: normalizeAcpProviderReview(record.providerReview),
+        providerVersionReadiness: normalizeAcpProviderVersionReadiness(record.providerVersionReadiness),
+        createdAt: readString(record, 'createdAt'),
+        updatedAt: readString(record, 'updatedAt'),
+    };
+}
+export function normalizeAcpProviderCatalogSnapshot(value) {
+    const record = asRecord(value);
+    const source = record.source === 'network' || record.source === 'cache' || record.source === 'fallback'
+        ? record.source
+        : null;
+    if (!source || !Array.isArray(record.entries))
+        return null;
+    return {
+        acpEnabled: record.acpEnabled !== false,
+        preferredAgentId: readOptionalString(record, 'preferredAgentId'),
+        source,
+        refreshedAt: readString(record, 'refreshedAt'),
+        entries: record.entries.map(normalizeAcpProviderCatalogEntry).filter((entry) => !!entry),
+        syncErrors: readStringArray(record.syncErrors),
+    };
+}
+export function normalizeAcpProviderCatalogEntry(value) {
+    const record = asRecord(value);
+    const id = readString(record, 'id');
+    const name = readString(record, 'name');
+    const status = normalizeCatalogEntryStatus(record.status);
+    const distributionKind = normalizeCatalogDistributionKind(record.distributionKind);
+    if (!id || !name || !status || !distributionKind)
+        return null;
+    return {
+        id,
+        name,
+        description: readString(record, 'description'),
+        version: readOptionalString(record, 'version'),
+        iconUrl: readOptionalString(record, 'iconUrl'),
+        website: readOptionalString(record, 'website'),
+        repository: readOptionalString(record, 'repository'),
+        authors: readStringArray(record.authors),
+        license: readOptionalString(record, 'license'),
+        distributionKind,
+        installed: record.installed === true,
+        configured: record.configured === true,
+        enabled: record.enabled === true,
+        preferred: record.preferred === true,
+        canAutoSetup: record.canAutoSetup === true,
+        primaryAction: normalizeAcpProviderCatalogAction(record.primaryAction),
+        availableActions: Array.isArray(record.availableActions)
+            ? record.availableActions.map(normalizeAcpProviderCatalogAction).filter((action) => !!action)
+            : [],
+        agentConfigId: readOptionalString(record, 'agentConfigId'),
+        status,
+        statusMessage: readString(record, 'statusMessage'),
+    };
+}
+function normalizeAcpProviderCatalogAction(value) {
+    const record = asRecord(value);
+    const id = readOptionalString(record, 'id');
+    const label = readOptionalString(record, 'label');
+    const validId = id === 'install' || id === 'enable' || id === 'disable' || id === 'update' || id === 'login' || id === 'certify' || id === 'configure';
+    if (!validId || !label || (record.mode !== 'automatic' && record.mode !== 'external'))
+        return undefined;
+    return { id, label, mode: record.mode };
+}
+function normalizeAcpEndpointKind(value) {
+    if (value === 'xeno-acp-provider' || value === 'native-acp' || value === 'custom-acp')
+        return value;
+    return undefined;
+}
+export function normalizeAcpProviderVersionReadiness(value) {
+    const record = asRecord(value);
+    const agentId = readOptionalString(record, 'agentId');
+    const status = readOptionalString(record, 'status');
+    if (!agentId || !isAcpProviderVersionReadinessStatus(status))
+        return undefined;
+    return {
+        agentId,
+        status,
+        ok: record.ok === true,
+        installedVersion: readOptionalString(record, 'installedVersion'),
+        minimumVersion: readOptionalString(record, 'minimumVersion'),
+        recommendedVersion: readOptionalString(record, 'recommendedVersion'),
+        updateHint: readOptionalString(record, 'updateHint'),
+        message: readString(record, 'message'),
+    };
+}
+export function normalizeAcpCertification(value) {
+    const record = asRecord(value);
+    const status = readOptionalString(record, 'status');
+    if (!isAcpCertificationStatus(status))
+        return undefined;
+    return {
+        status,
+        certifiedAt: readOptionalString(record, 'certifiedAt'),
+        certifiedBy: record.certifiedBy === 'harness' ? 'harness' : undefined,
+        protocolVersion: readNumber(record, 'protocolVersion'),
+        agentName: readOptionalString(record, 'agentName'),
+        agentVersion: readOptionalString(record, 'agentVersion'),
+        notes: readOptionalString(record, 'notes'),
+    };
+}
+export function normalizeAcpProviderReview(value) {
+    const record = asRecord(value);
+    const providerId = readOptionalString(record, 'providerId');
+    if (!providerId)
+        return undefined;
+    const secretBinding = normalizeAcpProviderSecretBinding(record.secretBinding);
+    const enforcementClassification = normalizeAcpProviderEnforcement(record.enforcementClassification);
+    return {
+        providerId,
+        displayName: readOptionalString(record, 'displayName'),
+        trustClass: readOptionalString(record, 'trustClass'),
+        runnable: record.runnable === true,
+        approvalState: normalizeAcpProviderApprovalState(record.approvalState),
+        runtimeEnvKeys: readStringArray(record.runtimeEnvKeys),
+        requiredAuthRefs: readStringArray(record.requiredAuthRefs),
+        optionalAuthRefs: readStringArray(record.optionalAuthRefs),
+        secretBinding,
+        enforcementClassification,
+    };
+}
+function normalizeAcpProviderSecretBinding(value) {
+    const record = asRecord(value);
+    if (Object.keys(record).length === 0)
+        return undefined;
+    return {
+        complete: record.complete === true,
+        missingRequiredRefs: readStringArray(record.missingRequiredRefs),
+        bindingCount: readNumber(record, 'bindingCount') || 0,
+        valuePolicy: readOptionalString(record, 'valuePolicy'),
+    };
+}
+function normalizeAcpProviderEnforcement(value) {
+    const record = asRecord(value);
+    const network = readOptionalString(record, 'network');
+    const filesystem = readOptionalString(record, 'filesystem');
+    if (!network && !filesystem)
+        return undefined;
+    return { network, filesystem };
+}
+export function normalizeAcpDiagnostics(value) {
+    const record = asRecord(value);
+    if (Object.keys(record).length === 0)
+        return null;
+    return {
+        path: readString(record, 'path') || 'acp-agents.json',
+        exists: record.exists === true,
+        version: readNumber(record, 'version') || 0,
+        agentCount: readNumber(record, 'agentCount') || 0,
+        enabledCount: readNumber(record, 'enabledCount') || 0,
+        repaired: record.repaired === true,
+        backupPath: readOptionalString(record, 'backupPath'),
+        agents: Array.isArray(record.agents)
+            ? record.agents.map(normalizeAcpAgentView).filter((agent) => !!agent)
+            : [],
+    };
+}
+export function normalizeAcpTestResult(value) {
+    const record = asRecord(value);
+    const agentInfo = asRecord(record.agentInfo);
+    return {
+        success: record.success === true,
+        protocolVersion: readNumber(record, 'protocolVersion'),
+        agentInfo: Object.keys(agentInfo).length
+            ? {
+                name: readOptionalString(agentInfo, 'name'),
+                title: readOptionalString(agentInfo, 'title'),
+                version: readOptionalString(agentInfo, 'version'),
+            }
+            : undefined,
+        updateCount: readNumber(record, 'updateCount') || 0,
+        stopReason: readOptionalString(record, 'stopReason'),
+        diagnostics: asRecord(record.diagnostics),
+        error: readOptionalString(record, 'error'),
+    };
+}
+export function normalizeAcpExternalCertificationResult(value) {
+    const record = asRecord(value);
+    const status = readOptionalString(record, 'status');
+    if (!isAcpExternalCertificationStatus(status))
+        return null;
+    return {
+        status,
+        realExternalAttempted: record.realExternalAttempted === true,
+        fixtureSimulation: record.fixtureSimulation === true,
+        agentId: readString(record, 'agentId'),
+        agentName: readString(record, 'agentName'),
+        commandBasename: readString(record, 'commandBasename') || '[redacted-command]',
+        argsCount: readNumber(record, 'argsCount') || 0,
+        envKeys: readStringArray(record.envKeys),
+        protocolVersion: readNumber(record, 'protocolVersion'),
+        stopReason: readOptionalString(record, 'stopReason'),
+        updateCount: readNumber(record, 'updateCount') || 0,
+        certification: normalizeAcpCertification(record.certification),
+        diagnostics: asRecord(record.diagnostics),
+        error: readOptionalString(record, 'error'),
+    };
+}
+export function normalizeAcpProviderApprovalResult(value) {
+    const record = asRecord(value);
+    const status = readOptionalString(record, 'status');
+    if (status !== 'approved' && status !== 'revoked' && status !== 'failed')
+        return null;
+    return {
+        success: record.success === true,
+        status,
+        action: record.action === 'approve' || record.action === 'revoke' ? record.action : undefined,
+        providerId: readString(record, 'providerId'),
+        commandBasename: readString(record, 'commandBasename') || '[redacted-command]',
+        argsCount: readNumber(record, 'argsCount') || 0,
+        stdoutTail: readStringArray(record.stdoutTail),
+        stderrTail: readStringArray(record.stderrTail),
+        error: readOptionalString(record, 'error'),
+    };
+}
+export function buildAcpSavePayload(input) {
+    const payload = {
+        id: input.id.trim(),
+        name: input.name.trim(),
+        enabled: input.enabled === true,
+        trustLevel: input.trustLevel === 'workspace' ? 'workspace' : 'restricted',
+    };
+    if (input.command?.trim())
+        payload.command = input.command.trim();
+    if (input.args)
+        payload.args = input.args;
+    if (input.cwd?.trim())
+        payload.cwd = input.cwd.trim();
+    if (input.env && Object.keys(input.env).length > 0)
+        payload.env = input.env;
+    return payload;
+}
+let catalogLoadInFlight = null;
+let catalogSyncInFlight = null;
+const catalogSetupPolls = new Map();
+const runtimeAgentDetailLoads = new Map();
+export const useAcpAgentStore = create((set, get) => ({
+    agents: [],
+    runtimeAgentDetails: {},
+    runtimeAgentDetailLoadingIds: [],
+    runtimeAgentDetailErrors: {},
+    catalog: null,
+    selectedAgentId: null,
+    diagnostics: null,
+    testResult: null,
+    certificationResult: null,
+    approvalResult: null,
+    loading: false,
+    catalogLoading: false,
+    catalogSyncing: false,
+    catalogActionId: null,
+    updatingProviderId: null,
+    saving: false,
+    diagnosticsLoading: false,
+    testingAgentId: null,
+    certifyingAgentId: null,
+    approvingAgentId: null,
+    removingAgentId: null,
+    error: null,
+    catalogError: null,
+    formError: null,
+    selectAgent: (id) => set({ selectedAgentId: id, formError: null, testResult: null, certificationResult: null, approvalResult: null }),
+    clearErrors: () => set({ error: null, formError: null }),
+    load: async () => {
+        set({ loading: true, error: null });
+        try {
+            const response = await getAgentPlatformBridge()?.acp?.listAgents();
+            if (!response?.success) {
+                set({ loading: false, agents: [], error: response?.error || 'ACP registry load failed.' });
+                return;
+            }
+            const agents = Array.isArray(response.agents)
+                ? response.agents.map(normalizeAcpAgentView).filter((agent) => !!agent)
+                : [];
+            const current = get().selectedAgentId;
+            set({
+                agents,
+                selectedAgentId: current && agents.some((agent) => agent.id === current) ? current : agents[0]?.id || null,
+                loading: false,
+            });
+        }
+        catch (error) {
+            set({ loading: false, agents: [], error: safeError(error, 'ACP registry load failed.') });
+        }
+    },
+    loadAgentDetails: async (id, options = {}) => {
+        const agentId = id.trim();
+        if (!agentId)
+            return { success: false, error: 'ACP agent id is required.' };
+        const force = options.force === true;
+        if (!force && get().runtimeAgentDetails[agentId])
+            return { success: true };
+        const inFlight = runtimeAgentDetailLoads.get(agentId);
+        if (inFlight) {
+            const result = await inFlight;
+            if (!force || !result.success)
+                return result;
+        }
+        const operation = (async () => {
+            set((state) => ({
+                runtimeAgentDetails: force
+                    ? Object.fromEntries(Object.entries(state.runtimeAgentDetails).filter(([key]) => key !== agentId))
+                    : state.runtimeAgentDetails,
+                runtimeAgentDetailLoadingIds: state.runtimeAgentDetailLoadingIds.includes(agentId)
+                    ? state.runtimeAgentDetailLoadingIds
+                    : [...state.runtimeAgentDetailLoadingIds, agentId],
+                runtimeAgentDetailErrors: Object.fromEntries(Object.entries(state.runtimeAgentDetailErrors).filter(([key]) => key !== agentId)),
+            }));
+            try {
+                const response = await getAgentPlatformBridge()?.acp?.getAgent?.(agentId);
+                const agent = normalizeAcpAgentView(response?.agent);
+                if (!response?.success || !agent) {
+                    const message = response?.error || 'ACP runtime readiness could not be loaded.';
+                    set((state) => ({
+                        runtimeAgentDetailLoadingIds: state.runtimeAgentDetailLoadingIds.filter((key) => key !== agentId),
+                        runtimeAgentDetailErrors: { ...state.runtimeAgentDetailErrors, [agentId]: message },
+                    }));
+                    return { success: false, error: message };
+                }
+                set((state) => ({
+                    runtimeAgentDetails: { ...state.runtimeAgentDetails, [agentId]: agent },
+                    runtimeAgentDetailLoadingIds: state.runtimeAgentDetailLoadingIds.filter((key) => key !== agentId),
+                    runtimeAgentDetailErrors: Object.fromEntries(Object.entries(state.runtimeAgentDetailErrors).filter(([key]) => key !== agentId)),
+                }));
+                return { success: true };
+            }
+            catch (error) {
+                const message = safeError(error, 'ACP runtime readiness could not be loaded.');
+                set((state) => ({
+                    runtimeAgentDetailLoadingIds: state.runtimeAgentDetailLoadingIds.filter((key) => key !== agentId),
+                    runtimeAgentDetailErrors: { ...state.runtimeAgentDetailErrors, [agentId]: message },
+                }));
+                return { success: false, error: message };
+            }
+        })();
+        runtimeAgentDetailLoads.set(agentId, operation);
+        try {
+            return await operation;
+        }
+        finally {
+            if (runtimeAgentDetailLoads.get(agentId) === operation)
+                runtimeAgentDetailLoads.delete(agentId);
+        }
+    },
+    loadCatalog: async (refresh = false) => {
+        if (catalogLoadInFlight)
+            return catalogLoadInFlight;
+        const operation = (async () => {
+            set({ catalogLoading: true, catalogError: null });
+            try {
+                const response = await getAgentPlatformBridge()?.acp?.listProviderCatalog?.(refresh);
+                const catalog = normalizeAcpProviderCatalogSnapshot(response?.catalog);
+                if (!response?.success || !catalog) {
+                    const message = response?.error || 'ACP provider catalog could not be loaded.';
+                    set({ catalogLoading: false, catalogError: message });
+                    return { success: false, error: message };
+                }
+                set({ catalogLoading: false, catalog, catalogError: null });
+                reconcileCatalogSetupPolls(catalog);
+                if (!refresh)
+                    void get().syncCatalog();
+                return { success: true };
+            }
+            catch (error) {
+                const message = safeError(error, 'ACP provider catalog could not be loaded.');
+                set({ catalogLoading: false, catalogError: message });
+                return { success: false, error: message };
+            }
+        })();
+        catalogLoadInFlight = operation;
+        try {
+            return await operation;
+        }
+        finally {
+            if (catalogLoadInFlight === operation)
+                catalogLoadInFlight = null;
+        }
+    },
+    syncCatalog: async () => {
+        if (catalogSyncInFlight)
+            return catalogSyncInFlight;
+        const operation = (async () => {
+            set({ catalogSyncing: true });
+            try {
+                const response = await getAgentPlatformBridge()?.acp?.syncProviderCatalog?.(false);
+                const catalog = normalizeAcpProviderCatalogSnapshot(response?.catalog);
+                if (!response?.success || !catalog) {
+                    const message = response?.error || 'Automatic ACP provider discovery failed.';
+                    set({ catalogSyncing: false, catalogError: message });
+                    return { success: false, error: message };
+                }
+                set({ catalogSyncing: false, catalog, catalogError: null });
+                reconcileCatalogSetupPolls(catalog);
+                return { success: true };
+            }
+            catch (error) {
+                const message = safeError(error, 'Automatic ACP provider discovery failed.');
+                set({ catalogSyncing: false, catalogError: message });
+                return { success: false, error: message };
+            }
+        })();
+        catalogSyncInFlight = operation;
+        try {
+            return await operation;
+        }
+        finally {
+            if (catalogSyncInFlight === operation)
+                catalogSyncInFlight = null;
+        }
+    },
+    setCatalogEnabled: async (enabled) => {
+        set({ catalogActionId: 'catalog', catalogError: null });
+        try {
+            const response = await getAgentPlatformBridge()?.acp?.setProviderCatalogEnabled?.(enabled);
+            const catalog = normalizeAcpProviderCatalogSnapshot(response?.catalog);
+            if (!response?.success || !catalog) {
+                const message = response?.error || 'ACP could not be updated.';
+                set({ catalogActionId: null, catalogError: message });
+                return { success: false, error: message };
+            }
+            set({ catalogActionId: null, catalog });
+            reconcileCatalogSetupPolls(catalog);
+            return { success: true };
+        }
+        catch (error) {
+            const message = safeError(error, 'ACP could not be updated.');
+            set({ catalogActionId: null, catalogError: message });
+            return { success: false, error: message };
+        }
+    },
+    setCatalogProviderEnabled: async (providerId, enabled) => {
+        set({ catalogActionId: providerId, catalogError: null });
+        try {
+            const response = await getAgentPlatformBridge()?.acp?.setCatalogProviderEnabled?.(providerId, enabled);
+            const catalog = normalizeAcpProviderCatalogSnapshot(response?.catalog);
+            if (!response?.success || !catalog) {
+                const message = response?.error || 'ACP provider setup failed.';
+                set({ catalogActionId: null, catalogError: message });
+                return { success: false, error: message };
+            }
+            set({ catalogActionId: null, catalog });
+            reconcileCatalogSetupPolls(catalog);
+            void get().load();
+            void get().refreshDiagnostics();
+            return { success: true };
+        }
+        catch (error) {
+            const message = safeError(error, 'ACP provider setup failed.');
+            set({ catalogActionId: null, catalogError: message });
+            return { success: false, error: message };
+        }
+    },
+    updateCatalogProvider: async (providerId) => {
+        set({ catalogActionId: providerId, updatingProviderId: providerId, catalogError: null });
+        try {
+            const response = await getAgentPlatformBridge()?.acp?.updateCatalogProvider?.(providerId);
+            const catalog = normalizeAcpProviderCatalogSnapshot(response?.catalog);
+            if (!response?.success || !catalog) {
+                const message = response?.error || 'ACP provider update failed.';
+                set({ catalogActionId: null, updatingProviderId: null, catalogError: message });
+                return { success: false, error: message };
+            }
+            set({ catalogActionId: null, updatingProviderId: null, catalog, catalogError: null });
+            reconcileCatalogSetupPolls(catalog);
+            void get().load();
+            void get().refreshDiagnostics();
+            return { success: true };
+        }
+        catch (error) {
+            const message = safeError(error, 'ACP provider update failed.');
+            set({ catalogActionId: null, updatingProviderId: null, catalogError: message });
+            return { success: false, error: message };
+        }
+    },
+    setPreferredCatalogProvider: async (providerId) => {
+        set({ catalogActionId: providerId, catalogError: null });
+        try {
+            const response = await getAgentPlatformBridge()?.acp?.setPreferredCatalogProvider?.(providerId);
+            const catalog = normalizeAcpProviderCatalogSnapshot(response?.catalog);
+            if (!response?.success || !catalog) {
+                const message = response?.error || 'Preferred ACP provider could not be updated.';
+                set({ catalogActionId: null, catalogError: message });
+                return { success: false, error: message };
+            }
+            set({ catalogActionId: null, catalog });
+            reconcileCatalogSetupPolls(catalog);
+            return { success: true };
+        }
+        catch (error) {
+            const message = safeError(error, 'Preferred ACP provider could not be updated.');
+            set({ catalogActionId: null, catalogError: message });
+            return { success: false, error: message };
+        }
+    },
+    refreshDiagnostics: async () => {
+        set({ diagnosticsLoading: true, error: null });
+        try {
+            const response = await getAgentPlatformBridge()?.acp?.getDiagnostics();
+            set({
+                diagnosticsLoading: false,
+                diagnostics: response?.success ? normalizeAcpDiagnostics(response.diagnostics) : null,
+                error: response?.success ? null : (response?.error || 'ACP diagnostics unavailable.'),
+            });
+        }
+        catch (error) {
+            set({ diagnosticsLoading: false, error: safeError(error, 'ACP diagnostics unavailable.') });
+        }
+    },
+    saveAgent: async (input) => {
+        set({ saving: true, formError: null, error: null });
+        try {
+            const response = await getAgentPlatformBridge()?.acp?.saveAgent(buildAcpSavePayload(input));
+            if (!response?.success) {
+                const message = response?.error || 'ACP agent save failed.';
+                set({ saving: false, formError: message });
+                return { success: false, error: message };
+            }
+            const agent = normalizeAcpAgentView(response.agent);
+            await get().load();
+            await get().refreshDiagnostics();
+            set({ saving: false, selectedAgentId: agent?.id || input.id, formError: null });
+            return { success: true };
+        }
+        catch (error) {
+            const message = safeError(error, 'ACP agent save failed.');
+            set({ saving: false, formError: message });
+            return { success: false, error: message };
+        }
+    },
+    removeAgent: async (id) => {
+        set({ removingAgentId: id, error: null });
+        try {
+            const response = await getAgentPlatformBridge()?.acp?.removeAgent(id);
+            if (!response?.success) {
+                const message = response?.error || 'ACP agent remove failed.';
+                set({ removingAgentId: null, error: message });
+                return { success: false, error: message };
+            }
+            await get().load();
+            await get().refreshDiagnostics();
+            set({ removingAgentId: null, testResult: null, certificationResult: null, approvalResult: null });
+            return { success: true };
+        }
+        catch (error) {
+            const message = safeError(error, 'ACP agent remove failed.');
+            set({ removingAgentId: null, error: message });
+            return { success: false, error: message };
+        }
+    },
+    testAgent: async (id) => {
+        set({ testingAgentId: id, testResult: null, error: null });
+        try {
+            const response = await getAgentPlatformBridge()?.acp?.testAgent(id);
+            const result = normalizeAcpTestResult(response);
+            set({ testingAgentId: null, testResult: result });
+            await get().refreshDiagnostics();
+            return result.success ? { success: true } : { success: false, error: result.error || 'ACP fixture test failed.' };
+        }
+        catch (error) {
+            const message = safeError(error, 'ACP fixture test failed.');
+            set({ testingAgentId: null, testResult: { success: false, updateCount: 0, diagnostics: {}, error: message } });
+            return { success: false, error: message };
+        }
+    },
+    certifyAgent: async (id) => {
+        set({ certifyingAgentId: id, certificationResult: null, error: null });
+        try {
+            const response = await getAgentPlatformBridge()?.acp?.certifyAgent?.(id);
+            const result = normalizeAcpExternalCertificationResult(response?.result);
+            if (!response?.success || !result) {
+                const message = response?.error || 'ACP certification harness failed.';
+                set({ certifyingAgentId: null, certificationResult: result, error: message });
+                return { success: false, error: message };
+            }
+            const agent = normalizeAcpAgentView(response.agent);
+            await get().load();
+            await get().refreshDiagnostics();
+            set({
+                certifyingAgentId: null,
+                certificationResult: result,
+                selectedAgentId: agent?.id || id,
+            });
+            if (result.status === 'PASSED' || result.status === 'FALLBACK_FIXTURE_ONLY')
+                return { success: true };
+            return { success: false, error: result.error || `ACP certification ${result.status}.` };
+        }
+        catch (error) {
+            const message = safeError(error, 'ACP certification harness failed.');
+            set({ certifyingAgentId: null, error: message });
+            return { success: false, error: message };
+        }
+    },
+    approveProvider: async (id, providerId) => {
+        set({ approvingAgentId: id, approvalResult: null, error: null });
+        try {
+            const response = await getAgentPlatformBridge()?.acp?.approveProvider?.(id, providerId);
+            const result = normalizeAcpProviderApprovalResult(response?.result);
+            if (!response?.success || !result) {
+                const message = response?.error || result?.error || 'ACP provider approval failed.';
+                set({ approvingAgentId: null, approvalResult: result, error: message });
+                return { success: false, error: message };
+            }
+            await get().load();
+            const detail = await get().loadAgentDetails(id, { force: true });
+            await get().refreshDiagnostics();
+            set({ approvingAgentId: null, approvalResult: result });
+            if (!detail.success) {
+                const message = `Provider approved, but runtime readiness refresh failed: ${detail.error || 'unknown error'}`;
+                set({ error: message });
+                return { success: false, error: message };
+            }
+            return { success: true };
+        }
+        catch (error) {
+            const message = safeError(error, 'ACP provider approval failed.');
+            set({ approvingAgentId: null, error: message });
+            return { success: false, error: message };
+        }
+    },
+    revokeProvider: async (id, providerId) => {
+        set({ approvingAgentId: id, approvalResult: null, error: null });
+        try {
+            const response = await getAgentPlatformBridge()?.acp?.revokeProvider?.(id, providerId);
+            const result = normalizeAcpProviderApprovalResult(response?.result);
+            if (!response?.success || !result) {
+                const message = response?.error || result?.error || 'ACP provider approval revoke failed.';
+                set({ approvingAgentId: null, approvalResult: result, error: message });
+                return { success: false, error: message };
+            }
+            await get().load();
+            const detail = await get().loadAgentDetails(id, { force: true });
+            await get().refreshDiagnostics();
+            set({ approvingAgentId: null, approvalResult: result });
+            if (!detail.success) {
+                const message = `Provider revoked, but runtime readiness refresh failed: ${detail.error || 'unknown error'}`;
+                set({ error: message });
+                return { success: false, error: message };
+            }
+            return { success: true };
+        }
+        catch (error) {
+            const message = safeError(error, 'ACP provider approval revoke failed.');
+            set({ approvingAgentId: null, error: message });
+            return { success: false, error: message };
+        }
+    },
+    createFixtureAgent: async () => {
+        set({ saving: true, formError: null, error: null });
+        try {
+            const response = await getAgentPlatformBridge()?.acp?.createFixtureAgent?.({ mode: 'normal', id: 'fixture-normal' });
+            if (!response?.success) {
+                const message = response?.error || 'Fixture ACP agent creation is unavailable.';
+                set({ saving: false, formError: message });
+                return { success: false, error: message };
+            }
+            const agent = normalizeAcpAgentView(response.agent);
+            await get().load();
+            await get().refreshDiagnostics();
+            set({ saving: false, selectedAgentId: agent?.id || 'fixture-normal' });
+            return { success: true };
+        }
+        catch (error) {
+            const message = safeError(error, 'Fixture ACP agent creation failed.');
+            set({ saving: false, formError: message });
+            return { success: false, error: message };
+        }
+    },
+    createLocalProviderAgent: async (providerId) => {
+        set({ saving: true, formError: null, error: null });
+        try {
+            const response = await getAgentPlatformBridge()?.acp?.createLocalProviderAgent?.(providerId);
+            if (!response?.success) {
+                const message = response?.error || 'Local ACP provider setup failed.';
+                set({ saving: false, formError: message });
+                return { success: false, error: message };
+            }
+            const agent = normalizeAcpAgentView(response.agent);
+            await get().load();
+            await get().refreshDiagnostics();
+            set({ saving: false, selectedAgentId: agent?.id || providerId });
+            return { success: true };
+        }
+        catch (error) {
+            const message = safeError(error, 'Local ACP provider setup failed.');
+            set({ saving: false, formError: message });
+            return { success: false, error: message };
+        }
+    },
+}));
+function cancelCatalogSetupPoll(providerId) {
+    const timer = catalogSetupPolls.get(providerId);
+    if (timer)
+        clearTimeout(timer);
+    catalogSetupPolls.delete(providerId);
+}
+function reconcileCatalogSetupPolls(catalog) {
+    const activeProviderIds = new Set(catalog.entries
+        .filter((provider) => provider.status === 'setting_up')
+        .map((provider) => provider.id));
+    for (const providerId of catalogSetupPolls.keys()) {
+        if (!activeProviderIds.has(providerId))
+            cancelCatalogSetupPoll(providerId);
+    }
+    for (const providerId of activeProviderIds)
+        scheduleCatalogSetupPoll(providerId);
+}
+function scheduleCatalogSetupPoll(providerId, attempt = 0) {
+    cancelCatalogSetupPoll(providerId);
+    if (attempt >= 130) {
+        useAcpAgentStore.setState({ catalogError: 'Provider setup is taking longer than expected. You can keep using Hub and retry later.' });
+        return;
+    }
+    const timer = setTimeout(() => {
+        void (async () => {
+            try {
+                const response = await getAgentPlatformBridge()?.acp?.listProviderCatalog?.(false);
+                const catalog = normalizeAcpProviderCatalogSnapshot(response?.catalog);
+                if (!response?.success || !catalog) {
+                    scheduleCatalogSetupPoll(providerId, attempt + 1);
+                    return;
+                }
+                useAcpAgentStore.setState({ catalog, catalogError: null });
+                const provider = catalog.entries.find((entry) => entry.id === providerId);
+                if (provider?.status === 'setting_up')
+                    scheduleCatalogSetupPoll(providerId, attempt + 1);
+                else
+                    cancelCatalogSetupPoll(providerId);
+                if (provider?.status === 'setting_up')
+                    return;
+                void useAcpAgentStore.getState().load();
+                void useAcpAgentStore.getState().refreshDiagnostics();
+            }
+            catch {
+                scheduleCatalogSetupPoll(providerId, attempt + 1);
+            }
+        })();
+    }, 1_000);
+    catalogSetupPolls.set(providerId, timer);
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function readString(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : '';
+}
+function readOptionalString(record, key) {
+    const value = readString(record, key);
+    return value.trim() ? value : undefined;
+}
+function readNumber(record, key) {
+    const value = record[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function readStringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function isAcpCertificationStatus(value) {
+    return value === 'not_certified'
+        || value === 'fixture_only'
+        || value === 'certified'
+        || value === 'authentication_required'
+        || value === 'blocked_by_environment'
+        || value === 'failed';
+}
+function isAcpExternalCertificationStatus(value) {
+    return value === 'PASSED'
+        || value === 'AUTHENTICATION_REQUIRED'
+        || value === 'BLOCKED_BY_ENVIRONMENT'
+        || value === 'FAILED_WITH_BUG'
+        || value === 'FALLBACK_FIXTURE_ONLY';
+}
+function isAcpProviderVersionReadinessStatus(value) {
+    return value === 'not_applicable'
+        || value === 'ok'
+        || value === 'outdated'
+        || value === 'unavailable'
+        || value === 'unknown';
+}
+function normalizeCatalogEntryStatus(value) {
+    return value === 'ready'
+        || value === 'setting_up'
+        || value === 'available'
+        || value === 'disabled'
+        || value === 'update_required'
+        || value === 'needs_attention'
+        || value === 'not_installed'
+        ? value
+        : null;
+}
+function normalizeCatalogDistributionKind(value) {
+    return value === 'binary' || value === 'npx' || value === 'uvx' || value === 'custom' ? value : null;
+}
+function normalizeAcpProviderApprovalState(value) {
+    return value === 'approved'
+        || value === 'missing'
+        || value === 'stale'
+        || value === 'blocked'
+        || value === 'not_required'
+        ? value
+        : undefined;
+}
+function safeError(error, fallback) {
+    return error instanceof Error && error.message.trim() ? error.message : fallback;
+}
+//# sourceMappingURL=acpAgentStore.js.map