@click.command()
@click.option("-e", "--engine", "engine_key", default=None, help="Engine backend.")
@click.option(
"-m",
"--model",
"model_name",
default=None,
help=(
"Model id. Omit or use ``smart`` for preset: [intelligence] model_chat / "
"model_short / model_long / model_code, then default_model."
),
)
@click.option(
"--pick-model",
"pick_model",
is_flag=True,
default=False,
help=(
"Show the model list before chat. Bare ``jarvis`` already does this on a TTY "
"unless JARVIS_SKIP_MODEL_PICK=1."
),
)
@click.option("-a", "--agent", "agent_name", default=None, help="Agent type.")
@click.option("--tools", default=None, help="Comma-separated tool names.")
@click.option("--system", "system_prompt", default=None, help="Custom system prompt.")
@click.option(
"--persona",
"persona_name",
default=None,
help=(
"Named persona dir under ~/.openjarvis/personas/<name>/ "
"(overrides config). Pass 'none' to disable all persona files."
),
)
@click.option(
"--voice",
"voice_mode",
is_flag=True,
default=False,
help="Enable voice I/O: mic input with silence detection + TTS response playback.",
)
@runtime_cli_options
def chat(
engine_key: str | None,
model_name: str | None,
pick_model: bool,
agent_name: str | None,
tools: str | None,
system_prompt: str | None,
persona_name: str | None,
voice_mode: bool,
num_ctx: int | None,
num_gpu: int | None,
skip_runtime_panel: bool,
) -> None:
"""Start an interactive multi-turn chat session.
Model: omit ``-m`` to use ``[intelligence] model_chat`` if set, else
``default_model``; ``-m smart`` is the same. Use ``--pick-model`` to open the
engine list first (bare ``jarvis`` does this on a TTY unless
``JARVIS_SKIP_MODEL_PICK=1``).
Commands during chat:
/quit, /exit — end session
/clear — clear conversation history
/model — show current model
/runtime — Ollama context + GPU offload for this session
/help — show available commands
/history — show conversation history
Pass --voice to use microphone input (silence-detection) and hear responses
read back via text-to-speech (kokoro local or OpenAI TTS).
"""
console = Console(stderr=True)
config = load_config()
bus = EventBus(record_history=False)
import dataclasses as _dc
effective_mf = (
_dc.replace(config.memory_files, persona_name=persona_name)
if persona_name is not None
else config.memory_files
)
# Resolve engine
from openjarvis.engine import get_engine
from openjarvis.intelligence import register_builtin_models
register_builtin_models()
resolved = get_engine(config, engine_key)
if resolved is None:
console.print("[red]No inference engine available.[/red]")
sys.exit(1)
engine_name, engine = resolved
from openjarvis.cli._model_switch import (
interactive_pick_model,
resolve_chat_cli_model,
tty_wants_model_picker,
)
model = ""
if tty_wants_model_picker(pick_model):
console.print(
"[dim]Pick a model below, or press Enter for config default "
"(intelligence presets / default_model).[/dim]\n",
)
picked = interactive_pick_model(console, engine)
if picked:
model = picked
if not model:
model = resolve_chat_cli_model(
console=console,
config=config,
engine=engine,
engine_name=engine_name,
cli_model=model_name,
chat_variant="chat",
)
if not model:
console.print("[red]No model available.[/red]")
sys.exit(1)
from openjarvis.cli._runtime_panel import (
ChatRuntimeOptions,
interactive_pick_runtime_options,
tty_wants_runtime_panel,
)
if engine_name != "ollama" and (num_ctx is not None or num_gpu is not None):
raise click.UsageError(
"--num-ctx and --num-gpu are supported only with --engine ollama"
)
if engine_name == "ollama" and tty_wants_runtime_panel(skip_runtime_panel):
runtime_opts = interactive_pick_runtime_options(
console,
engine_name=engine_name,
cli_num_ctx=num_ctx,
cli_num_gpu=num_gpu,
)
elif engine_name == "ollama" and (num_ctx is not None or num_gpu is not None):
runtime_opts = ChatRuntimeOptions(num_ctx=num_ctx, num_gpu=num_gpu)
else:
runtime_opts = ChatRuntimeOptions()
engine_kwargs = runtime_opts.to_engine_kwargs(engine_name=engine_name)
# Resolve agent (optional)
agent = None
agent_key = agent_name or config.agent.default_agent
if agent_key and agent_key != "none":
try:
import openjarvis.agents # noqa: F401 — trigger registration
from openjarvis.core.registry import AgentRegistry
if AgentRegistry.contains(agent_key):
agent_cls = AgentRegistry.get(agent_key)
kwargs: dict = {"bus": bus}
if getattr(agent_cls, "accepts_tools", False):
tool_names_list = resolve_tool_names(
tools,
getattr(config.tools, "enabled", None),
getattr(config.agent, "tools", None),
)
if tool_names_list:
import openjarvis.tools # noqa: F401 — trigger registration
from openjarvis.core.registry import ToolRegistry
from openjarvis.tools._stubs import BaseTool
tool_instances = []
for tname in tool_names_list:
if ToolRegistry.contains(tname):
tcls = ToolRegistry.get(tname)
if isinstance(tcls, type) and issubclass(
tcls, BaseTool
):
tool_instances.append(tcls())
elif isinstance(tcls, BaseTool):
tool_instances.append(tcls)
if tool_instances:
kwargs["tools"] = tool_instances
kwargs["max_turns"] = config.agent.max_turns
def _confirm(prompt: str) -> bool:
console.print(
f"[yellow]Confirm:[/yellow] {prompt} [y/N] ",
end="",
)
ans = input().strip().lower()
return ans in ("y", "yes")
kwargs["interactive"] = True
kwargs["confirm_callback"] = _confirm
import inspect as _inspect
if (
"prompt_builder"
in _inspect.signature(agent_cls.__init__).parameters
):
from openjarvis.prompt.builder import SystemPromptBuilder
kwargs["prompt_builder"] = SystemPromptBuilder(
agent_template=config.agent.default_system_prompt or "",
memory_files_config=effective_mf,
system_prompt_config=config.system_prompt,
)
agent = agent_cls(engine, model, **kwargs)
if agent is not None and engine_kwargs:
# Agents like NativeReActAgent do not accept engine_options
# in __init__; session opts live on BaseAgent._engine_options.
setattr(agent, "_engine_options", dict(engine_kwargs))
except Exception as exc:
console.print(
f"[yellow]Agent '{_safe_rich_label(agent_key)}' failed: "
f"{escape(str(exc))}[/yellow]"
)
# Keep voice state outside the core chat path so picker/runtime changes can
# be layered independently. Loaded speech models live for this session.
voice_session = VoiceSession(config) if voice_mode else None
# Print banner
voice_hint = (
" [magenta]Voice mode ON[/magenta] — type normally, or press Enter "
"to speak; silence stops recording.\n"
if voice_mode
else ""
)
console.print(
f"[green bold]OpenJarvis Chat[/green bold]\n"
f" Engine: [cyan]{_safe_rich_label(engine_name)}[/cyan] "
f"Model: [cyan]{_safe_rich_label(model)}[/cyan]"
f" Agent: [cyan]{_safe_rich_label(agent_key or 'direct')}[/cyan]\n"
f" Runtime: [cyan]{runtime_opts.summary(engine_name=engine_name)}[/cyan]\n"
f"{voice_hint}"
f" Type /help for commands, /quit to exit.\n",
)
# Background-work status banner (disappears after first user message)
from openjarvis.cli._bg_state import get_status
from openjarvis.cli._chat_banner import render_startup_banner
_banner = render_startup_banner(get_status())
if _banner:
console.print(f"[dim cyan]{_banner}[/dim cyan]")
# Completion-notification dispatcher (fires once per task per session)
from openjarvis.cli._chat_notifications import NotificationDispatcher
_notifications = NotificationDispatcher(get_status())
# Automatic long-term memory — extracts durable facts in the background.
memory_service = None
try:
from openjarvis.memory import build_memory_service
memory_service = build_memory_service(config, engine, model, event_bus=bus)
if memory_service is not None:
memory_service.start()
console.print("[dim] Memory: active[/dim]")
except Exception as exc:
console.print(f"[yellow]Memory service unavailable: {exc}[/yellow]")
memory_service = None
# The document backend and automatic fact store are separate persistence
# mechanisms. Context injection combines both at read time so facts from
# previous sessions are immediately available without a manual index step.
memory_backend = None
if config.agent.context_from_memory:
from openjarvis.cli.ask import _get_memory_backend
memory_backend = _get_memory_backend(config)
# Conversation state
if not system_prompt:
from openjarvis.prompt.builder import SystemPromptBuilder
builder = SystemPromptBuilder(
agent_template=config.agent.default_system_prompt or "",
memory_files_config=effective_mf,
system_prompt_config=config.system_prompt,
)
system_prompt = builder.build()
history: List[Message] = []
if system_prompt:
history.append(Message(role=Role.SYSTEM, content=system_prompt))
# REPL loop
while True:
for note in _notifications.diff(get_status()):
console.print(f"[dim cyan]{note}[/dim cyan]")
if voice_mode:
assert voice_session is not None
result = read_voice_input(console, voice_session)
if result is VOICE_EXIT:
console.print("\n[dim]Goodbye![/dim]")
break
if result is None:
continue # nothing heard, loop again
user_input = result
else:
user_input = _read_input()
if user_input is None:
console.print("\n[dim]Goodbye![/dim]")
break
user_input = user_input.strip()
if not user_input:
continue
# Handle slash commands
cmd = user_input.lower()
if cmd in ("/quit", "/exit", "/q"):
console.print("[dim]Goodbye![/dim]")
break
elif cmd == "/clear":
history = []
if system_prompt:
history.append(Message(role=Role.SYSTEM, content=system_prompt))
console.print("[dim]History cleared.[/dim]")
continue
elif cmd == "/model":
console.print(
f"Model: [cyan]{_safe_rich_label(model)}[/cyan] "
f"Engine: [cyan]{_safe_rich_label(engine_name)}[/cyan]"
)
continue
elif cmd == "/runtime":
console.print(
f"Runtime: [cyan]{runtime_opts.summary(engine_name=engine_name)}[/cyan]"
)
if engine_kwargs:
console.print(f" engine kwargs: {engine_kwargs}")
continue
elif cmd == "/help":
console.print(
"[bold]Commands:[/bold]\n"
" /quit, /exit — end session\n"
" /clear — clear conversation\n"
" /model — show model info\n"
" /runtime — Ollama context + GPU offload for this session\n"
" /history — show conversation\n"
" /help — this message"
)
continue
elif cmd == "/history":
if not history:
console.print("[dim]No history yet.[/dim]")
else:
for msg in history:
role_str = msg.role if isinstance(msg.role, str) else msg.role.value
role = role_str.upper()
console.print(f"[bold]{role}:[/bold] {msg.content[:200]}")
continue
# Add user message
history.append(Message(role=Role.USER, content=user_input))
generation_history = history
agent_context_message = None
if config.agent.context_from_memory:
try:
from openjarvis.memory import load_configured_facts
from openjarvis.tools.storage.context import (
ContextConfig,
inject_context,
)
if memory_service is not None and hasattr(memory_service, "list_facts"):
facts = memory_service.list_facts()
else:
facts = load_configured_facts(config)
ctx_cfg = ContextConfig(
top_k=config.memory.context_top_k,
min_score=config.memory.context_min_score,
max_context_tokens=config.memory.context_max_tokens,
)
context_messages = inject_context(
user_input,
[] if agent is not None else history,
memory_backend,
config=ctx_cfg,
facts=facts,
)
if agent is not None:
if context_messages:
agent_context_message = context_messages[0]
else:
generation_history = context_messages
except Exception:
logger.debug("Failed to inject memory context", exc_info=True)
# Generate response even when optional memory context is unavailable.
try:
if agent is not None:
from openjarvis.agents._stubs import AgentContext
agent_context = AgentContext()
if agent_context_message is not None:
agent_context.conversation.add(agent_context_message)
for msg in history[:-1]:
if msg.role != Role.SYSTEM:
agent_context.conversation.add(msg)
response = agent.run(user_input, context=agent_context)
content = (
response.content if hasattr(response, "content") else str(response)
)
else:
result = engine.generate(
generation_history,
model=model,
**engine_kwargs,
)
content = (
result.get("content", "")
if isinstance(result, dict)
else str(result)
)
history.append(Message(role=Role.ASSISTANT, content=content))
console.print()
console.print(Markdown(content))
console.print()
if voice_mode:
assert voice_session is not None
speak(content, console, voice_session)
publish_completed_exchange(
bus,
user_input,
content,
source="cli.chat",
)
except KeyboardInterrupt:
console.print("\n[dim]Generation interrupted.[/dim]")
except Exception as exc:
console.print(f"\n[red]Error: {exc}[/red]\n")
if memory_service is not None:
memory_service.stop()