InvokeAI 6.9.0rc3__py3-none-any.whl → 6.10.0rc1__py3-none-any.whl

invokeai/app/services/shared/graph.py

@@ -2,7 +2,8 @@
 
 import copy
 import itertools
-from typing import Any, Optional, TypeVar, Union, get_args, get_origin
+from collections import deque
+from typing import Any, Deque, Iterable, Optional, Type, TypeVar, Union, get_args, get_origin
 
 import networkx as nx
 from pydantic import (
@@ -10,6 +11,7 @@ from pydantic import (
     ConfigDict,
     GetCoreSchemaHandler,
     GetJsonSchemaHandler,
+    PrivateAttr,
     ValidationError,
     field_validator,
 )
@@ -33,6 +35,10 @@ from invokeai.app.util.misc import uuid_string
 # in 3.10 this would be "from types import NoneType"
 NoneType = type(None)
 
+# Port name constants
+ITEM_FIELD = "item"
+COLLECTION_FIELD = "collection"
+
 
 class EdgeConnection(BaseModel):
     node_id: str = Field(description="The id of the node for this edge connection")
@@ -395,7 +401,7 @@ class Graph(BaseModel):
 
         try:
             self.edges.remove(edge)
-        except KeyError:
+        except ValueError:
             pass
 
     def validate_self(self) -> None:
@@ -414,7 +420,8 @@ class Graph(BaseModel):
 
         # Validate that all node ids are unique
         node_ids = [n.id for n in self.nodes.values()]
-        duplicate_node_ids = {node_id for node_id in node_ids if node_ids.count(node_id) >= 2}
+        seen = set()
+        duplicate_node_ids = {nid for nid in node_ids if (nid in seen) or seen.add(nid)}
         if duplicate_node_ids:
             raise DuplicateNodeIdError(f"Node ids must be unique, found duplicates {duplicate_node_ids}")
 
@@ -529,19 +536,19 @@ class Graph(BaseModel):
             raise InvalidEdgeError(f"Field types are incompatible ({edge})")
 
         # Validate if iterator output type matches iterator input type (if this edge results in both being set)
-        if isinstance(to_node, IterateInvocation) and edge.destination.field == "collection":
+        if isinstance(to_node, IterateInvocation) and edge.destination.field == COLLECTION_FIELD:
             err = self._is_iterator_connection_valid(edge.destination.node_id, new_input=edge.source)
             if err is not None:
                 raise InvalidEdgeError(f"Iterator input type does not match iterator output type ({edge}): {err}")
 
         # Validate if iterator input type matches output type (if this edge results in both being set)
-        if isinstance(from_node, IterateInvocation) and edge.source.field == "item":
+        if isinstance(from_node, IterateInvocation) and edge.source.field == ITEM_FIELD:
             err = self._is_iterator_connection_valid(edge.source.node_id, new_output=edge.destination)
             if err is not None:
                 raise InvalidEdgeError(f"Iterator output type does not match iterator input type ({edge}): {err}")
 
         # Validate if collector input type matches output type (if this edge results in both being set)
-        if isinstance(to_node, CollectInvocation) and edge.destination.field == "item":
+        if isinstance(to_node, CollectInvocation) and edge.destination.field == ITEM_FIELD:
             err = self._is_collector_connection_valid(edge.destination.node_id, new_input=edge.source)
             if err is not None:
                 raise InvalidEdgeError(f"Collector output type does not match collector input type ({edge}): {err}")
@@ -549,7 +556,7 @@ class Graph(BaseModel):
         # Validate if collector output type matches input type (if this edge results in both being set) - skip if the destination field is not Any or list[Any]
         if (
             isinstance(from_node, CollectInvocation)
-            and edge.source.field == "collection"
+            and edge.source.field == COLLECTION_FIELD
             and not self._is_destination_field_list_of_Any(edge)
             and not self._is_destination_field_Any(edge)
         ):
@@ -639,8 +646,8 @@ class Graph(BaseModel):
         new_input: Optional[EdgeConnection] = None,
         new_output: Optional[EdgeConnection] = None,
     ) -> str | None:
