pygpt-net 2.6.60__py3-none-any.whl → 2.6.61__py3-none-any.whl

pygpt_net/CHANGELOG.txt

@@ -1,3 +1,10 @@
+2.6.61 (2025-09-26)
+
+- Enhanced the agents node editor, custom agent flow, and instruction following.
+- Added drag-and-drop and reordering functionality to the presets list.
+- Added statistics for response tokens, including time elapsed and tokens per second.
+- Improved UI/UX.
+
 2.6.60 (2025-09-25)
 
 - Added a new tool: Agents Builder - allowing visual design of agent workflows using nodes - available in Tools -> Agents Builder (beta).

pygpt_net/__init__.py

@@ -6,15 +6,15 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.25 00:00:00                  #
+# Updated Date: 2025.09.26 00:00:00                  #
 # ================================================== #
 
 __author__ = "Marcin Szczygliński"
 __copyright__ = "Copyright 2025, Marcin Szczygliński"
 __credits__ = ["Marcin Szczygliński"]
 __license__ = "MIT"
-__version__ = "2.6.60"
-__build__ = "2025-09-25"
+__version__ = "2.6.61"
+__build__ = "2025-09-26"
 __maintainer__ = "Marcin Szczygliński"
 __github__ = "https://github.com/szczyglis-dev/py-gpt"
 __report__ = "https://github.com/szczyglis-dev/py-gpt/issues"

pygpt_net/controller/chat/common.py

@@ -6,10 +6,12 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.01 23:00:00                  #
+# Updated Date: 2025.09.25 12:00:00                  #
 # ================================================== #
 
 import os
+from time import perf_counter
+from typing import Callable, Optional
 
 from PySide6.QtGui import QTextCursor
 from PySide6.QtWidgets import QFileDialog, QApplication
@@ -18,7 +20,7 @@ from pygpt_net.core.events import Event, AppEvent, RenderEvent, KernelEvent
 from pygpt_net.core.types import MODE_ASSISTANT, MODE_AUDIO
 from pygpt_net.item.ctx import CtxItem
 from pygpt_net.item.model import ModelItem
-from pygpt_net.utils import trans
+from pygpt_net.utils import trans, short_num
 
 
 class Common:
