OpenJarvis 1.0.3.dev732__tar.gz → 1.0.3.dev736__tar.gz

{openjarvis-1.0.3.dev732 → openjarvis-1.0.3.dev736}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenJarvis
-Version: 1.0.3.dev732
+Version: 1.0.3.dev736
 Summary: OpenJarvis — modular AI assistant backend with composable intelligence primitives
 Project-URL: Homepage, https://github.com/open-jarvis/OpenJarvis
 Project-URL: Documentation, https://open-jarvis.github.io/OpenJarvis/

{openjarvis-1.0.3.dev732 → openjarvis-1.0.3.dev736}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "OpenJarvis"
-version = "1.0.3.dev732"
+version = "1.0.3.dev736"
 description = "OpenJarvis — modular AI assistant backend with composable intelligence primitives"
 readme = "README.md"
 requires-python = ">=3.10"

{openjarvis-1.0.3.dev732 → openjarvis-1.0.3.dev736}/src/openjarvis/agents/_stubs.py

@@ -121,6 +121,23 @@ class BaseAgent(ABC):
             payload.update(data)
             self._bus.publish(EventType.AGENT_TURN_END, payload)
 
+    def _apply_persona(self, system_prompt: Optional[str]) -> Optional[str]:
+        """Append SOUL/MEMORY/USER persona to a self-assembled system prompt.
+
+        Agents like ``monitor_operative`` / ``operative`` build their own
+        system prompt and bypass ``_build_messages`` (and thus the prompt
+        builder). This lets them honor the same persona files as one-shot
+        ``jarvis ask`` (#376) by *appending* persona to — never replacing —
+        their specialized instructions. No-op when no ``prompt_builder`` is
+        wired or no persona files exist.
+        """
+        if self._prompt_builder is None:
+            return system_prompt
+        persona = self._prompt_builder.persona_sections()
+        if not persona:
+            return system_prompt
+        return f"{system_prompt}\n\n{persona}" if system_prompt else persona
+
     def _build_messages(
         self,
         input: str,
@@ -307,6 +324,7 @@ class ToolUsingAgent(BaseAgent):
         interactive: bool = False,
         confirm_callback: Optional[Any] = None,
         skill_few_shot_examples: Optional[List[str]] = None,
+        prompt_builder: Optional[Any] = None,
     ) -> None:
         super().__init__(
             engine,
@@ -314,6 +332,7 @@ class ToolUsingAgent(BaseAgent):
             bus=bus,
             temperature=temperature,
             max_tokens=max_tokens,
+            prompt_builder=prompt_builder,
         )
         from openjarvis.tools._stubs import ToolExecutor
 

{openjarvis-1.0.3.dev732 → openjarvis-1.0.3.dev736}/src/openjarvis/agents/executor.py

@@ -404,6 +404,21 @@ class AgentExecutor:
                 state_kwargs["memory_backend"] = getattr(
                     self._system, "memory_backend", None
                 )
+            # Wire SOUL.md / MEMORY.md / USER.md persona files into persistent
+            # agents, mirroring the one-shot `jarvis ask` path so they no
+            # longer apply to CLI calls only (#376).
+            cfg = getattr(self._system, "config", None)
+            if cfg is not None and _accepts("prompt_builder"):
+                from openjarvis.prompt.builder import SystemPromptBuilder
+
+                state_kwargs["prompt_builder"] = SystemPromptBuilder(
+                    agent_template=getattr(
+                        cfg.agent, "default_system_prompt", ""
+                    )
+                    or "",
+                    memory_files_config=cfg.memory_files,
+                    system_prompt_config=cfg.system_prompt,
+                )
 
         try:
             agent_instance = agent_cls(

{openjarvis-1.0.3.dev732 → openjarvis-1.0.3.dev736}/src/openjarvis/agents/monitor_operative.py

@@ -139,6 +139,7 @@ class MonitorOperativeAgent(ToolUsingAgent):
             max_tokens=max_tokens,
             interactive=interactive,
             confirm_callback=confirm_callback,
+            prompt_builder=kwargs.get("prompt_builder"),
         )
         # Validate strategies
         if memory_extraction not in VALID_MEMORY_EXTRACTION:
