@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/components/features/AiProfilesModule.js

@@ -0,0 +1,744 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { AlertTriangle, Bot, ChevronLeft, Cloud, LaptopMinimal, Loader2, Plug, Users } from 'lucide-react';
+import styles from '../../Taskforce.module.css';
+import { EditableAvatarButton } from '../ui/EditableAvatarButton';
+import { resolveCloudAssetDisplayUrl } from '../../utils/cloudAssetDisplay';
+import { useFallbackImageUrl } from '../ui/useFallbackImageUrl';
+import { AvatarImageManagerModal } from '../views/standalone/modals/AvatarImageManagerModal';
+import { prepareAvatarUploadFile } from '../../utils/avatarUpload';
+import { buildVersionedAvatarUrl } from '../../utils/avatarDisplay';
+import { getAiProfileDefaultLogoUrl } from '../../utils/aiProfileDefaultLogo';
+import { dispatchTaskforceAiProfilesMutated, TASKFORCE_AI_PROFILES_MUTATED_EVENT, } from '../../utils/aiProfileEvents';
+import { getTaskforceManagedAgentId, isAiProfileAvatarGenerationEligible, } from '../../shared/aiProfileAvatarEligibility.js';
+import { AI_PROFILE_COLOR_TOKENS } from '../../shared/aiProfileColors.js';
+import { AiIdentityRosterCard } from '../ui/AiIdentityRosterCard.js';
+import { COLOR_PALETTE } from '../../shared/colorPalette.js';
+import { AI_PROFILE_SURFACE_TYPES, formatAiProfileSurfaceTypeLabel, formatAiProfileSurfaceTypeSectionLabel, getAiProfileSurfaceTypeSection, parseAiProfileSurfaceType } from '../../shared/aiProfileSurfaceType.js';
+import { formatAiProfileSeatScopeLabel, parseAiProfileSeatScope } from '../../shared/aiProfileSeatScope.js';
+const AI_PROFILE_DISPLAY_SECTION_ORDER = [
+    'chat_app',
+    'ide',
+    'cli',
+    'coding_tool',
+    'taskforce_agent',
+    'agent',
+    'unclassified',
+];
+function hasAiProfileAvatar(profile) {
+    return typeof profile.avatarUrl === 'string' && profile.avatarUrl.trim().length > 0;
+}
+function getAiProfileAvatarDisplayUrl(profile) {
+    if (!profile)
+        return '';
+    return buildVersionedAvatarUrl(profile.avatarUrl, profile.avatarRevision, profile.avatarUpdatedAt);
+}
+function getAiProfileAvatarSourceUrl(profile) {
+    if (!profile)
+        return '';
+    return buildVersionedAvatarUrl(profile.avatarSourceUrl, profile.avatarRevision, profile.avatarUpdatedAt);
+}
+function selectAiProfileGroupPrimary(profiles) {
+    return profiles.find(hasAiProfileAvatar) || profiles[0];
+}
+function AiProfileAvatarImage({ profile, className = '' }) {
+    const avatarUrl = getAiProfileAvatarDisplayUrl(profile);
+    const fallbackLogoUrl = getAiProfileDefaultLogoUrl(profile);
+    const { activeImageUrl, handleImageError } = useFallbackImageUrl(avatarUrl, fallbackLogoUrl);
+    if (!activeImageUrl)
+        return _jsx(Bot, { size: 22 });
+    return (_jsx("img", { src: activeImageUrl, alt: "", className: className, onError: handleImageError }));
+}
+function buildAiProfileGroupKey(profile) {
+    const taskforceAgentId = getTaskforceManagedAgentId(profile);
+    if (taskforceAgentId)
+        return `taskforce-agent:${taskforceAgentId}`;
+    return `${profile.seatScope || 'unknown'}:${profile.name.trim().toLowerCase()}`;
+}
+function isTaskforceManagedAiProfile(profile) {
+    const taskforceMetadata = profile.providerMetadata?.taskforce;
+    return Boolean(taskforceMetadata
+        && typeof taskforceMetadata === 'object'
+        && !Array.isArray(taskforceMetadata)
+        && String(taskforceMetadata.taskforceAgentId || '').trim());
+}
+function getAiProfileDisplaySection(profile) {
+    return isTaskforceManagedAiProfile(profile)
+        ? 'taskforce_agent'
+        : getAiProfileSurfaceTypeSection(profile.surfaceType);
+}
+function formatAiProfileDisplaySectionLabel(section) {
+    return section === 'taskforce_agent'
+        ? 'Taskforce Agents'
+        : formatAiProfileSurfaceTypeSectionLabel(section);
+}
+function formatAiProfileCategoryLabel(profile) {
+    if (isTaskforceManagedAiProfile(profile))
+        return 'Taskforce Agent';
+    return profile.surfaceType ? formatAiProfileSurfaceTypeLabel(profile.surfaceType) : '';
+}
+function formatDuplicateCount(count) {
+    const duplicates = Math.max(0, count - 1);
+    return `${duplicates} duplicate${duplicates === 1 ? '' : 's'}`;
+}
+function parseAiProfileSeatUsage(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    return {
+        used: Math.max(0, Number(value.used || 0)),
+        limit: value.limit === null || value.limit === undefined
+            ? null
+            : Math.max(0, Number(value.limit || 0)),
+        remaining: value.remaining === null || value.remaining === undefined
+            ? null
+            : Math.max(0, Number(value.remaining || 0)),
+    };
+}
+function renderAiProfileSeatScopeIcon(seatScope, options) {
+    const className = options?.variant === 'inline'
+        ? `${styles.aiProfileSeatScopeIcon} ${styles.aiProfileSeatScopeIconInline}`
+        : options?.variant === 'detail'
+            ? `${styles.aiProfileSeatScopeIcon} ${styles.aiProfileSeatScopeIconDetail}`
+            : styles.aiProfileSeatScopeIcon;
+    if (seatScope === 'cloud_metered') {
+        return (_jsx("span", { className: `${className} ${styles.aiProfileSeatScopeIconCloud}`, title: "Cloud MCP", "aria-label": "Cloud MCP", children: _jsx(Cloud, { size: 20 }) }));
+    }
+    if (seatScope === 'local_unmetered') {
+        return (_jsx("span", { className: `${className} ${styles.aiProfileSeatScopeIconLocal}`, title: "Local MCP", "aria-label": "Local MCP", children: _jsx(LaptopMinimal, { size: 20 }) }));
+    }
+    return null;
+}
+export function AiProfilesModule({ workspaceId, runtimeMode = 'local', cloudAuthConfigured = false, authSessionResolved = false, isAuthenticated = false, cloudAiProfileSeatUsage = null, agentTrayOpen = false, onCloseAgentTray, mcpSettingsNode = null, resolveCloudAuthUrl, theme = 'dark', onNotice, }) {
+    const [aiProfiles, setAiProfiles] = useState([]);
+    const [localAiProfileSeatUsage, setLocalAiProfileSeatUsage] = useState(null);
+    const [aiProfilesLoading, setAiProfilesLoading] = useState(false);
+    const [aiProfileMergeState, setAiProfileMergeState] = useState(null);
+    const [aiProfileArchiveError, setAiProfileArchiveError] = useState(null);
+    const [aiProfileCategoryError, setAiProfileCategoryError] = useState(null);
+    const [aiProfileCategoryBusy, setAiProfileCategoryBusy] = useState(false);
+    const [selectedGroupId, setSelectedGroupId] = useState(null);
+    const [avatarEditorProfileId, setAvatarEditorProfileId] = useState(null);
+    const [aiAvatarBusy, setAiAvatarBusy] = useState(false);
+    const [aiAvatarError, setAiAvatarError] = useState(null);
+    const [aiAvatarNotice, setAiAvatarNotice] = useState(null);
+    const [generatingAvatarProfileId, setGeneratingAvatarProfileId] = useState(null);
+    const [avatarGenerationFeedbackByProfileId, setAvatarGenerationFeedbackByProfileId] = useState({});
+    const [colorPickerOpen, setColorPickerOpen] = useState(false);
+    const [colorBusy, setColorBusy] = useState(false);
+    const [colorError, setColorError] = useState(null);
+    const loadAiProfiles = useCallback(async () => {
+        if (!workspaceId)
+            return;
+        setAiProfilesLoading(true);
+        try {
+            const rosterUrl = `/api/taskforce/workspace/assignee-options?workspaceId=${encodeURIComponent(workspaceId)}&kind=agent`;
+            const rosterResponse = await fetch(rosterUrl, {
+                credentials: 'include',
+            });
+            const rosterData = rosterResponse.ok
+                ? await rosterResponse.json().catch(() => ({}))
+                : {};
+            const fallbackSeatUsage = parseAiProfileSeatUsage(rosterData?.aiProfileSeatUsage);
+            const agents = Array.isArray(rosterData?.assignees)
+                ? rosterData.assignees
+                    .filter((assignee) => assignee.kind === 'agent')
+                    .map((assignee) => ({
+                    id: String(assignee.value || ''),
+                    name: String(assignee.label || assignee.value || 'Unknown Agent'),
+                    username: String(assignee.username || assignee.value || ''),
+                    icon: String(assignee.icon || 'Bot'),
+                    color: String(assignee.color || '#6B7280'),
+                    colorSource: typeof assignee.colorSource === 'string' ? assignee.colorSource : null,
+                    colorUpdatedAt: typeof assignee.colorUpdatedAt === 'string' ? assignee.colorUpdatedAt : null,
+                    avatarUrl: typeof assignee.avatarUrl === 'string' ? assignee.avatarUrl : null,
+                    avatarSourceUrl: typeof assignee.avatarSourceUrl === 'string' ? assignee.avatarSourceUrl : null,
+                    avatarRevision: Number.isFinite(Number(assignee.avatarRevision)) ? Math.max(0, Math.floor(Number(assignee.avatarRevision))) : 0,
+                    avatarUpdatedAt: typeof assignee.avatarUpdatedAt === 'string' ? assignee.avatarUpdatedAt : null,
+                    kind: String(assignee.kind || 'agent'),
+                    description: typeof assignee.description === 'string' ? assignee.description : null,
+                    role: typeof assignee.role === 'string' ? assignee.role : null,
+                    provider: typeof assignee.provider === 'string' ? assignee.provider : null,
+                    model: typeof assignee.model === 'string' ? assignee.model : null,
+                    surfaceType: parseAiProfileSurfaceType(assignee.surfaceType),
+                    seatScope: parseAiProfileSeatScope(assignee.seatScope),
+                    providerMetadata: assignee.providerMetadata && typeof assignee.providerMetadata === 'object' && !Array.isArray(assignee.providerMetadata)
+                        ? assignee.providerMetadata
+                        : null,
+                    archivedAt: typeof assignee.archivedAt === 'string' ? assignee.archivedAt : null,
+                    createdAt: String(assignee.createdAt || ''),
+                    updatedAt: String(assignee.updatedAt || assignee.createdAt || ''),
+                    lastActiveAt: typeof assignee.lastActiveAt === 'string' ? assignee.lastActiveAt : null,
+                }))
+                : [];
+            setAiProfiles(agents);
+            setLocalAiProfileSeatUsage(fallbackSeatUsage);
+            setAiProfileArchiveError((current) => (current && !agents.some((agent) => agent.id === current.profileId)
+                ? null
+                : current));
+            setAiProfileCategoryError((current) => (current && !agents.some((agent) => agent.id === current.profileId)
+                ? null
+                : current));
+        }
+        finally {
+            setAiProfilesLoading(false);
+        }
+    }, [workspaceId]);
+    useEffect(() => {
+        void loadAiProfiles();
+    }, [loadAiProfiles]);
+    useEffect(() => {
+        const handleAiProfilesMutated = (event) => {
+            const detail = event.detail;
+            const eventWorkspaceId = String(detail?.workspaceId || '').trim() || 'default';
+            if (eventWorkspaceId !== workspaceId)
+                return;
+            if (detail?.origin === 'ai-profiles-module')
+                return;
+            void loadAiProfiles();
+        };
+        window.addEventListener(TASKFORCE_AI_PROFILES_MUTATED_EVENT, handleAiProfilesMutated);
+        return () => window.removeEventListener(TASKFORCE_AI_PROFILES_MUTATED_EVENT, handleAiProfilesMutated);
+    }, [loadAiProfiles, workspaceId]);
+    const groupedProfilesBySurfaceType = useMemo(() => {
+        const bySection = new Map();
+        for (const profile of aiProfiles) {
+            const section = getAiProfileDisplaySection(profile);
+            if (!bySection.has(section))
+                bySection.set(section, new Map());
+            const sectionEntries = bySection.get(section);
+            const key = buildAiProfileGroupKey(profile);
+            if (!sectionEntries.has(key))
+                sectionEntries.set(key, []);
+            sectionEntries.get(key).push(profile);
+        }
+        return AI_PROFILE_DISPLAY_SECTION_ORDER
+            .map((section) => ({
+            section,
+            label: formatAiProfileDisplaySectionLabel(section),
+            groups: Array.from(bySection.get(section)?.entries() || []).map(([key, profiles]) => ({
+                groupId: `${section}:${key}`,
+                section,
+                sectionLabel: formatAiProfileDisplaySectionLabel(section),
+                profiles,
+                primaryProfile: selectAiProfileGroupPrimary(profiles)
+            }))
+        }))
+            .filter((entry) => entry.groups.length > 0);
+    }, [aiProfiles]);
+    const allGroups = useMemo(() => groupedProfilesBySurfaceType.flatMap((section) => section.groups), [groupedProfilesBySurfaceType]);
+    const selectedGroup = useMemo(() => allGroups.find((group) => group.groupId === selectedGroupId) || allGroups[0] || null, [allGroups, selectedGroupId]);
+    const avatarEditorProfile = useMemo(() => aiProfiles.find((profile) => profile.id === avatarEditorProfileId) || null, [aiProfiles, avatarEditorProfileId]);
+    const avatarEditorGenerationFeedback = avatarEditorProfile
+        ? avatarGenerationFeedbackByProfileId[avatarEditorProfile.id] || null
+        : null;
+    const selectedProfileGenerationFeedback = selectedGroup
+        ? avatarGenerationFeedbackByProfileId[selectedGroup.primaryProfile.id] || null
+        : null;
+    useEffect(() => {
+        if (!allGroups.length) {
+            if (selectedGroupId !== null)
+                setSelectedGroupId(null);
+            return;
+        }
+        if (!selectedGroupId || !allGroups.some((group) => group.groupId === selectedGroupId)) {
+            setSelectedGroupId(allGroups[0].groupId);
+        }
+    }, [allGroups, selectedGroupId]);
+    const handleMerge = async (keepId, mergeId) => {
+        setAiProfileArchiveError(null);
+        try {
+            const res = await fetch('/api/taskforce/workspace/ai-profiles/merge', {
+                method: 'POST',
+                credentials: 'include',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ keepId, mergeId }),
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok) {
+                onNotice?.(String(data?.error || 'Failed to merge AI profiles.'), 'error');
+                return;
+            }
+            setAiProfileMergeState(null);
+            onNotice?.('AI profiles merged.', 'success');
+            await loadAiProfiles();
+            dispatchTaskforceAiProfilesMutated({ workspaceId, profileId: keepId, reason: 'merge', origin: 'ai-profiles-module' });
+        }
+        catch {
+            onNotice?.('Failed to merge AI profiles.', 'error');
+        }
+    };
+    const handleArchive = async (profile) => {
+        const confirmed = window.confirm(`Remove ${profile.name} from the active roster? This frees an AI profile seat and preserves task and comment history.`);
+        if (!confirmed)
+            return;
+        setAiProfileArchiveError(null);
+        try {
+            const res = await fetch('/api/taskforce/workspace/ai-profiles/archive', {
+                method: 'POST',
+                credentials: 'include',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ profileId: profile.id, reason: 'manual_archive' }),
+            });
+            const data = await res.json().catch(() => ({}));
+            if (!res.ok) {
+                setAiProfileArchiveError({
+                    profileId: profile.id,
+                    message: String(data?.error || 'Failed to remove AI profile from roster.')
+                });
+                return;
+            }
+            if (aiProfileMergeState?.keepId === profile.id || aiProfileMergeState?.mergeId === profile.id) {
+                setAiProfileMergeState(null);
+            }
+            onNotice?.('AI profile removed from active roster.', 'success');
+            await loadAiProfiles();
+            dispatchTaskforceAiProfilesMutated({ workspaceId, profileId: profile.id, reason: 'archive', origin: 'ai-profiles-module' });
+        }
+        catch {
+            setAiProfileArchiveError({
+                profileId: profile.id,
+                message: 'Failed to remove AI profile from roster.'
+            });
+        }
+    };
+    const handleCategoryChange = async (group, value) => {
+        const nextSurfaceType = parseAiProfileSurfaceType(value);
+        const currentSurfaceTypes = new Set(group.profiles.map((profile) => profile.surfaceType ?? ''));
+        const nextSurfaceTypeKey = nextSurfaceType ?? '';
+        if (currentSurfaceTypes.size === 1 && currentSurfaceTypes.has(nextSurfaceTypeKey))
+            return;
+        setAiProfileCategoryBusy(true);
+        setAiProfileCategoryError(null);
+        const updatedProfiles = [];
+        try {
+            for (const profile of group.profiles) {
+                const res = await fetch('/api/taskforce/workspace/ai-profiles/surface-type', {
+                    method: 'POST',
+                    credentials: 'include',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        profileId: profile.id,
+                        surfaceType: nextSurfaceType
+                    }),
+                });
+                const data = await res.json().catch(() => ({}));
+                if (!res.ok || !data?.profile) {
+                    throw new Error(String(data?.error || 'Failed to update AI profile category.'));
+                }
+                const updated = data.profile;
+                updatedProfiles.push({
+                    ...profile,
+                    surfaceType: parseAiProfileSurfaceType(updated.surfaceType),
+                    updatedAt: typeof updated.updatedAt === 'string' ? updated.updatedAt : profile.updatedAt
+                });
+            }
+            const updatedById = new Map(updatedProfiles.map((profile) => [profile.id, profile]));
+            setAiProfiles((current) => current.map((profile) => updatedById.get(profile.id) || profile));
+            const nextPrimary = updatedById.get(group.primaryProfile.id) || {
+                ...group.primaryProfile,
+                surfaceType: nextSurfaceType
+            };
+            const nextSection = getAiProfileSurfaceTypeSection(nextPrimary.surfaceType);
+            setSelectedGroupId(`${nextSection}:${buildAiProfileGroupKey(nextPrimary)}`);
+            onNotice?.('AI profile category updated.', 'success');
+            for (const profile of updatedProfiles) {
+                dispatchTaskforceAiProfilesMutated({ workspaceId, profileId: profile.id, reason: 'update', origin: 'ai-profiles-module' });
+            }
+        }
+        catch (error) {
+            setAiProfileCategoryError({
+                profileId: group.primaryProfile.id,
+                message: String(error?.message || 'Failed to update AI profile category.')
+            });
+        }
+        finally {
+            setAiProfileCategoryBusy(false);
+        }
+    };
+    const handleColorChange = async (group, color, reset = false) => {
+        setColorBusy(true);
+        setColorError(null);
+        try {
+            const groupKey = buildAiProfileGroupKey(group.primaryProfile);
+            const linkedProfiles = aiProfiles.filter((profile) => buildAiProfileGroupKey(profile) === groupKey);
+            const res = await fetch('/api/taskforce/workspace/ai-profiles/color', {
+                method: 'POST', credentials: 'include', headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ profileIds: linkedProfiles.map((profile) => profile.id), color, reset }),
+            });
+            const responseText = await res.text();
+            let data = {};
+            try {
+                data = responseText ? JSON.parse(responseText) : {};
+            }
+            catch {
+                data = {};
+            }
+            if (!res.ok) {
+                const unavailableMessage = res.status === 404
+                    ? 'Color updates are unavailable in the running Taskforce server. Restart Taskforce and try again.'
+                    : `Failed to update AI profile color (HTTP ${res.status}).`;
+                throw new Error(String(data.error || unavailableMessage));
+            }
+            if (!Array.isArray(data.profiles)) {
+                throw new Error('Taskforce returned an invalid response while updating the AI profile color.');
+            }
+            const updates = new Map(data.profiles.map((profile) => [String(profile.id), profile]));
+            setAiProfiles((current) => current.map((profile) => {
+                const updated = updates.get(profile.id);
+                return updated ? {
+                    ...profile,
+                    color: String(updated.color || profile.color),
+                    colorSource: updated.colorSource ?? profile.colorSource,
+                    colorUpdatedAt: updated.colorUpdatedAt ?? profile.colorUpdatedAt,
+                    updatedAt: updated.updatedAt ?? profile.updatedAt,
+                } : profile;
+            }));
+            setColorPickerOpen(false);
+            for (const profile of linkedProfiles)
+                dispatchTaskforceAiProfilesMutated({ workspaceId, profileId: profile.id, reason: 'update', origin: 'ai-profiles-module' });
+        }
+        catch (error) {
+            setColorError(String(error?.message || 'Failed to update AI profile color.'));
+        }
+        finally {
+            setColorBusy(false);
+        }
+    };
+    const fileToDataUrl = (file) => new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => resolve(String(reader.result || ''));
+        reader.onerror = () => reject(new Error('Failed to read image file.'));
+        reader.readAsDataURL(file);
+    });
+    const applyAiProfileAvatarUpdate = (updatedProfile) => {
+        const updatedId = String(updatedProfile?.id || '').trim();
+        if (!updatedId)
+            return;
+        setAiProfiles((current) => current.map((profile) => (profile.id === updatedId
+            ? {
+                ...profile,
+                avatarUrl: typeof updatedProfile.avatarUrl === 'string' ? updatedProfile.avatarUrl : null,
+                avatarSourceUrl: typeof updatedProfile.avatarSourceUrl === 'string' ? updatedProfile.avatarSourceUrl : null,
+                avatarRevision: Number.isFinite(Number(updatedProfile.avatarRevision)) ? Math.max(0, Math.floor(Number(updatedProfile.avatarRevision))) : profile.avatarRevision,
+                avatarUpdatedAt: typeof updatedProfile.avatarUpdatedAt === 'string' ? updatedProfile.avatarUpdatedAt : profile.avatarUpdatedAt,
+                updatedAt: typeof updatedProfile.updatedAt === 'string' ? updatedProfile.updatedAt : profile.updatedAt
+            }
+            : profile)));
+    };
+    const uploadAiProfileAvatar = async (profileId, displayFile, sourceFile, preserveExistingSource = false) => {
+        const displayDataUrl = await fileToDataUrl(displayFile);
+        const sourceDataUrl = sourceFile ? await fileToDataUrl(sourceFile) : null;
+        const payload = {
+            profileId,
+            preserveExistingSource,
+            displayImage: {
+                dataUrl: displayDataUrl,
+                mimeType: displayFile.type || 'application/octet-stream',
+                originalName: displayFile.name || 'display-avatar'
+            }
+        };
+        if (sourceFile && sourceDataUrl) {
+            payload.sourceImage = {
+                dataUrl: sourceDataUrl,
+                mimeType: sourceFile.type || 'application/octet-stream',
+                originalName: sourceFile.name || 'source-avatar'
+            };
+        }
+        const res = await fetch('/api/taskforce/workspace/ai-profiles/avatar/upload', {
+            method: 'POST',
+            credentials: 'include',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+        const data = await res.json().catch(() => ({}));
+        if (!res.ok || !data?.profile) {
+            throw new Error(String(data?.error || 'Failed to update AI profile avatar.'));
+        }
+        applyAiProfileAvatarUpdate(data.profile);
+        dispatchTaskforceAiProfilesMutated({ workspaceId, profileId, reason: 'avatar', origin: 'ai-profiles-module' });
+    };
+    const clearAiProfileAvatar = async (profileId) => {
+        const res = await fetch('/api/taskforce/workspace/ai-profiles/avatar', {
+            method: 'POST',
+            credentials: 'include',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                profileId,
+                avatarUrl: null,
+                avatarSourceUrl: null
+            })
+        });
+        const data = await res.json().catch(() => ({}));
+        if (!res.ok || !data?.profile) {
+            throw new Error(String(data?.error || 'Failed to update AI profile avatar.'));
+        }
+        applyAiProfileAvatarUpdate(data.profile);
+        dispatchTaskforceAiProfilesMutated({ workspaceId, profileId, reason: 'avatar', origin: 'ai-profiles-module' });
+    };
+    const handleGenerateAiProfileAvatar = async (profile) => {
+        if (generatingAvatarProfileId)
+            return false;
+        const taskforceAgentId = getTaskforceManagedAgentId(profile);
+        const replaceExisting = hasAiProfileAvatar(profile);
+        if (replaceExisting && !window.confirm(`Replace the existing avatar for ${profile.name}?`))
+            return false;
+        const visualDirection = taskforceAgentId
+            ? ''
+            : window.prompt('Optional visual direction (300 characters maximum). Leave blank to use the profile details.', '');
+        if (visualDirection === null)
+            return false;
+        const shouldUseCloud = runtimeMode === 'local';
+        if (shouldUseCloud && (!cloudAuthConfigured || !authSessionResolved || !isAuthenticated || !resolveCloudAuthUrl)) {
+            setAiAvatarError('Sign in to Taskforce Cloud to generate profile avatars.');
+            setAiAvatarNotice(null);
+            return false;
+        }
+        setGeneratingAvatarProfileId(profile.id);
+        setAiAvatarError(null);
+        setAiAvatarNotice(null);
+        setAvatarGenerationFeedbackByProfileId((current) => ({
+            ...current,
+            [profile.id]: { error: null, notice: null },
+        }));
+        try {
+            const path = taskforceAgentId
+                ? `/api/taskforce/agents/${encodeURIComponent(taskforceAgentId)}/avatar/generate`
+                : '/api/taskforce/workspace/ai-profiles/avatar/generate';
+            const url = shouldUseCloud && resolveCloudAuthUrl ? resolveCloudAuthUrl(path) : path;
+            const res = await fetch(url, {
+                method: 'POST',
+                credentials: 'include',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(taskforceAgentId ? { workspaceId } : {
+                    workspaceId,
+                    profileId: profile.id,
+                    visualDirection: visualDirection.slice(0, 300),
+                    replaceExisting,
+                }),
+            });
+            const responseText = await res.text().catch(() => '');
+            let data = {};
+            if (responseText && !/^\s*(?:<!doctype\s+html|<html\b)/i.test(responseText)) {
+                try {
+                    data = JSON.parse(responseText);
+                }
+                catch {
+                    data = {};
+                }
+            }
+            if (!res.ok || (!data?.profile && !data?.agent)) {
+                throw new Error(String(data?.error || (res.status ? `Unable to generate avatar. HTTP ${res.status}.` : 'Unable to generate avatar.')));
+            }
+            const generatedProfile = data.profile || {
+                id: profile.id,
+                avatarUrl: data.agent?.avatarUrl ?? null,
+                avatarSourceUrl: data.agent?.avatarSourceUrl ?? null,
+                avatarRevision: data.agent?.avatarRevision ?? 0,
+                avatarUpdatedAt: data.agent?.avatarUpdatedAt ?? null,
+            };
+            const displayedProfile = shouldUseCloud && resolveCloudAuthUrl ? {
+                ...generatedProfile,
+                avatarUrl: generatedProfile.avatarUrl
+                    ? resolveCloudAssetDisplayUrl(generatedProfile.avatarUrl)
+                    : generatedProfile.avatarUrl,
+                avatarSourceUrl: generatedProfile.avatarSourceUrl
+                    ? resolveCloudAssetDisplayUrl(generatedProfile.avatarSourceUrl)
+                    : generatedProfile.avatarSourceUrl,
+            } : generatedProfile;
+            applyAiProfileAvatarUpdate(displayedProfile);
+            if (shouldUseCloud) {
+                setAvatarGenerationFeedbackByProfileId((current) => ({
+                    ...current,
+                    [profile.id]: {
+                        error: null,
+                        notice: `Generated photo for ${profile.name} was saved in Taskforce Cloud. The local copy will be retained when sync runs.`,
+                    },
+                }));
+            }
+            else {
+                setAvatarGenerationFeedbackByProfileId((current) => ({
+                    ...current,
+                    [profile.id]: { error: null, notice: `Generated photo for ${profile.name} was saved.` },
+                }));
+            }
+            dispatchTaskforceAiProfilesMutated({
+                workspaceId,
+                profileId: profile.id,
+                reason: 'avatar',
+                origin: 'ai-profiles-module',
+                ...(taskforceAgentId ? {
+                    taskforceAgentAvatar: {
+                        agentId: taskforceAgentId,
+                        avatarUrl: typeof displayedProfile.avatarUrl === 'string' ? displayedProfile.avatarUrl : null,
+                        avatarSourceUrl: typeof displayedProfile.avatarSourceUrl === 'string' ? displayedProfile.avatarSourceUrl : null,
+                        avatarRevision: Number.isFinite(Number(displayedProfile.avatarRevision))
+                            ? Math.max(0, Math.floor(Number(displayedProfile.avatarRevision)))
+                            : 0,
+                        avatarUpdatedAt: typeof displayedProfile.avatarUpdatedAt === 'string'
+                            ? displayedProfile.avatarUpdatedAt
+                            : null,
+                    },
+                } : {}),
+            });
+            return true;
+        }
+        catch (error) {
+            setAvatarGenerationFeedbackByProfileId((current) => ({
+                ...current,
+                [profile.id]: { error: String(error?.message || 'Unable to generate profile avatar.'), notice: null },
+            }));
+            return false;
+        }
+        finally {
+            setGeneratingAvatarProfileId(null);
+        }
+    };
+    const handleAiProfileAvatarSelected = async (file, sourceFile, options) => {
+        if (!avatarEditorProfile)
+            return false;
+        if (!file.type.startsWith('image/')) {
+            setAiAvatarError('AI profile photo must be an image file.');
+            return false;
+        }
+        setAiAvatarBusy(true);
+        setAiAvatarError(null);
+        setAiAvatarNotice(null);
+        setAvatarGenerationFeedbackByProfileId((current) => {
+            const next = { ...current };
+            delete next[avatarEditorProfile.id];
+            return next;
+        });
+        try {
+            const preparedAvatar = await prepareAvatarUploadFile(file, { maxBytes: 5 * 1024 * 1024 });
+            if (preparedAvatar.exceededLimit) {
+                throw new Error(file.type === 'image/gif'
+                    ? 'Animated GIF AI profile photos must be 5 MB or smaller.'
+                    : 'AI profile photo must be 5 MB or smaller.');
+            }
+            const uploadFile = preparedAvatar.file;
+            let preparedSourceFile = null;
+            if (sourceFile) {
+                const preparedSource = await prepareAvatarUploadFile(sourceFile, { maxBytes: 5 * 1024 * 1024 });
+                if (preparedSource.exceededLimit) {
+                    throw new Error(sourceFile.type === 'image/gif'
+                        ? 'Animated GIF AI profile photos must be 5 MB or smaller.'
+                        : 'AI profile source photo must be 5 MB or smaller.');
+                }
+                preparedSourceFile = preparedSource.file;
+            }
+            await uploadAiProfileAvatar(avatarEditorProfile.id, uploadFile, preparedSourceFile, options?.preserveExistingSource === true);
+            return true;
+        }
+        catch (error) {
+            setAiAvatarError(String(error?.message || 'Failed to update AI profile photo.'));
+            return false;
+        }
+        finally {
+            setAiAvatarBusy(false);
+        }
+    };
+    const handleAiProfileAvatarRemove = async () => {
+        if (!avatarEditorProfile)
+            return;
+        setAiAvatarBusy(true);
+        setAiAvatarError(null);
+        setAiAvatarNotice(null);
+        setAvatarGenerationFeedbackByProfileId((current) => {
+            const next = { ...current };
+            delete next[avatarEditorProfile.id];
+            return next;
+        });
+        try {
+            await clearAiProfileAvatar(avatarEditorProfile.id);
+            setAiAvatarNotice('Profile photo removed.');
+        }
+        catch (error) {
+            setAiAvatarError(String(error?.message || 'Failed to remove AI profile photo.'));
+        }
+        finally {
+            setAiAvatarBusy(false);
+        }
+    };
+    const formatTimestamp = (value) => {
+        const normalized = String(value || '').trim();
+        if (!normalized)
+            return 'Unknown';
+        const timestamp = Date.parse(normalized);
+        if (!Number.isFinite(timestamp))
+            return normalized;
+        return new Date(timestamp).toLocaleString(undefined, {
+            dateStyle: 'medium',
+            timeStyle: 'short'
+        });
+    };
+    const selectedProfileDataGroups = useMemo(() => {
+        if (!selectedGroup)
+            return { attributes: [], dates: [] };
+        const profile = selectedGroup.primaryProfile;
+        const formatRowValue = (value) => value || 'Not set';
+        return {
+            attributes: [
+                { label: 'Category', value: formatAiProfileCategoryLabel(profile) },
+                { label: 'Connection', value: profile.seatScope ? formatAiProfileSeatScopeLabel(profile.seatScope) : '' },
+                { label: 'Provider', value: profile.provider || '' },
+                { label: 'Model', value: profile.model || '' },
+            ].map((row) => ({ ...row, value: formatRowValue(row.value) })),
+            dates: [
+                { label: 'Status', value: profile.archivedAt ? 'Retired' : 'Active' },
+                { label: 'Recruited', value: formatTimestamp(profile.createdAt) },
+                { label: 'Last updated', value: formatTimestamp(profile.updatedAt) },
+                { label: 'Last active', value: formatTimestamp(profile.lastActiveAt) },
+            ].map((row) => ({ ...row, value: formatRowValue(row.value) })),
+        };
+    }, [selectedGroup]);
+    const selectedGroupHasDuplicates = !!selectedGroup && selectedGroup.profiles.length > 1;
+    const selectedProfileUsesDefaultLogo = !!selectedGroup
+        && !hasAiProfileAvatar(selectedGroup.primaryProfile)
+        && Boolean(getAiProfileDefaultLogoUrl(selectedGroup.primaryProfile));
+    const shouldPromptForCloudLogin = cloudAuthConfigured && authSessionResolved && !isAuthenticated;
+    const displayedSeatUsage = cloudAuthConfigured
+        ? parseAiProfileSeatUsage(cloudAiProfileSeatUsage)
+        : localAiProfileSeatUsage;
+    const cloudAiProfileSeatLabel = shouldPromptForCloudLogin
+        ? 'Log into account for Cloud AI Profiles'
+        : displayedSeatUsage
+            ? `${displayedSeatUsage.used}/${displayedSeatUsage.limit === null ? 'Unlimited' : displayedSeatUsage.limit}`
+            : null;
+    const showAgentTray = !!mcpSettingsNode;
+    return (_jsxs("section", { className: `${styles.agentsModuleRoot} ${showAgentTray ? styles.agentsModuleWithTray : ''} ${showAgentTray && agentTrayOpen ? styles.agentsModuleTrayOpen : ''}`.trim(), children: [showAgentTray && (_jsxs("aside", { className: `${styles.agentTrayPanel} ${agentTrayOpen ? styles.agentTrayPanelOpen : ''}`.trim(), "aria-label": "AI Profile MCP settings tray", "aria-hidden": !agentTrayOpen, children: [_jsxs("div", { className: styles.agentTrayHeader, children: [_jsxs("span", { className: styles.agentTrayTitle, children: [_jsx(Plug, { size: 14 }), "MCP Settings"] }), _jsx("button", { type: "button", className: "tf-control-icon", onClick: onCloseAgentTray, title: "Collapse AI Profile tray", "aria-label": "Collapse AI Profile tray", children: _jsx(ChevronLeft, { size: 16 }) })] }), _jsx("div", { className: `${styles.agentTrayContent} tf-scrollbar tf-scrollbar--track-transparent`, children: _jsx("div", { className: styles.agentTrayContentInner, children: mcpSettingsNode }) })] })), _jsx("div", { className: styles.agentsModuleContent, children: _jsxs("div", { className: styles.aiProfilesExplorer, children: [_jsxs("aside", { className: styles.aiProfilesRosterPanel, "aria-label": "AI profile roster", children: [_jsx("div", { className: styles.taskforceAgentRosterHeader, children: _jsxs("span", { className: styles.taskforceAgentRosterTitle, children: [_jsx(Users, { size: 14 }), "AI Profiles"] }) }), cloudAiProfileSeatLabel && (_jsx("div", { className: styles.aiProfilesRosterSummary, children: _jsx("div", { className: styles.aiProfileSeatSummary, children: shouldPromptForCloudLogin
+                                            ? cloudAiProfileSeatLabel
+                                            : `Registered Cloud AI Profiles: ${cloudAiProfileSeatLabel}` }) })), aiProfilesLoading ? (_jsxs("div", { className: styles.aiProfilesRosterState, role: "status", "aria-live": "polite", children: [_jsx(Loader2, { size: 13, className: styles.spinner }), " Loading profiles\u2026"] })) : aiProfiles.length === 0 ? (_jsx("div", { className: styles.aiProfilesRosterState, children: "No AI profiles registered yet." })) : groupedProfilesBySurfaceType.length > 0 ? (_jsx("div", { className: `${styles.aiProfilesListPane} tf-scrollbar tf-scrollbar--track-transparent tf-tray-scroll-viewport`, children: _jsx("div", { className: styles.aiProfilesList, children: groupedProfilesBySurfaceType.map((section) => (_jsxs("div", { className: styles.aiProfilesSection, children: [_jsx("div", { className: styles.aiProfilesSectionHeader, children: section.label }), section.groups.map((group) => {
+                                                    const isSelected = selectedGroup?.groupId === group.groupId;
+                                                    const primary = group.primaryProfile;
+                                                    const usesDefaultLogo = !hasAiProfileAvatar(primary) && Boolean(getAiProfileDefaultLogoUrl(primary));
+                                                    return (_jsx(AiIdentityRosterCard, { name: primary.name, username: primary.username, subtitle: primary.role || 'Role not set', selected: isSelected, onSelect: () => setSelectedGroupId(group.groupId), avatarVariant: usesDefaultLogo ? 'logo' : 'portrait', avatar: _jsx(AiProfileAvatarImage, { profile: primary }), avatarStyle: { color: primary.color }, className: group.profiles.length > 1 ? styles.aiProfileGroupDuplicate : '', topUtility: renderAiProfileSeatScopeIcon(primary.seatScope), bottomUtility: _jsx("span", { className: styles.aiProfileGroupSignatureSwatch, style: { backgroundColor: primary.color }, title: `Signature color ${primary.color}`, "aria-hidden": "true" }), footer: group.profiles.length > 1 ? (_jsxs("span", { className: styles.aiProfileDuplicateBadge, children: [_jsx(AlertTriangle, { size: 11 }), " ", formatDuplicateCount(group.profiles.length)] })) : null }, group.groupId));
+                                                })] }, section.section))) }) })) : null] }), _jsx("main", { className: `${styles.aiProfilesDetailViewport} tf-scrollbar`, "aria-label": "AI profile details", children: selectedGroup && (_jsx("div", { className: styles.aiProfileDetailPane, children: _jsxs("div", { className: styles.aiProfileDetailCard, children: [renderAiProfileSeatScopeIcon(selectedGroup.primaryProfile.seatScope, { variant: 'detail' }), _jsxs("div", { className: styles.aiProfileDetailHero, children: [_jsx(EditableAvatarButton, { label: "Edit AI profile photo", imageUrl: getAiProfileAvatarDisplayUrl(selectedGroup.primaryProfile), fallbackImageUrl: getAiProfileDefaultLogoUrl(selectedGroup.primaryProfile), fallback: _jsx(Bot, { size: 38 }), accentColor: selectedProfileUsesDefaultLogo ? null : selectedGroup.primaryProfile.color, size: 176, width: selectedProfileUsesDefaultLogo ? 176 : 153, height: selectedProfileUsesDefaultLogo ? 176 : 207, radius: selectedProfileUsesDefaultLogo ? 0 : 6, editBadgeSize: 28, editIconSize: 14, loading: generatingAvatarProfileId === selectedGroup.primaryProfile.id, loadingLabel: `Generating ${selectedGroup.primaryProfile.name} photo`, error: Boolean(selectedProfileGenerationFeedback?.error), errorLabel: selectedProfileGenerationFeedback?.error || 'Profile photo generation failed', className: `${styles.aiProfileDetailAvatar} ${selectedProfileUsesDefaultLogo ? styles.aiProfileDetailAvatarLogo : ''}`.trim(), onClick: () => {
+                                                        setAiAvatarError(null);
+                                                        setAiAvatarNotice(null);
+                                                        setAvatarEditorProfileId(selectedGroup.primaryProfile.id);
+                                                    } }), _jsxs("div", { className: styles.aiProfileDetailHeading, children: [_jsx("div", { className: styles.aiProfileDetailTitleRow, children: _jsx("h5", { className: styles.aiProfileDetailTitle, children: selectedGroup.primaryProfile.name }) }), _jsxs("div", { className: styles.aiProfileDetailMetaRow, children: [_jsxs("span", { className: styles.aiProfileDetailHandle, children: ["@", selectedGroup.primaryProfile.username] }), selectedGroup.profiles.length > 1 && (_jsxs("span", { className: styles.aiProfileDetailLinkedCount, children: [selectedGroup.profiles.length, " linked"] }))] }), _jsxs("div", { className: styles.aiProfileDetailRole, children: ["Role: ", selectedGroup.primaryProfile.role || 'Not set'] }), selectedGroup.primaryProfile.description && (_jsx("div", { className: styles.aiProfileDetailDescription, children: selectedGroup.primaryProfile.description })), _jsxs("div", { className: styles.aiProfileSignatureColor, children: [_jsx("span", { children: "Signature color" }), _jsxs("button", { type: "button", className: styles.aiProfileSignatureColorButton, onClick: () => setColorPickerOpen((open) => !open), disabled: colorBusy, "aria-expanded": colorPickerOpen, "aria-label": "Change signature color", children: [_jsx("span", { className: styles.aiProfileSignatureSwatch, style: { backgroundColor: selectedGroup.primaryProfile.color }, "aria-hidden": "true" }), _jsx("span", { children: selectedGroup.primaryProfile.color })] })] }), colorPickerOpen && (_jsxs("div", { className: styles.aiProfileColorPicker, "aria-label": "Signature color options", children: [AI_PROFILE_COLOR_TOKENS.map((token) => {
+                                                                    const color = COLOR_PALETTE[token];
+                                                                    return _jsx("button", { type: "button", className: styles.aiProfileColorOption, style: { backgroundColor: color }, "aria-label": `Use ${token}`, "aria-pressed": selectedGroup.primaryProfile.color.toLowerCase() === color.toLowerCase(), disabled: colorBusy, onClick: () => { void handleColorChange(selectedGroup, color); } }, token);
+                                                                }), _jsx("button", { type: "button", className: styles.secondaryHeaderBtn, disabled: colorBusy, onClick: () => { void handleColorChange(selectedGroup, undefined, true); }, children: "Reset" })] })), colorError && _jsx("div", { className: styles.aiProfileInlineError, children: colorError })] })] }), _jsxs("div", { className: styles.aiProfileDetailDataList, children: [_jsx("div", { className: styles.aiProfileDetailDataGroup, children: selectedProfileDataGroups.attributes.map((row) => (_jsxs("div", { className: styles.aiProfileDetailDataRow, children: [_jsx("span", { className: styles.aiProfileDetailDataLabel, children: row.label }), row.label === 'Category' && !isTaskforceManagedAiProfile(selectedGroup.primaryProfile) ? (_jsx("span", { className: styles.aiProfileDetailDataValue, children: _jsxs("select", { className: styles.aiProfileStatusSelect, "aria-label": "Agent category", value: selectedGroup.primaryProfile.surfaceType ?? '', disabled: aiProfileCategoryBusy, onChange: (event) => {
+                                                                        void handleCategoryChange(selectedGroup, event.target.value);
+                                                                    }, children: [_jsx("option", { value: "", children: "Unclassified" }), AI_PROFILE_SURFACE_TYPES.map((surfaceType) => (_jsx("option", { value: surfaceType, children: formatAiProfileSurfaceTypeLabel(surfaceType) }, surfaceType)))] }) })) : (_jsx("span", { className: styles.aiProfileDetailDataValue, children: row.value }))] }, row.label))) }), _jsx("div", { className: `${styles.aiProfileDetailDataGroup} ${styles.aiProfileDetailDateGroup}`, children: selectedProfileDataGroups.dates.map((row) => (_jsxs("div", { className: styles.aiProfileDetailDataRow, children: [_jsx("span", { className: styles.aiProfileDetailDataLabel, children: row.label }), row.label === 'Status' ? (_jsx("span", { className: styles.aiProfileDetailDataValue, children: _jsxs("select", { className: styles.aiProfileStatusSelect, "aria-label": "Agent roster status", value: selectedGroup.primaryProfile.archivedAt ? 'retired' : 'active', onChange: (event) => {
+                                                                        if (event.target.value === 'retire') {
+                                                                            void handleArchive(selectedGroup.primaryProfile);
+                                                                        }
+                                                                    }, children: [_jsx("option", { value: "active", children: "Active" }), selectedGroup.primaryProfile.archivedAt ? (_jsx("option", { value: "retired", children: "Retired" })) : (_jsx("option", { value: "retire", children: "Retire from roster" }))] }) })) : (_jsx("span", { className: styles.aiProfileDetailDataValue, children: row.value }))] }, row.label))) })] }), aiProfileCategoryError?.profileId === selectedGroup.primaryProfile.id && (_jsxs("div", { className: styles.aiProfileInlineError, role: "alert", children: [_jsx(AlertTriangle, { size: 12 }), _jsx("span", { children: aiProfileCategoryError.message })] })), selectedGroupHasDuplicates ? (_jsxs("div", { className: styles.aiProfileInstanceSection, children: [_jsxs("div", { className: styles.aiProfileInstanceSectionHeader, children: [_jsx("span", { children: "Profile instances" }), _jsx("span", { className: styles.settingsHint, children: "Choose a keeper here if duplicates need to be merged." })] }), _jsx("div", { className: styles.aiProfileInstanceList, children: selectedGroup.profiles.map((profile) => (_jsxs("div", { className: styles.aiProfileInstanceCard, children: [_jsxs("div", { className: styles.aiProfileInstanceTopRow, children: [_jsxs("div", { children: [_jsxs("div", { className: styles.aiProfileInstanceName, children: ["@", profile.username] }), _jsx("div", { className: styles.aiProfileIdChip, children: profile.id })] }), aiProfileMergeState?.keepId === profile.id && (_jsx("span", { className: styles.aiProfileKeepBadge, children: "Keeping" }))] }), _jsxs("div", { className: styles.aiProfileInstanceMeta, children: [_jsxs("span", { children: ["Created ", formatTimestamp(profile.createdAt)] }), _jsxs("span", { children: ["Updated ", formatTimestamp(profile.updatedAt)] })] }), aiProfileMergeState?.keepId !== profile.id && (_jsx("button", { className: styles.secondaryHeaderBtn, title: "Keep this profile, merge others into it", onClick: () => {
+                                                                    const otherId = selectedGroup.profiles.find((candidate) => candidate.id !== profile.id)?.id;
+                                                                    if (otherId)
+                                                                        setAiProfileMergeState({ keepId: profile.id, mergeId: otherId });
+                                                                }, children: "Keep this" })), aiProfileArchiveError?.profileId === profile.id && (_jsxs("div", { className: styles.aiProfileInlineError, role: "alert", children: [_jsx(AlertTriangle, { size: 12 }), _jsx("span", { children: aiProfileArchiveError.message })] })), _jsx("button", { className: styles.aiProfileDangerTextButton, title: "Remove this profile from the active roster", onClick: () => { void handleArchive(profile); }, children: "Remove from roster" })] }, profile.id))) }), aiProfileMergeState && selectedGroup.profiles.some((profile) => profile.id === aiProfileMergeState.keepId) && (_jsxs("div", { className: styles.aiProfileMergeActions, children: [_jsx("button", { className: styles.dangerBtn, onClick: () => { void handleMerge(aiProfileMergeState.keepId, aiProfileMergeState.mergeId); }, children: "Merge duplicates" }), _jsx("button", { className: styles.secondaryHeaderBtn, onClick: () => setAiProfileMergeState(null), children: "Cancel" })] }))] })) : (_jsxs("div", { className: styles.aiProfileIdFooter, children: [_jsx("div", { className: styles.aiProfileIdFooterValue, children: selectedGroup.primaryProfile.id }), aiProfileArchiveError?.profileId === selectedGroup.primaryProfile.id && (_jsxs("div", { className: styles.aiProfileInlineError, role: "alert", children: [_jsx(AlertTriangle, { size: 12 }), _jsx("span", { children: aiProfileArchiveError.message })] }))] }))] }) })) })] }) }), _jsx(AvatarImageManagerModal, { isOpen: !!avatarEditorProfile, theme: theme, title: "Edit AI Profile Photo", currentImageUrl: getAiProfileAvatarDisplayUrl(avatarEditorProfile), editorImageUrl: getAiProfileAvatarSourceUrl(avatarEditorProfile), fallbackInitial: (avatarEditorProfile?.name || 'AI').charAt(0).toUpperCase(), accept: "image/png,image/jpeg,image/webp,image/gif", busy: aiAvatarBusy, generating: generatingAvatarProfileId === avatarEditorProfile?.id, generateLabel: avatarEditorProfile && hasAiProfileAvatar(avatarEditorProfile) ? 'Regenerate' : 'Generate', hasPendingImage: false, canRemove: !!avatarEditorProfile?.avatarUrl, error: aiAvatarError || avatarEditorGenerationFeedback?.error || null, notice: aiAvatarNotice || avatarEditorGenerationFeedback?.notice || null, onClose: () => {
+                    if (aiAvatarBusy)
+                        return;
+                    setAvatarEditorProfileId(null);
+                    setAiAvatarError(null);
+                    setAiAvatarNotice(null);
+                }, onApplyImage: handleAiProfileAvatarSelected, onGenerateImage: avatarEditorProfile
+                    && (!generatingAvatarProfileId || generatingAvatarProfileId === avatarEditorProfile.id)
+                    && (isAiProfileAvatarGenerationEligible(avatarEditorProfile)
+                        || Boolean(getTaskforceManagedAgentId(avatarEditorProfile)))
+                    ? () => handleGenerateAiProfileAvatar(avatarEditorProfile)
+                    : undefined, onRemoveImage: handleAiProfileAvatarRemove }, avatarEditorProfile?.id || 'ai-profile-avatar-closed')] }));
+}