@@ -30,6 +32,12 @@ class Common:
         """
         self.window = window
         self.initialized = False
+        # Counter (seconds, float) – current/last measured time
+        self.counter: float = 0.0
+        # Private start timestamp
+        self._t0: Optional[float] = None
+        # Optional number-shortening function (e.g., 10000 -> "10k"); if None, a fallback is used
+        self._shortener = None
 
     def setup(self):
         """Set up UI"""
@@ -310,6 +318,7 @@ class Common:
             dispatch(AppEvent(AppEvent.INPUT_STOPPED))  # app event
 
         self.stop_client()  # stop clients
+        self.reset_counter()
 
     def stop_client(self):
         """Stop all clients"""
@@ -457,15 +466,115 @@ class Common:
                 f.write(str(text).strip())
             self.window.update_status(f"{trans('status.saved')}: {os.path.basename(file_name)}")
 
+    # --- Timer control ---
+
+    def start_counter(self) -> None:
+        """Start the timer – call when send the request."""
+        self._t0 = perf_counter()
+
+    def stop_counter(self) -> float:
+        """
+        Stop the timer. Returns elapsed seconds and stores it in self.counter.
+        """
+        if self._t0 is None:
+            raise RuntimeError("Timer was not started (start_counter()).")
+        self.counter = perf_counter() - self._t0
+        self._t0 = None
+        return self.counter
+
+    def get_counter(self) -> float:
+        """
+        Current elapsed time (if running) or last measured time (in seconds).
+        """
+        if self._t0 is not None:
+            return perf_counter() - self._t0
+        return self.counter
+
+    def reset_counter(self) -> None:
+        """Reset the timer."""
+        self._t0 = None
+        self.counter = 0.0
+
+    # --- Calculation and formatting ---
+
+    def tokens_per_second(self, tokens_generated: int, seconds: Optional[float] = None) -> float:
+        """
+        Average tokens/s for the given token count and time (defaults to current/last).
+        """
+        sec = self.get_counter() if seconds is None else max(float(seconds), 0.0)
+        if sec <= 0.0:
+            return 0.0
+        return float(tokens_generated) / sec
+
+    def format_duration(self, seconds: Optional[float] = None, max_units: int = 2) -> str:
+        """
+        Pretty duration: e.g., 800ms, 12s, 1m 12s, 3h 5m, 1d 2h (by default up to 2 units).
+        """
+        sec = self.get_counter() if seconds is None else max(float(seconds), 0.0)
+
+        if sec < 1.0:
+            return f"{int(round(sec * 1000)):d}ms"
+
+        total = int(sec)  # floor to whole seconds
+        days, rem = divmod(total, 86400)
+        hours, rem = divmod(rem, 3600)
+        minutes, seconds = divmod(rem, 60)
+
+        parts = []
+        if days:
+            parts.append(f"{days}d")
+        if hours:
+            parts.append(f"{hours}h")
+        if minutes:
+            parts.append(f"{minutes}m")
+        if seconds or not parts:
+            parts.append(f"{seconds}s")
+
+        return " ".join(parts[:max_units])
+
+    def _fallback_shorten(self, value: float) -> str:
+        """
+        Simple fallback shortener (e.g., 15300 -> '15.3k').
+        """
+        n = abs(value)
+        sign = "-" if value < 0 else ""
+        if n < 1_000:
+            return f"{sign}{int(round(n))}"
+        elif n < 1_000_000:
+            v = n / 1_000
+            s = f"{v:.1f}".rstrip("0").rstrip(".")
+            return f"{sign}{s}k"
+        elif n < 1_000_000_000:
+            v = n / 1_000_000
+            s = f"{v:.1f}".rstrip("0").rstrip(".")
+            return f"{sign}{s}M"
+        else:
+            v = n / 1_000_000_000
+            s = f"{v:.1f}".rstrip("0").rstrip(".")
+            return f"{sign}{s}B"
+
+    def format_stats(self, tokens_generated: int) -> str:
+        """
+        Returns a string in the format: "<X> tokens/s - <duration>", e.g., "15k tokens/s - 1m 12s".
+        """
+        tps = self.tokens_per_second(tokens_generated)
+        if self._shortener:
+            tps_str = self._shortener(tps if isinstance(tps, (int, float)) else float(tps))
+        else:
+            tps_str = self._fallback_shorten(tps)
+        duration = self.format_duration()
+        return f"{tps_str} tokens/s - {duration}"
+
     def show_response_tokens(self, ctx: CtxItem):
         """
         Update response tokens
 
         :param ctx: CtxItem
         """
-        extra_data = ""
-        if ctx.is_vision:
-            extra_data = " (VISION)"
+        stats = ""
+        if ctx.output_tokens > 0 and self.get_counter() > 0:
+            stats = f" | {self.format_stats(ctx.output_tokens)}"
+        self.reset_counter()
         self.window.update_status(
-            f"{trans('status.tokens')}: {ctx.input_tokens} + {ctx.output_tokens} = {ctx.total_tokens}{extra_data}"
+            f"{trans('status.tokens')}: {short_num(ctx.input_tokens)} + {short_num(ctx.output_tokens)} = {short_num(ctx.total_tokens)}{stats}"
         )

pygpt_net/controller/chat/input.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.23 15:00:00                  #
+# Updated Date: 2025.09.25 12:00:00                  #
 # ================================================== #
 
 from typing import Optional, Any, Dict
@@ -206,6 +206,9 @@ class Input:
             'mode': mode,
         }))
 
+        # start timer
+        self.window.controller.chat.common.start_counter()
+
         # send input to API
         if mode == MODE_IMAGE:
             controller.chat.image.send(

pygpt_net/controller/presets/presets.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.05 18:00:00                  #
+# Updated Date: 2025.09.26 03:00:00                  #
 # ================================================== #
 
 import re
@@ -24,12 +24,14 @@ from pygpt_net.core.types import (
     MODE_AGENT_OPENAI,
 )
 from pygpt_net.controller.presets.editor import Editor
+    # Editor controller
 from pygpt_net.core.events import AppEvent
 from pygpt_net.item.preset import PresetItem
 from pygpt_net.utils import trans
 
 
 _FILENAME_SANITIZE_RE = re.compile(r'[^a-zA-Z0-9_\-\.]')
+# keep original validation (do not break other parts)
 _VALIDATE_FILENAME_RE = re.compile(r'[^\w\s\-\.]')
 
 
@@ -76,7 +78,7 @@ class Presets:
 
     def select(self, idx: int):
         """
