hyperforge-nucliadb 1.0.0.post105__tar.gz → 1.0.0.post111__tar.gz

{hyperforge_nucliadb-1.0.0.post105 → hyperforge_nucliadb-1.0.0.post111}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperforge_nucliadb
-Version: 1.0.0.post105
+Version: 1.0.0.post111
 Summary: NucliaDB Hyperforge agent
 Author-email: Nuclia <nucliadb@nuclia.com>
 License-Expression: Apache-2.0
@@ -25,3 +25,13 @@ Basic ASK - Basic initial agent
 Advanced ASK (deprecated)
 ASK (experimental)
 Sync (Sync Service oauth linked)
+
+## Client identification
+
+NucliaDB `/ask` and `/find` requests made by these agents use
+`X-NDB-Client: agentic`, including when invoked as tools by a smart agent in a
+RAO workflow. The Sync driver inherits the same behavior. Other request headers
+are preserved, and caller-provided headers are not modified.
+
+Workflow memory searches through `/find` also use the `agentic` client type.
+The receiving NucliaDB API must support the `agentic` client type.

hyperforge_nucliadb-1.0.0.post111/README.md

@@ -0,0 +1,16 @@
+# NucliaDB Hyperforge agents
+
+Basic ASK - Basic initial agent
+Advanced ASK (deprecated)
+ASK (experimental)
+Sync (Sync Service oauth linked)
+
+## Client identification
+
+NucliaDB `/ask` and `/find` requests made by these agents use
+`X-NDB-Client: agentic`, including when invoked as tools by a smart agent in a
+RAO workflow. The Sync driver inherits the same behavior. Other request headers
+are preserved, and caller-provided headers are not modified.
+
+Workflow memory searches through `/find` also use the `agentic` client type.
+The receiving NucliaDB API must support the `agentic` client type.

{hyperforge_nucliadb-1.0.0.post105 → hyperforge_nucliadb-1.0.0.post111}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hyperforge_nucliadb"
-version = "1.0.0.post105"
+version = "1.0.0.post111"
 license = "Apache-2.0"
 description = "NucliaDB Hyperforge agent"
 authors = [{ name = "Nuclia", email = "nucliadb@nuclia.com" }]

{hyperforge_nucliadb-1.0.0.post105 → hyperforge_nucliadb-1.0.0.post111}/src/hyperforge_nucliadb/driver.py

@@ -303,9 +303,13 @@ class NucliaDBDriver(Driver):
                 result.append(word)
         return " ".join(result)
 
-    async def ask(self, item: AskRequest, headers={}) -> SyncAskResponse:
+    async def ask(
+        self, item: AskRequest, headers: dict[str, str] | None = None
+    ) -> SyncAskResponse:
+        request_headers = httpx.Headers(headers)
+        request_headers["X-NDB-Client"] = "agentic"
         return await self.driver.ask(
-            kbid=self.config.kbid, content=item, headers=headers
+            kbid=self.config.kbid, content=item, headers=dict(request_headers)
         )
 
     async def find(
@@ -313,6 +317,7 @@ class NucliaDBDriver(Driver):
     ) -> KnowledgeboxFindResults:
         return await self.driver.find(
             kbid=self.config.kbid,
+            headers={"X-NDB-Client": "agentic"},
             content=FindRequest(
                 query=q,
                 resource_filters=rids,
@@ -326,6 +331,7 @@ class NucliaDBDriver(Driver):
         return await self.driver.find(
             kbid=self.config.kbid,
             content=q,
+            headers={"X-NDB-Client": "agentic"},
         )
 
     async def graph_relations(

{hyperforge_nucliadb-1.0.0.post105 → hyperforge_nucliadb-1.0.0.post111}/src/hyperforge_nucliadb/sync/agent.py

@@ -398,6 +398,8 @@ class SyncAskAgent(BasicAskAgent):
                 connection_id,
                 connection_credentials,
             ) in existing_credentials.items():
+                if connection_id not in connections_by_resource:
+                    continue
                 source = connections[kb_source_id]
                 if (
                     connection_id not in source.sync_configs

{hyperforge_nucliadb-1.0.0.post105 → hyperforge_nucliadb-1.0.0.post111}/src/hyperforge_nucliadb.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperforge_nucliadb
-Version: 1.0.0.post105
+Version: 1.0.0.post111
 Summary: NucliaDB Hyperforge agent
 Author-email: Nuclia <nucliadb@nuclia.com>
 License-Expression: Apache-2.0
@@ -25,3 +25,13 @@ Basic ASK - Basic initial agent
 Advanced ASK (deprecated)
 ASK (experimental)
 Sync (Sync Service oauth linked)
+
+## Client identification
+
+NucliaDB `/ask` and `/find` requests made by these agents use
+`X-NDB-Client: agentic`, including when invoked as tools by a smart agent in a
+RAO workflow. The Sync driver inherits the same behavior. Other request headers
+are preserved, and caller-provided headers are not modified.
+
+Workflow memory searches through `/find` also use the `agentic` client type.
+The receiving NucliaDB API must support the `agentic` client type.

hyperforge_nucliadb-1.0.0.post111/tests/test_driver.py

@@ -0,0 +1,99 @@
+import json
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import httpx
+import pytest
+from nucliadb_models.search import AskRequest, FindRequest
+from nucliadb_sdk.v2 import NucliaDBAsync
+
+from hyperforge_nucliadb.driver import NucliaDBDriver
+from hyperforge_nucliadb.sync.driver import SyncDriver
+
+
+def make_driver(client, driver_type=NucliaDBDriver):
+    return driver_type.model_construct(
+        provider="nucliadb",
+        name="test",
+        config=SimpleNamespace(kbid="test-kb", filters=[]),
+        driver=client,
+        manager=SimpleNamespace(),
+        _synonyms=None,
+    )
+
+
+@pytest.mark.asyncio
+async def test_labels_uses_complete_labelsets_response():
+    client = AsyncMock()
+    client.get_labelsets.return_value = SimpleNamespace(
+        labelsets={
+            "type": SimpleNamespace(labels=[SimpleNamespace(title="report")]),
+            "topic": SimpleNamespace(labels=[SimpleNamespace(title="science")]),
+        }
+    )
+    driver = make_driver(client)
+
+    assert await driver.labels() == {"type": ["report"], "topic": ["science"]}
+
+    client.get_labelsets.assert_awaited_once_with(kbid="test-kb")
+    client.get_labelset.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("driver_type", [NucliaDBDriver, SyncDriver])
+@pytest.mark.parametrize("operation", ["ask", "find", "find_raw"])
+async def test_search_requests_use_agentic_client_type(driver_type, operation):
+    def handle(request: httpx.Request) -> httpx.Response:
+        endpoint = "ask" if operation == "ask" else "find"
+        assert request.url.path.endswith(f"/kb/test-kb/{endpoint}")
+        assert request.headers.get_list("x-ndb-client") == ["agentic"]
+        assert request.headers["x-test-header"] == "preserved"
+        assert json.loads(request.content)["query"] == "question"
+        result = {"resources": {}, "total": 0}
+        if operation == "ask":
+            result = {
+                "status": "success",
+                "answer": "answer",
+                "retrieval_results": result,
+            }
+        return httpx.Response(200, json=result)
+
+    client = NucliaDBAsync(
+        url="http://nucliadb.test/api",
+        headers={"X-NDB-Client": "api", "x-test-header": "preserved"},
+        _httpx_transport=httpx.MockTransport(handle),
+    )
+    driver = make_driver(client, driver_type)
+
+    async with client.session:
+        if operation == "ask":
+            result = await driver.ask(AskRequest(query="question"))
+            assert result.answer == "answer"
+        elif operation == "find":
+            result = await driver.find("question")
+            assert result.total == 0
+        else:
+            result = await driver.find_raw(FindRequest(query="question"))
+            assert result.total == 0
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "client_header", ["X-NDB-Client", "x-ndb-client", "X-NdB-ClIeNt"]
+)
+async def test_ask_preserves_caller_headers_without_mutating_them(client_header):
+    client = AsyncMock()
+    driver = make_driver(client)
+    headers = {client_header: "widget", "X-Synchronous": "true"}
+    original_headers = headers.copy()
+    request = AskRequest(query="question")
+
+    await driver.ask(request, headers=headers)
+
+    kwargs = client.ask.await_args.kwargs
+    sent_headers = httpx.Headers(kwargs["headers"])
+    assert sent_headers.get_list("x-ndb-client") == ["agentic"]
+    assert sent_headers["X-Synchronous"] == "true"
+    assert kwargs["kbid"] == "test-kb"
+    assert kwargs["content"] is request
+    assert headers == original_headers

{hyperforge_nucliadb-1.0.0.post105 → hyperforge_nucliadb-1.0.0.post111}/tests/test_sync.py

@@ -311,6 +311,60 @@ async def test_hybrid_dynamic_connection_is_authorized():
     assert result == {"source": {SYNC_CONFIG_ID: ["connected-resource"]}}
 
 
+async def test_hybrid_dynamic_connection_ignores_unrequested_credentials():
+    agent = SyncAskAgent(SyncAskAgentConfig(sources=["source"]))
+    driver = SimpleNamespace(
+        config=SimpleNamespace(connection_ids=[]),
+        sync_configs={SYNC_CONFIG_ID: [EXTERNAL_CONNECTION_ID]},
+        information={
+            EXTERNAL_CONNECTION_ID: SimpleNamespace(provider="sharefile_oauth")
+        },
+        validate_resources=AsyncMock(return_value=["connected-resource"]),
+    )
+    resource = SimpleNamespace(
+        id="connected-resource",
+        origin=SimpleNamespace(
+            source_id=f"sync_config_{SYNC_CONFIG_ID}",
+            sync_metadata=SimpleNamespace(model_dump=MagicMock(return_value={})),
+        ),
+    )
+    ndb = SimpleNamespace(
+        config=SimpleNamespace(kbid="kb"),
+        driver=SimpleNamespace(get_resource_by_id=AsyncMock(return_value=resource)),
+    )
+    manager = SimpleNamespace(
+        drivers=SimpleNamespace(get=MagicMock(return_value=driver))
+    )
+    memory = MagicMock()
+    memory.get_session_id.return_value = "session"
+    memory.send_feedback = AsyncMock(
+        return_value=UserToAgentInteraction(
+            request_id="session",
+            response=json.dumps(
+                {
+                    "existing_credentials": {
+                        SYNC_CONFIG_ID: {EXTERNAL_CONNECTION_ID: "credential"},
+                        "00000000-0000-0000-0000-000000000002": {
+                            "unrequested-connection": "credential"
+                        },
+                    }
+                }
+            ),
+        )
+    )
+
+    with patch("hyperforge_nucliadb.sync.agent.get_ndb_driver", return_value=ndb):
+        result = await agent._post_filter_configured_resources(
+            memory=memory,
+            manager=manager,  # type: ignore[arg-type]
+            resources={"source": [resource.id]},
+            allowed_connection_ids={SYNC_CONFIG_ID},
+        )
+
+    assert result == {"source": {SYNC_CONFIG_ID: ["connected-resource"]}}
+    driver.validate_resources.assert_awaited_once()
+
+
 async def test_hybrid_resources_without_connections_skip_authorization():
     agent = SyncAskAgent(SyncAskAgentConfig(sources=["source"]))
     driver = SimpleNamespace(config=SimpleNamespace(connection_ids=[]))

hyperforge_nucliadb-1.0.0.post105/README.md

@@ -1,6 +0,0 @@
-# NucliaDB Hyperforge agents
-
-Basic ASK - Basic initial agent
-Advanced ASK (deprecated)
-ASK (experimental)
-Sync (Sync Service oauth linked)

hyperforge_nucliadb-1.0.0.post105/tests/test_driver.py

@@ -1,34 +0,0 @@
-from types import SimpleNamespace
-from unittest.mock import AsyncMock
-
-import pytest
-
-from hyperforge_nucliadb.driver import NucliaDBDriver
-
-
-def make_driver(client):
-    return NucliaDBDriver.model_construct(
-        provider="nucliadb",
-        name="test",
-        config=SimpleNamespace(kbid="test-kb"),
-        driver=client,
-        manager=SimpleNamespace(),
-        _synonyms=None,
-    )
-
-
-@pytest.mark.asyncio
-async def test_labels_uses_complete_labelsets_response():
-    client = AsyncMock()
-    client.get_labelsets.return_value = SimpleNamespace(
-        labelsets={
-            "type": SimpleNamespace(labels=[SimpleNamespace(title="report")]),
-            "topic": SimpleNamespace(labels=[SimpleNamespace(title="science")]),
-        }
-    )
-    driver = make_driver(client)
-
-    assert await driver.labels() == {"type": ["report"], "topic": ["science"]}
-
-    client.get_labelsets.assert_awaited_once_with(kbid="test-kb")
-    client.get_labelset.assert_not_awaited()