-        inputs = [e.source for e in self._get_input_edges(node_id, "collection")]
-        outputs = [e.destination for e in self._get_output_edges(node_id, "item")]
+        inputs = [e.source for e in self._get_input_edges(node_id, COLLECTION_FIELD)]
+        outputs = [e.destination for e in self._get_output_edges(node_id, ITEM_FIELD)]
 
         if new_input is not None:
             inputs.append(new_input)
@@ -670,7 +677,7 @@ class Graph(BaseModel):
         if isinstance(input_node, CollectInvocation):
             # Traverse the graph to find the first collector input edge. Collectors validate that their collection
             # inputs are all of the same type, so we can use the first input edge to determine the collector's type
-            first_collector_input_edge = self._get_input_edges(input_node.id, "item")[0]
+            first_collector_input_edge = self._get_input_edges(input_node.id, ITEM_FIELD)[0]
             first_collector_input_type = get_output_field_type(
                 self.get_node(first_collector_input_edge.source.node_id), first_collector_input_edge.source.field
             )
@@ -690,8 +697,8 @@ class Graph(BaseModel):
         new_input: Optional[EdgeConnection] = None,
         new_output: Optional[EdgeConnection] = None,
     ) -> str | None:
-        inputs = [e.source for e in self._get_input_edges(node_id, "item")]
-        outputs = [e.destination for e in self._get_output_edges(node_id, "collection")]
+        inputs = [e.source for e in self._get_input_edges(node_id, ITEM_FIELD)]
+        outputs = [e.destination for e in self._get_output_edges(node_id, COLLECTION_FIELD)]
 
         if new_input is not None:
             inputs.append(new_input)
@@ -761,7 +768,7 @@ class Graph(BaseModel):
         # TODO: figure out if iteration nodes need to be expanded
 
         unique_edges = {(e.source.node_id, e.destination.node_id) for e in self.edges}
-        g.add_edges_from([(e[0], e[1]) for e in unique_edges])
+        g.add_edges_from(unique_edges)
         return g
 
 
@@ -802,6 +809,41 @@ class GraphExecutionState(BaseModel):
         description="The map of original graph nodes to prepared nodes",
         default_factory=dict,
     )
