hyperforge-external 1.0.0.post21__py3-none-any.whl

hyperforge_external/__init__.py

@@ -0,0 +1,3 @@
+from .agent import ExternalCallAgent
+
+__all__ = ["ExternalCallAgent"]

hyperforge_external/agent.py

@@ -0,0 +1,136 @@
+from copy import deepcopy
+from time import time
+
+from hyperforge.agent import Agent
+from hyperforge.configure import agent
+from hyperforge.manager import Manager
+from hyperforge.memory import QuestionMemory
+from hyperforge.trace import trace_agent
+from hyperforge.utils import check_dns
+from hyperforge.utils.http import safe_http_client
+
+from hyperforge import PROMPT_ENVIRONMENT, logger
+from hyperforge_external.config import ExternalCallAgentConfig
+
+EXTERNAL_CALL_PROMPT = """
+Collect the parameters to call the query based on the schema and the context:
+{{prompt}}
+
+
+[START OF CONTEXT]
+{{context}}
+[END OF CONTEXT]
+
+MAIN QUESTION: {{question}}
+
+MAIN ANSWER: {{answer}}
+"""
+
+EXTERNAL_CALL_PROMPT_TEMPLATE = PROMPT_ENVIRONMENT.from_string(EXTERNAL_CALL_PROMPT)
+
+
+@agent(
+    id="external",
+    agent_type="postprocess",
+    title="External Call",
+    description="Agent that performs External Call.",
+    config_schema=ExternalCallAgentConfig,
+)
+class ExternalCallAgent(Agent[ExternalCallAgentConfig]):
+    config: ExternalCallAgentConfig
+
+    @trace_agent
+    async def __call__(
+        self,
+        memory: QuestionMemory,
+        manager: Manager,
+    ):
+        t0 = time()
+
+        prompt = EXTERNAL_CALL_PROMPT_TEMPLATE.render(
+            question=memory.original_question,
+            context=memory.contexts_minimal(),
+            answer=memory.final_answer,
+            prompt=self.config.prompt,
+        )
+        t0 = time()
+
+        resp = None
+
+        input_nuclia_tokens: float = 0.0
+        output_nuclia_tokens: float = 0.0
+
+        evaluation = None
+        async with safe_http_client() as client:
+            url = await check_dns(self.config.url)
+
+            if self.config.call_schema:
+                logger.debug(
+                    f"Calling external API with schema: {self.config.call_schema}, description: {self.config.description}"
+                )
+                evaluation, input_tokens, output_tokens = await manager.execute_json(
+                    user_id="external_call_agent",
+                    model=self.config.model,
+                    schema={
+                        "title": "external_call_agent",
+                        "description": self.config.description
+                        or "Choose the parameters to call an external API",
+                        "parameters": self.config.call_schema,
+                    },
+                    prompt=prompt,
+                    tracking=memory.get_tracking_info(),
+                )
+                output_nuclia_tokens += output_tokens
+                input_nuclia_tokens += input_tokens
+                logger.debug(f"Json to do the call: {evaluation}")
+                resp = await client.request(
+                    method=self.config.method.value,
+                    url=url,
+                    json=evaluation,
+                    headers=self.config.headers,
+                )
+            elif self.config.context:
+                logger.debug(
+                    f"Calling external API with generated context: {memory.contexts}"
+                )
+                resp = await client.request(
+                    method=self.config.method.value,
+                    url=url,
+                    json=memory.contexts,
+                    headers=self.config.headers,
+                )
+            else:
+                logger.debug(
+                    f"Calling external API with call object: {self.config.call_obj}"
+                )
+                if self.config.call_obj is not None:
+                    evaluation = deepcopy(self.config.call_obj)
+                else:
+                    evaluation = {}
+                evaluation["answer"] = memory.final_answer
+                evaluation["question"] = memory.original_question
+                resp = await client.request(
+                    method=self.config.method.value,
+                    url=self.config.url,
+                    json=evaluation,
+                    headers=self.config.headers,
+                )
+        error_resp = None
+        if resp is None:
+            error_resp = "No response from external API"
+        elif resp.status_code != 200:
+            error_resp = f"Error calling external API: {resp.status_code} - {resp.content.decode()}"
+        if error_resp:
+            logger.error(error_resp)
+            raise Exception(error_resp)
+        logger.info(f"Response from external API: {resp.content.decode()}")
+        await memory.add_step(
+            step_module="external",
+            step_title=self.step_title(self.config.method.value),
+            step_value=self.config.url,
+            step_reason=resp.content.decode(),
+            timeit=time() - t0,
+            step_agent_path=f"/postprocess/{self.config.id if self.config.id else 'default'}",
+            input_nuclia_tokens=input_nuclia_tokens,
+            output_nuclia_tokens=output_nuclia_tokens,
+        )

