OpenJarvis 1.0.2.dev678__tar.gz → 1.0.2.dev690__tar.gz

{openjarvis-1.0.2.dev678 → openjarvis-1.0.2.dev690}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenJarvis
-Version: 1.0.2.dev678
+Version: 1.0.2.dev690
 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.2.dev678 → openjarvis-1.0.2.dev690}/docs/architecture/engine.md

@@ -116,7 +116,7 @@ All providers produce the same output format consumed by agents:
 | **LM Studio** | `lmstudio` | OpenAI-compatible | 1234 | No (GPU optional) | Desktop GUI, easy model management |
 | **Exo** | `exo` | OpenAI-compatible | 52415 | No (distributed) | Distributed inference across heterogeneous devices |
 | **Nexa** | `nexa` | OpenAI-compatible | 18181 | No (CPU/GPU) | On-device inference with GGUF models |
-| **Lemonade** | `lemonade` | OpenAI-compatible | 8000 | AMD GPU/NPU | AMD consumer GPUs (RDNA), Ryzen AI NPUs |
+| **Lemonade** | `lemonade` | OpenAI-compatible | 13305 | AMD GPU/NPU | AMD consumer GPUs (RDNA), Ryzen AI NPUs |
 | **Uzu** | `uzu` | OpenAI-compatible | 8000 | Varies | Uzu inference runtime |
 | **Apple FM** | `apple_fm` | OpenAI-compatible | 8079 | Apple Silicon | Apple Foundation Model on-device inference |
 | **LiteLLM** | `litellm` | OpenAI-compatible | — | No | Unified proxy to 100+ LLM providers |
@@ -135,7 +135,7 @@ The Ollama backend communicates via Ollama's native HTTP API at `/api/chat` and
 
 The vLLM backend uses the OpenAI-compatible `/v1/chat/completions` API. It is recommended for datacenter GPUs (NVIDIA A100, H100, L40, A10, A30 and AMD MI300, MI325, MI350, MI355).
 
-- **Default host:** `http://localhost:8000`
+- **Default host:** `http://localhost:13305`
 - **Health check:** `GET /v1/models`
 - **Tool fallback:** If the server returns HTTP 400 when tools are included, the engine automatically retries without tools
 