+    # Ready queues grouped by node class name (internal only)
+    _ready_queues: dict[str, Deque[str]] = PrivateAttr(default_factory=dict)
+    # Current class being drained; stays until its queue empties
+    _active_class: Optional[str] = PrivateAttr(default=None)
+    # Optional priority; others follow in name order
+    ready_order: list[str] = Field(default_factory=list)
+    indegree: dict[str, int] = Field(default_factory=dict, description="Remaining unmet input count for exec nodes")
+
+    def _type_key(self, node_obj: BaseInvocation) -> str:
+        return node_obj.__class__.__name__
+
+    def _queue_for(self, cls_name: str) -> Deque[str]:
+        q = self._ready_queues.get(cls_name)
+        if q is None:
+            q = deque()
+            self._ready_queues[cls_name] = q
+        return q
+
+    def set_ready_order(self, order: Iterable[Type[BaseInvocation] | str]) -> None:
+        names: list[str] = []
+        for x in order:
+            names.append(x.__name__ if hasattr(x, "__name__") else str(x))
+        self.ready_order = names
+
+    def _enqueue_if_ready(self, nid: str) -> None:
+        """Push nid to its class queue if unmet inputs == 0."""
+        # Invariants: exec node exists and has an indegree entry
+        if nid not in self.execution_graph.nodes:
+            raise KeyError(f"exec node {nid} missing from execution_graph")
+        if nid not in self.indegree:
+            raise KeyError(f"indegree missing for exec node {nid}")
+        if self.indegree[nid] != 0 or nid in self.executed:
+            return
+        node_obj = self.execution_graph.nodes[nid]
+        self._queue_for(self._type_key(node_obj)).append(nid)
 
     model_config = ConfigDict(
         json_schema_extra={
@@ -834,12 +876,14 @@ class GraphExecutionState(BaseModel):
         # If there are no prepared nodes, prepare some nodes
         next_node = self._get_next_node()
         if next_node is None:
-            prepared_id = self._prepare()
+            base_g = self.graph.nx_graph_flat()
+            prepared_id = self._prepare(base_g)
 
             # Prepare as many nodes as we can
             while prepared_id is not None:
-                prepared_id = self._prepare()
-                next_node = self._get_next_node()
+                prepared_id = self._prepare(base_g)
+                if next_node is None:
+                    next_node = self._get_next_node()
 
         # Get values from edges
         if next_node is not None:
@@ -869,6 +913,18 @@ class GraphExecutionState(BaseModel):
             self.executed.add(source_node)
             self.executed_history.append(source_node)
 
+        # Decrement children indegree and enqueue when ready
+        for e in self.execution_graph._get_output_edges(node_id):
+            child = e.destination.node_id
+            if child not in self.indegree:
+                raise KeyError(f"indegree missing for exec node {child}")
+            # Only decrement if there's something to satisfy
+            if self.indegree[child] == 0:
+                raise RuntimeError(f"indegree underflow for {child} from parent {node_id}")
+            self.indegree[child] -= 1
+            if self.indegree[child] == 0:
+                self._enqueue_if_ready(child)
+
     def set_node_error(self, node_id: str, error: str):
         """Marks a node as errored"""
         self.errors[node_id] = error
@@ -892,7 +948,7 @@ class GraphExecutionState(BaseModel):
         # If this is an iterator node, we must create a copy for each iteration
         if isinstance(node, IterateInvocation):
             # Get input collection edge (should error if there are no inputs)
-            input_collection_edge = next(iter(self.graph._get_input_edges(node_id, "collection")))
+            input_collection_edge = next(iter(self.graph._get_input_edges(node_id, COLLECTION_FIELD)))
             input_collection_prepared_node_id = next(
                 n[1] for n in iteration_node_map if n[0] == input_collection_edge.source.node_id
             )
@@ -922,7 +978,7 @@ class GraphExecutionState(BaseModel):
         # Create a new node (or one for each iteration of this iterator)
         for i in range(self_iteration_count) if self_iteration_count > 0 else [-1]:
             # Create a new node
-            new_node = copy.deepcopy(node)
+            new_node = node.model_copy(deep=True)
 
             # Create the node id (use a random uuid)
             new_node.id = uuid_string()
@@ -946,53 +1002,55 @@ class GraphExecutionState(BaseModel):
                 )
                 self.execution_graph.add_edge(new_edge)
 
+            # Initialize indegree as unmet inputs only and enqueue if ready
+            inputs = self.execution_graph._get_input_edges(new_node.id)
+            unmet = sum(1 for e in inputs if e.source.node_id not in self.executed)
+            self.indegree[new_node.id] = unmet
+            self._enqueue_if_ready(new_node.id)
+
             new_nodes.append(new_node.id)
 
         return new_nodes
 
-    def _iterator_graph(self) -> nx.DiGraph:
+    def _iterator_graph(self, base: Optional[nx.DiGraph] = None) -> nx.DiGraph:
         """Gets a DiGraph with edges to collectors removed so an ancestor search produces all active iterators for any node"""
-        g = self.graph.nx_graph_flat()
+        g = base.copy() if base is not None else self.graph.nx_graph_flat()
         collectors = (n for n in self.graph.nodes if isinstance(self.graph.get_node(n), CollectInvocation))
         for c in collectors:
             g.remove_edges_from(list(g.in_edges(c)))
         return g
 
-    def _get_node_iterators(self, node_id: str) -> list[str]:
+    def _get_node_iterators(self, node_id: str, it_graph: Optional[nx.DiGraph] = None) -> list[str]:
         """Gets iterators for a node"""
-        g = self._iterator_graph()
-        iterators = [n for n in nx.ancestors(g, node_id) if isinstance(self.graph.get_node(n), IterateInvocation)]
-        return iterators
+        g = it_graph or self._iterator_graph()
+        return [n for n in nx.ancestors(g, node_id) if isinstance(self.graph.get_node(n), IterateInvocation)]
 
-    def _prepare(self) -> Optional[str]:
+    def _prepare(self, base_g: Optional[nx.DiGraph] = None) -> Optional[str]:
         # Get flattened source graph
-        g = self.graph.nx_graph_flat()
+        g = base_g or self.graph.nx_graph_flat()
 
         # Find next node that:
         # - was not already prepared
         # - is not an iterate node whose inputs have not been executed
         # - does not have an unexecuted iterate ancestor
         sorted_nodes = nx.topological_sort(g)
+
+        def unprepared(n: str) -> bool:
+            return n not in self.source_prepared_mapping
+
+        def iter_inputs_ready(n: str) -> bool:
+            if not isinstance(self.graph.get_node(n), IterateInvocation):
+                return True
+            return all(u in self.executed for u, _ in g.in_edges(n))
+
+        def no_unexecuted_iter_ancestors(n: str) -> bool:
+            return not any(
+                isinstance(self.graph.get_node(a), IterateInvocation) and a not in self.executed
+                for a in nx.ancestors(g, n)
+            )
+
         next_node_id = next(
-            (
-                n
-                for n in sorted_nodes
-                # exclude nodes that have already been prepared
-                if n not in self.source_prepared_mapping
-                # exclude iterate nodes whose inputs have not been executed
-                and not (
-                    isinstance(self.graph.get_node(n), IterateInvocation)  # `n` is an iterate node...
-                    and not all((e[0] in self.executed for e in g.in_edges(n)))  # ...that has unexecuted inputs
-                )
-                # exclude nodes who have unexecuted iterate ancestors
-                and not any(
-                    (
-                        isinstance(self.graph.get_node(a), IterateInvocation)  # `a` is an iterate ancestor of `n`...
-                        and a not in self.executed  # ...that is not executed
-                        for a in nx.ancestors(g, n)  # for all ancestors `a` of node `n`
-                    )
-                )
-            ),
+            (n for n in sorted_nodes if unprepared(n) and iter_inputs_ready(n) and no_unexecuted_iter_ancestors(n)),
             None,
         )
 
@@ -1000,7 +1058,7 @@ class GraphExecutionState(BaseModel):
             return None
 
         # Get all parents of the next node
-        next_node_parents = [e[0] for e in g.in_edges(next_node_id)]
+        next_node_parents = [u for u, _ in g.in_edges(next_node_id)]
 
         # Create execution nodes
         next_node = self.graph.get_node(next_node_id)
@@ -1018,7 +1076,8 @@ class GraphExecutionState(BaseModel):
         else:  # Iterators or normal nodes
             # Get all iterator combinations for this node
             # Will produce a list of lists of prepared iterator nodes, from which results can be iterated
-            iterator_nodes = self._get_node_iterators(next_node_id)
+            it_g = self._iterator_graph(g)
+            iterator_nodes = self._get_node_iterators(next_node_id, it_g)
             iterator_nodes_prepared = [list(self.source_prepared_mapping[n]) for n in iterator_nodes]
             iterator_node_prepared_combinations = list(itertools.product(*iterator_nodes_prepared))
 
@@ -1066,45 +1125,41 @@ class GraphExecutionState(BaseModel):
         )
 
     def _get_next_node(self) -> Optional[BaseInvocation]:
