agentgraph-connector-feed 0.1.0__tar.gz

agentgraph_connector_feed-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Simon Wade
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agentgraph_connector_feed-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: agentgraph-connector-feed
+Version: 0.1.0
+Summary: Shared mutation feed connector for AgentGraph
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/simonexmachina/agentgraph-connector-feed
+Project-URL: Repository, https://github.com/simonexmachina/agentgraph-connector-feed
+Project-URL: Issues, https://github.com/simonexmachina/agentgraph-connector-feed/issues
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: agentgraph-server<0.7,>=0.6.1
+Requires-Dist: httpx<1.0,>=0.28
+Dynamic: license-file
+
+# AgentGraph Feed Connector
+
+The AgentGraph Feed Connector shares local observations, bookmark changes, and explicit
+deletions through a separately deployed AgentGraph feed server.
+
+## Installation
+
+Install the connector into the same Python environment as AgentGraph:
+
+```sh
+uv pip install agentgraph-connector-feed
+```
+
+The `0.1.x` connector releases support `agentgraph-server>=0.6.1,<0.7`.
+
+## Configuration
+
+Configure the feed server base URL, then inspect the saved configuration:
+
+```sh
+agentgraph connector feed configure http://localhost:8767
+agentgraph connector feed status
+```
+
+The configured URL must not include `/events` or `/events-feed`. The connector adds `/events`
+and `/events/tail` when it publishes and polls respectively. For a deployed server behind a
+reverse proxy, configure the URL at which those endpoints are exposed.
+
+The connector publishes new local observations, bookmark changes, and explicit deletions as
+best-effort HTTP requests. It polls the feed once per minute. Its first poll starts at the current
+feed tail, so existing events are not imported.
+
+The server must expose `POST /events`, `GET /events`, and `GET /events/tail`. The connector and
+server communicate only through this HTTP API; the server is deployed and maintained separately.
+
+## Security
+
+The feed is unauthenticated and should only be exposed on a trusted network.
+
+## Development
+
+```sh
+uv sync --locked
+uv run pytest
+uv run pyright
+uv run ruff check .
+uv run ruff format --check .
+```

agentgraph_connector_feed-0.1.0/README.md

@@ -0,0 +1,48 @@
+# AgentGraph Feed Connector
+
+The AgentGraph Feed Connector shares local observations, bookmark changes, and explicit
+deletions through a separately deployed AgentGraph feed server.
+
+## Installation
+
+Install the connector into the same Python environment as AgentGraph:
+
+```sh
+uv pip install agentgraph-connector-feed
+```
+
+The `0.1.x` connector releases support `agentgraph-server>=0.6.1,<0.7`.
+
+## Configuration
+
+Configure the feed server base URL, then inspect the saved configuration:
+
+```sh
+agentgraph connector feed configure http://localhost:8767
+agentgraph connector feed status
+```
+
+The configured URL must not include `/events` or `/events-feed`. The connector adds `/events`
+and `/events/tail` when it publishes and polls respectively. For a deployed server behind a
+reverse proxy, configure the URL at which those endpoints are exposed.
+
+The connector publishes new local observations, bookmark changes, and explicit deletions as
+best-effort HTTP requests. It polls the feed once per minute. Its first poll starts at the current
+feed tail, so existing events are not imported.
+
+The server must expose `POST /events`, `GET /events`, and `GET /events/tail`. The connector and
+server communicate only through this HTTP API; the server is deployed and maintained separately.
+
+## Security
+
+The feed is unauthenticated and should only be exposed on a trusted network.
+
+## Development
+
+```sh
+uv sync --locked
+uv run pytest
+uv run pyright
+uv run ruff check .
+uv run ruff format --check .
+```