@@ -215,6 +216,9 @@ class MonitorOperativeAgent(ToolUsingAgent):
             sys_parts.append(f"\n## Previous State\n{previous_state}")
 
         system_prompt = "\n\n".join(sys_parts) if sys_parts else None
+        # Honor SOUL.md / MEMORY.md / USER.md persona files like `jarvis ask`,
+        # appended so the monitor's own instructions are preserved (#376).
+        system_prompt = self._apply_persona(system_prompt)
 
         # 3. Load session history
         session_messages = self._load_session()

{openjarvis-1.0.3.dev732 → openjarvis-1.0.3.dev736}/src/openjarvis/agents/operative.py

@@ -70,6 +70,7 @@ class OperativeAgent(ToolUsingAgent):
             max_tokens=max_tokens,
             interactive=interactive,
             confirm_callback=confirm_callback,
+            prompt_builder=kwargs.get("prompt_builder"),
         )
         self._system_prompt = system_prompt or ""
         self._operator_id = operator_id
@@ -96,6 +97,9 @@ class OperativeAgent(ToolUsingAgent):
             sys_parts.append(f"\n## Previous State\n{previous_state}")
 
         system_prompt = "\n\n".join(sys_parts) if sys_parts else None
+        # Honor SOUL.md / MEMORY.md / USER.md persona files like `jarvis ask`,
+        # appended so the operative's own instructions are preserved (#376).
+        system_prompt = self._apply_persona(system_prompt)
 
         # 3. Load session history
         session_messages = self._load_session()

{openjarvis-1.0.3.dev732 → openjarvis-1.0.3.dev736}/src/openjarvis/prompt/builder.py

@@ -45,9 +45,9 @@ class SystemPromptBuilder:
             parts.append(f"\n\n## Previous State\n\n{self._previous_state}")
         return "".join(parts)
 
-    def _build_frozen_prefix(self) -> str:
+    def _persona_sections(self) -> list[str]:
+        """The SOUL / MEMORY / USER sections (no agent template, no skills)."""
         sections: list[str] = []
-        sections.append(self._agent_template)
         soul = self._load_file(
             self._mf_config.soul_path,
             self._sp_config.soul_max_chars,
@@ -66,6 +66,22 @@ class SystemPromptBuilder:
         )
         if user:
             sections.append(f"## User Profile\n\n{user}")
+        return sections
+
+    def persona_sections(self) -> str:
+        """Just the SOUL / MEMORY / USER persona, joined.
+
+        For agents that assemble their own system prompt (monitor_operative,
+        operative) and want to *append* persona without letting the builder
+        replace their specialized instructions (#376). Returns "" when no
+        persona files are present.
+        """
+        return "\n\n".join(self._persona_sections())
+
+    def _build_frozen_prefix(self) -> str:
+        sections: list[str] = []
+        sections.append(self._agent_template)
+        sections.extend(self._persona_sections())
         # XML skill catalog (preferred over legacy markdown list)
         if self._skill_catalog_xml:
             sections.append("## Available Skills\n\n" + self._skill_catalog_xml)

{openjarvis-1.0.3.dev732 → openjarvis-1.0.3.dev736}/src/openjarvis/server/agent_manager_routes.py

@@ -398,6 +398,139 @@ def _resolve_tool_specs(
     return resolved
 
 
+# Per-agent sampler params forwarded to the engine when present in config.
+# The OpenAI-compat engine passes **kwargs straight through to the upstream
+# payload, so these reach local servers (vLLM / mlx_lm / etc.) that support
+# them. Only forwarded when explicitly set, so default agents send nothing
+# extra and engines that don't support a key never receive it. (#386)
+_SAMPLER_PARAM_KEYS = (
+    "top_p",
+    "top_k",
+    "min_p",
+    "repetition_penalty",
+    "frequency_penalty",
+    "presence_penalty",
+)
+
+
+def _sampler_kwargs(config: Dict[str, Any]) -> Dict[str, Any]:
+    """Extract per-agent sampler params from a managed agent's config (#386)."""
+    out: Dict[str, Any] = {}
+    for key in _SAMPLER_PARAM_KEYS:
+        val = config.get(key)
+        if val is not None:
+            out[key] = val
+    return out
+
+
+def _replay_history_messages(
+    history: List[Dict[str, Any]],
+    exclude_id: str,
+) -> List[Any]:
+    """Rebuild prior-turn LLM messages from stored managed-agent history.
+
+    When a stored assistant turn recorded ``tool_calls``, replay them as an
+    assistant tool-use message followed by the corresponding tool-result
+    messages — so the model sees its own prior tool pattern instead of
+    regressing to fabricated tool output on later turns. Without this, only
+    the assistant's text is replayed and the tool-use signal is lost (#382).
+    """
+    from openjarvis.core.types import Message, Role, ToolCall
+
+    messages: List[Any] = []
+    for m in reversed(history):
+        if m.get("id") == exclude_id:
+            continue
+        direction = m.get("direction")
+        if direction == "user_to_agent":
+            messages.append(Message(role=Role.USER, content=m.get("content") or ""))
+        elif direction == "agent_to_user":
+            stored = m.get("tool_calls")
+            if stored:
+                calls = []
+                results = []
+                for i, tc in enumerate(stored):
+                    call_id = f"hist-{m.get('id', '')}-{i}"
+                    calls.append(
+                        ToolCall(
+                            id=call_id,
+                            name=tc.get("tool", ""),
+                            arguments=tc.get("arguments") or "",
+                        )
+                    )
+                    results.append(
+                        Message(
+                            role=Role.TOOL,
+                            content=str(tc.get("result", "")),
+                            tool_call_id=call_id,
+                            name=tc.get("tool", ""),
+                        )
+                    )
+                messages.append(
+                    Message(
+                        role=Role.ASSISTANT,
+                        content=m.get("content") or None,
+                        tool_calls=calls,
+                    )
+                )
+                messages.extend(results)
+            else:
+                messages.append(
+                    Message(role=Role.ASSISTANT, content=m.get("content") or "")
+                )
+    return messages
+
+
+def _instantiate_managed_tool(
+    tool_cls: Any,
+    name: str,
+    *,
+    engine: Any,
+    model: str,
+    app_state: Any,
+) -> Any:
+    """Instantiate a tool with the same dependency injection as the canonical
+    ``cli/ask.py`` path, so ``memory_*`` / ``channel_*`` / ``llm`` tools work
+    instead of silently failing with "No backend configured" (#395).
+    """
+    try:
+        from openjarvis.cli.ask import (
+            _CHANNEL_TOOLS,
+            _MEMORY_TOOLS,
+            _get_memory_backend,
+        )
+    except Exception:  # pragma: no cover - cli import should always succeed
+        _MEMORY_TOOLS = frozenset()
+        _CHANNEL_TOOLS = frozenset()
+        _get_memory_backend = None
+
+    if name in _MEMORY_TOOLS:
+        backend = getattr(app_state, "memory_backend", None) if app_state else None
+        if backend is None and app_state is not None and _get_memory_backend:
+            cfg = getattr(app_state, "config", None)
+            if cfg is not None:
+                backend = _get_memory_backend(cfg)
+        if backend is None:
+            logger.warning(
+                "Memory tool %r instantiated without a backend — calls will "
+                "return no results.",
+                name,
+            )
+        return tool_cls(backend=backend)
+    if name in _CHANNEL_TOOLS:
+        channel = getattr(app_state, "channel_bridge", None) if app_state else None
+        if channel is None:
+            logger.warning(
+                "Channel tool %r instantiated without a channel — calls will "
+                "fail with 'No channel backend configured'.",
+                name,
+            )
+        return tool_cls(channel=channel)
+    if name == "llm":
+        return tool_cls(engine=engine, model=model)
+    return tool_cls()
+
+
 def _build_deep_research_tools(
     engine: Any,
     model: str,
@@ -657,15 +790,11 @@ async def _stream_managed_agent(
         if app_state is not None and dr_tools:
             app_state._dr_tools = dr_tools
 
-    # Load prior conversation context (DESC order, reverse for chronological)
+    # Load prior conversation context (DESC order, reverse for chronological).
+    # Replaying recorded tool_calls (assistant tool-use + tool results) keeps
+    # multi-turn tool behaviour from regressing to fabricated output (#382).
     history = manager.list_messages(agent_id, limit=50)
-    for m in reversed(history):
-        if m["id"] == message_id:
-            continue
-        if m["direction"] == "user_to_agent":
-            llm_messages.append(Message(role=Role.USER, content=m["content"]))
-        elif m["direction"] == "agent_to_user":
-            llm_messages.append(Message(role=Role.ASSISTANT, content=m["content"]))
+    llm_messages.extend(_replay_history_messages(history, message_id))
 
     # Append the current user message
     llm_messages.append(Message(role=Role.USER, content=user_content))
@@ -960,6 +1089,10 @@ async def _stream_managed_agent(
     if resolved_tools:
         stream_kwargs["tools"] = resolved_tools
 
+    # Forward any per-agent sampler params (repetition_penalty, top_p, …) so
+    # locally-hosted models can be tuned per agent (#386).
+    stream_kwargs.update(_sampler_kwargs(config))
+
     # Discover MCP tools and merge into stream_kwargs
     mcp_adapters: Dict[str, Any] = {}
     if app_state is not None:
@@ -1175,7 +1308,17 @@ async def _stream_managed_agent(
 
                             tool_cls = ToolRegistry.get(tool_name)
                             if tool_cls is not None:
-                                tool_instance = tool_cls()
+                                # Inject backend / channel / engine the same
+                                # way cli/ask.py does, else memory_* / channel_*
+                                # / llm tools fail with "No backend configured"
+                                # on every call (#395).
+                                tool_instance = _instantiate_managed_tool(
+                                    tool_cls,
+                                    tool_name,
+                                    engine=engine,
+                                    model=model,
+                                    app_state=app_state,
+                                )
                                 # Tools the user explicitly added to this
                                 # agent's toolkit are considered pre-approved —
                                 # selecting them in the wizard is the

openjarvis-1.0.3.dev736/tests/agents/test_persona_persistent.py

@@ -0,0 +1,96 @@
+"""Persona files reach persistent agents, not just one-shot `jarvis ask` (#376).
+
+SOUL.md / MEMORY.md / USER.md are loaded by `jarvis ask` via SystemPromptBuilder.
+Persistent agents (monitor_operative, operative) assemble their own system
+prompt and previously ignored these files entirely. These tests verify the
+persona is now appended to their prompt without replacing their specialized
+instructions.
+"""
+
+from __future__ import annotations
+
+from openjarvis.core.config import MemoryFilesConfig, SystemPromptConfig
+from openjarvis.prompt.builder import SystemPromptBuilder
+
+
+def _builder_with_soul(tmp_path, text="You are Kira."):
+    soul = tmp_path / "SOUL.md"
+    soul.write_text(text, encoding="utf-8")
+    mf = MemoryFilesConfig(
+        soul_path=str(soul),
+        memory_path=str(tmp_path / "MEMORY.md"),  # absent → ignored
+        user_path=str(tmp_path / "USER.md"),  # absent → ignored
+    )
+    return SystemPromptBuilder(
+        agent_template="AGENT_TEMPLATE",
+        memory_files_config=mf,
+        system_prompt_config=SystemPromptConfig(),
+    )
+
+
+class TestPersonaSections:
+    def test_persona_sections_excludes_template(self, tmp_path):
+        builder = _builder_with_soul(tmp_path)
+        persona = builder.persona_sections()
+        assert "You are Kira." in persona
+        assert "AGENT_TEMPLATE" not in persona  # template is NOT in persona
+
+    def test_full_build_still_includes_template_and_persona(self, tmp_path):
+        builder = _builder_with_soul(tmp_path)
+        full = builder.build()
+        assert "AGENT_TEMPLATE" in full
+        assert "You are Kira." in full
+
+    def test_persona_sections_empty_when_no_files(self, tmp_path):
+        mf = MemoryFilesConfig(
+            soul_path=str(tmp_path / "nope.md"),
+            memory_path=str(tmp_path / "nope2.md"),
+            user_path=str(tmp_path / "nope3.md"),
+        )
+        builder = SystemPromptBuilder(agent_template="T", memory_files_config=mf)
+        assert builder.persona_sections() == ""
+
+
+class TestApplyPersona:
+    def test_appends_to_base_prompt(self, tmp_path):
+        from openjarvis.agents.simple import SimpleAgent
+
+        agent = SimpleAgent(object(), "m", prompt_builder=_builder_with_soul(tmp_path))
+        out = agent._apply_persona("MONITOR INSTRUCTIONS")
+        assert out.startswith("MONITOR INSTRUCTIONS")
+        assert "You are Kira." in out
+
+    def test_noop_without_builder(self):
+        from openjarvis.agents.simple import SimpleAgent
+
+        agent = SimpleAgent(object(), "m")
+        assert agent._apply_persona("BASE") == "BASE"
+
+
+class TestPersistentAgentsReceivePromptBuilder:
+    """The __init__ chain must forward prompt_builder through to BaseAgent."""
+
+    def test_monitor_operative_forwards_prompt_builder(self, tmp_path):
+        from openjarvis.agents.monitor_operative import MonitorOperativeAgent
+
+        builder = _builder_with_soul(tmp_path)
+        agent = MonitorOperativeAgent(object(), "m", prompt_builder=builder)
+        assert agent._prompt_builder is builder
+        applied = agent._apply_persona("MONITOR INSTRUCTIONS")
+        assert "MONITOR INSTRUCTIONS" in applied
+        assert "You are Kira." in applied
+
+    def test_operative_forwards_prompt_builder(self, tmp_path):
+        from openjarvis.agents.operative import OperativeAgent
+
+        builder = _builder_with_soul(tmp_path)
+        agent = OperativeAgent(object(), "m", prompt_builder=builder)
+        assert agent._prompt_builder is builder
+        assert "You are Kira." in agent._apply_persona("OP INSTRUCTIONS")
+
+    def test_monitor_operative_without_builder_is_unaffected(self):
+        from openjarvis.agents.monitor_operative import MonitorOperativeAgent
+
+        agent = MonitorOperativeAgent(object(), "m")
+        assert agent._prompt_builder is None
+        assert agent._apply_persona("BASE") == "BASE"

openjarvis-1.0.3.dev736/tests/server/test_managed_agent_streaming.py

@@ -0,0 +1,131 @@
+"""Managed-agent streaming parity tests (#382, #386, #395).
+
+These exercise the pure helpers extracted from ``_stream_managed_agent`` so the
+streaming path's history replay, sampler forwarding, and tool dependency
+injection can be verified without a live engine.
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+
+pytest.importorskip("fastapi")  # agent_manager_routes imports FastAPI at module load
+
+from openjarvis.core.types import Role  # noqa: E402
+from openjarvis.server.agent_manager_routes import (  # noqa: E402
+    _instantiate_managed_tool,
+    _replay_history_messages,
+    _sampler_kwargs,
+)
+
+
+class TestReplayHistoryToolCalls:
+    """#382 — stored tool_calls must be replayed, not dropped."""
+
+    def test_assistant_tool_calls_are_replayed_with_results(self):
+        history = [  # DESC order (newest first), as list_messages returns
+            {"id": "m2", "direction": "agent_to_user", "content": "", "tool_calls": [
+                {"tool": "shell_exec", "arguments": '{"command":"pwd"}',
+                 "result": "/home/u", "success": True, "latency": 1.0},
+            ]},
+            {"id": "m1", "direction": "user_to_agent", "content": "run pwd",
+             "tool_calls": None},
+        ]
+        msgs = _replay_history_messages(history, exclude_id="current")
+        # Chronological: user, assistant(tool_calls), tool(result)
+        assert [m.role for m in msgs] == [Role.USER, Role.ASSISTANT, Role.TOOL]
+        assistant = msgs[1]
+        assert assistant.tool_calls is not None
+        assert assistant.tool_calls[0].name == "shell_exec"
+        tool_msg = msgs[2]
+        assert tool_msg.content == "/home/u"
+        # The tool result must reference the assistant's tool_call id.
+        assert tool_msg.tool_call_id == assistant.tool_calls[0].id
+
+    def test_plain_assistant_without_tool_calls(self):
+        history = [
+            {"id": "m1", "direction": "agent_to_user", "content": "hi",
+             "tool_calls": None},
+        ]
+        msgs = _replay_history_messages(history, exclude_id="current")
+        assert len(msgs) == 1
+        assert msgs[0].role == Role.ASSISTANT
+        assert msgs[0].tool_calls is None
+
+    def test_excludes_current_message(self):
+        history = [
+            {"id": "cur", "direction": "user_to_agent", "content": "now",
+             "tool_calls": None},
+            {"id": "old", "direction": "user_to_agent", "content": "before",
+             "tool_calls": None},
+        ]
+        msgs = _replay_history_messages(history, exclude_id="cur")
+        assert [m.content for m in msgs] == ["before"]
+
+
+class TestSamplerKwargs:
+    """#386 — sampler params forwarded only when set."""
+
+    def test_reads_present_keys(self):
+        cfg = {"temperature": 0.7, "repetition_penalty": 1.1, "top_p": 0.9,
+               "top_k": 40, "min_p": 0.05, "frequency_penalty": 0.2,
+               "presence_penalty": 0.1}
+        out = _sampler_kwargs(cfg)
+        assert out == {"repetition_penalty": 1.1, "top_p": 0.9, "top_k": 40,
+                       "min_p": 0.05, "frequency_penalty": 0.2,
+                       "presence_penalty": 0.1}
+        # temperature/max_tokens are handled separately, not here.
+        assert "temperature" not in out
+
+    def test_omits_absent_keys(self):
+        assert _sampler_kwargs({"temperature": 0.7}) == {}
+
+    def test_none_values_skipped(self):
+        assert _sampler_kwargs({"top_p": None, "repetition_penalty": 1.05}) == {
+            "repetition_penalty": 1.05
+        }
+
+
+class _FakeTool:
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+
+
+class TestInstantiateManagedTool:
+    """#395 — tools get their dependencies injected."""
+
+    def test_memory_tool_gets_backend(self):
+        backend = object()
+        app_state = SimpleNamespace(memory_backend=backend, config=None,
+                                    channel_bridge=None)
+        tool = _instantiate_managed_tool(_FakeTool, "memory_store",
+                                         engine=object(), model="m",
+                                         app_state=app_state)
+        assert tool.kwargs == {"backend": backend}
+
+    def test_llm_tool_gets_engine_and_model(self):
+        engine = object()
+        app_state = SimpleNamespace(memory_backend=None, config=None,
+                                    channel_bridge=None)
+        tool = _instantiate_managed_tool(_FakeTool, "llm", engine=engine,
+                                         model="qwen", app_state=app_state)
+        assert tool.kwargs == {"engine": engine, "model": "qwen"}
+
+    def test_channel_tool_gets_channel(self):
+        bridge = object()
+        app_state = SimpleNamespace(memory_backend=None, config=None,
+                                    channel_bridge=bridge)
+        tool = _instantiate_managed_tool(_FakeTool, "channel_send",
+                                         engine=object(), model="m",
+                                         app_state=app_state)
+        assert tool.kwargs == {"channel": bridge}
+
+    def test_plain_tool_gets_no_injection(self):
+        app_state = SimpleNamespace(memory_backend=None, config=None,
+                                    channel_bridge=None)
+        tool = _instantiate_managed_tool(_FakeTool, "calculator",
+                                         engine=object(), model="m",
+                                         app_state=app_state)
+        assert tool.kwargs == {}