hyperforge_external/config.py

@@ -0,0 +1,71 @@
+from enum import Enum
+from typing import Any, Dict, Literal, Optional
+
+from hyperforge.agent import AgentConfig
+from hyperforge.utils import WidgetType, sync_dns_validation
+from pydantic import Field, field_validator
+from pydantic.config import ConfigDict
+
+
+class Method(str, Enum):
+    POST = "POST"
+    GET = "GET"
+    PATCH = "PATCH"
+
+
+class ExternalCallAgentConfig(AgentConfig):
+    model_config = ConfigDict(title="External call")
+    module: Literal["external"] = "external"
+    prompt: Optional[str] = Field(
+        None,
+        title="Extra Prompt",
+        description="Extra prompt to provide more clues to extract parameters",
+        json_schema_extra={
+            "show_in_node": True,
+            "widget": WidgetType.EXPANDABLE_TEXTAREA,
+        },
+    )
+    method: Method = Field(
+        Method.POST,
+        title="Request method",
+        description="POST, GET and PATCH are supported",
+    )
+    description: Optional[str] = Field(
+        None,
+        title="Description of the operation ",
+        description="Description to help the LLM to extract the parameters",
+    )
+    call_schema: Optional[Dict[str, Any]] = Field(
+        None,
+        title="JSON Schema to compute parameters ",
+        description="Valid JSON Schema to define the parameters to call the URL Its incompatible with call_obj and context",
+    )
+    call_obj: Optional[Dict[str, Any]] = Field(
+        None,
+        title="Object to call the endpoint ",
+        description="Object that will be used to call the endpoint adding the answer and the question to it. Its incompatible with call_schema and context",
+    )
+    headers: Dict[str, str] = Field(
+        {},
+        title="Headers to use on the API call ",
+    )
+    model: str = Field(
+        default="chatgpt-o3-mini",
+        title="Generative model",
+        description="Model used to extract the parameters to call the URL",
+        json_schema_extra={"widget": WidgetType.MODEL_SELECT},
+    )
+    context: bool = Field(
+        False,
+        title="Use context as payload",
+        description="Use the context as payload. Its incompatible with call_schema and call_obj",
+    )
+    url: str = Field(
+        ...,
+        title="URL to call",
+        description="",
+    )
+
+    @field_validator("url")
+    def validate_url(cls, v):
+        return sync_dns_validation(v)

hyperforge_external-1.0.0.post21.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: hyperforge_external
+Version: 1.0.0.post21
+Summary: External Hyperforge agent
+Author-email: Nuclia <nucliadb@nuclia.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://progress.com
+Project-URL: Repository, https://github.com/nuclia/forge
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: <4,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: hyperforge
+
+# External/Webhook Hyperforge agents

hyperforge_external-1.0.0.post21.dist-info/RECORD

@@ -0,0 +1,7 @@
+hyperforge_external/__init__.py,sha256=XP1agyAfPTWHolRYnIY7M65zDxPrBlhuVMD5YYXJUto,70
+hyperforge_external/agent.py,sha256=x6F1eeeMOuH3lYpIF7GBHyLXa3qiwLyH3LuZht6pCX8,4881
+hyperforge_external/config.py,sha256=17D7FWNcTBSo6tGmbt5sdlHjd7O4AxOtkQ35FR3FfE8,2339
+hyperforge_external-1.0.0.post21.dist-info/METADATA,sha256=9OPp1uX8f-j_VM5mCbkBYL0ArZmfbXX51Rl-M1Dn9Lo,736
+hyperforge_external-1.0.0.post21.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+hyperforge_external-1.0.0.post21.dist-info/top_level.txt,sha256=2lPfd_Xd8E3r3hJ9A4xfdHqmTl5wZ_dOVV1j_J-iHT4,20
+hyperforge_external-1.0.0.post21.dist-info/RECORD,,

hyperforge_external-1.0.0.post21.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hyperforge_external-1.0.0.post21.dist-info/top_level.txt

@@ -0,0 +1 @@
+hyperforge_external