-        Select preset
+        Select preset by list index (legacy)
 
         :param idx: value of the list (row idx)
         """
@@ -94,6 +96,32 @@ class Presets:
         if editor_ctrl.opened and editor_ctrl.current != preset_id:
             self.editor.init(preset_id)
 
+    def select_by_id(self, preset_id: str):
+        """
+        Select preset by explicit ID (robust for DnD-ordered views).
+        """
+        if self.preset_change_locked():
+            return
+        if not preset_id:
+            return
+        w = self.window
+        mode = w.core.config.get('mode')
+        if not w.core.presets.has(mode, preset_id):
+            return
+        w.core.config.set("preset", preset_id)
+        if 'current_preset' not in w.core.config.data:
+            w.core.config.data['current_preset'] = {}
+        w.core.config.data['current_preset'][mode] = preset_id
+        self.select_model()
+        w.controller.ui.update()
+        w.controller.model.select_current()
+        w.dispatch(AppEvent(AppEvent.PRESET_SELECTED))
+        idx = w.core.presets.get_idx_by_id(mode, preset_id)
+        self.set_selected(idx)
+        editor_ctrl = w.controller.presets.editor
+        if editor_ctrl.opened and editor_ctrl.current != preset_id:
+            self.editor.init(preset_id)
+
     def get_current(self) -> Optional[PresetItem]:
         """
         Get current preset
@@ -584,6 +612,43 @@ class Presets:
         if mode == MODE_ASSISTANT:
             w.core.assistants.load()
 
+    def _nearest_id_after_delete(self, mode: str, idx: Optional[int], deleting_id: Optional[str]) -> Optional[str]:
+        """
+        Compute the nearest neighbor to select after deletion:
+        - Prefer the next item (below) if exists;
+        - Otherwise choose the previous one (above);
+        - Returns None when no neighbor can be determined.
+        This uses the current view order for the given mode, including pinned current.<mode> at index 0.
+        """
+        try:
+            w = self.window
+            data = w.core.presets.get_by_mode(mode) or {}
+            ids = list(data.keys())
+            if not ids:
+                return None
+
+            # If idx is invalid, try to resolve from deleting_id
+            if idx is None or idx < 0 or idx >= len(ids):
+                if deleting_id and deleting_id in ids:
+                    idx = ids.index(deleting_id)
+                else:
+                    return None
+
+            # Prefer below
+            if idx + 1 < len(ids):
+                cand = ids[idx + 1]
+                if cand and cand != deleting_id:
+                    return cand
+
+            # Otherwise above
+            if idx - 1 >= 0:
+                cand = ids[idx - 1]
+                if cand and cand != deleting_id:
+                    return cand
+        except Exception:
+            pass
+        return None
+
     def delete(
             self,
             idx: Optional[int] = None,
@@ -607,10 +672,31 @@ class Presets:
                         msg=trans('confirm.preset.delete'),
                     )
                     return
-                if preset_id == w.core.config.get('preset'):
-                    w.core.config.set('preset', None)
-                    w.ui.nodes['preset.prompt'].setPlainText("")
+
+                # Determine neighbor only if the deleted preset is currently active.
+                # This keeps API semantics untouched and prevents unexpected selection changes.
+                is_current = (preset_id == w.core.config.get('preset'))
+                target_id = None
+                if is_current:
+                    target_id = self._nearest_id_after_delete(mode, idx, preset_id)
+
+                # Remove from core (also removes file when True)
                 w.core.presets.remove(preset_id, True)