agentgraph_connector_feed-0.1.0/agentgraph_connector_feed.egg-info/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: agentgraph-connector-feed
+Version: 0.1.0
+Summary: Shared mutation feed connector for AgentGraph
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/simonexmachina/agentgraph-connector-feed
+Project-URL: Repository, https://github.com/simonexmachina/agentgraph-connector-feed
+Project-URL: Issues, https://github.com/simonexmachina/agentgraph-connector-feed/issues
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: agentgraph-server<0.7,>=0.6.1
+Requires-Dist: httpx<1.0,>=0.28
+Dynamic: license-file
+
+# AgentGraph Feed Connector
+
+The AgentGraph Feed Connector shares local observations, bookmark changes, and explicit
+deletions through a separately deployed AgentGraph feed server.
+
+## Installation
+
+Install the connector into the same Python environment as AgentGraph:
+
+```sh
+uv pip install agentgraph-connector-feed
+```
+
+The `0.1.x` connector releases support `agentgraph-server>=0.6.1,<0.7`.
+
+## Configuration
+
+Configure the feed server base URL, then inspect the saved configuration:
+
+```sh
+agentgraph connector feed configure http://localhost:8767
+agentgraph connector feed status
+```
+
+The configured URL must not include `/events` or `/events-feed`. The connector adds `/events`
+and `/events/tail` when it publishes and polls respectively. For a deployed server behind a
+reverse proxy, configure the URL at which those endpoints are exposed.
+
+The connector publishes new local observations, bookmark changes, and explicit deletions as
+best-effort HTTP requests. It polls the feed once per minute. Its first poll starts at the current
+feed tail, so existing events are not imported.
+
+The server must expose `POST /events`, `GET /events`, and `GET /events/tail`. The connector and
+server communicate only through this HTTP API; the server is deployed and maintained separately.
+
+## Security
+
+The feed is unauthenticated and should only be exposed on a trusted network.
+
+## Development
+
+```sh
+uv sync --locked
+uv run pytest
+uv run pyright
+uv run ruff check .
+uv run ruff format --check .
+```

agentgraph_connector_feed-0.1.0/agentgraph_connector_feed.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+agentgraph_connector_feed.egg-info/PKG-INFO
+agentgraph_connector_feed.egg-info/SOURCES.txt
+agentgraph_connector_feed.egg-info/dependency_links.txt
+agentgraph_connector_feed.egg-info/entry_points.txt
+agentgraph_connector_feed.egg-info/requires.txt
+agentgraph_connector_feed.egg-info/top_level.txt
+agentgraph_feed_connector/__init__.py
+agentgraph_feed_connector/config.py
+tests/test_connector.py
+tests/test_lint.py

agentgraph_connector_feed-0.1.0/agentgraph_connector_feed.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agentgraph_connector_feed-0.1.0/agentgraph_connector_feed.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[agentgraph.connectors]
+feed = agentgraph_feed_connector:AgentGraphFeedConnector

agentgraph_connector_feed-0.1.0/agentgraph_connector_feed.egg-info/requires.txt

@@ -0,0 +1,2 @@
+agentgraph-server<0.7,>=0.6.1
+httpx<1.0,>=0.28

agentgraph_connector_feed-0.1.0/agentgraph_connector_feed.egg-info/top_level.txt

@@ -0,0 +1 @@
+agentgraph_feed_connector

agentgraph_connector_feed-0.1.0/agentgraph_feed_connector/__init__.py

