@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/components/features/taskforceAgentEditorModel.js

@@ -0,0 +1,145 @@
+import { AGENT_DEFINITION_SCHEMA_VERSION, } from '../../shared/taskforceAgentDefinition.js';
+import { getTaskforceAgentModel, } from '../../shared/taskforceAgentModels.js';
+export const PERSONALITY_PRESETS = [
+    { key: 'practical', label: 'Practical' },
+    { key: 'encouraging', label: 'Encouraging' },
+    { key: 'analytical', label: 'Analytical' },
+    { key: 'direct', label: 'Direct' },
+    { key: 'friendly-coach', label: 'Friendly Coach' },
+    { key: 'creative-partner', label: 'Creative Partner' },
+];
+export const RESPONSE_STYLE_PRESETS = [
+    { key: 'concise', label: 'Concise' },
+    { key: 'balanced', label: 'Balanced' },
+    { key: 'detailed', label: 'Detailed' },
+    { key: 'executive-summary', label: 'Executive Summary' },
+    { key: 'critical-review', label: 'Critical Review' },
+    { key: 'technical', label: 'Technical' },
+    { key: 'creative', label: 'Creative' },
+];
+export const AVATAR_ART_STYLE_PRESETS = [
+    { key: 'taskforce-default', label: 'Taskforce Agent' },
+    { key: 'photographic', label: 'Photographic' },
+    { key: 'cinematic', label: 'Cinematic' },
+    { key: 'painterly', label: 'Painterly' },
+    { key: 'watercolor', label: 'Watercolor' },
+    { key: 'graphic-novel', label: 'Graphic Novel' },
+    { key: 'anime-inspired', label: 'Anime-inspired' },
+    { key: 'stylized-3d', label: 'Stylized 3D' },
+    { key: 'pixel-art', label: 'Pixel Art' },
+    { key: 'ink-sketch', label: 'Ink Sketch' },
+];
+export const CUSTOM_PRESET_VALUE = '__custom__';
+export const DEFAULT_AVATAR_ART_STYLE_LABEL = 'Default';
+export const DEFAULT_AGENT_PURPOSE = 'Help users complete work in Taskforce.';
+export const DEFAULT_AGENT_WORKING_GUIDELINES = 'Be concise and actionable.';
+export const DEFAULT_AGENT_TOOL_CAPABILITIES = [
+    'tasks',
+    'planning',
+    'documents',
+    'images',
+    'workspace',
+];
+const DEFAULT_AGENT_TOOL_CAPABILITY_SET = new Set(DEFAULT_AGENT_TOOL_CAPABILITIES);
+export function createTaskforceAgentEditorDraft(definition, fallback = {}) {
+    const personality = definition?.behavior.personality;
+    const responseStyle = definition?.behavior.responseStyle;
+    const artStyle = definition?.presentation.avatar.artStyle;
+    const disabledCapabilities = new Set(definition?.toolPolicy.disabledCapabilities || []);
+    const requestedCapabilities = definition?.toolPolicy.requestedCapabilities?.length
+        ? definition.toolPolicy.requestedCapabilities
+        : DEFAULT_AGENT_TOOL_CAPABILITIES;
+    return {
+        purpose: definition?.purpose || DEFAULT_AGENT_PURPOSE,
+        personalitySelection: personality?.presetKey
+            || (personality?.customDescription ? CUSTOM_PRESET_VALUE : ''),
+        personalityCustom: personality?.customDescription || '',
+        responseStyleSelection: responseStyle?.presetKey
+            || (responseStyle?.customDescription ? CUSTOM_PRESET_VALUE : ''),
+        responseStyleCustom: responseStyle?.customDescription || '',
+        workingGuidelines: definition?.behavior.workingGuidelines
+            || fallback.systemPrompt
+            || DEFAULT_AGENT_WORKING_GUIDELINES,
+        avatarVisualDescription: definition?.presentation.avatar.visualDescription || '',
+        avatarArtStyleSelection: artStyle?.mode === 'preset'
+            ? artStyle.presetKey
+            : artStyle?.mode === 'custom'
+                ? CUSTOM_PRESET_VALUE
+                : '',
+        avatarArtStyleCustom: artStyle?.mode === 'custom' ? artStyle.customDescription : '',
+        roleRef: definition?.roleRef ? { ...definition.roleRef } : null,
+        skillRefs: (definition?.skillRefs || []).map((reference) => ({ ...reference })),
+        requestedCapabilities: requestedCapabilities.filter((capability) => !disabledCapabilities.has(capability)),
+        toolAccessChanged: false,
+    };
+}
+function selectedBehavior(selection, customDescription) {
+    const custom = customDescription.trim();
+    if (selection === CUSTOM_PRESET_VALUE) {
+        return custom ? { customDescription: custom } : undefined;
+    }
+    return selection ? { presetKey: selection } : undefined;
+}
+function selectedAvatarArtStyle(selection, customDescription) {
+    const custom = customDescription.trim();
+    if (selection === CUSTOM_PRESET_VALUE) {
+        return custom ? { mode: 'custom', customDescription: custom } : undefined;
+    }
+    return selection ? { mode: 'preset', presetKey: selection } : undefined;
+}
+export function buildTaskforceAgentDefinitionFromDraft(input) {
+    const { baseDefinition, draft } = input;
+    const personality = selectedBehavior(draft.personalitySelection, draft.personalityCustom);
+    const responseStyle = selectedBehavior(draft.responseStyleSelection, draft.responseStyleCustom);
+    const workingGuidelines = draft.workingGuidelines.trim();
+    const visualDescription = draft.avatarVisualDescription.trim();
+    const artStyle = selectedAvatarArtStyle(draft.avatarArtStyleSelection, draft.avatarArtStyleCustom);
+    const requestedCapabilities = draft.requestedCapabilities
+        .filter((capability) => DEFAULT_AGENT_TOOL_CAPABILITY_SET.has(capability));
+    return {
+        ...(baseDefinition || {}),
+        schemaVersion: AGENT_DEFINITION_SCHEMA_VERSION,
+        name: input.name.trim(),
+        purpose: draft.purpose.trim(),
+        model: {
+            providerKey: input.providerKey,
+            modelKey: input.modelKey,
+            modelSource: getTaskforceAgentModel(input.modelKey)?.source || 'bedrock',
+            tier: input.tier,
+        },
+        behavior: {
+            ...(personality ? { personality } : {}),
+            ...(responseStyle ? { responseStyle } : {}),
+            ...(workingGuidelines ? { workingGuidelines } : {}),
+        },
+        presentation: {
+            avatar: {
+                ...(visualDescription ? { visualDescription } : {}),
+                ...(artStyle ? { artStyle } : {}),
+            },
+        },
+        ...(draft.roleRef ? { roleRef: { ...draft.roleRef } } : { roleRef: undefined }),
+        skillRefs: draft.skillRefs.map((reference) => ({ ...reference })),
+        toolPolicy: baseDefinition?.toolPolicy && !draft.toolAccessChanged
+            ? baseDefinition.toolPolicy
+            : {
+                basePolicyRef: baseDefinition?.toolPolicy.basePolicyRef || {
+                    id: 'managed-agent-default',
+                    resolution: 'current',
+                },
+                requestedCapabilities: requestedCapabilities.length > 0
+                    ? requestedCapabilities
+                    : undefined,
+                disabledCapabilities: requestedCapabilities.length === 0
+                    ? [...DEFAULT_AGENT_TOOL_CAPABILITIES]
+                    : undefined,
+                toolOverrides: undefined,
+            },
+    };
+}
+export function hasUnsavedAvatarPresentation(definition, draft) {
+    const saved = createTaskforceAgentEditorDraft(definition);
+    return saved.avatarVisualDescription !== draft.avatarVisualDescription
+        || saved.avatarArtStyleSelection !== draft.avatarArtStyleSelection
+        || saved.avatarArtStyleCustom !== draft.avatarArtStyleCustom;
+}

package/dist/components/features/useDocumentWorkspaceController.d.ts

@@ -1,16 +1,29 @@
 import { type DocumentAttachmentFilter, type DocumentTypeFilter } from './documentWorkspaceFilters';
 import { type DocMeta } from './documentWorkspaceModel';
+import { type TraySortField, type TraySortOrder } from '../../utils/assetTraySorting';
 interface Options {
     runtimeMode?: 'local' | 'cloud';
+    workspaceId?: string | null;
     apiBaseUrl?: string;
     cloudAuthBaseUrl?: string;
     typeFilters?: DocumentTypeFilter[];
     attachmentFilters?: DocumentAttachmentFilter[];
     onTypeFiltersChange?: (values: DocumentTypeFilter[]) => void;
     onAttachmentFiltersChange?: (values: DocumentAttachmentFilter[]) => void;
+    sortField?: TraySortField;
+    sortOrder?: TraySortOrder;
+    onSortFieldChange?: (field: TraySortField) => void;
+    onSortOrderChange?: (order: TraySortOrder) => void;
+    pinnedDocIds?: string[];
+    onPinnedDocIdsChange?: (docIds: string[]) => void;
+    selectedDocId?: string | null;
+    onSelectedDocIdChange?: (docId: string | null) => void;
+    searchQuery?: string;
+    onSearchQueryChange?: (value: string) => void;
     requestedDocPath?: string | null;
     requestedDocAssetId?: string | null;
     onRequestedDocHandled?: () => void;
+    selectionReady?: boolean;
 }
 interface Result {
     documentApiBaseUrl: string;
@@ -23,12 +36,18 @@ interface Result {
     typeFilters: DocumentTypeFilter[];
     attachmentFilters: DocumentAttachmentFilter[];
     hasActiveFilters: boolean;
+    sortField: TraySortField;
+    sortOrder: TraySortOrder;
+    setSortField: (field: TraySortField) => void;
+    setSortOrder: (order: TraySortOrder) => void;
     setSearchQuery: (value: string) => void;
+    pinnedDocIds: string[];
+    togglePinnedDoc: (docId: string) => void;
     handleTypeFiltersChange: (values: DocumentTypeFilter[]) => void;
     handleAttachmentFiltersChange: (values: DocumentAttachmentFilter[]) => void;
     fetchDocuments: () => Promise<void>;
     selectDoc: (doc: DocMeta | null) => void;
     handleDeleteSelected: () => Promise<void>;
 }
-export declare function useDocumentWorkspaceController({ runtimeMode, apiBaseUrl, cloudAuthBaseUrl, typeFilters: controlledTypeFilters, attachmentFilters: controlledAttachmentFilters, onTypeFiltersChange, onAttachmentFiltersChange, requestedDocPath, requestedDocAssetId, onRequestedDocHandled, }: Options): Result;
+export declare function useDocumentWorkspaceController({ runtimeMode, workspaceId, apiBaseUrl, cloudAuthBaseUrl, typeFilters: controlledTypeFilters, attachmentFilters: controlledAttachmentFilters, onTypeFiltersChange, onAttachmentFiltersChange, sortField: controlledSortField, sortOrder: controlledSortOrder, onSortFieldChange, onSortOrderChange, pinnedDocIds: controlledPinnedDocIds, onPinnedDocIdsChange, selectedDocId: controlledSelectedDocId, onSelectedDocIdChange, searchQuery: controlledSearchQuery, onSearchQueryChange, requestedDocPath, requestedDocAssetId, onRequestedDocHandled, selectionReady, }: Options): Result;
 export {};

package/dist/components/features/useDocumentWorkspaceController.js

@@ -1,14 +1,20 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { fetchTaskforceApi } from '../../utils/taskforceApiClient';
 import { logDocumentManagerDebug, resolveDocumentManagerApiBase } from '../../utils/documentManagerApi';
 import { DOCUMENT_ATTACHMENT_FILTER_OPTIONS, DOCUMENT_TYPE_FILTER_OPTIONS, } from './documentWorkspaceFilters';
-import { docPathMatches, extractAssetIdFromPath, filterDocuments, normalizeDocPath, } from './documentWorkspaceModel';
-export function useDocumentWorkspaceController({ runtimeMode = 'local', apiBaseUrl = '', cloudAuthBaseUrl = '', typeFilters: controlledTypeFilters, attachmentFilters: controlledAttachmentFilters, onTypeFiltersChange, onAttachmentFiltersChange, requestedDocPath = null, requestedDocAssetId = null, onRequestedDocHandled, }) {
+import { docPathMatches, extractAssetIdFromPath, filterDocuments, normalizeDocPath, withWorkspaceQuery, } from './documentWorkspaceModel';
+import { sortDocuments, } from '../../utils/assetTraySorting';
+import { TASKFORCE_CONTEXT_ASSETS_MUTATED_EVENT } from '../../utils/contextAssetEvents';
+import { TASKFORCE_WORKSPACE_RESOURCES_INVALIDATED_EVENT, } from '../../utils/workspaceResourceEvents';
+export function useDocumentWorkspaceController({ runtimeMode = 'local', workspaceId = null, apiBaseUrl = '', cloudAuthBaseUrl = '', typeFilters: controlledTypeFilters, attachmentFilters: controlledAttachmentFilters, onTypeFiltersChange, onAttachmentFiltersChange, sortField: controlledSortField, sortOrder: controlledSortOrder, onSortFieldChange, onSortOrderChange, pinnedDocIds: controlledPinnedDocIds, onPinnedDocIdsChange, selectedDocId: controlledSelectedDocId, onSelectedDocIdChange, searchQuery: controlledSearchQuery, onSearchQueryChange, requestedDocPath = null, requestedDocAssetId = null, onRequestedDocHandled, selectionReady = true, }) {
     const [documents, setDocuments] = useState([]);
     const [loading, setLoading] = useState(true);
     const [error, setError] = useState(null);
-    const [selectedDocId, setSelectedDocId] = useState(null);
-    const [searchQuery, setSearchQuery] = useState('');
+    const [internalSelectedDocId, setInternalSelectedDocId] = useState(null);
+    const [internalSearchQuery, setInternalSearchQuery] = useState('');
+    const [internalSortField, setInternalSortField] = useState('updated');
+    const [internalSortOrder, setInternalSortOrder] = useState('desc');
+    const [internalPinnedDocIds, setInternalPinnedDocIds] = useState([]);
     const [internalTypeFilters, setInternalTypeFilters] = useState(() => DOCUMENT_TYPE_FILTER_OPTIONS.map((option) => option.value));
     const [internalAttachmentFilters, setInternalAttachmentFilters] = useState(() => DOCUMENT_ATTACHMENT_FILTER_OPTIONS.map((option) => option.value));
     const documentApiBaseUrl = resolveDocumentManagerApiBase({
@@ -16,15 +22,31 @@ export function useDocumentWorkspaceController({ runtimeMode = 'local', apiBaseU
         apiBaseUrl,
         cloudAuthBaseUrl,
     });
+    const normalizedWorkspaceId = String(workspaceId || '').trim();
+    const documentsListUrl = withWorkspaceQuery('/api/taskforce/documents', workspaceId);
     const typeFilters = controlledTypeFilters ?? internalTypeFilters;
     const attachmentFilters = controlledAttachmentFilters ?? internalAttachmentFilters;
     const handleTypeFiltersChange = onTypeFiltersChange ?? setInternalTypeFilters;
     const handleAttachmentFiltersChange = onAttachmentFiltersChange ?? setInternalAttachmentFilters;
+    const sortField = controlledSortField ?? internalSortField;
+    const sortOrder = controlledSortOrder ?? internalSortOrder;
+    const selectedDocId = controlledSelectedDocId !== undefined ? controlledSelectedDocId : internalSelectedDocId;
+    const searchQuery = controlledSearchQuery !== undefined ? controlledSearchQuery : internalSearchQuery;
+    const handleSortFieldChange = onSortFieldChange ?? setInternalSortField;
+    const handleSortOrderChange = onSortOrderChange ?? setInternalSortOrder;
+    const pinnedDocIds = controlledPinnedDocIds ?? internalPinnedDocIds;
+    const handlePinnedDocIdsChange = onPinnedDocIdsChange ?? setInternalPinnedDocIds;
+    const pinnedDocIdsRef = useRef(pinnedDocIds);
+    const handlePinnedDocIdsChangeRef = useRef(handlePinnedDocIdsChange);
+    pinnedDocIdsRef.current = pinnedDocIds;
+    handlePinnedDocIdsChangeRef.current = handlePinnedDocIdsChange;
+    const handleSelectedDocIdChange = onSelectedDocIdChange ?? setInternalSelectedDocId;
+    const handleSearchQueryChange = onSearchQueryChange ?? setInternalSearchQuery;
     const fetchDocuments = useCallback(async () => {
         setLoading(true);
         setError(null);
         try {
-            const res = await fetchTaskforceApi('/api/taskforce/documents', {
+            const res = await fetchTaskforceApi(documentsListUrl, {
                 credentials: 'include',
             }, documentApiBaseUrl);
             if (!res.ok)
@@ -37,6 +59,12 @@ export function useDocumentWorkspaceController({ runtimeMode = 'local', apiBaseU
                 count: nextDocuments.length,
             });
             setDocuments(nextDocuments);
+            const documentIds = new Set(nextDocuments.map((doc) => doc.assetId));
+            const currentPinnedDocIds = pinnedDocIdsRef.current;
+            const nextPinnedDocIds = currentPinnedDocIds.filter((id) => documentIds.has(id));
+            if (nextPinnedDocIds.length !== currentPinnedDocIds.length) {
+                handlePinnedDocIdsChangeRef.current(nextPinnedDocIds);
+            }
         }
         catch (e) {
             setError(e?.message || 'Failed to load documents');
@@ -49,12 +77,55 @@ export function useDocumentWorkspaceController({ runtimeMode = 'local', apiBaseU
         finally {
             setLoading(false);
         }
-    }, [documentApiBaseUrl, runtimeMode]);
+    }, [documentApiBaseUrl, documentsListUrl, runtimeMode]);
     useEffect(() => {
         void fetchDocuments();
     }, [fetchDocuments]);
-    const filteredDocs = useMemo(() => filterDocuments(documents, searchQuery, typeFilters, attachmentFilters), [attachmentFilters, documents, searchQuery, typeFilters]);
-    const selectedDoc = useMemo(() => (selectedDocId ? documents.find((doc) => doc.id === selectedDocId) ?? null : null), [documents, selectedDocId]);
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const handleContextAssetsMutated = (event) => {
+            const detail = event.detail || {};
+            const eventWorkspaceId = String(detail.workspaceId || '').trim();
+            if (normalizedWorkspaceId && eventWorkspaceId && eventWorkspaceId !== normalizedWorkspaceId)
+                return;
+            void fetchDocuments();
+        };
+        window.addEventListener(TASKFORCE_CONTEXT_ASSETS_MUTATED_EVENT, handleContextAssetsMutated);
+        return () => {
+            window.removeEventListener(TASKFORCE_CONTEXT_ASSETS_MUTATED_EVENT, handleContextAssetsMutated);
+        };
+    }, [fetchDocuments, normalizedWorkspaceId]);
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const handleWorkspaceResourcesInvalidated = (event) => {
+            const detail = event.detail;
+            const eventWorkspaceId = String(detail?.workspaceId || '').trim();
+            if (normalizedWorkspaceId && eventWorkspaceId && eventWorkspaceId !== normalizedWorkspaceId)
+                return;
+            void fetchDocuments();
+        };
+        window.addEventListener(TASKFORCE_WORKSPACE_RESOURCES_INVALIDATED_EVENT, handleWorkspaceResourcesInvalidated);
+        return () => {
+            window.removeEventListener(TASKFORCE_WORKSPACE_RESOURCES_INVALIDATED_EVENT, handleWorkspaceResourcesInvalidated);
+        };
+    }, [fetchDocuments, normalizedWorkspaceId]);
+    const baseFiltered = useMemo(() => filterDocuments(documents, searchQuery, typeFilters, attachmentFilters), [attachmentFilters, documents, searchQuery, typeFilters]);
+    const filteredDocs = useMemo(() => {
+        const sorted = sortDocuments(baseFiltered, sortField, sortOrder);
+        const pinned = new Set(pinnedDocIds);
+        return [
+            ...sorted.filter((doc) => pinned.has(doc.assetId)),
+            ...sorted.filter((doc) => !pinned.has(doc.assetId)),
+        ];
+    }, [baseFiltered, pinnedDocIds, sortField, sortOrder]);
+    const togglePinnedDoc = useCallback((docId) => {
+        handlePinnedDocIdsChange(pinnedDocIds.includes(docId)
+            ? pinnedDocIds.filter((id) => id !== docId)
+            : [...pinnedDocIds, docId].slice(-50));
+    }, [handlePinnedDocIdsChange, pinnedDocIds]);
+    const selectedDoc = useMemo(() => (selectedDocId ? documents.find((doc) => doc.assetId === selectedDocId) ?? null : null), [documents, selectedDocId]);
     useEffect(() => {
         if ((!requestedDocPath && !requestedDocAssetId) || documents.length === 0)
             return;
@@ -62,7 +133,7 @@ export function useDocumentWorkspaceController({ runtimeMode = 'local', apiBaseU
         const normalizedRequestedAssetId = String(requestedDocAssetId || '').trim().toLowerCase()
             || extractAssetIdFromPath(requestedDocPath);
         const matched = documents.find((doc) => {
-            const candidateAssetId = extractAssetIdFromPath(doc.fsPath) || String(doc.assetId || '').trim().toLowerCase() || null;
+            const candidateAssetId = String(doc.assetId || '').trim().toLowerCase() || extractAssetIdFromPath(doc.fsPath);
             if (normalizedRequestedAssetId && candidateAssetId && candidateAssetId === normalizedRequestedAssetId)
                 return true;
             if (!requested)
@@ -71,27 +142,35 @@ export function useDocumentWorkspaceController({ runtimeMode = 'local', apiBaseU
         });
         if (!matched)
             return;
-        setSelectedDocId(matched.id);
+        handleSelectedDocIdChange(matched.assetId);
         onRequestedDocHandled?.();
-    }, [documents, onRequestedDocHandled, requestedDocAssetId, requestedDocPath]);
+    }, [documents, handleSelectedDocIdChange, onRequestedDocHandled, requestedDocAssetId, requestedDocPath]);
     useEffect(() => {
+        // A restored selection must survive until the list has actually loaded;
+        // documents is empty during fetch (and after a failed fetch), not truly empty.
+        if (loading || error)
+            return;
         if ((requestedDocPath || requestedDocAssetId) && !selectedDoc)
             return;
+        if (!selectionReady)
+            return;
         if (filteredDocs.length === 0) {
             if (selectedDocId !== null) {
-                setSelectedDocId(null);
+                handleSelectedDocIdChange(null);
             }
             return;
         }
-        if (selectedDoc && filteredDocs.some((doc) => doc.id === selectedDoc.id))
+        if (selectedDoc && filteredDocs.some((doc) => doc.assetId === selectedDoc.assetId))
             return;
-        setSelectedDocId(filteredDocs[0].id);
-    }, [filteredDocs, requestedDocAssetId, requestedDocPath, selectedDoc, selectedDocId]);
+        handleSelectedDocIdChange(filteredDocs[0].assetId);
+    }, [error, filteredDocs, handleSelectedDocIdChange, loading, requestedDocAssetId, requestedDocPath, selectedDoc, selectedDocId, selectionReady]);
     const handleDeleteSelected = useCallback(async () => {
-        setSelectedDocId(null);
+        handleSelectedDocIdChange(null);
         await fetchDocuments();
-    }, [fetchDocuments]);
-    const hasActiveFilters = searchQuery.trim().length > 0 || typeFilters.length > 0 || attachmentFilters.length > 0;
+    }, [fetchDocuments, handleSelectedDocIdChange]);
+    const hasActiveFilters = searchQuery.trim().length > 0
+        || typeFilters.length !== DOCUMENT_TYPE_FILTER_OPTIONS.length
+        || attachmentFilters.length !== DOCUMENT_ATTACHMENT_FILTER_OPTIONS.length;
     return {
         documentApiBaseUrl,
         documents,
@@ -103,11 +182,17 @@ export function useDocumentWorkspaceController({ runtimeMode = 'local', apiBaseU
         typeFilters,
         attachmentFilters,
         hasActiveFilters,
-        setSearchQuery,
+        sortField,
+        sortOrder,
+        setSortField: handleSortFieldChange,
+        setSortOrder: handleSortOrderChange,
+        setSearchQuery: handleSearchQueryChange,
+        pinnedDocIds,
+        togglePinnedDoc,
         handleTypeFiltersChange,
         handleAttachmentFiltersChange,
         fetchDocuments,
-        selectDoc: (doc) => setSelectedDocId(doc?.id ?? null),
+        selectDoc: (doc) => handleSelectedDocIdChange(doc?.assetId ?? null),
         handleDeleteSelected,
     };
 }

package/dist/components/features/workflowManager/WorkflowManagerModule.d.ts

@@ -0,0 +1,11 @@
+import { type TaskAssigneeOption } from '../../../utils/assignees.js';
+type WorkflowManagerModuleProps = {
+    workspaceId: string;
+    libraryTrayOpen?: boolean;
+    onCloseLibraryTray?: () => void;
+    assigneeOptions?: TaskAssigneeOption[];
+    theme?: 'light' | 'dawn' | 'dark' | 'midnight';
+    onUnsavedChangesChange?: (hasUnsavedChanges: boolean) => void;
+};
+export declare function WorkflowManagerModule({ workspaceId, libraryTrayOpen, onCloseLibraryTray, assigneeOptions, theme, onUnsavedChangesChange, }: WorkflowManagerModuleProps): import("react/jsx-runtime").JSX.Element;
+export {};