+
+                # When removing the active preset, jump to the nearest neighbor (below or above).
+                # If no neighbor can be determined, fall back to previous behavior (clear and let defaults apply).
+                if is_current:
+                    if target_id and target_id in w.core.presets.items:
+                        # Persist new selection in config (and keep current_preset mapping coherent)
+                        w.core.config.set('preset', target_id)
+                        if 'current_preset' not in w.core.config.data:
+                            w.core.config.data['current_preset'] = {}
+                        w.core.config.data['current_preset'][mode] = target_id
+                    else:
+                        # Fallback: clear selection to allow select_default() to pick the first available
+                        w.core.config.set('preset', None)
+                        w.ui.nodes['preset.prompt'].setPlainText("")
+
                 self.refresh(no_scroll=True)
                 w.update_status(trans('status.preset.deleted'))
 
@@ -715,4 +801,33 @@ class Presets:
 
     def clear_selected(self):
         """Clear selected list"""
-        self.selected = []
+        self.selected = []
+
+    # ----------------------------
+    # Drag & drop ordering helpers
+    # ----------------------------
+
+    def persist_order_for_mode(self, mode: str, uuids: List[str]):
+        """
+        Persist new order (by UUIDs) for given mode.
+
+        The special '*' preset (current.<mode>) is not included here and always pinned at index 0.
+        """
+        w = self.window
+        cfg = w.core.config
+        order = cfg.get('presets_order') or {}
+        # Normalize to lists
+        if isinstance(order.get(mode), dict):
+            mapped = order.get(mode)
+            order[mode] = [mapped[k] for k in sorted(mapped.keys(), key=lambda x: int(x))]
+        order[mode] = [u for u in uuids if u]
+        cfg.set('presets_order', order)
+
+    def dnd_enabled(self) -> bool:
+        """
+        Check if drag and drop is globally enabled in config.
+        """
+        try:
+            return bool(self.window.core.config.get('presets.drag_and_drop.enabled'))
+        except Exception:
+            return False

pygpt_net/controller/settings/editor.py

@@ -51,11 +51,9 @@ class Editor:
         self.window.ui.add_hook("update.config.font_size.ctx", self.hook_update)
         self.window.ui.add_hook("update.config.font_size.toolbox", self.hook_update)
         self.window.ui.add_hook("update.config.zoom", self.hook_update)
-        self.window.ui.add_hook("update.config.theme.markdown", self.hook_update)
         self.window.ui.add_hook("update.config.vision.capture.enabled", self.hook_update)
         self.window.ui.add_hook("update.config.vision.capture.auto", self.hook_update)
         self.window.ui.add_hook("update.config.ctx.records.limit", self.hook_update)
-        self.window.ui.add_hook("update.config.ctx.convert_lists", self.hook_update)
         self.window.ui.add_hook("update.config.ctx.records.separators", self.hook_update)
         self.window.ui.add_hook("update.config.ctx.records.groups.separators", self.hook_update)
         self.window.ui.add_hook("update.config.ctx.records.pinned.separators", self.hook_update)
@@ -176,10 +174,6 @@ class Editor:
             value = self.window.core.config.get('theme.style')
             self.window.controller.theme.toggle_style(value)
 
-        # convert lists
-        if self.config_changed('ctx.convert_lists'):
-            self.window.controller.ctx.refresh()
-
         # access: voice control
         if self.config_changed('access.voice_control'):
             self.window.controller.access.voice.update()
@@ -266,19 +260,10 @@ class Editor:
             self.window.core.config.set(key, value)
             self.window.controller.ui.update_font_size()
 
-        # update markdown
-        elif key == "theme.markdown":
-            self.window.core.config.set(key, value)
-            self.window.controller.theme.markdown.update(force=True)
-
         elif key == "render.code_syntax":
             self.window.core.config.set(key, value)
             self.window.controller.theme.toggle_syntax(value, update_menu=True)
 
-        elif key == "ctx.convert_lists":
-            self.window.core.config.set(key, value)
-            self.window.controller.ctx.refresh()
-
         elif key == "ctx.records.separators":
             self.window.core.config.set(key, value)
             self.window.controller.ctx.update()

pygpt_net/controller/theme/markdown.py