-        """Gets the deepest node that is ready to be executed"""
-        g = self.execution_graph.nx_graph()
-
-        # Perform a topological sort using depth-first search
-        topo_order = list(nx.dfs_postorder_nodes(g))
-
-        # Get all IterateInvocation nodes
-        iterate_nodes = [n for n in topo_order if isinstance(self.execution_graph.nodes[n], IterateInvocation)]
-
-        # Sort the IterateInvocation nodes based on their index attribute
-        iterate_nodes.sort(key=lambda x: self.execution_graph.nodes[x].index)
-
-        # Prioritize IterateInvocation nodes and their children
-        for iterate_node in iterate_nodes:
-            if iterate_node not in self.executed and all((e[0] in self.executed for e in g.in_edges(iterate_node))):
-                return self.execution_graph.nodes[iterate_node]
-
-            # Check the children of the IterateInvocation node
-            for child_node in nx.dfs_postorder_nodes(g, iterate_node):
-                if child_node not in self.executed and all((e[0] in self.executed for e in g.in_edges(child_node))):
-                    return self.execution_graph.nodes[child_node]
-
-        # If no IterateInvocation node or its children are ready, return the first ready node in the topological order
-        for node in topo_order:
-            if node not in self.executed and all((e[0] in self.executed for e in g.in_edges(node))):
-                return self.execution_graph.nodes[node]
-
-        # If no node is found, return None
+        """Gets the next ready node: FIFO within class, drain class before switching."""
+        # 1) Continue draining the active class
+        if self._active_class:
+            q = self._ready_queues.get(self._active_class)
+            while q:
+                nid = q.popleft()
+                if nid not in self.executed:
+                    return self.execution_graph.nodes[nid]
+            # emptied: release active class
+            self._active_class = None
+
+        # 2) Pick next class by priority, then by class name
+        seen = set(self.ready_order)
+        for cls_name in self.ready_order:
+            q = self._ready_queues.get(cls_name)
+            if q:
+                self._active_class = cls_name
+                # recurse to drain newly set active class
+                return self._get_next_node()
+        for cls_name in sorted(k for k in self._ready_queues.keys() if k not in seen):
+            q = self._ready_queues[cls_name]
+            if q:
+                self._active_class = cls_name
+                return self._get_next_node()
         return None
 
     def _prepare_inputs(self, node: BaseInvocation):