@@ -0,0 +1,221 @@
+"""AgentGraph connector for a shared observation and bookmark feed."""
+
+from __future__ import annotations
+
+import logging
+from datetime import timedelta
+from typing import Any, ClassVar, cast
+from uuid import UUID
+
+import httpx
+from agentgraph.connectors.base import EntityBatch, FetchPolicy, ResourceType
+from agentgraph.connectors.feed import (
+    FeedConnector,
+    MutationEvent,
+    suppress_feed_notifications,
+)
+from agentgraph.core.context import get_backend
+from agentgraph.graph.bookmark import bookmark_url, set_entity_bookmark
+from agentgraph.graph.delete import delete_platform_entity
+from agentgraph.server.observation import record_observation
+
+from agentgraph_feed_connector.config import (
+    FeedConfig,
+    load_feed_config,
+    save_feed_config,
+)
+
+logger = logging.getLogger(__name__)
+
+_HTTP_TIMEOUT = httpx.Timeout(5.0)
+_POLL_LIMIT = 100
+
+
+class AgentGraphFeedConnector(FeedConnector):
+    source: ClassVar[str] = "feed"
+    fetch_policy: ClassVar[FetchPolicy] = FetchPolicy(stale_after_seconds=60)
+    poll_interval: ClassVar[timedelta | None] = timedelta(minutes=1)
+    appears_in_auth_status: ClassVar[bool] = False
+    auth_description: ClassVar[str | None] = (
+        "Shares local observations and bookmarks through an AgentGraph feed server."
+    )
+
+    def can_handle(self, url: str) -> bool:
+        _ = url
+        return False
+
+    async def fetch(
+        self,
+        resource_type: ResourceType,
+        resource_id: str,
+        meta: dict[str, str] | None = None,
+        account_id: str | None = None,
+    ) -> EntityBatch:
+        _ = (resource_type, resource_id, meta, account_id)
+        return EntityBatch()
+
+    async def publish_mutation(self, event: MutationEvent) -> None:
+        config = load_feed_config()
+        if config is None:
+            return
+        payload = event.model_dump(mode="json")
+        payload["origin_id"] = str(config.origin_id)
+        async with httpx.AsyncClient(timeout=_HTTP_TIMEOUT, trust_env=False) as client:
+            response = await client.post(f"{config.feed_url}/events", json=payload)
+            response.raise_for_status()
+
+    async def poll(
+        self,
+        cursor: dict[str, Any],
+        account_id: str | None = None,
+    ) -> tuple[EntityBatch, dict[str, Any]]:
+        _ = account_id
+        config = load_feed_config()
+        if config is None:
+            return EntityBatch(), cursor
+
+        logger.info("Polling feed server at %s", config.feed_url)
+        async with httpx.AsyncClient(timeout=_HTTP_TIMEOUT, trust_env=False) as client:
+            if "last_event_id" not in cursor:
+                response = await client.get(f"{config.feed_url}/events/tail")
+                response.raise_for_status()
+                tail_payload = cast(dict[str, Any], response.json())
+                return EntityBatch(), {"last_event_id": int(tail_payload["cursor"])}
+
+            since = int(cursor["last_event_id"])
+            response = await client.get(
+                f"{config.feed_url}/events",
+                params={"since": since, "limit": _POLL_LIMIT},
+            )
+            response.raise_for_status()
+            payload = cast(dict[str, Any], response.json())
+            events = cast(list[dict[str, Any]], payload.get("events", []))
+
+            next_cursor = since
+            for event in events:
+                await _apply_event(event, config)
+                next_cursor = int(event["sequence"])
+            return EntityBatch(), {"last_event_id": next_cursor}
+
+    @classmethod
+    def run_cli_command(cls, args: list[str]) -> dict[str, Any]:
+        if not args or args[0] in {"--help", "help"}:
+            raise ValueError(cls.cli_help())
+        if args[0] == "status":
+            config = load_feed_config()
+            return {
+                "configured": config is not None,
+                "feed_url": config.feed_url if config else None,
+                "origin_id": str(config.origin_id) if config else None,
+            }
+        if args[0] != "configure":
+            raise ValueError(
+                f"Unknown feed connector command {args[0]!r}\n{cls.cli_help()}"
+            )
+        config = _parse_configure_args(args[1:])
+        save_feed_config(config)
+        return {
+            "configured": True,
+            "feed_url": config.feed_url,
+            "origin_id": str(config.origin_id),
+        }
+
+    @classmethod
+    def cli_help(cls) -> str:
+        return (
+            "Usage: agentgraph connector feed configure <feed-url> "
+            "[--origin-id <uuid>]\n"
+            "   or: agentgraph connector feed status"
+        )
+
+
+async def _apply_event(event: dict[str, Any], config: FeedConfig) -> None:
+    kind = event.get("kind")
+    event_id = str(event["event_id"])
+    origin_id = UUID(str(event["origin_id"]))
+    target = cast(dict[str, Any], event["target"])
+
+    if kind == "observation":
+        if origin_id == config.origin_id:
+            return
+        url = target.get("url")
+        if not isinstance(url, str) or not url:
+            raise ValueError(f"Observation event {event_id} has no target URL")
+        meta_value = event.get("meta")
+        meta = (
+            cast(dict[str, str], meta_value) if isinstance(meta_value, dict) else None
+        )
+        with suppress_feed_notifications():
+            result = await record_observation(
+                url=url,
+                observation_duration_ms=int(event["observation_duration_ms"]),
+                observation_id=event_id,
+                observed=True,
+                meta=meta,
+            )
+        if result.get("status") == "error":
+            raise RuntimeError(
+                f"AgentGraph failed to apply observation event {event_id}"
+            )
+        return
+
+    platform = str(target["platform"])
+    platform_entity_id = str(target["platform_entity_id"])
+    with suppress_feed_notifications():
+        if kind == "bookmark":
+            await _apply_bookmark(
+                platform=platform,
+                platform_entity_id=platform_entity_id,
+                entity_type=str(target["entity_type"]),
+                url=target.get("url") if isinstance(target.get("url"), str) else None,
+                bookmarked=bool(event["bookmarked"]),
+            )
+            return
+        if kind == "tombstone":
+            await delete_platform_entity(platform, platform_entity_id)
+            return
+    raise ValueError(f"Unsupported feed event kind {kind!r}")
+
+
+async def _apply_bookmark(
+    *,
+    platform: str,
+    platform_entity_id: str,
+    entity_type: str,
+    url: str | None,
+    bookmarked: bool,
+) -> None:
+    backend = get_backend()
+    entity = await backend.get_entity_by_platform(platform, platform_entity_id)
+    if entity is None and not bookmarked:
+        return
+    if entity is None and url is not None:
+        try:
+            await bookmark_url(url)
+        except Exception:  # noqa: BLE001 - remote connector failures should create a stub.
+            logger.info("Could not fetch remote bookmark %s; creating a stub", url)
+        entity = await backend.get_entity_by_platform(platform, platform_entity_id)
+    if entity is None:
+        entity_id = await backend.upsert_stub_entity(
+            entity_type, platform, platform_entity_id
+        )
+    else:
+        entity_id = str(entity["id"])
+    await set_entity_bookmark(entity_id, bookmarked)
+
+
+def _parse_configure_args(args: list[str]) -> FeedConfig:
+    if not args:
+        raise ValueError(AgentGraphFeedConnector.cli_help())
+    feed_url = args[0]
+    origin_id: UUID | None = None
+    index = 1
+    while index < len(args):
+        if args[index] != "--origin-id" or index + 1 >= len(args):
+            raise ValueError(AgentGraphFeedConnector.cli_help())
+        origin_id = UUID(args[index + 1])
+        index += 2
+    return FeedConfig.create(feed_url=feed_url, origin_id=origin_id)
+
+
+__all__ = ["AgentGraphFeedConnector"]

agentgraph_connector_feed-0.1.0/agentgraph_feed_connector/config.py

@@ -0,0 +1,47 @@
+"""Connector-owned feed configuration."""
+
+from __future__ import annotations
+
+import json
+import tomllib
+from pathlib import Path
+from urllib.parse import urlparse
+from uuid import UUID, uuid4
+
+from agentgraph.config import get_config_paths
+from pydantic import BaseModel
+
+
+class FeedConfig(BaseModel):
+    feed_url: str
+    origin_id: UUID
+
+    @classmethod
+    def create(cls, feed_url: str, origin_id: UUID | None = None) -> FeedConfig:
+        normalised_url = feed_url.rstrip("/")
+        parsed = urlparse(normalised_url)
+        if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+            raise ValueError("Feed URL must be an absolute HTTP(S) URL")
+        return cls(feed_url=normalised_url, origin_id=origin_id or uuid4())
+
+
+def feed_config_path() -> Path:
+    return get_config_paths()[0] / "feed.toml"
+
+
+def load_feed_config() -> FeedConfig | None:
+    path = feed_config_path()
+    if not path.exists():
+        return None
+    with path.open("rb") as handle:
+        return FeedConfig.model_validate(tomllib.load(handle))
+
+
+def save_feed_config(config: FeedConfig) -> None:
+    path = feed_config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    content = (
+        f"feed_url = {json.dumps(config.feed_url)}\n"
+        f"origin_id = {json.dumps(str(config.origin_id))}\n"
+    )
+    path.write_text(content)