@@ -33,11 +33,8 @@ class Markdown:
         """
         if force:
             self.window.controller.ui.store_state()  # store state before theme change
-
-        if self.window.core.config.get('theme.markdown'):
-            self.load()
-        else:
-            self.set_default()
+        
+        self.load()
         self.apply()
 
         if force:

pygpt_net/controller/ui/ui.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.08.23 15:00:00                  #
+# Updated Date: 2025.09.25 12:00:00                  #
 # ================================================== #
 
 from typing import Optional
@@ -15,7 +15,7 @@ from PySide6.QtGui import QColor
 
 from pygpt_net.core.types import MODE_IMAGE
 from pygpt_net.core.events import BaseEvent, Event
-from pygpt_net.utils import trans
+from pygpt_net.utils import trans, short_num
 
 from .mode import Mode
 from .tabs import Tabs
@@ -156,15 +156,12 @@ class UI:
         attachments_tokens = self.window.controller.chat.attachment.get_current_tokens()
         sum_tokens += attachments_tokens
 
-        ctx_string = f"{ctx_len} / {ctx_len_all} - {ctx_tokens} {trans('ctx.tokens')}"
+        ctx_string = f"{short_num(ctx_len)} / {short_num(ctx_len_all)} - {short_num(ctx_tokens)} {trans('ctx.tokens')}"
         if ctx_string != self._last_ctx_string:
             ui_nodes['prompt.context'].setText(ctx_string)
             self._last_ctx_string = ctx_string
 
-        parsed_sum = self.format_tokens(sum_tokens)
-        parsed_max_current = self.format_tokens(max_current)
-
-        input_string = f"{input_tokens} + {system_tokens} + {ctx_tokens} + {extra_tokens} + {attachments_tokens} = {parsed_sum} / {parsed_max_current}"
+        input_string = f"{short_num(input_tokens)} + {short_num(system_tokens)} + {short_num(ctx_tokens)} + {short_num(extra_tokens)} + {short_num(attachments_tokens)} = {short_num(sum_tokens)} / {short_num(max_current)}"
         if input_string != self._last_input_string:
             ui_nodes['input.counter'].setText(input_string)
             self._last_input_string = input_string

pygpt_net/core/agents/custom/__init__.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.24 23:00:00                  #
+# Updated Date: 2025.09.25 14:00:00                  #
 # ================================================== #
 
 import copy
@@ -182,6 +182,12 @@ class Custom:
                             slots = node["slots"]
                             if "name" in slots and slots["name"]:
                                 tab["label"] = slots["name"]
+                            if "role" in slots:
+                                opts["role"] = {
+                                    "type": "str",
+                                    "label": trans("agent.option.role"),
+                                    "default": slots["role"],
+                                }
                             if "instruction" in slots:
                                 opts["prompt"] = {
                                     "type": "textarea",

pygpt_net/core/agents/custom/llama_index/factory.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.24 23:00:00                  #
+# Updated Date: 2025.09.25 14:00:00                  #
 # ================================================== #
 
 from __future__ import annotations
@@ -32,7 +32,6 @@ class BuiltAgentLI:
 class AgentFactoryLI:
     """
     Build LlamaIndex ReActAgent/FunctionAgent from AgentNode + NodeRuntime and explicit LLM/tools.
