PraisonAI 4.6.139__tar.gz → 4.6.141__tar.gz

{praisonai-4.6.139 → praisonai-4.6.141}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.139
+Version: 4.6.141
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,9 +11,9 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.6.142
-Requires-Dist: praisonai-code>=0.0.38
-Requires-Dist: praisonai-bot>=0.0.23
+Requires-Dist: praisonaiagents>=1.6.144
+Requires-Dist: praisonai-code>=0.0.40
+Requires-Dist: praisonai-bot>=0.0.25
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.139 → praisonai-4.6.141}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.139
+Version: 4.6.141
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,9 +11,9 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.6.142
-Requires-Dist: praisonai-code>=0.0.38
-Requires-Dist: praisonai-bot>=0.0.23
+Requires-Dist: praisonaiagents>=1.6.144
+Requires-Dist: praisonai-code>=0.0.40
+Requires-Dist: praisonai-bot>=0.0.25
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.139 → praisonai-4.6.141}/PraisonAI.egg-info/requires.txt

@@ -1,9 +1,9 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.142
-praisonai-code>=0.0.38
-praisonai-bot>=0.0.23
+praisonaiagents>=1.6.144
+praisonai-code>=0.0.40
+praisonai-bot>=0.0.25
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.6.139 → praisonai-4.6.141}/praisonai/cli/commands/app.py

@@ -137,3 +137,10 @@ def _load_agents_from_config(config_path: str, console) -> list:
             console.print(f"[yellow]Warning: Could not load agents from config: {e}[/yellow]")
     
     return agents
+
+
+# Expose the command under the name the praisonai-code lazy loader looks up
+# via getattr(module, "app"), so the wrapper owns the `app` command when
+# installed (C8.2). Without this alias the loader raises AttributeError and
+# silently falls back to the inline duplicate in praisonai-code.
+app = app_command

{praisonai-4.6.139 → praisonai-4.6.141}/praisonai/cli/commands/knowledge.py

@@ -326,7 +326,19 @@ def knowledge_search(
                     user_id=user_id, agent_id=agent_id, run_id=run_id,
                 )
             
-            if not results:
+            # Normalize search results to a list of dicts.
+            # Knowledge.search() may return a typed SearchResult dataclass,
+            # a legacy dict with a "results" key, or a plain list.
+            if hasattr(results, "to_legacy_format"):
+                result_list = results.to_legacy_format().get("results", [])
+            elif isinstance(results, dict):
+                result_list = results.get("results", [])
+            elif isinstance(results, list):
+                result_list = results
+            else:
+                result_list = []
+            
+            if not result_list:
                 console.print("[yellow]No results found.[/yellow]")
                 return
             