@@ -204,7 +204,7 @@ The Nexa backend connects to the Nexa SDK on-device inference server via a FastA
 
 The Lemonade backend connects to the [Lemonade](https://lemonade-server.ai/) inference server, which is optimized for AMD consumer GPUs (RDNA architecture) and Ryzen AI Neural Processing Units (NPUs). It uses the OpenAI-compatible `/v1/chat/completions` API.
 
-- **Default host:** `http://localhost:8000`
+- **Default host:** `http://localhost:13305`
 - **Health check:** `GET /v1/models`
 - **Install:** Visit [lemonade-server.ai](https://lemonade-server.ai/) for platform-specific installation instructions
 - **Best for:** Ryzen AI GPUs and NPUs, and AMD-based desktop and laptop systems
@@ -357,7 +357,7 @@ host = "http://localhost:30000"
 # binary_path = ""
 
 # [engine.lemonade]
-# host = "http://localhost:8000"
+# host = "http://localhost:13305"
 ```
 
 The `EngineConfig` dataclass and its per-engine sub-dataclasses map these settings:
@@ -370,7 +370,7 @@ The `EngineConfig` dataclass and its per-engine sub-dataclasses map these settin
 | `SGLangEngineConfig` | `host` | `http://localhost:30000` | SGLang server URL |
 | `LlamaCppEngineConfig` | `host` | `http://localhost:8080` | llama.cpp server URL |
 | `LlamaCppEngineConfig` | `binary_path` | `""` | Path to llama.cpp binary (for managed mode) |
-| `LemonadeEngineConfig` | `host` | `http://localhost:8000` | Lemonade server URL |
+| `LemonadeEngineConfig` | `host` | `http://localhost:13305` | Lemonade server URL |
 
 !!! note "Backward compatibility"
     The old flat field names `ollama_host`, `vllm_host`, `llamacpp_host`, `llamacpp_path`, `sglang_host`, and `lemonade_host` under `[engine]` are still accepted as backward-compatible properties on `EngineConfig`. New configurations should use the nested sub-section format.

{openjarvis-1.0.2.dev678 → openjarvis-1.0.2.dev690}/docs/user-guide/skills.md

@@ -148,6 +148,14 @@ jarvis skill sync openclaw --search "web3|crypto"
 jarvis skill install github:user/repo/path/to/skill --url https://github.com/user/repo
 ```
 
+For example, install the Hermes Tweet skill when you want an agent to search
+Twitter/X, read tweet replies, monitor tweets, export followers, and run
+gated post, reply, or DM workflows:
+
+```bash
+jarvis skill install github:Xquik-dev/hermes-tweet/skills/hermes-tweet --url https://github.com/Xquik-dev/hermes-tweet
+```
+
 ### Config-Driven Auto Import
 
 Add sources to `~/.openjarvis/config.toml` for automatic syncing:

{openjarvis-1.0.2.dev678 → openjarvis-1.0.2.dev690}/pyproject.toml

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

{openjarvis-1.0.2.dev678 → openjarvis-1.0.2.dev690}/src/openjarvis/agents/executor.py

@@ -317,6 +317,24 @@ class AgentExecutor:
                         tool_instances.append(tool)
                     except Exception:
                         logger.warning("Failed to instantiate tool %s", tname)
+
+            # Pull tools already discovered by SystemBuilder (e.g. external MCP
+            # adapters) that aren't in the static ToolRegistry. Without this,
+            # agents declaring MCP-discovered tools in their template would
+            # silently fall back to natives only.
+            if (
+                self._system is not None
+                and getattr(self._system, "tool_executor", None) is not None
+            ):
+                mcp_pool = getattr(self._system.tool_executor, "_tools", {}) or {}
+                existing = {t.spec.name for t in tool_instances}
+                for tname in tool_names:
+                    if tname in existing:
+                        continue
+                    pooled = mcp_pool.get(tname)
+                    if pooled is not None:
+                        tool_instances.append(pooled)
+
             if tool_instances:
                 logger.info(
                     "Agent %s: resolved %d/%d tools",
@@ -332,6 +350,12 @@ class AgentExecutor:
             agent_kwargs["system_prompt"] = sys_prompt
         if getattr(agent_cls, "accepts_tools", False) and tool_instances:
             agent_kwargs["tools"] = tool_instances
+        # Propagate confirmation policy from the AgentExecutor down to the
+        # agent's own ToolExecutor. Set by CLI paths like `jarvis agents ask`
+        # so non-interactive runs can auto-approve tool execution.
+        if getattr(self, "_confirm_callback", None) is not None:
+            agent_kwargs["interactive"] = True
+            agent_kwargs["confirm_callback"] = self._confirm_callback
         try:
             agent_instance = agent_cls(engine, model, **agent_kwargs)
         except TypeError:

{openjarvis-1.0.2.dev678 → openjarvis-1.0.2.dev690}/src/openjarvis/agents/research_loop.py

@@ -17,10 +17,11 @@ from __future__ import annotations
 
 import json
 import logging
+import re
 import sys
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from openjarvis.connectors.hybrid_search import HybridSearch, SearchHit
 from openjarvis.core.types import Message, Role, ToolCall
@@ -102,7 +103,15 @@ SEARCH_TOOL_SPEC: Dict[str, Any] = {
                 },
                 "sources": {
                     "type": "array",
-                    "description": "Restrict to these connectors (e.g. ['gmail']).",
+                    "description": (
+                        "Restrict the search to one or more connectors. Use this "
+                        "whenever the user names a data source (e.g. \"in my "
+                        "Granola notes\" → ['granola']; \"check Slack and Gmail\" "
+                        "→ ['slack', 'gmail']). Valid IDs include: gmail, slack, "
+                        "granola, notion, obsidian, gcalendar, gdrive, gmail_imap, "
+                        "outlook, imessage, whatsapp, apple_notes, apple_contacts, "
+                        "gcontacts, google_tasks, github_notifications."
+                    ),
                     "items": {"type": "string"},
                 },
                 "limit": {
@@ -117,7 +126,12 @@ SEARCH_TOOL_SPEC: Dict[str, Any] = {
 }
 
 
-SYSTEM_PROMPT = """You are a research assistant with access to the user's personal knowledge corpus (their email, notes, calendar). You answer questions by calling two tools:
+SYSTEM_PROMPT = """You are a research assistant with access to the user's personal knowledge corpus.
+
+The user's corpus contains data from these sources only:
+{available_sources}
+
+You answer questions by calling two tools:
 
     search(query, person=None, time_range=None, sources=None, limit=20)
     clarify(question)
@@ -126,10 +140,12 @@ Strategy:
   1. If the user names a person, ALWAYS pass `person=` rather than relying on lexical match. Hybrid search will fuzzy-match name or address fragments.
   2. When the user mentions ANY time window — "this past week", "recently", "last month", "past few days", "yesterday" — you MUST translate it to a `time_range` parameter. Today is {today}.
   3. The `time_range` argument is a JSON object: `{{"start": "<ISO 8601>", "end": "<ISO 8601>"}}`. Either bound may be omitted, but pass at least one whenever the user gave you a temporal cue.
-  4. If the first structured search returns nothing useful, broaden with a semantic query and drop filters one at a time.
-  5. You have a clarify tool. Only use it AFTER at least one search attempt. Use it when: you found multiple ambiguous matches (e.g. 3 different people named John), search returned zero results and the query might need reframing, or the scope is too broad to synthesize meaningfully. Never use clarify before searching — always try first.
-  6. After receiving a clarify response, use the information to construct a precise search with the correct person, time_range, and query parameters. Never send an empty query or a query with no parameters — extract every concrete signal from the user's reply (names, dates, topics) and put it on the call.
-  7. Tool calls — search AND clarify — share a budget of 5 total. Spend wisely.
+  4. When the user names a specific data source — "my Granola notes", "in Slack", "from my email" — you MUST pass `sources=[...]` with the matching connector ID. Only use IDs that appear in the connected-sources list above; do NOT invent or assume sources that are not connected. Common synonyms: "meeting notes"/"meetings"/"transcripts" → granola; "email"/"inbox" → gmail; "DMs"/"channels" → slack. Without this filter the search returns mail/messages ABOUT a tool instead of records FROM that tool.
+  4a. Never apologize about sources that aren't in the connected-sources list — if the user asks about "Notion" but Notion isn't connected, just say "Notion isn't connected, but here's what I found in {available_sources}" and answer from what is available.
+  5. If the first structured search returns nothing useful, broaden with a semantic query and drop filters one at a time.
+  6. You have a clarify tool. Only use it AFTER at least one search attempt. Use it when: you found multiple ambiguous matches (e.g. 3 different people named John), search returned zero results and the query might need reframing, or the scope is too broad to synthesize meaningfully. Never use clarify before searching — always try first.
+  7. After receiving a clarify response, use the information to construct a precise search with the correct person, time_range, sources, and query parameters. Never send an empty query or a query with no parameters — extract every concrete signal from the user's reply (names, dates, topics, sources) and put it on the call.
+  8. Tool calls — search AND clarify — share a budget of 5 total. Spend wisely.
 
 Synthesis rules:
   - Cite sources as individual numbers in square brackets. Always separate — write [4] [7] [20], never [4, 7, 20]. Never format citations as markdown links. Just the number in brackets: [1]. The `ref` field on each hit is the citation number.
@@ -161,21 +177,24 @@ def shape_results_for_model(
     detailed_top: int = 5,
     thread_ctx_per_hit: int = 3,
     total_cap: int = 20,
+    ref_offset: int = 0,
 ) -> Dict[str, Any]:
     """Compact a hit list into a JSON payload the planner can chew through.
 
     The first ``detailed_top`` rows keep their content snippet and trimmed
     thread context; the remainder are summarised to title + sender + date so
     the planner still sees the breadth of what's available without blowing the
-    context window. Each hit gets a 1-indexed numeric ``ref`` so the synthesis
-    can cite it as ``[N]``.
+    context window. Each hit gets a numeric ``ref`` (1-indexed, plus
+    ``ref_offset``) so the synthesis can cite it as ``[N]``. The offset lets
+    multi-search runs hand the planner globally unique refs across calls so
+    a later renumbering pass can dedupe by first appearance.
     """
     out_hits: List[Dict[str, Any]] = []
     visible = hits[:total_cap]
     for i, h in enumerate(visible):
         sender = h.participants[0] if h.participants else ""
         base = {
-            "ref": i + 1,
+            "ref": i + 1 + ref_offset,
             "title": h.title,
             "sender": sender,
             "timestamp": h.timestamp,
@@ -223,11 +242,15 @@ def _bare_doc_id(source: str, document_id: str) -> str:
 
 
 def _hit_url(source: str, document_id: str) -> str:
-    """Build a clickable URL for a hit, when we know how to link it.
+    """Reconstruct a clickable URL from a hit's ``doc_id`` alone.
 
-    Gmail and Slack are the linkable sources today; anything else falls
-    back to an empty string and the client renders a non-clickable
-    citation chip.
+    Used as a *fallback* when the connector didn't persist a URL on the
+    chunk (``SearchHit.url`` is empty). Reconstruction only works for
+    sources whose doc_id encodes everything the permalink needs — Gmail
+    and Slack today. Sources whose doc_id is just an opaque ID (e.g.
+    Granola, where the web URL uses a different UUID than the API note_id)
+    must populate ``Document.url`` at ingest time; we can't make a working
+    link from the doc_id alone.
 
     Gmail ids land here in two flavors:
 
@@ -275,10 +298,76 @@ def _hit_url(source: str, document_id: str) -> str:
     return ""
 
 
+_CITE_RE = re.compile(r"\[(\d+)\]")
+
+
+def renumber_citations(
+    text: str,
+    ref_to_source: Dict[int, Dict[str, Any]],
+) -> Tuple[str, List[Dict[str, Any]]]:
+    """Renumber ``[N]`` citations in ``text`` by first-appearance order.
+
+    The planner sees globally-offset refs across multiple search calls
+    (search 1 returns 1..20, search 2 returns 21..40, …). When the
+    synthesis arrives, the first ref the model actually cited becomes
+    ``[1]``, the second unique one becomes ``[2]``, and so on. Repeats
+    map to the same new ref. Refs the synthesis never cites are dropped
+    from the returned ``sources`` list — only the ones the user can
+    actually click on get carried through.
+
+    Parameters
+    ----------
+    text:
+        Synthesis text containing inline ``[N]`` references.
+    ref_to_source:
+        Mapping from the original (offset) ref to the source dict that
+        ``build_sources_for_client`` produced for that hit.
+
+    Returns
+    -------
+    (new_text, ordered_sources)
+        ``new_text`` has every cited ``[N]`` rewritten to its new
+        sequence number. ``ordered_sources`` is the deduped list of
+        source dicts in the order they appear in the synthesis, each
+        with its ``ref`` field set to the new sequence number.
+    """
+    old_to_new: Dict[int, int] = {}
+    ordered: List[Dict[str, Any]] = []
+    for m in _CITE_RE.finditer(text):
+        try:
+            old = int(m.group(1))
+        except ValueError:
+            continue
+        if old in old_to_new:
+            continue
+        src = ref_to_source.get(old)
+        if src is None:
+            # Synthesis cited a ref that doesn't exist in the corpus —
+            # leave the literal text alone, drop the source entry.
+            continue
+        new_ref = len(ordered) + 1
+        old_to_new[old] = new_ref
+        renumbered_src = dict(src)
+        renumbered_src["ref"] = new_ref
+        ordered.append(renumbered_src)
+
+    def _replace(match: "re.Match[str]") -> str:
+        try:
+            old = int(match.group(1))
+        except ValueError:
+            return match.group(0)
+        new = old_to_new.get(old)
+        return f"[{new}]" if new is not None else match.group(0)
+
+    new_text = _CITE_RE.sub(_replace, text)
+    return new_text, ordered
+
+
 def build_sources_for_client(
     hits: List[SearchHit],
     *,
     total_cap: int = 20,
+    ref_offset: int = 0,
 ) -> List[Dict[str, Any]]:
     """Produce the citation-friendly sources list streamed to the frontend.
 
@@ -291,14 +380,21 @@ def build_sources_for_client(
     out: List[Dict[str, Any]] = []
     for i, h in enumerate(hits[:total_cap]):
         sender = h.participants[0] if h.participants else ""
+        # Prefer the URL the connector stored at ingest time (Granola's
+        # ``web_url``, Notion's page URL, etc.) — it's the only reliable
+        # link for sources whose web URL doesn't derive from the doc_id.
+        # Fall back to the doc_id-based reconstruction for sources where
+        # that still works (Slack, Gmail).
+        url = h.url or _hit_url(h.source, h.document_id)
         out.append(
             {
-                "ref": i + 1,
+                "ref": i + 1 + ref_offset,
                 "title": h.title,
                 "sender": sender,
                 "date": _hit_date(h.timestamp),
+                "source": h.source,
                 "source_id": _bare_doc_id(h.source, h.document_id),
-                "url": _hit_url(h.source, h.document_id),
+                "url": url,
             }
         )
     return out
@@ -389,6 +485,7 @@ class ResearchAgent:
         num_ctx: int = 16384,
         clarify_handler: Optional[Callable[[str], str]] = None,
         on_event: Optional[Callable[[Dict[str, Any]], None]] = None,
+        available_sources: Optional[List[str]] = None,
     ) -> None:
         self._engine = engine
         self._search = search
@@ -399,6 +496,10 @@ class ResearchAgent:
         self._num_ctx = int(num_ctx)
         self._clarify_handler = clarify_handler or _default_clarify_handler
         self._on_event = on_event
+        # Explicit list wins; otherwise we'll discover sources from the
+        # KnowledgeStore on each run() call so the prompt stays accurate
+        # even as the user connects new connectors mid-session.
+        self._available_sources_override = available_sources
 
     def _emit(self, event: Dict[str, Any]) -> None:
         """Fire ``self._on_event`` if set; swallow callback errors."""
@@ -485,17 +586,56 @@ class ResearchAgent:
     # Loop
     # ------------------------------------------------------------------
 
+    def _resolve_available_sources(self) -> List[str]:
+        """Return the source IDs the user actually has data for.
+
+        Override > live query of the KnowledgeStore. Failure to read the
+        store (e.g. no _store attribute on the search backend) returns
+        ``[]`` so the prompt still formats — better empty than crashing.
+        """
+        if self._available_sources_override is not None:
+            return list(self._available_sources_override)
+        store = getattr(self._search, "_store", None)
+        if store is None:
+            return []
+        try:
+            return list(store.distinct_sources())
+        except Exception as exc:  # noqa: BLE001
+            logger.debug("distinct_sources() failed: %s", exc)
+            return []
+
     def run(self, query: str) -> ResearchResult:
         """Run the loop end-to-end and return the synthesis plus a trace."""
+        sources_list = self._resolve_available_sources()
+        if sources_list:
+            sources_blurb = ", ".join(sources_list)
+        else:
+            sources_blurb = (
+                "(no connected sources — tell the user to connect a "
+                "connector before searching)"
+            )
         sys_msg = Message(
             role=Role.SYSTEM,
-            content=SYSTEM_PROMPT.format(today=datetime.now().isoformat(timespec="minutes")),
+            content=SYSTEM_PROMPT.format(
+                today=datetime.now().isoformat(timespec="minutes"),
+                available_sources=sources_blurb,
+            ),
         )
         messages: List[Message] = [sys_msg, Message(role=Role.USER, content=query)]
 
         invocations: List[ToolInvocation] = []
         total_usage = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
 
+        # Global ref counter: each search increments by the number of hits
+        # it returned so the planner sees unique refs across calls. The
+        # accumulator lets us renumber whatever the synthesis cites at the
+        # end into a single deduped client-facing sources list.
+        next_ref: int = 1
+        ref_to_source: Dict[int, Dict[str, Any]] = {}
+
+        def _finalize(text: str) -> Tuple[str, List[Dict[str, Any]]]:
+            return renumber_citations(text, ref_to_source)
+
         iterations = 0
         for _ in range(self._max_iterations + 1):
             iterations += 1
@@ -520,8 +660,14 @@ class ResearchAgent:
 
             if not tool_calls_raw:
                 if content.strip():
-                    answer = content.strip()
-                    self._emit({"type": "final_answer", "text": answer})
+                    answer, final_sources = _finalize(content.strip())
+                    self._emit(
+                        {
+                            "type": "final_answer",
+                            "text": answer,
+                            "sources": final_sources,
+                        }
+                    )
                     return ResearchResult(
                         answer=answer,
                         iterations=iterations,
@@ -542,7 +688,9 @@ class ResearchAgent:
                     )
                     continue
                 fallback = "(model returned no content and no tool calls)"
-                self._emit({"type": "final_answer", "text": fallback})
+                self._emit(
+                    {"type": "final_answer", "text": fallback, "sources": []}
+                )
                 return ResearchResult(
                     answer=fallback,
                     iterations=iterations,
@@ -579,16 +727,24 @@ class ResearchAgent:
                     self._emit({"type": "search_call", "arguments": args})
                     inv = self._execute_search(args)
                     invocations.append(inv)
+                    offset = next_ref - 1
+                    sources_for_search = build_sources_for_client(
+                        inv.raw_hits, ref_offset=offset
+                    )
                     self._emit(
                         {
                             "type": "search_result",
                             "num_hits": inv.num_results,
                             "top_titles": inv.top_titles,
-                            "sources": build_sources_for_client(inv.raw_hits),
+                            "sources": sources_for_search,
                         }
                     )
+                    for src in sources_for_search:
+                        ref_to_source[int(src["ref"])] = src
+                    next_ref += len(sources_for_search)
                     tool_output = json.dumps(
-                        shape_results_for_model(inv.raw_hits), ensure_ascii=False
+                        shape_results_for_model(inv.raw_hits, ref_offset=offset),
+                        ensure_ascii=False,
                     )
                 elif name == "clarify":
                     # Enforce the "search first" rule at runtime so we don't
@@ -686,7 +842,10 @@ class ResearchAgent:
                 "(no synthesis available — the search budget was exhausted "
                 "and the model returned no text response)"
             )
-        self._emit({"type": "final_answer", "text": answer})
+        answer, final_sources = _finalize(answer)
+        self._emit(
+            {"type": "final_answer", "text": answer, "sources": final_sources}
+        )
         return ResearchResult(
             answer=answer,
             iterations=iterations,

{openjarvis-1.0.2.dev678 → openjarvis-1.0.2.dev690}/src/openjarvis/cli/agent_cmd.py

@@ -702,16 +702,34 @@ def errors():
 @agent.command("ask")
 @click.argument("agent_id")
 @click.argument("message")
-def ask(agent_id, message):
+@click.option(
+    "--yes/--no-yes",
+    "auto_approve",
+    default=True,
+    help="Auto-approve tool execution that would otherwise need confirmation. "
+    "Default: on (suits non-interactive CLI use). Pass --no-yes to require a "
+    "TTY prompt for tools whose ToolSpec sets requires_confirmation=True.",
+)
+def ask(agent_id, message, auto_approve):
     """Ask an agent a question (immediate response)."""
     manager = _get_manager()
     agent_id = _resolve_agent_id(manager, agent_id)
     manager.send_message(agent_id, message, mode="immediate")
     click.echo("Asking agent...")
-    _, executor, _ = _get_scheduler_and_executor()
+    _, executor, system = _get_scheduler_and_executor()
     if executor is None:
         click.echo("Executor not available", err=True)
         raise SystemExit(1)
+    # Wire a confirmation callback so the agent's own ToolExecutor can actually
+    # run tools whose ToolSpec sets requires_confirmation=True (e.g. shell_exec,
+    # git_*). `executor` is the AgentExecutor; the callback is read in
+    # _invoke_agent and propagated to the constructed agent via agent_kwargs.
+    if auto_approve:
+        executor._confirm_callback = lambda _prompt: True
+    else:
+        executor._confirm_callback = (
+            lambda prompt: click.confirm(f"\n{prompt}", default=False)
+        )
     executor.execute_tick(agent_id)
     msgs = manager.list_messages(agent_id)
     responses = [m for m in msgs if m["direction"] == "agent_to_user"]

{openjarvis-1.0.2.dev678 → openjarvis-1.0.2.dev690}/src/openjarvis/connectors/granola.py

@@ -10,6 +10,7 @@ Settings → API (requires Business or Enterprise plan).
 
 from __future__ import annotations
 
+import logging
 from datetime import datetime, timezone
 from typing import Any, Dict, Iterator, List, Optional
 
@@ -21,6 +22,8 @@ from openjarvis.core.config import DEFAULT_CONFIG_DIR
 from openjarvis.core.registry import ConnectorRegistry
 from openjarvis.tools._stubs import ToolSpec
 
+logger = logging.getLogger(__name__)
+
 # ---------------------------------------------------------------------------
 # Constants
 # ---------------------------------------------------------------------------
@@ -286,6 +289,7 @@ class GranolaConnector(BaseConnector):
                 created_after=created_after,
             )
             notes: List[Dict[str, Any]] = list_resp.get("notes", [])
+            logger.info("Granola: Found %d notes on this page", len(notes))
 
             for note_summary in notes:
                 note_id: str = note_summary.get("id", "")
@@ -297,11 +301,18 @@ class GranolaConnector(BaseConnector):
 
                 title: str = note.get("title", "")
                 owner: Dict[str, Any] = note.get("owner") or {}
-                author: str = owner.get("email", "")
+                author: str = (owner.get("email") or "").lower()
 
                 attendees: List[Dict[str, Any]] = note.get("attendees") or []
                 participants: List[str] = [
-                    a.get("email", "") for a in attendees if a.get("email")
+                    (a.get("email") or "").lower()
+                    for a in attendees
+                    if a.get("email")
+                ]
+                participants_raw: List[str] = [
+                    a.get("name") or a.get("email") or ""
+                    for a in attendees
+                    if a.get("name") or a.get("email")
                 ]
 
                 created_at_str: str = note.get("created_at", "")
@@ -309,11 +320,14 @@ class GranolaConnector(BaseConnector):
 
                 content = _format_note_content(note)
 
-                # Build URL from calendar event if available, else None
-                cal_event: Optional[Dict[str, Any]] = note.get("calendar_event")
-                url: Optional[str] = None
-                if cal_event:
-                    url = note.get("url")
+                cal_event: Dict[str, Any] = note.get("calendar_event") or {}
+                channel: str = cal_event.get("event_title") or "meeting"
+
+                # ``web_url`` (e.g. https://notes.granola.ai/d/{uuid}) is the
+                # only reliable way to deep-link to a Granola note — the API
+                # ``note_id`` and the web UUID are different, so we must store
+                # what the API gives us here.
+                web_url: Optional[str] = note.get("web_url") or None
 
                 doc = Document(
                     doc_id=f"granola:{note_id}",
@@ -323,8 +337,11 @@ class GranolaConnector(BaseConnector):
                     title=title,
                     author=author,
                     participants=participants,
+                    participants_raw=participants_raw,
+                    channel=channel,
+                    thread_id=note_id,
                     timestamp=timestamp,
-                    url=url,
+                    url=web_url,
                     metadata={
                         "note_id": note_id,
                         "owner_name": owner.get("name", ""),
@@ -343,6 +360,7 @@ class GranolaConnector(BaseConnector):
 
         self._items_synced = synced
         self._last_sync = datetime.now(tz=timezone.utc)
+        logger.info("Granola: Sync complete, %d notes total", synced)
 
     def sync_status(self) -> SyncStatus:
         """Return sync progress from the most recent :meth:`sync` call."""

{openjarvis-1.0.2.dev678 → openjarvis-1.0.2.dev690}/src/openjarvis/connectors/hybrid_search.py

@@ -54,6 +54,11 @@ class SearchHit:
     vector_score: float
     thread_id: str = ""
     thread_context: List[Dict[str, Any]] = field(default_factory=list)
+    # ``url`` is the connector-provided deep-link, persisted on
+    # ``knowledge_chunks.url``. Empty when the source didn't supply one — in
+    # that case callers may fall back to a doc_id-based reconstruction (Slack,
+    # Gmail), or render the citation as non-clickable.
+    url: str = ""
 
     def to_dict(self) -> Dict[str, Any]:
         return {
@@ -435,7 +440,7 @@ class HybridSearch:
         meta_rows = self._store._conn.execute(
             f"""
             SELECT id, doc_id, content, source, title, author, participants,
-                   timestamp, thread_id, chunk_index
+                   timestamp, thread_id, chunk_index, url
             FROM knowledge_chunks
             WHERE id IN ({placeholders})
             """,
@@ -463,6 +468,7 @@ class HybridSearch:
                     vector_score=vec_score,
                     thread_id=r["thread_id"] or "",
                     thread_context=self._thread_context(r["thread_id"] or "", chunk_id),
+                    url=r["url"] or "",
                 )
             )
         return hits

{openjarvis-1.0.2.dev678 → openjarvis-1.0.2.dev690}/src/openjarvis/connectors/store.py

@@ -470,6 +470,21 @@ class KnowledgeStore(MemoryBackend):
         row = self._conn.execute("SELECT COUNT(*) FROM knowledge_chunks").fetchone()
         return row[0] if row else 0
 
+    def distinct_sources(self) -> List[str]:
+        """Return the sorted list of distinct ``source`` values currently indexed.
+
+        Used by the research agent to populate the system prompt with the
+        sources the user actually has connected — so the model doesn't
+        mention "Notion" or "Apple Notes" when nothing from those sources
+        is in the corpus.
+        """
+        rows = self._conn.execute(
+            "SELECT DISTINCT source FROM knowledge_chunks "
+            "WHERE source IS NOT NULL AND source != '' "
+            "ORDER BY source"
+        ).fetchall()
+        return [r[0] for r in rows]
+
     def close(self) -> None:
         """Close the underlying SQLite connection."""
         try: