def build(self) -> JarvisSystem:
"""Construct a fully wired JarvisSystem."""
config = self._config
bus = self._bus or get_event_bus()
engine, engine_key = self._resolve_engine(config)
model = self._resolve_model(config, engine)
telemetry_enabled = (
self._telemetry if self._telemetry is not None else config.telemetry.enabled
)
traces_enabled = (
self._traces if self._traces is not None else config.traces.enabled
)
config.traces.enabled = traces_enabled
gpu_monitor = None
energy_monitor = None
if telemetry_enabled and config.telemetry.gpu_metrics:
try:
from openjarvis.telemetry.energy_monitor import (
create_energy_monitor,
)
energy_monitor = create_energy_monitor(
poll_interval_ms=config.telemetry.gpu_poll_interval_ms,
prefer_vendor=config.telemetry.energy_vendor or None,
)
except ImportError:
pass
if energy_monitor is None:
try:
from openjarvis.telemetry.gpu_monitor import GpuMonitor
if GpuMonitor.available():
gpu_monitor = GpuMonitor(
poll_interval_ms=config.telemetry.gpu_poll_interval_ms,
)
except ImportError:
pass
from openjarvis.security import setup_security
sec = setup_security(config, engine, bus)
engine = sec.engine
if telemetry_enabled:
from openjarvis.telemetry.instrumented_engine import (
InstrumentedEngine,
)
engine = InstrumentedEngine(
engine,
bus,
gpu_monitor=gpu_monitor,
energy_monitor=energy_monitor,
)
telemetry_store = None
if telemetry_enabled:
telemetry_store = self._setup_telemetry(config, bus)
memory_backend = self._resolve_memory(config)
channel_backend = self._resolve_channel(config, bus)
tool_list = self._resolve_tools(
config,
engine,
model,
memory_backend,
channel_backend,
)
tool_executor = ToolExecutor(tool_list, bus) if tool_list else None
skill_manager = None
skill_few_shot_examples: List[str] = []
if config.skills.enabled:
try:
from pathlib import Path
from openjarvis.skills.manager import SkillManager
skill_manager = SkillManager(
bus, capability_policy=sec.capability_policy
)
skill_paths = [Path(config.skills.skills_dir).expanduser()]
workspace_skills = Path("./skills")
if workspace_skills.exists():
skill_paths.insert(0, workspace_skills)
skill_manager.discover(paths=skill_paths)
if tool_executor:
skill_manager.set_tool_executor(tool_executor)
skill_tools = skill_manager.get_skill_tools(
tool_executor=tool_executor,
)
tool_list.extend(skill_tools)
if tool_list:
tool_executor = ToolExecutor(tool_list, bus)
skill_few_shot_examples = skill_manager.get_few_shot_examples()
except Exception as exc:
logger.warning("Failed to initialize skills: %s", exc)
agent_name = self._agent_name or config.agent.default_agent
container_runner = self._setup_sandbox(config)
scheduler_store, task_scheduler = self._setup_scheduler(config, bus)
workflow_engine = self._setup_workflow(config, bus)
session_store = self._setup_sessions(config)
trace_store = None
if traces_enabled:
try:
from openjarvis.traces.store import TraceStore
trace_store = TraceStore(config.traces.db_path)
except Exception:
logger.warning("Failed to initialize TraceStore", exc_info=True)
capability_policy = sec.capability_policy
learning_orchestrator = self._setup_learning_orchestrator(config)
agent_manager = None
if config.agent_manager.enabled:
try:
from pathlib import Path
from openjarvis.agents.manager import AgentManager
am_db = config.agent_manager.db_path or str(
Path("~/.openjarvis/agents.db").expanduser()
)
agent_manager = AgentManager(db_path=am_db)
except Exception as exc:
logger.warning("Failed to initialize agent manager: %s", exc)
agent_executor = None
agent_scheduler = None
if agent_manager is not None:
try:
from openjarvis.agents.executor import AgentExecutor
from openjarvis.agents.scheduler import AgentScheduler
_trace_store = None
if config.traces.enabled:
try:
from openjarvis.traces.store import TraceStore
_trace_store = TraceStore(config.traces.db_path)
except Exception:
logger.warning(
"Failed to initialize TraceStore",
exc_info=True,
)
agent_executor = AgentExecutor(
manager=agent_manager,
event_bus=bus,
trace_store=_trace_store,
)
agent_scheduler = AgentScheduler(
manager=agent_manager,
executor=agent_executor,
)
except Exception:
logger.warning("Failed to initialize agent scheduler", exc_info=True)
speech_backend = None
speech_enabled = self._speech if self._speech is not None else True
if speech_enabled:
try:
from openjarvis.speech._discovery import get_speech_backend
speech_backend = get_speech_backend(config)
except Exception as exc:
logger.warning("Failed to initialize speech backend: %s", exc)
system = JarvisSystem(
config=config,
bus=bus,
engine=engine,
engine_key=engine_key,
model=model,
agent_name=agent_name,
tools=tool_list,
tool_executor=tool_executor,
memory_backend=memory_backend,
channel_backend=channel_backend,
telemetry_store=telemetry_store,
trace_store=trace_store,
gpu_monitor=gpu_monitor,
scheduler_store=scheduler_store,
scheduler=task_scheduler,
container_runner=container_runner,
workflow_engine=workflow_engine,
session_store=session_store,
capability_policy=capability_policy,
audit_logger=sec.audit_logger,
agent_manager=agent_manager,
agent_scheduler=agent_scheduler,
agent_executor=agent_executor,
speech_backend=speech_backend,
skill_manager=skill_manager,
)
system._learning_orchestrator = learning_orchestrator
system._skill_few_shot_examples = skill_few_shot_examples
system._mcp_clients = list(getattr(self, "_mcp_clients", []))
if system.agent_executor is not None:
system.agent_executor.set_system(system)
return system