nucliadb-agentic-api 1.0.0.post226__tar.gz → 1.0.0.post240__tar.gz

{nucliadb_agentic_api-1.0.0.post226 → nucliadb_agentic_api-1.0.0.post240}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nucliadb_agentic_api
-Version: 1.0.0.post226
+Version: 1.0.0.post240
 Summary: NucliaDB Agentic API for Hyperforge
 Author: AI Data Team
 Author-email: AI Data Team <learning@nuclia.com>

nucliadb_agentic_api-1.0.0.post240/VERSION

@@ -0,0 +1 @@
+1.0.0.post240

{nucliadb_agentic_api-1.0.0.post226 → nucliadb_agentic_api-1.0.0.post240}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "nucliadb_agentic_api"
-version = "1.0.0.post226"
+version = "1.0.0.post240"
 description = "NucliaDB Agentic API for Hyperforge"
 readme = "README.md"
 requires-python = ">=3.12"

{nucliadb_agentic_api-1.0.0.post226 → nucliadb_agentic_api-1.0.0.post240}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "nucliadb_agentic_api"
-version = "1.0.0.post226"
+version = "1.0.0.post240"
 authors = [{ name = "AI Data Team", email = "learning@nuclia.com" }]
 description = "NucliaDB Agentic API for Hyperforge"
 readme = "README.md"

{nucliadb_agentic_api-1.0.0.post226 → nucliadb_agentic_api-1.0.0.post240}/src/nucliadb_agentic_api/db/transform.py

@@ -1,11 +1,14 @@
-from typing import Any, Dict, Tuple
+from typing import Dict, Tuple
 from uuid import uuid4
 
+from hyperforge.agent import AgentConfig
+from hyperforge.context.config import ContextAgentConfig
 from hyperforge.driver import DriverConfig
 from hyperforge.models import MemoryConfig, Rules
 from hyperforge.retrieval.config import RetrievalAgentConfig
 from hyperforge.workflows import WorkflowData