-        input_edges = [e for e in self.execution_graph.edges if e.destination.node_id == node.id]
+        input_edges = self.execution_graph._get_input_edges(node.id)
         # Inputs must be deep-copied, else if a node mutates the object, other nodes that get the same input
         # will see the mutation.
         if isinstance(node, CollectInvocation):
             output_collection = [
                 copydeep(getattr(self.results[edge.source.node_id], edge.source.field))
                 for edge in input_edges
-                if edge.destination.field == "item"
+                if edge.destination.field == ITEM_FIELD
             ]
             node.collection = output_collection
         else:

invokeai/app/services/workflow_records/workflow_records_base.py

@@ -74,3 +74,11 @@ class WorkflowRecordsStorageBase(ABC):
     def update_opened_at(self, workflow_id: str) -> None:
         """Open a workflow."""
         pass
+
+    @abstractmethod
+    def get_all_tags(
+        self,
+        categories: Optional[list[WorkflowCategory]] = None,
+    ) -> list[str]:
+        """Gets all unique tags from workflows."""
+        pass

invokeai/app/services/workflow_records/workflow_records_sqlite.py

@@ -332,6 +332,48 @@ class SqliteWorkflowRecordsStorage(WorkflowRecordsStorageBase):
                 (workflow_id,),
             )
 
+    def get_all_tags(
+        self,
+        categories: Optional[list[WorkflowCategory]] = None,
+    ) -> list[str]:
+        with self._db.transaction() as cursor:
+            conditions: list[str] = []
+            params: list[str] = []
+
+            # Only get workflows that have tags
+            conditions.append("tags IS NOT NULL AND tags != ''")
+
+            if categories:
+                assert all(c in WorkflowCategory for c in categories)
+                placeholders = ", ".join("?" for _ in categories)
+                conditions.append(f"category IN ({placeholders})")
+                params.extend([category.value for category in categories])
+
+            stmt = """--sql
+                SELECT DISTINCT tags
+                FROM workflow_library
+                """
+
+            if conditions:
+                stmt += " WHERE " + " AND ".join(conditions)
+
+            cursor.execute(stmt, params)
+            rows = cursor.fetchall()
+
+            # Parse comma-separated tags and collect unique tags
+            all_tags: set[str] = set()
+
+            for row in rows:
+                tags_value = row[0]
+                if tags_value and isinstance(tags_value, str):
+                    # Tags are stored as comma-separated string
+                    for tag in tags_value.split(","):
+                        tag_stripped = tag.strip()
+                        if tag_stripped:
+                            all_tags.add(tag_stripped)
+
+            return sorted(all_tags)
+
     def _sync_default_workflows(self) -> None:
         """Syncs default workflows to the database. Internal use only."""
 

