hyperforge 1.0.0.post80__tar.gz → 1.0.0.post116__tar.gz

{hyperforge-1.0.0.post80 → hyperforge-1.0.0.post116}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperforge
-Version: 1.0.0.post80
+Version: 1.0.0.post116
 Summary: Agentic Framework for Orchestrated Runtime, Governance, and Execution
 Author: AI Data Team
 Author-email: AI Data Team <learning@nuclia.com>

{hyperforge-1.0.0.post80 → hyperforge-1.0.0.post116}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "hyperforge"
-version = "1.0.0.post80"
+version = "1.0.0.post116"
 authors = [{ name = "AI Data Team", email = "learning@nuclia.com" }]
 description = "Agentic Framework for Orchestrated Runtime, Governance, and Execution"
 readme = "README.md"

{hyperforge-1.0.0.post80 → hyperforge-1.0.0.post116}/src/hyperforge/api/session.py

@@ -1,5 +1,6 @@
 """Session management functions for ARAG agents with NucliaDB memory."""
 
+from uuid import UUID
 from typing import Optional
 
 from nucliadb_models import (
@@ -19,6 +20,14 @@ from hyperforge.api.models import INFO_FIELD_ID
 from hyperforge.memory.memory import QUESTION_ANSWERS_FIELD
 
 
+def _is_uuid(value: str) -> bool:
+    try:
+        UUID(value)
+        return True
+    except (ValueError, TypeError):
+        return False
+
+
 async def create_session_resource(
     ndb: NucliaDBAsync,
     agent_id: str,
@@ -110,11 +119,18 @@ async def session_exists(
         True if session exists, False otherwise
     """
     try:
-        await ndb.get_resource_by_id(
-            rid=session_id,
-            kbid=agent_id,
-            query_params={"show": ["basic"]},
-        )
+        if _is_uuid(session_id):
+            await ndb.get_resource_by_id(
+                rid=session_id,
+                kbid=agent_id,
+                query_params={"show": ["basic"]},
+            )
+        else:
+            await ndb.get_resource_by_slug(
+                slug=session_id,
+                kbid=agent_id,
+                query_params={"show": ["basic"]},
+            )
         return True
     except NotFoundError:
         return False

{hyperforge-1.0.0.post80 → hyperforge-1.0.0.post116}/src/hyperforge/broker/redis.py

@@ -1,10 +1,14 @@
 import asyncio
 import json
-from typing import AsyncIterator, cast
+import time
+from typing import Any, AsyncIterator, cast
 
 import opentelemetry.propagate
 from pydantic import TypeAdapter
 from redis.asyncio import Redis, ResponseError
+from redis.asyncio.retry import Retry
+from redis.backoff import ExponentialBackoff
+from redis.exceptions import ConnectionError as RedisConnectionError
 
 from hyperforge import logger
 from hyperforge.broker import AgentTimeoutError, Broker
@@ -12,6 +16,15 @@ from hyperforge.pubsub import AgentMessage, StartInteraction
 from hyperforge.redis_utils import ManualStreamKeysRedisCluster
 
 
+_REDIS_CONNECT_TIMEOUT_SECONDS = 5
+_REDIS_HEALTH_CHECK_INTERVAL_SECONDS = 30
+_REDIS_RETRY_ATTEMPTS = 3
+_REDIS_RETRY_BACKOFF_BASE_SECONDS = 0.1
+_REDIS_RETRY_BACKOFF_CAP_SECONDS = 1.0
+_REDIS_SUBSCRIBE_ACTIVATIONS_RETRY_SLEEP_SECONDS = 1
+_REPLY_READ_BLOCK_MAX_MS = 2000
+
+
 class RedisBroker(Broker):
     def __init__(self, client: Redis, activate_subject: str, keepalive_ms: int):
         self._client = client
@@ -30,23 +43,42 @@ class RedisBroker(Broker):
         keepalive_ms: int,
         cluster_mode: bool = False,
     ) -> "RedisBroker":
+        client_kwargs = cls._client_kwargs(keepalive_ms)
         if cluster_mode:
             client = cast(
                 Redis,
                 ManualStreamKeysRedisCluster.from_url(
                     url=url,
-                    decode_responses=True,
                     dynamic_startup_nodes=False,
+                    **client_kwargs,
                 ),
             )
         else:
             client = Redis.from_url(
                 url,
-                decode_responses=True,
-                socket_timeout=keepalive_ms / 1000,
-            )
+                **client_kwargs,
+            )  # type: ignore[call-overload]
         return cls(client, activate_subject, keepalive_ms)
 
+    @staticmethod
+    def _client_kwargs(keepalive_ms: int) -> dict[str, Any]:
+        retry = Retry(
+            backoff=ExponentialBackoff(
+                base=_REDIS_RETRY_BACKOFF_BASE_SECONDS,
+                cap=_REDIS_RETRY_BACKOFF_CAP_SECONDS,
+            ),
+            retries=_REDIS_RETRY_ATTEMPTS,
+        )
+        return {
+            "decode_responses": True,
+            "socket_timeout": keepalive_ms / 1000,
+            "socket_connect_timeout": _REDIS_CONNECT_TIMEOUT_SECONDS,
+            "health_check_interval": _REDIS_HEALTH_CHECK_INTERVAL_SECONDS,
+            "socket_keepalive": True,
+            "retry": retry,
+            "retry_on_timeout": True,
+        }
+
     async def publish_activation(
         self, msg: StartInteraction, trace: dict[str, str]
     ) -> None:
@@ -99,11 +131,15 @@ class RedisBroker(Broker):
                     logger.warning("Consumer group lost, re-creating...")
                     await self._ensure_consumer_group()
                 else:
-                    logger.exception("Error while subscribing to activations, retrying...")
-                    await asyncio.sleep(1)
+                    logger.exception(
+                        "Error while subscribing to activations, retrying..."
+                    )
+                    await asyncio.sleep(
+                        _REDIS_SUBSCRIBE_ACTIVATIONS_RETRY_SLEEP_SECONDS
+                    )
             except Exception:
                 logger.exception("Error while subscribing to activations, retrying...")
-                await asyncio.sleep(1)
+                await asyncio.sleep(_REDIS_SUBSCRIBE_ACTIVATIONS_RETRY_SLEEP_SECONDS)
 
     async def publish(self, topic: str, message: AgentMessage) -> None:
         async with self._client.pipeline() as pipe:
@@ -157,14 +193,38 @@ class RedisBroker(Broker):
         )
 
     async def receive_reply(self, key: str, timeout_ms: int) -> str | None:
-        response = await self._client.xread(
-            {key: "$"},
-            block=timeout_ms,
-            count=1,
-        )
-        if not response:
-            return None
-        return response[0][1][0][1]["msg"]
+        deadline = time.monotonic() + (timeout_ms / 1000)
+        reconnect_attempts = 0
+
+        while True:
+            remaining_s = deadline - time.monotonic()
+            if remaining_s <= 0:
+                return None
+
+            # Keep each blocking read short so transient socket closures/failovers
+            # can be recovered within the same overall timeout budget.
+            block_ms = min(_REPLY_READ_BLOCK_MAX_MS, max(1, int(remaining_s * 1000)))
+
+            try:
+                response = await self._client.xread(
+                    {key: "$"},
+                    block=block_ms,
+                    count=1,
+                )
+            except RedisConnectionError:
+                reconnect_attempts += 1
+                backoff_s = min(1.0, 0.1 * reconnect_attempts)
+                logger.warning(
+                    "Redis connection closed while receiving reply key=%s; retrying (attempt=%d)",
+                    key,
+                    reconnect_attempts,
+                )
+                await asyncio.sleep(backoff_s)
+                continue
+
+            if not response:
+                continue
+            return response[0][1][0][1]["msg"]
 
     async def initialize(self) -> None:
         pass

{hyperforge-1.0.0.post80 → hyperforge-1.0.0.post116}/src/hyperforge/server/session.py

@@ -111,7 +111,7 @@ class SessionManager:
                 logger.error(f"Module {load_module} could not be loaded")
 
         self.activation_task = asyncio.create_task(self.activation_listener())
-        if health_check:
+        if health_check and self.settings.health_check_enabled:
             self.server = await start_health_check()
 
     async def finalize(self):

{hyperforge-1.0.0.post80 → hyperforge-1.0.0.post116}/src/hyperforge/server/settings.py

@@ -45,3 +45,5 @@ class Settings(BaseSettings):
     # the kbid for internal NUA calls from the account_id request header
     # instead.
     standalone: bool = False
+
+    health_check_enabled: bool = True

{hyperforge-1.0.0.post80 → hyperforge-1.0.0.post116}/src/hyperforge/api/v1/oauth.py

@@ -3,13 +3,13 @@ from urllib.parse import urlencode
 
 from cryptography.fernet import InvalidToken
 from fastapi import Query
+from hyperforge_mcp.http import _fingerprint, decrypt_mcp_oauth_state
 from starlette.requests import Request
 from starlette.responses import HTMLResponse
 
 from hyperforge.api.settings import Settings
 from hyperforge.api.v1.router import router
 from hyperforge.api.v1.utils import tracer
-from hyperforge_mcp.http import _fingerprint, decrypt_mcp_oauth_state
 
 logger = logging.getLogger(__name__)
 

{hyperforge-1.0.0.post80 → hyperforge-1.0.0.post116}/src/hyperforge/server/sandbox.py

@@ -2,12 +2,12 @@ import asyncio
 from importlib.metadata import version
 
 import sentry_sdk
+from hyperforge_restricted import sandbox
 from nucliadb_telemetry.fastapi import application_metrics
 from nucliadb_telemetry.logs import setup_logging
 from nucliadb_telemetry.settings import LogLevel, LogSettings
 from sentry_sdk.integrations.excepthook import ExcepthookIntegration
 
-from hyperforge_restricted import sandbox
 from hyperforge.server.settings import Settings