-    Best practice: chat_history/max_iterations przekazujemy do konstruktora agenta.
     """
     def __init__(self, window, logger) -> None:
         self.window = window
@@ -45,7 +44,7 @@ class AgentFactoryLI:
         node_runtime: NodeRuntime,
         llm: Any,                 # LLM instance (z appki lub resolve_llm)
         tools: List[Any],         # BaseTool list
-        friendly_map: Dict[str, str],
+        friendly_map: Dict[str, Any],
         force_router: bool = False,
         chat_history: List[Any] = None,
         max_iterations: int = 10,
@@ -62,23 +61,35 @@ class AgentFactoryLI:
 
         node_tools = tools if (node_runtime.allow_local_tools or node_runtime.allow_remote_tools) else []
 
+        # Prefer FunctionAgent if the underlying LLM supports function-calling (recommended by LI).
+        # This yields more direct compliance with system_prompt for simple single-output tasks.
+        is_fc_model = False
+        try:
+            is_fc_model = bool(getattr(getattr(llm, "metadata", None), "is_function_calling_model", False))
+        except Exception:
+            is_fc_model = False
+
         if multi_output:
-            agent_cls = FunctionAgent  # routers behave better with FunctionAgent (JSON compliance)
+            agent_cls = FunctionAgent  # routers: keep JSON compliance
         else:
-            agent_cls = FunctionAgent if node_tools else ReActAgent
+            agent_cls = FunctionAgent if is_fc_model else ReActAgent
+
         kwargs: Dict[str, Any] = {
             "name": agent_name,
             "system_prompt": instr,
             "llm": llm,
             "chat_history": chat_history or [],
             "max_iterations": int(max_iterations),
+            # Provide a short description to reinforce the agent's purpose (if role present).
+            "description": (node_runtime.role or agent_name),
         }
         if node_tools:
             kwargs["tools"] = coerce_li_tools(node_tools)
 
         instance = agent_cls(**kwargs)
         self.logger.debug(
-            f"[li] Built agent {node.id} ({agent_name}), multi_output={multi_output}, routes={allowed_routes}"
+            f"[li] Built agent {node.id} ({agent_name}), multi_output={multi_output}, "
+            f"routes={allowed_routes}, agent_cls={agent_cls.__name__}"
         )
         return BuiltAgentLI(
             instance=instance,

pygpt_net/core/agents/custom/llama_index/runner.py

@@ -6,7 +6,7 @@
 # GitHub:  https://github.com/szczyglis-dev/py-gpt   #
 # MIT License                                        #
 # Created By  : Marcin Szczygliński                  #
-# Updated Date: 2025.09.24 23:00:00                  #
+# Updated Date: 2025.09.25 14:00:00                  #
 # ================================================== #
 
 from __future__ import annotations
@@ -210,6 +210,34 @@ class DynamicFlowWorkflowLI(Workflow):
     def _friendly_map(self) -> Dict[str, str]:
         return {aid: a.name or aid for aid, a in self.fs.agents.items()}
 
+    def _friendly_map_for_routes(self, route_ids: List[str]) -> Dict[str, Any]:
+        """
+        Build a friendly map for the given route ids:
+        - Always include a human-friendly name.
+        - Include role only if provided in preset options or schema and non-empty.
+        """
+        out: Dict[str, Any] = {}
+        for rid in route_ids or []:
+            a = self.fs.agents.get(rid)
+            name = (a.name if a and a.name else rid)
+            # Prefer preset option, then schema role
+            role_opt = None
+            try:
+                role_opt = self.option_get(rid, "role", None)
+            except Exception:
+                role_opt = None
+            role_schema = getattr(a, "role", None) if a is not None else None
+            role_val = None
+            if isinstance(role_opt, str) and role_opt.strip():
+                role_val = role_opt.strip()
+            elif isinstance(role_schema, str) and role_schema.strip():
+                role_val = role_schema.strip()
+            item = {"name": name}
+            if role_val:
+                item["role"] = role_val
+            out[rid] = item
+        return out
+
     async def _emit(self, ctx: Context, ev: Any):
         if self.dbg.event_echo:
             self.logger.debug(f"[event] emit {ev.__class__.__name__}")
@@ -412,6 +440,7 @@ class DynamicFlowWorkflowLI(Workflow):
                 f"[runtime] model={getattr(node_rt.model,'name',str(node_rt.model))} "
                 f"allow_local={node_rt.allow_local_tools} allow_remote={node_rt.allow_remote_tools} "
                 f"instructions='{ellipsize(node_rt.instructions, self.dbg.preview_chars)}'"
+                f" role='{ellipsize(node_rt.role or '', self.dbg.preview_chars)}'"
             )
 
         llm_node = resolve_llm(self.window, node_rt.model, self.llm_base, self.stream)
@@ -430,13 +459,17 @@ class DynamicFlowWorkflowLI(Workflow):
                 f"user='{ellipsize(user_msg_text, self.dbg.preview_chars)}'"
             )
 
+        # Prepare friendly map with optional roles for this node's allowed routes
+        allowed_routes_now = list(node.outputs or [])
+        friendly_map = self._friendly_map_for_routes(allowed_routes_now)
+
         # Build agent (chat_history/max_iterations in ctor – best practice)
         built = self.factory.build(
             node=node,
             node_runtime=node_rt,
             llm=llm_node,
             tools=tools_node,
-            friendly_map=self._friendly_map(),
+            friendly_map=friendly_map,
             chat_history=chat_history_msgs,
             max_iterations=self.max_iterations,
         )