agentgraph_connector_feed-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[project]
+name = "agentgraph-connector-feed"
+version = "0.1.0"
+description = "Shared mutation feed connector for AgentGraph"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.12"
+dependencies = [
+    "agentgraph-server>=0.6.1,<0.7",
+    "httpx>=0.28,<1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/simonexmachina/agentgraph-connector-feed"
+Repository = "https://github.com/simonexmachina/agentgraph-connector-feed"
+Issues = "https://github.com/simonexmachina/agentgraph-connector-feed/issues"
+
+[project.entry-points."agentgraph.connectors"]
+feed = "agentgraph_feed_connector:AgentGraphFeedConnector"
+
+[tool.uv]
+package = true
+
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["agentgraph_feed_connector*"]
+
+[dependency-groups]
+dev = [
+    "pyright>=1.1.408,<2",
+    "pytest>=8,<10",
+    "pytest-asyncio>=0.24,<2",
+    "ruff>=0.16,<1",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+pythonpath = ["."]
+
+[tool.ruff]
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "UP", "B", "SIM", "BLE", "RUF", "PYI"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["agentgraph_feed_connector"]

agentgraph_connector_feed-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agentgraph_connector_feed-0.1.0/tests/test_connector.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+import logging
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, ClassVar, Self
+from unittest.mock import AsyncMock, patch
+from uuid import UUID, uuid4
+
+import pytest
+from agentgraph.connectors.feed import BookmarkMutation, MutationTarget
+
+from agentgraph_feed_connector import AgentGraphFeedConnector, _apply_event
+from agentgraph_feed_connector.config import (
+    FeedConfig,
+    load_feed_config,
+    save_feed_config,
+)
+
+
+class _Response:
+    def __init__(self, payload: dict[str, Any]) -> None:
+        self._payload = payload
+
+    def raise_for_status(self) -> None:
+        return None
+
+    def json(self) -> dict[str, Any]:
+        return self._payload
+
+
+class _Client:
+    responses: ClassVar[dict[str, dict[str, Any]]] = {}
+    posts: ClassVar[list[tuple[str, dict[str, Any]]]] = []
+
+    def __init__(self, **_: Any) -> None:
+        pass
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(self, *_: object) -> None:
+        return None
+
+    async def get(self, url: str, **_: Any) -> _Response:
+        return _Response(self.responses[url])
+
+    async def post(self, url: str, json: dict[str, Any]) -> _Response:
+        self.posts.append((url, json))
+        return _Response({"id": 1, "duplicate": False})
+
+
+@pytest.fixture
+def config() -> FeedConfig:
+    return FeedConfig(
+        feed_url="https://feed.example.test",
+        origin_id=UUID("00000000-0000-0000-0000-000000000001"),
+    )
+
+
+def test_config_round_trip(tmp_path: Path) -> None:
+    path = tmp_path / "feed.toml"
+    config = FeedConfig.create("https://feed.example.test/")
+
+    with patch("agentgraph_feed_connector.config.feed_config_path", return_value=path):
+        save_feed_config(config)
+        loaded = load_feed_config()
+
+    assert loaded == config
+    assert loaded is not None and loaded.feed_url == "https://feed.example.test"
+
+
+@pytest.mark.asyncio
+async def test_publish_adds_stable_origin(config: FeedConfig) -> None:
+    _Client.posts = []
+    event = BookmarkMutation(
+        target=MutationTarget(
+            platform="web",
+            platform_entity_id="https://example.com",
+            entity_type="Document",
+            resource_type="document",
+            url="https://example.com",
+        ),
+        bookmarked=True,
+    )
+
+    with (
+        patch("agentgraph_feed_connector.load_feed_config", return_value=config),
+        patch("agentgraph_feed_connector.httpx.AsyncClient", _Client),
+    ):
+        await AgentGraphFeedConnector().publish_mutation(event)
+
+    assert _Client.posts[0][0] == "https://feed.example.test/events"
+    assert _Client.posts[0][1]["origin_id"] == str(config.origin_id)
+    assert _Client.posts[0][1]["kind"] == "bookmark"
+
+
+@pytest.mark.asyncio
+async def test_first_poll_starts_at_feed_tail(
+    config: FeedConfig, caplog: pytest.LogCaptureFixture
+) -> None:
+    _Client.responses = {"https://feed.example.test/events/tail": {"cursor": 42}}
+
+    caplog.set_level(logging.INFO, logger="agentgraph_feed_connector")
+    with (
+        patch("agentgraph_feed_connector.load_feed_config", return_value=config),
+        patch("agentgraph_feed_connector.httpx.AsyncClient", _Client),
+    ):
+        batch, cursor = await AgentGraphFeedConnector().poll({})
+
+    assert batch.entities == []
+    assert cursor == {"last_event_id": 42}
+    assert "Polling feed server at https://feed.example.test" in caplog.messages
+
+
+@pytest.mark.asyncio
+async def test_remote_observation_reuses_server_handler(config: FeedConfig) -> None:
+    event_id = uuid4()
+    event = {
+        "sequence": 7,
+        "event_id": str(event_id),
+        "origin_id": str(uuid4()),
+        "occurred_at": datetime.now(UTC).isoformat(),
+        "kind": "observation",
+        "target": {
+            "platform": "web",
+            "platform_entity_id": "https://example.com",
+            "entity_type": "Document",
+            "resource_type": "document",
+            "url": "https://example.com",
+        },
+        "observation_duration_ms": 3000,
+        "meta": {"source": "shared"},
+    }
+
+    with patch(
+        "agentgraph_feed_connector.record_observation",
+        new=AsyncMock(return_value={"status": "accepted"}),
+    ) as record:
+        await _apply_event(event, config)
+
+    record.assert_awaited_once_with(
+        url="https://example.com",
+        observation_duration_ms=3000,
+        observation_id=str(event_id),
+        observed=True,
+        meta={"source": "shared"},
+    )
+
+
+@pytest.mark.asyncio
+async def test_self_observation_is_not_applied(config: FeedConfig) -> None:
+    event = {
+        "sequence": 8,
+        "event_id": str(uuid4()),
+        "origin_id": str(config.origin_id),
+        "kind": "observation",
+        "target": {"url": "https://example.com"},
+        "observation_duration_ms": 3000,
+    }
+
+    with patch(
+        "agentgraph_feed_connector.record_observation", new=AsyncMock()
+    ) as record:
+        await _apply_event(event, config)
+
+    record.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_own_bookmark_is_replayed_for_feed_order(config: FeedConfig) -> None:
+    event = {
+        "sequence": 9,
+        "event_id": str(uuid4()),
+        "origin_id": str(config.origin_id),
+        "kind": "bookmark",
+        "target": {
+            "platform": "web",
+            "platform_entity_id": "https://example.com",
+            "entity_type": "Document",
+            "url": "https://example.com",
+        },
+        "bookmarked": False,
+    }
+
+    with patch(
+        "agentgraph_feed_connector._apply_bookmark", new=AsyncMock()
+    ) as apply_bookmark:
+        await _apply_event(event, config)
+
+    apply_bookmark.assert_awaited_once()

agentgraph_connector_feed-0.1.0/tests/test_lint.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).parents[1]
+
+
+def test_ruff() -> None:
+    for command in (("check", "."), ("format", "--check", ".")):
+        result = subprocess.run(
+            [sys.executable, "-m", "ruff", *command],
+            cwd=PROJECT_ROOT,
+            capture_output=True,
+            check=False,
+            text=True,
+        )
+        assert result.returncode == 0, result.stdout + result.stderr