invokeai/app/util/step_callback.py

@@ -164,6 +164,9 @@ def diffusion_step_callback(
         latent_rgb_factors = COGVIEW4_LATENT_RGB_FACTORS
     elif base_model == BaseModelType.Flux:
         latent_rgb_factors = FLUX_LATENT_RGB_FACTORS
+    elif base_model == BaseModelType.ZImage:
+        # Z-Image uses FLUX-compatible VAE with 16 latent channels
+        latent_rgb_factors = FLUX_LATENT_RGB_FACTORS
     else:
         raise ValueError(f"Unsupported base model: {base_model}")
 

invokeai/backend/model_manager/configs/controlnet.py

@@ -88,7 +88,9 @@ class ControlNet_Diffusers_Config_Base(Diffusers_Config_Base):
 
         cls._validate_base(mod)
 
-        return cls(**override_fields)
+        repo_variant = {"repo_variant": override_fields.get("repo_variant", cls._get_repo_variant_or_raise(mod))}
+        args = override_fields | repo_variant
+        return cls(**args)
 
     @classmethod
     def _validate_base(cls, mod: ModelOnDisk) -> None:
@@ -228,3 +230,47 @@ class ControlNet_Checkpoint_SDXL_Config(ControlNet_Checkpoint_Config_Base, Confi
 
 class ControlNet_Checkpoint_FLUX_Config(ControlNet_Checkpoint_Config_Base, Config_Base):
     base: Literal[BaseModelType.Flux] = Field(default=BaseModelType.Flux)
+
+
+def _has_z_image_control_keys(state_dict: dict) -> bool:
+    """Check if state dict contains Z-Image Control specific keys."""
+    z_image_control_keys = {"control_layers", "control_all_x_embedder", "control_noise_refiner"}
+    for key in state_dict.keys():
+        if isinstance(key, str):
+            prefix = key.split(".")[0]
+            if prefix in z_image_control_keys:
+                return True
+    return False
+
+
+class ControlNet_Checkpoint_ZImage_Config(Checkpoint_Config_Base, Config_Base):
+    """Model config for Z-Image Control adapter models (Safetensors checkpoint).
+
+    Z-Image Control models are standalone adapters containing only the control layers
+    (control_layers, control_all_x_embedder, control_noise_refiner) that extend
+    the base Z-Image transformer with spatial conditioning capabilities.
+
+    Supports: Canny, HED, Depth, Pose, MLSD.
+    Recommended control_context_scale: 0.65-0.80.
+    """
+
+    type: Literal[ModelType.ControlNet] = Field(default=ModelType.ControlNet)
+    format: Literal[ModelFormat.Checkpoint] = Field(default=ModelFormat.Checkpoint)
+    base: Literal[BaseModelType.ZImage] = Field(default=BaseModelType.ZImage)
+    default_settings: ControlAdapterDefaultSettings | None = Field(None)
+
+    @classmethod
+    def from_model_on_disk(cls, mod: ModelOnDisk, override_fields: dict[str, Any]) -> Self:
+        raise_if_not_file(mod)
+
+        raise_for_override_fields(cls, override_fields)
+
+        cls._validate_looks_like_z_image_control(mod)
+
+        return cls(**override_fields)
+
+    @classmethod
+    def _validate_looks_like_z_image_control(cls, mod: ModelOnDisk) -> None:
+        state_dict = mod.load_state_dict()
+        if not _has_z_image_control_keys(state_dict):
+            raise NotAMatchError("state dict does not look like a Z-Image Control model")

invokeai/backend/model_manager/configs/factory.py

@@ -20,6 +20,7 @@ from invokeai.backend.model_manager.configs.controlnet import (
     ControlNet_Checkpoint_SD1_Config,
     ControlNet_Checkpoint_SD2_Config,
     ControlNet_Checkpoint_SDXL_Config,
+    ControlNet_Checkpoint_ZImage_Config,
     ControlNet_Diffusers_FLUX_Config,
     ControlNet_Diffusers_SD1_Config,
     ControlNet_Diffusers_SD2_Config,
@@ -43,10 +44,12 @@ from invokeai.backend.model_manager.configs.lora import (
     LoRA_Diffusers_SD1_Config,
     LoRA_Diffusers_SD2_Config,
     LoRA_Diffusers_SDXL_Config,
+    LoRA_Diffusers_ZImage_Config,
     LoRA_LyCORIS_FLUX_Config,
     LoRA_LyCORIS_SD1_Config,
     LoRA_LyCORIS_SD2_Config,
     LoRA_LyCORIS_SDXL_Config,
+    LoRA_LyCORIS_ZImage_Config,
     LoRA_OMI_FLUX_Config,
     LoRA_OMI_SDXL_Config,
     LoraModelDefaultSettings,
@@ -58,15 +61,23 @@ from invokeai.backend.model_manager.configs.main import (
     Main_Checkpoint_SD2_Config,
     Main_Checkpoint_SDXL_Config,
     Main_Checkpoint_SDXLRefiner_Config,
+    Main_Checkpoint_ZImage_Config,
     Main_Diffusers_CogView4_Config,
     Main_Diffusers_SD1_Config,
     Main_Diffusers_SD2_Config,
     Main_Diffusers_SD3_Config,
     Main_Diffusers_SDXL_Config,
     Main_Diffusers_SDXLRefiner_Config,
+    Main_Diffusers_ZImage_Config,
     Main_GGUF_FLUX_Config,
+    Main_GGUF_ZImage_Config,
     MainModelDefaultSettings,
 )
+from invokeai.backend.model_manager.configs.qwen3_encoder import (
+    Qwen3Encoder_Checkpoint_Config,
+    Qwen3Encoder_GGUF_Config,
+    Qwen3Encoder_Qwen3Encoder_Config,
+)
 from invokeai.backend.model_manager.configs.siglip import SigLIP_Diffusers_Config
 from invokeai.backend.model_manager.configs.spandrel import Spandrel_Checkpoint_Config
 from invokeai.backend.model_manager.configs.t2i_adapter import (
@@ -138,15 +149,18 @@ AnyModelConfig = Annotated[
         Annotated[Main_Diffusers_SDXLRefiner_Config, Main_Diffusers_SDXLRefiner_Config.get_tag()],
         Annotated[Main_Diffusers_SD3_Config, Main_Diffusers_SD3_Config.get_tag()],
         Annotated[Main_Diffusers_CogView4_Config, Main_Diffusers_CogView4_Config.get_tag()],
+        Annotated[Main_Diffusers_ZImage_Config, Main_Diffusers_ZImage_Config.get_tag()],
         # Main (Pipeline) - checkpoint format
         Annotated[Main_Checkpoint_SD1_Config, Main_Checkpoint_SD1_Config.get_tag()],
         Annotated[Main_Checkpoint_SD2_Config, Main_Checkpoint_SD2_Config.get_tag()],
         Annotated[Main_Checkpoint_SDXL_Config, Main_Checkpoint_SDXL_Config.get_tag()],
         Annotated[Main_Checkpoint_SDXLRefiner_Config, Main_Checkpoint_SDXLRefiner_Config.get_tag()],
         Annotated[Main_Checkpoint_FLUX_Config, Main_Checkpoint_FLUX_Config.get_tag()],
+        Annotated[Main_Checkpoint_ZImage_Config, Main_Checkpoint_ZImage_Config.get_tag()],
         # Main (Pipeline) - quantized formats
         Annotated[Main_BnBNF4_FLUX_Config, Main_BnBNF4_FLUX_Config.get_tag()],
         Annotated[Main_GGUF_FLUX_Config, Main_GGUF_FLUX_Config.get_tag()],
+        Annotated[Main_GGUF_ZImage_Config, Main_GGUF_ZImage_Config.get_tag()],
         # VAE - checkpoint format
         Annotated[VAE_Checkpoint_SD1_Config, VAE_Checkpoint_SD1_Config.get_tag()],
         Annotated[VAE_Checkpoint_SD2_Config, VAE_Checkpoint_SD2_Config.get_tag()],
@@ -160,6 +174,7 @@ AnyModelConfig = Annotated[
         Annotated[ControlNet_Checkpoint_SD2_Config, ControlNet_Checkpoint_SD2_Config.get_tag()],
         Annotated[ControlNet_Checkpoint_SDXL_Config, ControlNet_Checkpoint_SDXL_Config.get_tag()],
         Annotated[ControlNet_Checkpoint_FLUX_Config, ControlNet_Checkpoint_FLUX_Config.get_tag()],
+        Annotated[ControlNet_Checkpoint_ZImage_Config, ControlNet_Checkpoint_ZImage_Config.get_tag()],
         # ControlNet - diffusers format
         Annotated[ControlNet_Diffusers_SD1_Config, ControlNet_Diffusers_SD1_Config.get_tag()],
         Annotated[ControlNet_Diffusers_SD2_Config, ControlNet_Diffusers_SD2_Config.get_tag()],
@@ -170,6 +185,7 @@ AnyModelConfig = Annotated[
         Annotated[LoRA_LyCORIS_SD2_Config, LoRA_LyCORIS_SD2_Config.get_tag()],
         Annotated[LoRA_LyCORIS_SDXL_Config, LoRA_LyCORIS_SDXL_Config.get_tag()],
         Annotated[LoRA_LyCORIS_FLUX_Config, LoRA_LyCORIS_FLUX_Config.get_tag()],
+        Annotated[LoRA_LyCORIS_ZImage_Config, LoRA_LyCORIS_ZImage_Config.get_tag()],
         # LoRA - OMI format
         Annotated[LoRA_OMI_SDXL_Config, LoRA_OMI_SDXL_Config.get_tag()],
         Annotated[LoRA_OMI_FLUX_Config, LoRA_OMI_FLUX_Config.get_tag()],
@@ -178,11 +194,16 @@ AnyModelConfig = Annotated[
         Annotated[LoRA_Diffusers_SD2_Config, LoRA_Diffusers_SD2_Config.get_tag()],
         Annotated[LoRA_Diffusers_SDXL_Config, LoRA_Diffusers_SDXL_Config.get_tag()],
         Annotated[LoRA_Diffusers_FLUX_Config, LoRA_Diffusers_FLUX_Config.get_tag()],
+        Annotated[LoRA_Diffusers_ZImage_Config, LoRA_Diffusers_ZImage_Config.get_tag()],
         # ControlLoRA - diffusers format
         Annotated[ControlLoRA_LyCORIS_FLUX_Config, ControlLoRA_LyCORIS_FLUX_Config.get_tag()],
         # T5 Encoder - all formats
         Annotated[T5Encoder_T5Encoder_Config, T5Encoder_T5Encoder_Config.get_tag()],
         Annotated[T5Encoder_BnBLLMint8_Config, T5Encoder_BnBLLMint8_Config.get_tag()],
+        # Qwen3 Encoder
+        Annotated[Qwen3Encoder_Qwen3Encoder_Config, Qwen3Encoder_Qwen3Encoder_Config.get_tag()],
+        Annotated[Qwen3Encoder_Checkpoint_Config, Qwen3Encoder_Checkpoint_Config.get_tag()],
+        Annotated[Qwen3Encoder_GGUF_Config, Qwen3Encoder_GGUF_Config.get_tag()],
         # TI - file format
         Annotated[TI_File_SD1_Config, TI_File_SD1_Config.get_tag()],
         Annotated[TI_File_SD2_Config, TI_File_SD2_Config.get_tag()],
@@ -333,7 +354,11 @@ class ModelConfigFactory:
             # For directories, do a quick file count check with early exit
             total_files = 0
             # Ignore hidden files and directories
-            paths_to_check = (p for p in path.rglob("*") if not p.name.startswith("."))
+            paths_to_check = (
+                p
+                for p in path.rglob("*")
+                if not p.name.startswith(".") and not any(part.startswith(".") for part in p.parts)
+            )
             for item in paths_to_check:
                 if item.is_file():
                     total_files += 1