support for slash command; support for session management and project management; support for personalization module

Author: alcholiclg

.gitignore

@@ -121,6 +121,7 @@ venv.bak/
 .vscode
 .idea
 .cursor
+.firecrawl
 
 # custom
 *.pkl

ms_agent/agent/llm_agent.py

@@ -24,6 +24,9 @@
 from ms_agent.utils import async_retry, read_history, save_history
 from ms_agent.utils.constants import DEFAULT_TAG, DEFAULT_USER
 from ms_agent.utils.logger import get_logger
+from ms_agent.personalization.injector import PersonalizationInjector
+from ms_agent.personalization.profile import ProfileManager
+from ms_agent.personalization.types import PersonalizationConfig
 from ms_agent.skill.catalog import SkillCatalog
 from ms_agent.skill.prompt_injector import SkillPromptInjector
 from ms_agent.skill.search import SkillSearchEngine
@@ -111,6 +114,9 @@ def __init__(
         self._skill_catalog = None
         self._skill_injector = None
 
+        # Personalization (lazy-loaded in _build_personalization_section)
+        self._profile_manager = ProfileManager()
+
     async def prepare_skills(self):
         """Initialize the skill system from config.skills.
 
@@ -474,6 +480,11 @@ async def create_messages(
                 Message(role='user', content=messages or self.query),
             ]
 
+        # Inject personalization section (before skills)
+        personalization_section = self._build_personalization_section()
+        if personalization_section:
+            messages[0].content += "\n\n" + personalization_section
+
         # Inject skill prompt section into system message
         if self._skill_injector:
             skill_section = self._skill_injector.build_skill_prompt_section()
@@ -482,6 +493,19 @@ async def create_messages(
 
         return messages
 
+    def _build_personalization_section(self) -> str:
+        p_config = getattr(self.config, 'personalization', None)
+        config = PersonalizationConfig(
+            global_instruction=(
+                getattr(p_config, 'global_instruction', '') or ''
+            ) if p_config else '',
+            project_instruction=(
+                getattr(p_config, 'project_instruction', '') or ''
+            ) if p_config else '',
+            user_profile=self._profile_manager.read(),
+        )
+        return PersonalizationInjector.build(config)
+
     async def do_rag(self, messages: List[Message]):
         """Process RAG or knowledge search to enrich the user query with context.
 

ms_agent/callbacks/input_callback.py

@@ -1,20 +1,38 @@
 # Copyright (c) ModelScope Contributors. All rights reserved.
-from typing import List
+from typing import TYPE_CHECKING, List, Optional
 
 from ms_agent.agent.runtime import Runtime
 from ms_agent.callbacks import Callback
 from ms_agent.llm.utils import Message
 from ms_agent.utils import get_logger
 from omegaconf import DictConfig
 
+if TYPE_CHECKING:
+    from ms_agent.command.router import CommandRouter
+
 logger = get_logger()
 
 
 class InputCallback(Callback):
-    """Waiting for human inputs."""
+    """Waiting for human inputs. Supports slash command interception."""
 
-    def __init__(self, config: DictConfig):
+    def __init__(
+        self,
+        config: DictConfig,
+        command_router: Optional['CommandRouter'] = None,
+    ):
         super().__init__(config)
+        if command_router is None:
+            command_router = self._build_default_router()
+        self._command_router = command_router
+
+    @staticmethod
+    def _build_default_router() -> 'CommandRouter':
+        from ms_agent.command import CommandRouter, register_builtin_commands
+
+        router = CommandRouter()
+        register_builtin_commands(router)
+        return router
 
     async def after_tool_call(self, runtime: Runtime, messages: List[Message]):
         if messages[-1].tool_calls or messages[-1].role in ('tool', 'user'):
@@ -27,6 +45,47 @@ async def after_tool_call(self, runtime: Runtime, messages: List[Message]):
 
         if not query:
             runtime.should_stop = True
-        else:
+            return
+
+        if self._command_router:
+            handled = await self._try_command(query, runtime, messages)
+            if handled:
+                return
+
+        runtime.should_stop = False
+        messages.append(Message(role='user', content=query))
+
+    async def _try_command(
+        self,
+        query: str,
+        runtime: Runtime,
+        messages: List[Message],
+    ) -> bool:
+        """Try to dispatch as slash command. Returns True if handled."""
+        from ms_agent.command.router import CommandRouter
+        from ms_agent.command.types import CommandContext, CommandResultType
+
+        if not CommandRouter.is_command(query):
+            return False
+
+        cmd_name, args = CommandRouter.parse_input(query)
+        ctx = CommandContext(
+            raw_input=query,
+            command_name=cmd_name,
+            args=args,
+            source='cli',
+            runtime=runtime,
+            extra={'router': self._command_router},
+        )
+        result = await self._command_router.dispatch(ctx)
+        if result is None:
+            return False
+
+        if result.type == CommandResultType.QUIT:
+            runtime.should_stop = True
+        elif result.type == CommandResultType.MESSAGE:
+            print(result.content)
+        elif result.type == CommandResultType.SUBMIT_PROMPT:
+            messages.append(Message(role='user', content=result.content))
             runtime.should_stop = False
-            messages.append(Message(role='user', content=query))
+        return True

ms_agent/command/__init__.py

@@ -0,0 +1,19 @@
+from ms_agent.command.router import CommandRouter
+from ms_agent.command.types import (
+    CommandContext,
+    CommandDef,
+    CommandHandler,
+    CommandResult,
+    CommandResultType,
+)
+from ms_agent.command.builtin import register_builtin_commands
+
+__all__ = [
+    'CommandContext',
+    'CommandDef',
+    'CommandHandler',
+    'CommandResult',
+    'CommandResultType',
+    'CommandRouter',
+    'register_builtin_commands',
+]

ms_agent/command/builtin/__init__.py

@@ -0,0 +1,8 @@
+from ms_agent.command.router import CommandRouter
+from ms_agent.command.builtin.session_cmds import register_session_commands
+from ms_agent.command.builtin.info_cmds import register_info_commands
+
+
+def register_builtin_commands(router: CommandRouter) -> None:
+    register_session_commands(router)
+    register_info_commands(router)

ms_agent/command/builtin/info_cmds.py

@@ -0,0 +1,56 @@
+from ms_agent.command.router import CommandRouter
+from ms_agent.command.types import (
+    CommandContext,
+    CommandDef,
+    CommandResult,
+    CommandResultType,
+)
+
+CMD_HELP = CommandDef(
+    name='help',
+    description='Show available commands',
+    category='info',
+    aliases=('?',),
+)
+
+CMD_VERSION = CommandDef(
+    name='version',
+    description='Show MS-Agent version',
+    category='info',
+)
+
+
+async def cmd_help(ctx: CommandContext) -> CommandResult:
+    router = ctx.extra.get('router')
+    if not router:
+        return CommandResult(
+            type=CommandResultType.MESSAGE, content='No commands available.'
+        )
+
+    lines = ['Available commands:\n']
+    for category, cmds in router.list_commands(ctx.source).items():
+        lines.append(f'\n  [{category}]')
+        for cmd in cmds:
+            aliases = f' ({", ".join(cmd.aliases)})' if cmd.aliases else ''
+            lines.append(f'    /{cmd.name}{aliases} — {cmd.description}')
+
+    return CommandResult(
+        type=CommandResultType.MESSAGE, content='\n'.join(lines)
+    )
+
+
+async def cmd_version(ctx: CommandContext) -> CommandResult:
+    try:
+        from ms_agent import __version__
+
+        ver = __version__
+    except (ImportError, AttributeError):
+        ver = 'unknown'
+    return CommandResult(
+        type=CommandResultType.MESSAGE, content=f'MS-Agent v{ver}'
+    )
+
+
+def register_info_commands(router: CommandRouter) -> None:
+    router.register(CMD_HELP, cmd_help)
+    router.register(CMD_VERSION, cmd_version)

ms_agent/command/builtin/session_cmds.py

@@ -0,0 +1,60 @@
+from ms_agent.command.router import CommandRouter
+from ms_agent.command.types import (
+    CommandContext,
+    CommandDef,
+    CommandResult,
+    CommandResultType,
+)
+
+CMD_STOP = CommandDef(
+    name='stop',
+    description='Stop the current agent execution',
+    category='session',
+    priority=0,
+    aliases=('abort', 'cancel'),
+)
+
+CMD_NEW = CommandDef(
+    name='new',
+    description='End current session',
+    category='session',
+    aliases=('reset',),
+)
+
+CMD_STATUS = CommandDef(
+    name='status',
+    description='Show current agent status',
+    category='session',
+)
+
+
+async def cmd_stop(ctx: CommandContext) -> CommandResult:
+    if ctx.runtime:
+        ctx.runtime.should_stop = True
+    return CommandResult(type=CommandResultType.MESSAGE, content='Agent stopped.')
+
+
+async def cmd_new(ctx: CommandContext) -> CommandResult:
+    if ctx.runtime:
+        ctx.runtime.should_stop = True
+    return CommandResult(
+        type=CommandResultType.QUIT, content='Session ended. Start a new one.'
+    )
+
+
+async def cmd_status(ctx: CommandContext) -> CommandResult:
+    if ctx.runtime:
+        content = (
+            f'Round: {ctx.runtime.round}\n'
+            f'Tag: {ctx.runtime.tag}\n'
+            f'Should stop: {ctx.runtime.should_stop}'
+        )
+    else:
+        content = 'No active agent.'
+    return CommandResult(type=CommandResultType.MESSAGE, content=content)
+
+
+def register_session_commands(router: CommandRouter) -> None:
+    router.register(CMD_STOP, cmd_stop)
+    router.register(CMD_NEW, cmd_new)
+    router.register(CMD_STATUS, cmd_status)