-from hyperforge_mcp.config import Transport
+from hyperforge_google.config import GoogleAgentConfig
+from hyperforge_mcp.config import MCPAgentConfig, Transport
 from hyperforge_mcp.config_driver import (
     MCPHTTPDriverConfig,
     MCPHTTPInnerConfig,
@@ -14,10 +17,15 @@ from hyperforge_nucliadb.driver_config import (
     NucliaDBConfig,
     NucliaDBConnection,
 )
+from hyperforge_nucliadb_agentic.config import NucliaDBAgentConfig
 from hyperforge_nucliadb_agentic.internal_driver import (
     InternalNucliaDBConfig,
     InternalNucliaDBConnection,
 )
+from hyperforge_perplexity.config import PerplexityAgentConfig
+from hyperforge_rephrase.config import RephraseAgentConfig
+from hyperforge_smart.config import SmartAgentConfig
+from hyperforge_summarize.config import SummarizeAgentConfig
 
 from nucliadb_agentic_api.db.sources import Sources
 from nucliadb_agentic_api.models import AgenticConfigSchema
@@ -43,60 +51,35 @@ async def transform_agentic_config(
     global_driver = []
 
     title = agentic_config.title if agentic_config.title else "Default Agentic Config"
+    preprocess: list[AgentConfig] = []
+    context: list[AgentConfig] = []
+    generation: list[AgentConfig] = []
 
     if agentic_config.rephrase:
-        config: Dict[str, Any] = {
-            "title": f"{title} - Retrieval",
-        }
-        if agentic_config.rephrase.model:
-            config["model"] = agentic_config.rephrase.model
-        if agentic_config.rephrase.prompt:
-            config["rules"] = [agentic_config.rephrase.prompt]
-        if agentic_config.rephrase.ask_to:
-            # Same KB with different layers
-            config["kbid"] = agentic_config.rephrase.ask_to
-        if agentic_config.rephrase.history is not None:
-            config["history"] = agentic_config.rephrase.history
-
-        config["module"] = "rephrase"
-        preprocess = [config]
-    else:
-        preprocess = []
+        rephrase = agentic_config.rephrase
+        rephrase_config = RephraseAgentConfig(
+            title=f"{title} - Retrieval",
+            rules=[rephrase.prompt] if rephrase.prompt else None,
+            kb=rephrase.ask_to,
+            history=rephrase.history if rephrase.history is not None else False,
+        )
+        if rephrase.model:
+            rephrase_config.model = rephrase.model
+        preprocess.append(rephrase_config)
 
     if agentic_config.smart_agent:
-        config = {
-            "title": f"{title} - Smart Agent",
-        }
-        if agentic_config.smart_agent.extra_prompt:
-            config["extra_prompt"] = agentic_config.smart_agent.extra_prompt
-        if agentic_config.smart_agent.models:
-            if agentic_config.smart_agent.models.context_validation:
-                config["context_validation_model"] = (
-                    agentic_config.smart_agent.models.context_validation
-                )
-            if agentic_config.smart_agent.models.planner:
-                config["planner_model"] = agentic_config.smart_agent.models.planner
-            if agentic_config.smart_agent.models.executor:
-                config["executor_model"] = agentic_config.smart_agent.models.executor
-            if agentic_config.smart_agent.extra_prompt:
-                config["extra_prompt"] = agentic_config.smart_agent.extra_prompt
-        if agentic_config.smart_agent.history is not None:
-            config["history"] = agentic_config.smart_agent.history
-        registered_agents = []
-        for source in agentic_config.smart_agent.sources:
+        smart_agent = agentic_config.smart_agent
+        registered_agents: list[ContextAgentConfig] = []
+        for source in smart_agent.sources:
             source_obj = await source_manager.get_source(account, kbid, source)
-            source_config: Dict[str, Any] = {
-                "title": f"{title} - Smart Agent - {source_obj.type.capitalize()} Source",
-            }
+            source_title = (
+                f"{title} - Smart Agent - {source_obj.type.capitalize()} Source"
+            )
 
             if source_obj.type == "nucliadb":
                 # Same KB different
                 uid = uuid4().hex
 
-                source_config["id"] = f"nucliadb-agent-{source}"
-                source_config["sources"] = [uid]
-                source_config["module"] = "nucliadb_agent"
-
                 ndb_driver_config: DriverConfig
                 if internal_nucliadb and internal_nucliadb_url:
                     ndb_driver_config = InternalNucliaDBConfig(
@@ -137,15 +120,13 @@ async def transform_agentic_config(
                         "No NucliaDB URL configured for internal or external access"
                     )
                 drivers[uid] = ndb_driver_config
-                registered_agents.append(source_config)
+                registered_agents.append(
+                    NucliaDBAgentConfig(
+                        id=f"nucliadb-agent-{source}", title=source_title, sources=[uid]
+                    )
+                )
             elif source_obj.type == "mcp":
                 uid = uuid4().hex
-                # See the nucliadb branch above for why this must be
-                # deterministic rather than random.
-                source_config["id"] = f"mcp-agent-{source}"
-                source_config["sources"] = [uid]
-                source_config["transport"] = Transport.HTTP
-                source_config["module"] = "mcp"
                 mcp_driver_config = MCPHTTPDriverConfig(
                     identifier=uid,
                     name="MCPHTTP",
@@ -156,47 +137,68 @@ async def transform_agentic_config(
                     ),
                 )  # TODO: pass real config if needed
                 drivers[uid] = mcp_driver_config
-                registered_agents.append(source_config)
+                registered_agents.append(
+                    MCPAgentConfig(
+                        id=f"mcp-agent-{source}",
+                        title=source_title,
+                        source=uid,
+                        transport=Transport.HTTP,
+                        tool_choice_model=source_obj.tool_choice_model or "chatgpt-4.1",
+                        valid_headers=source_obj.valid_headers or [],
+                    )
+                )
 
             elif source_obj.type == "google":
-                source_config["id"] = f"google-agent-{source}"
-                source_config["module"] = "google"
                 global_driver.append("google")
-                registered_agents.append(source_config)
+                registered_agents.append(
+                    GoogleAgentConfig(id=f"google-agent-{source}", title=source_title)
+                )
 
             elif source_obj.type == "perplexity":
-                source_config["id"] = f"perplexity-agent-{source}"
-                source_config["module"] = "perplexity"
                 global_driver.append("perplexity")
-                registered_agents.append(source_config)
+                registered_agents.append(
+                    PerplexityAgentConfig(
+                        id=f"perplexity-agent-{source}",
+                        title=source_title,
+                        domain=source_obj.enabled_domains or [],
+                        prompt=None,
+                    )
+                )
 
-        config["registered_agents"] = registered_agents
-        config["module"] = "smart"
-        context = [config]
-    else:
-        context = []
+        models = smart_agent.models
+        smart_config = SmartAgentConfig(
+            title=f"{title} - Smart Agent",
+            planning_mode=smart_agent.mode.value,
+            extra_prompt=smart_agent.extra_prompt,
+            history=smart_agent.history if smart_agent.history is not None else False,
+            # SmartAgentConfig's before-validator accepts serialized agent configs.
+            registered_agents=[agent.model_dump() for agent in registered_agents],  # type: ignore[misc]
+        )
+        # Only set the models if they are provided; otherwise, leave them as None to use hyperforge's default models.
+        # TODO: Provide nucliadb agentic api level defaults for models
+        if models:
+            if models.context_validation:
+                smart_config.context_validation_model = models.context_validation
+            if models.planner:
+                smart_config.planner_model = models.planner
+            if models.executor:
+                smart_config.executor_model = models.executor
+        context.append(smart_config)
 
     if agentic_config.summarize:
-        config = {
-            "title": f"{title} - Summarize Agent",
-        }
-        if agentic_config.summarize.model:
-            config["model"] = agentic_config.summarize.model
-        if agentic_config.summarize.user_prompt:
-            config["user_prompt"] = agentic_config.summarize.user_prompt
-        if agentic_config.summarize.system_prompt:
-            config["system_prompt"] = agentic_config.summarize.system_prompt
-        config["conversational"] = agentic_config.summarize.conversational
-        config["citations"] = True
-        config["force_chunk_level_citations"] = False
-        if agentic_config.summarize.history is not None:
-            config["history"] = agentic_config.summarize.history
-
-        config["module"] = "summarize"
-
-        generation = [config]
-    else:
-        generation = []
+        summarize = agentic_config.summarize
+        summarize_config = SummarizeAgentConfig(
+            title=f"{title} - Summarize Agent",
+            prompt=summarize.user_prompt,
+            system_prompt=summarize.system_prompt,
+            conversational=summarize.conversational,
+            citations=True,
+            force_chunk_level_citations=False,
+            history=summarize.history if summarize.history is not None else False,
+        )
+        if summarize.model:
+            summarize_config.model = summarize.model
+        generation.append(summarize_config)
 
     return (
         RetrievalAgentConfig(
@@ -209,9 +211,9 @@ async def transform_agentic_config(
                 description="Default workflow for agentic config transformation",
                 parameters=None,
             ),
-            preprocess=preprocess,  # type: ignore
-            context=context,  # type: ignore
-            generation=generation,  # type: ignore
+            preprocess=preprocess,
+            context=context,
+            generation=generation,
             postprocess=[],
         ),
         drivers,

{nucliadb_agentic_api-1.0.0.post226 → nucliadb_agentic_api-1.0.0.post240}/src/nucliadb_agentic_api/v1/ask_websocket.py

@@ -5,6 +5,7 @@ from fastapi import Header, Query, WebSocket, WebSocketDisconnect
 from hyperforge.api.authentication import requires
 from hyperforge.api.v1.interaction import WebsocketReceiver, stream_response
 from hyperforge.interaction import AnswerOperation, AragAnswer, ARAGException
+from hyperforge_nucliadb_agentic.ask.audit import get_audit, get_trace_id
 from hyperforge_nucliadb_agentic.ask.model import (
     AskRequest,
 )
@@ -21,6 +22,7 @@ from nucliadb_models.security import RequestSecurity
 from nucliadb_utils.authentication import NucliaUser
 from pydantic import ValidationError
 
+from nucliadb_agentic_api import logger
 from nucliadb_agentic_api.v1.router import router
 
 
@@ -127,6 +129,23 @@ async def websocket_endpoint(
             interaction,
             workflow_id=agentic_config_id,
         ):
+            if msg.step and msg.step.external_usage:
+                audit = get_audit()
+                if audit is not None:
+                    audit.report_step_usage(
+                        account_id=x_stf_account,
+                        kbid=kbid,
+                        client_type=x_ndb_client,
+                        step=msg.step,
+                        trace_id=get_trace_id(),
+                    )
+                else:
+                    logger.warning(
+                        "Skipping WebSocket external usage report because audit utility is unavailable account=%s kb=%s module=%s",
+                        x_stf_account,
+                        kbid,
+                        msg.step.module,
+                    )
             try:
                 await websocket.send_text(msg.model_dump_json())
             except (RuntimeError, WebSocketDisconnect):

nucliadb_agentic_api-1.0.0.post226/VERSION

@@ -1 +0,0 @@
-1.0.0.post226