@@ -337,7 +349,6 @@ def knowledge_search(
             table.add_column("Source", width=20)
             table.add_column("Content", width=60)
             
-            result_list = results.get('results', results) if isinstance(results, dict) else results
             for i, result in enumerate(result_list[:top_k], 1):
                 if isinstance(result, dict):
                     score = f"{result.get('score', 0):.3f}" if result.get('score') else "-"

{praisonai-4.6.139 → praisonai-4.6.141}/praisonai/cli/interactive/async_tui.py

@@ -30,6 +30,9 @@ from datetime import datetime
 logger = logging.getLogger(__name__)
 _debug_initialized = False
 
+# Sentinel marking a failed registry build so it is not retried every command.
+_REGISTRY_FAILED = object()
+
 def _init_debug_logging():
     """Initialize debug logging to file. Only called when debug mode is enabled."""
     global _debug_initialized
@@ -208,6 +211,7 @@ class AsyncTUI:
         self._workspace_files: List[str] = []  # Files in workspace for @ completion
         self._runtime = None  # InteractiveRuntime for ACP/LSP
         self._runtime_started = False
+        self._registry = None  # Unified command registry (lazy)
         
         # Terminal size
         self.term_width, self.term_height = shutil.get_terminal_size((80, 24))
@@ -482,6 +486,56 @@ class AsyncTUI:
         if self._app:
             self._app.invalidate()
     
+    # Built-in slash commands registered into the unified registry so /help
+    # and autocomplete stay in lock-step with the dispatch branches below.
+    _BUILTIN_COMMANDS = {
+        "help": "Show this help",
+        "exit": "Exit Praison AI",
+        "quit": "Exit Praison AI",
+        "clear": "Clear conversation",
+        "new": "Start new conversation",
+        "model": "Show or change model",
+        "session": "Show current session info",
+        "sessions": "List all saved sessions",
+        "continue": "Continue most recent session",
+        "history": "Show conversation history",
+        "export": "Export conversation to file",
+        "import": "Import conversation from file",
+        "cost": "Show token usage and cost",
+        "status": "Show ACP/LSP runtime status",
+        "auto": "Toggle autonomy mode (auto-delegate complex tasks)",
+        "debug": "Toggle debug logging",
+        "plan": "Create a step-by-step plan for a task",
+        "handoff": "Delegate to specialized agent (code/research/review/docs)",
+        "compact": "Toggle compact output mode",
+        "multiline": "Toggle multiline input mode",
+        "files": "List workspace files for @ mentions",
+        "queue": "Show pending prompts in queue",
+    }
+
+    def _get_registry(self):
+        """Lazily build the unified command registry (built-ins + custom).
+
+        Custom ``.praisonai/commands/*.md`` commands become first-class
+        ``/name`` entries here, driven from the same discovery that powers
+        ``praisonai run --command``. Failures degrade to built-ins only.
+        """
+        if self._registry is None:
+            try:
+                from praisonai_code.cli.interactive.command_registry import (
+                    create_default_registry,
+                )
+
+                self._registry = create_default_registry(
+                    self._BUILTIN_COMMANDS, include_custom=True
+                )
+            except Exception as exc:  # pragma: no cover - defensive
+                logger.debug("Command registry unavailable: %s", exc)
+                self._registry = _REGISTRY_FAILED
+        if self._registry is _REGISTRY_FAILED:
+            return None
+        return self._registry
+
     def _handle_command(self, command: str) -> bool:
         """Handle slash commands. Returns True if handled."""
         parts = command.split(maxsplit=1)
@@ -529,6 +583,17 @@ Tips:
   Use @filename to include file contents in your prompt
   Type multiple prompts while AI is thinking (queued)
   Use --debug flag or /debug command to enable debug logging"""
+            registry = self._get_registry()
+            if registry:
+                custom = [
+                    c for c in registry.list_commands()
+                    if c.name not in self._BUILTIN_COMMANDS and c.kind.value != "builtin"
+                ]
+                if custom:
+                    lines = ["", "Custom Commands:"]
+                    for c in custom:
+                        lines.append(f"  /{c.name:<14} {c.description}")
+                    help_text += "\n" + "\n".join(lines)
             self.messages.append(ChatMessage(role="system", content=help_text))
             return True
         
@@ -807,6 +872,31 @@ Example: /handoff code "refactor the auth module" """
             return True
         
         else:
+            # Not a built-in: consult the unified command registry so custom
+            # .praisonai/commands/*.md commands are first-class /name commands.
+            registry = self._get_registry()
+            resolved = registry.get(cmd) if registry else None
+            if resolved is not None and resolved.handler is not None:
+                try:
+                    prompt = resolved.handler(args)
+                except Exception as exc:
+                    self.messages.append(ChatMessage(
+                        role="system",
+                        content=f"Command /{cmd} failed: {exc}",
+                    ))
+                    return True
+                if prompt:
+                    self.messages.append(ChatMessage(
+                        role="system", content=f"Running /{cmd}..."
+                    ))
+                    self._update_output()
+                    self._queue_or_execute(prompt)
+                else:
+                    self.messages.append(ChatMessage(
+                        role="system",
+                        content=f"Command /{cmd} produced no output.",
+                    ))
+                return True
             self.messages.append(ChatMessage(role="system", content=f"Unknown command: /{cmd}. Use /help for available commands."))
             return True
     

{praisonai-4.6.139 → praisonai-4.6.141}/praisonai/observability/hooks.py

@@ -7,12 +7,93 @@ used consistently across all entry points without duplicating logic.
 
 import os
 import sys
+import inspect
 import logging
 from contextlib import contextmanager
-from typing import Callable, Iterator, List, Optional
+from typing import Any, Callable, Iterator, List, Optional
 
 logger = logging.getLogger(__name__)
 
+# Sinks installed via entry-point discovery for the current run. Torn down in
+# finalize_observability so flush()/close() always runs.
+_installed_sinks: List[Any] = []
+
+
+class _FanoutSink:
+    """TraceSinkProtocol implementation that forwards to every registered sink.
+
+    Lets multiple third-party sinks (e.g. Langfuse + Arize + a custom sink) all
+    receive the same trace stream instead of the last-registered one replacing
+    the rest. Every per-sink call is guarded so a broken sink can't break a run.
+    """
+
+    def __init__(self, sinks: List[Any]):
+        self._sinks = list(sinks)
+
+    def emit(self, event: Any) -> None:
+        for s in self._sinks:
+            try:
+                s.emit(event)
+            except Exception:  # noqa: BLE001 -- telemetry must not crash the caller
+                logger.debug("sink emit failed", exc_info=True)
+
+    def flush(self) -> None:
+        for s in self._sinks:
+            try:
+                s.flush()
+            except Exception:  # noqa: BLE001
+                logger.debug("sink flush failed", exc_info=True)
+
+    def close(self) -> None:
+        for s in self._sinks:
+            try:
+                s.close()
+            except Exception:  # noqa: BLE001
+                logger.debug("sink close failed", exc_info=True)
+
+
+def _factory_wants_tag(factory: Callable) -> bool:
+    """Whether a sink factory accepts the framework tag as its first argument.
+
+    Only positional-capable parameters count. A ``**kwargs``-only factory would
+    otherwise be mis-detected and called as ``factory(framework_tag)``, raising
+    ``TypeError`` and silently dropping the sink.
+    """
+    try:
+        sig = inspect.signature(factory)
+        positional_kinds = {
+            inspect.Parameter.POSITIONAL_ONLY,
+            inspect.Parameter.POSITIONAL_OR_KEYWORD,
+            inspect.Parameter.VAR_POSITIONAL,
+        }
+        return any(p.kind in positional_kinds for p in sig.parameters.values())
+    except (ValueError, TypeError):
+        return False
+
+
+def _install_discovered_sinks(framework_tag: str) -> None:
+    """Discover, instantiate and wire third-party trace sinks (best-effort)."""
+    sinks: List[Any] = []
+    for factory in discover_observability_sinks():
+        try:
+            sink = factory(framework_tag) if _factory_wants_tag(factory) else factory()
+            if sink is not None:
+                sinks.append(sink)
+        except Exception:  # noqa: BLE001 -- a broken plugin must not break a run
+            logger.debug("observability sink factory %r failed", factory, exc_info=True)
+
+    if not sinks:
+        return
+
+    try:
+        from praisonaiagents.trace.protocol import TraceEmitter, set_default_emitter
+    except Exception:  # noqa: BLE001 -- core trace API unavailable; skip silently
+        logger.debug("trace protocol unavailable; skipping sink wiring", exc_info=True)
+        return
+
+    _installed_sinks.extend(sinks)
+    set_default_emitter(TraceEmitter(sink=_FanoutSink(sinks), enabled=True))
+
 
 def init_observability(framework_tag: str, *, tags: Optional[List[str]] = None) -> None:
     """
@@ -24,7 +105,11 @@ def init_observability(framework_tag: str, *, tags: Optional[List[str]] = None)
     """
     # Try to initialize AgentOps if available
     _init_agentops(framework_tag, tags or [])
-    
+
+    # Honour the documented "praisonai.observability_sinks" entry-point group so
+    # third-party TraceSinkProtocol implementations are actually loaded.
+    _install_discovered_sinks(framework_tag)
+
     # Future: Add other observability providers here
     # _init_langfuse(framework_tag, tags)
     # _init_wandb(framework_tag, tags)
@@ -43,7 +128,21 @@ def finalize_observability(_framework_tag: str, *, status: str = "Success") -> N
         status: Session status ("Success", "Failure", etc.)
     """
     _end_agentops(status)
-    
+
+    # Flush + close any entry-point sinks installed for this run. Each call is
+    # guarded independently so a failing flush() still lets close() release the
+    # sink's resources.
+    for sink in _installed_sinks:
+        try:
+            sink.flush()
+        except Exception:  # noqa: BLE001 -- telemetry must not crash the caller
+            logger.debug("sink flush failed", exc_info=True)
+        try:
+            sink.close()
+        except Exception:  # noqa: BLE001
+            logger.debug("sink close failed", exc_info=True)
+    _installed_sinks.clear()
+
     # Future: Add other observability providers here
     # _end_langfuse(status)
     # _end_wandb(status)

{praisonai-4.6.139 → praisonai-4.6.141}/praisonai/persistence/orchestrator.py

@@ -83,6 +83,21 @@ class PersistenceOrchestrator:
         self._current_session: Optional[ConversationSession] = None
         self._session_cache: Dict[str, ConversationSession] = {}
         self._cache_lock = threading.RLock()  # RLock allows re-entrant access
+
+    def _sync(self, value: Any) -> Any:
+        """Drive a store call to completion from a sync context.
+
+        Async backends (``mode="async"`` → ``AsyncConversationStore`` and friends)
+        return a coroutine from every method. Sync hooks that call them directly
+        would otherwise discard the coroutine unawaited — a silent no-op that loses
+        the write. When we detect a coroutine we run it via the shared async bridge
+        (single source of truth) so sync callers still get their result; otherwise
+        we pass the value through unchanged for genuinely sync stores.
+        """
+        if inspect.iscoroutine(value):
+            from .._async_bridge import run_sync
+            return run_sync(value)
+        return value
     
     @classmethod
     def from_config(cls, config: PersistenceConfig) -> "PersistenceOrchestrator":
@@ -153,7 +168,7 @@ class PersistenceOrchestrator:
         # Try to load existing session
         session = None
         if resume:
-            session = self.conversation.get_session(session_id)
+            session = self._sync(self.conversation.get_session(session_id))
         
         if session:
             logger.info(f"Resuming session: {session_id}")
@@ -161,7 +176,7 @@ class PersistenceOrchestrator:
             self._cache_put(session)
             
             # Load previous messages
-            messages = self.conversation.get_messages(session_id)
+            messages = self._sync(self.conversation.get_messages(session_id))
             return messages
         else:
             # Create new session
@@ -173,7 +188,7 @@ class PersistenceOrchestrator:
                 name=f"Session {session_id[:8]}",
                 metadata={"agent_type": type(agent).__name__},
             )
-            self.conversation.create_session(session)
+            self._sync(self.conversation.create_session(session))
             logger.info(f"Created new session: {session_id}")
             self._current_session = session
             self._cache_put(session)
@@ -215,7 +230,7 @@ class PersistenceOrchestrator:
             metadata=metadata,
         )
         
-        self.conversation.add_message(session_id, message)
+        self._sync(self.conversation.add_message(session_id, message))
         logger.debug(f"Persisted {role} message to session {session_id}")
         return message
     
@@ -236,12 +251,12 @@ class PersistenceOrchestrator:
         if not self.conversation:
             return
         
-        session = self._cache_get(session_id) or self.conversation.get_session(session_id)
+        session = self._cache_get(session_id) or self._sync(self.conversation.get_session(session_id))
         if session:
             session.updated_at = time.time()
             if metadata:
                 session.metadata = {**(session.metadata or {}), **metadata}
-            self.conversation.update_session(session)
+            self._sync(self.conversation.update_session(session))
             # Update cache with the modified session
             self._cache_put(session)
             logger.debug(f"Updated session metadata: {session_id}")
@@ -426,12 +441,12 @@ class PersistenceOrchestrator:
             logger.debug("No knowledge store configured")
             return []
         
-        return self.knowledge.search(
+        return self._sync(self.knowledge.search(
             collection=collection,
             query_embedding=query_embedding,
             limit=limit,
             filters=filters,
-        )
+        ))
     
     def add_knowledge(
         self,
@@ -451,7 +466,7 @@ class PersistenceOrchestrator:
         if not self.knowledge:
             raise ValueError("No knowledge store configured")
         
-        return self.knowledge.upsert(collection, documents)
+        return self._sync(self.knowledge.upsert(collection, documents))
     
     # =========================================================================
     # State Management
@@ -461,19 +476,19 @@ class PersistenceOrchestrator:
         """Get state value."""
         if not self.state:
             return None
-        return self.state.get(key)
+        return self._sync(self.state.get(key))
     
     def set_state(self, key: str, value: Any, ttl: Optional[int] = None) -> None:
         """Set state value with optional TTL."""
         if not self.state:
             return
-        self.state.set(key, value, ttl)
+        self._sync(self.state.set(key, value, ttl))
     
     def delete_state(self, key: str) -> bool:
         """Delete state value."""
         if not self.state:
             return False
-        return self.state.delete(key)
+        return self._sync(self.state.delete(key))
     
     # =========================================================================
     # Session Management
@@ -483,7 +498,7 @@ class PersistenceOrchestrator:
         """Get a session by ID."""
         if not self.conversation:
             return None
-        return self.conversation.get_session(session_id)
+        return self._sync(self.conversation.get_session(session_id))
     
     def list_sessions(
         self,
@@ -493,7 +508,7 @@ class PersistenceOrchestrator:
         """List sessions for a user."""
         if not self.conversation:
             return []
-        return self.conversation.list_sessions(user_id=user_id, limit=limit)
+        return self._sync(self.conversation.list_sessions(user_id=user_id, limit=limit))
     
     def delete_session(self, session_id: str) -> bool:
         """Delete a session and all its messages."""
@@ -503,7 +518,7 @@ class PersistenceOrchestrator:
         # Remove from cache using thread-safe method
         self._cache_delete(session_id)
         
-        return self.conversation.delete_session(session_id)
+        return self._sync(self.conversation.delete_session(session_id))
     
     def get_messages(
         self,
@@ -513,7 +528,7 @@ class PersistenceOrchestrator:
         """Get messages from a session."""
         if not self.conversation:
             return []
-        return self.conversation.get_messages(session_id, limit=limit)
+        return self._sync(self.conversation.get_messages(session_id, limit=limit))
     
     # =========================================================================
     # Context Building
@@ -547,7 +562,7 @@ class PersistenceOrchestrator:
         
         # Get conversation history
         if self.conversation:
-            messages = self.conversation.get_messages(session_id, limit=history_limit)
+            messages = self._sync(self.conversation.get_messages(session_id, limit=history_limit))
             context["history"] = [
                 {"role": m.role, "content": m.content}
                 for m in messages
@@ -555,11 +570,11 @@ class PersistenceOrchestrator:
         
         # Get relevant knowledge
         if self.knowledge and query_embedding:
-            docs = self.knowledge.search(
+            docs = self._sync(self.knowledge.search(
                 collection=knowledge_collection,
                 query_embedding=query_embedding,
                 limit=knowledge_limit,
-            )
+            ))
             context["knowledge"] = [
                 {"content": d.content, "metadata": d.metadata}
                 for d in docs
@@ -574,11 +589,11 @@ class PersistenceOrchestrator:
     def close(self) -> None:
         """Close all stores and release resources."""
         if self.conversation:
-            self.conversation.close()
+            self._sync(self.conversation.close())
         if self.knowledge:
-            self.knowledge.close()
+            self._sync(self.knowledge.close())
         if self.state:
-            self.state.close()
+            self._sync(self.state.close())
         
         # Clear cache using thread-safe method
         self._cache_clear()

{praisonai-4.6.139 → praisonai-4.6.141}/praisonai/security/__init__.py

@@ -96,7 +96,7 @@ def enable_injection_defense(
     Args:
         extra_patterns: Additional regex patterns to detect (appended to defaults).
         block_threshold: Override the threat level that triggers blocking.
-                         3 = CRITICAL (default), 2 = HIGH, 1 = MEDIUM.
+                         3 = CRITICAL, 2 = HIGH (default), 1 = MEDIUM.
         trusted_sources: Source names that bypass blocking (in addition to defaults).
 
     Returns:
@@ -109,7 +109,12 @@ def enable_injection_defense(
     from .injection import InjectionDefense, ThreatLevel
     from praisonaiagents.hooks import add_hook
 
-    threshold = ThreatLevel(block_threshold) if block_threshold is not None else ThreatLevel.CRITICAL
+    # HIGH matches InjectionDefense()'s class default and scan_text()'s own
+    # blocking policy. It blocks any single dangerous-category hit (instruction
+    # override, financial manipulation, self-harm) or any two categories total,
+    # so the documented one-liner is genuinely "safe by default" rather than
+    # requiring 3+ distinct vectors that CRITICAL demanded.
+    threshold = ThreatLevel(block_threshold) if block_threshold is not None else ThreatLevel.HIGH
 
     defense = InjectionDefense(
         extra_patterns=extra_patterns,

{praisonai-4.6.139 → praisonai-4.6.141}/praisonai/security/injection.py

@@ -9,6 +9,7 @@ Zero overhead when not enabled — all imports are local.
 """
 import re
 import logging
+import unicodedata
 from dataclasses import dataclass, field
 from enum import IntEnum
 from typing import Callable, List, Optional, Any
@@ -100,6 +101,50 @@ _SELF_HARM_PATTERNS: List[str] = [
 
 _LONG_B64_RE = re.compile(r"^[A-Za-z0-9+/]{40,}={0,2}$")
 
+# Zero-width / invisible characters commonly injected between letters to break
+# token matches (e.g. "ig\u200bnore"). Stripped BEFORE pattern search.
+_ZERO_WIDTH_RE = re.compile(
+    "[\u200b\u200c\u200d\u200e\u200f\u2060\ufeff\u00ad\u180e]"
+)
+
+# Cross-script homoglyph map. NFKC folds full-width / small-form / ligature
+# glyphs into ASCII, but it does NOT fold Cyrillic/Greek look-alikes onto Latin
+# (they are distinct code points in distinct scripts). This small confusables
+# table catches the common one-liner bypass "іgnore …" (Cyrillic і) etc.
+_CONFUSABLES = {
+    "\u0430": "a",  # Cyrillic а
+    "\u0435": "e",  # Cyrillic е
+    "\u043e": "o",  # Cyrillic о
+    "\u0440": "p",  # Cyrillic р
+    "\u0441": "c",  # Cyrillic с
+    "\u0443": "y",  # Cyrillic у
+    "\u0445": "x",  # Cyrillic х
+    "\u0456": "i",  # Cyrillic і
+    "\u0455": "s",  # Cyrillic ѕ
+    "\u0501": "d",  # Cyrillic ԁ
+    "\u04bb": "h",  # Cyrillic һ
+    "\u0391": "A",  "\u0392": "B",  "\u0395": "E",  "\u0396": "Z",
+    "\u0397": "H",  "\u0399": "I",  "\u039a": "K",  "\u039c": "M",
+    "\u039d": "N",  "\u039f": "O",  "\u03a1": "P",  "\u03a4": "T",
+    "\u03a5": "Y",  "\u03a7": "X",
+    "\u03b1": "a",  "\u03bf": "o",  "\u03c1": "p",  "\u03c5": "u",
+}
+_CONFUSABLES_TABLE = str.maketrans(_CONFUSABLES)
+
+
+def _normalize_for_scan(text: str) -> str:
+    """Fold obfuscation into canonical ASCII so pattern matching sees intent.
+
+    - NFKC collapses full-width, small-form, ligature and superscript glyphs
+      into their ASCII-equivalent forms.
+    - Zero-width joiners/spaces are stripped so they can't break word tokens.
+    - A small confusables table maps common Cyrillic/Greek homoglyphs onto
+      their Latin look-alikes (NFKC alone does not fold across scripts).
+    """
+    text = unicodedata.normalize("NFKC", text)
+    text = _ZERO_WIDTH_RE.sub("", text)
+    return text.translate(_CONFUSABLES_TABLE)
+
 # Trust sources that bypass injection scanning
 _TRUSTED_SOURCES = frozenset([
     "trusted_tool", "internal", "system", "praisonai_core",
@@ -203,21 +248,25 @@ def scan_text(text: str, source: str = "external") -> ScanResult:
     if not text or not isinstance(text, str):
         return ScanResult(ThreatLevel.LOW, blocked=False, source=source)
 
+    # Fold full-width / zero-width / homoglyph obfuscation to canonical ASCII
+    # before matching so attackers can't slip past ASCII-anchored patterns.
+    normalized = _normalize_for_scan(text)
+
     # Trusted sources: scan but never block
     is_trusted = source in _TRUSTED_SOURCES
 
     triggered = []
-    if detect_instruction_patterns(text):
+    if detect_instruction_patterns(normalized):
         triggered.append("instruction_override")
-    if detect_authority_claims(text):
+    if detect_authority_claims(normalized):
         triggered.append("authority_claim")
-    if detect_boundary_manipulation(text):
+    if detect_boundary_manipulation(normalized):
         triggered.append("boundary_manipulation")
-    if detect_obfuscation(text):
+    if detect_obfuscation(normalized):
         triggered.append("obfuscation")
-    if detect_financial_manipulation(text):
+    if detect_financial_manipulation(normalized):
         triggered.append("financial_manipulation")
-    if detect_self_harm_instructions(text):
+    if detect_self_harm_instructions(normalized):
         triggered.append("self_harm_instruction")
 
     count = len(triggered)
@@ -297,10 +346,12 @@ class InjectionDefense:
         """
         result = scan_text(text, source=source)
 
-        # Apply extra patterns as Check 1 extension
+        # Apply extra patterns as Check 1 extension (against normalized text so
+        # obfuscated payloads can't bypass custom patterns either).
         if self._extra_patterns and text:
+            normalized = _normalize_for_scan(text)
             for pat in self._extra_patterns:
-                if re.search(pat, text, re.IGNORECASE):
+                if re.search(pat, normalized, re.IGNORECASE):
                     if "extra_pattern" not in result.checks_triggered:
                         result.checks_triggered.append("extra_pattern")
                     # Escalate if extra pattern fires

praisonai-4.6.141/praisonai/version.py

@@ -0,0 +1 @@
+__version__ = "4.6.141"