hyperforge 1.0.0.post412__tar.gz → 1.0.0.post418__tar.gz

{hyperforge-1.0.0.post412 → hyperforge-1.0.0.post418}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperforge
-Version: 1.0.0.post412
+Version: 1.0.0.post418
 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.post412 → hyperforge-1.0.0.post418}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "hyperforge"
-version = "1.0.0.post412"
+version = "1.0.0.post418"
 description = "Agentic Framework for Orchestrated Runtime, Governance, and Execution"
 readme = "README.md"
 requires-python = ">=3.12"

{hyperforge-1.0.0.post412 → hyperforge-1.0.0.post418}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "hyperforge"
-version = "1.0.0.post412"
+version = "1.0.0.post418"
 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.post418/src/hyperforge/alembic/versions/8c7d2e4f91ab_structure_legacy_llm_fields.py

@@ -0,0 +1,24 @@
+"""Structure legacy string model fields in stored agent configurations.
+
+Revision ID: 8c7d2e4f91ab
+Revises: 6a23d8ef74c1
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+
+from hyperforge.db.legacy_llm_migration import migrate_legacy_llm_fields
+
+revision: str = "8c7d2e4f91ab"
+down_revision: Union[str, None] = "6a23d8ef74c1"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    migrate_legacy_llm_fields(op.get_bind())
+
+
+def downgrade() -> None:
+    pass

hyperforge-1.0.0.post418/src/hyperforge/db/legacy_llm_migration.py

@@ -0,0 +1,132 @@
+"""Convert old model strings in stored Hyperforge agent configs to LLMConfig.
+
+Only fields already declared as LLMField in Hyperforge are included. Agent
+plugins with string-typed model fields must remain strings until their schemas
+and runtimes are migrated separately.
+"""
+
+import json
+from typing import Any
+
+from sqlalchemy import text
+from sqlalchemy.engine import Connection
+
+from hyperforge.db.llm_migration_utils import HYPERFORGE_LLM_TABLES
+from hyperforge.llm_config import LLM_CONFIG_TYPE
+
+# Keep this inventory aligned with the LLMField declarations in Hyperforge.
+# Context fields are inherited by ContextAgentConfig subclasses, including
+# the installed progress-agents plugins. Their own string-typed model fields
+# are deliberately excluded from MODEL_FIELDS.
+CONTEXT_MODULES = {
+    "a2a",
+    "advanced_ask",
+    "ask",
+    "basic_ask",
+    "brave",
+    "context_conditional",
+    "cypher",
+    "google",
+    "http",
+    "marklogic",
+    "mcp",
+    "multi_mcp",
+    "pandas",
+    "perplexity",
+    "perplexity_search",
+    "restricted",
+    "salesforce",
+    "smart",
+    "snowflake",
+    "sparql",
+    "sql",
+    "static",
+    "static_string",
+    "sitefinity",
+    "sync",
+}
+CONTEXT_FIELDS = {"context_validation_model", "rephrase_model", "summarize_model"}
+MODEL_FIELDS = {
+    "advanced_ask": {"generative_model"},
+    "ask": {"configuration_model"},
+    "basic_ask": {"generative_model"},
+    "context_conditional": {"model"},
+    "external": {"model"},
+    "generate": {"model"},
+    "generation_conditional": {"model"},
+    "mcp": {"tool_choice_model", "sampling_model"},
+    "multi_mcp": {"summarize_model", "tool_choice_model"},
+    "post_conditional": {"model"},
+    "pre_conditional": {"model"},
+    "related": {"model"},
+    "rephrase": {"model"},
+    "restart": {"model"},
+    "restricted": {"decision_model"},
+    "salesforce": {"tool_choice_model", "sampling_model"},
+    "smart": {"planner_model", "executor_model"},
+    "summarize": {"model"},
+    "sync": {"generative_model"},
+}
+NESTED_FIELDS_BY_MODULE = {
+    "advanced_generation": {"summarize_config", "data_viz_config"},
+    "context_conditional": {"then", "else_"},
+    "generation_conditional": {"then", "else_"},
+    "multi_mcp": {"configs"},
+    "post_conditional": {"then", "else_"},
+    "pre_conditional": {"then", "else_"},
+    "restricted": {"agents"},
+    "smart": {"registered_agents"},
+}
+
+
+def wrap_legacy_llm_fields(config: Any) -> bool:
+    """Wrap string-valued LLMFields, including those inside nested agents."""
+    changed = False
+    if isinstance(config, list):
+        for item in config:
+            changed = wrap_legacy_llm_fields(item) or changed
+    elif isinstance(config, dict) and isinstance(config.get("module"), str):
+        module = config["module"]
+        fields = MODEL_FIELDS.get(module, set())
+        if module in CONTEXT_MODULES:
+            fields = fields | CONTEXT_FIELDS
+        for field in fields:
+            value = config.get(field)
+            if isinstance(value, str):
+                config[field] = {"_type": LLM_CONFIG_TYPE, "model_id": value}
+                changed = True
+        nested_fields = NESTED_FIELDS_BY_MODULE.get(module, set())
+        if module in CONTEXT_MODULES:
+            nested_fields = nested_fields | {"fallback", "next_agent"}
+        for field in nested_fields:
+            if field in config:
+                changed = wrap_legacy_llm_fields(config[field]) or changed
+    return changed
+
+
+def migrate_legacy_llm_fields(conn: Connection) -> int:
+    """Convert stored agent configs, leaving unrelated and structured data alone."""
+    modified = 0
+    for table, column in HYPERFORGE_LLM_TABLES:
+        last_id = "00000000-0000-0000-0000-000000000000"
+        while rows := conn.execute(
+            text(
+                f"SELECT id, {column} FROM {table} "
+                "WHERE id > CAST(:last_id AS uuid) ORDER BY id LIMIT 500"
+            ),
+            {"last_id": last_id},
+        ).fetchall():
+            for row_id, config in rows:
+                if isinstance(config, str):
+                    config = json.loads(config)
+                if wrap_legacy_llm_fields(config):
+                    conn.execute(
+                        text(
+                            f"UPDATE {table} SET {column} = CAST(:config AS jsonb) "
+                            "WHERE id = :id"
+                        ),
+                        {"config": json.dumps(config), "id": row_id},
+                    )
+                    modified += 1
+            last_id = str(rows[-1][0])
+    return modified

hyperforge-1.0.0.post418/src/hyperforge/errors.py

@@ -0,0 +1,105 @@
+import asyncio
+import re
+from collections.abc import Iterator
+
+_AUTH_CREDENTIAL = re.compile(r"(?i)\b(Bearer|Basic)\s+[^\s,;]+")
+_AUTHORIZATION_VALUE = re.compile(
+    r"(?i)\b(authorization)(\s*[:=]\s*)"
+    r"(?:\"[^\"]*\"|'[^']*'|(?:(?:Basic|Bearer)\s+)?[^\s,;]+)"
+)
+_COOKIE_VALUE = re.compile(r"(?i)\b(set-cookie|cookie)(\s*:\s*)[^\r\n]+")
+_SECRET_KEYS = (
+    r"api[_-]?key|access[_-]?token|auth[_-]?token|client[_-]?secret|"
+    r"credential|password|private[_-]?key|refresh[_-]?token|secret|session[_-]?id|"
+    r"oauth[_-]?token|token"
+)
+_QUOTED_SECRET_VALUE = re.compile(
+    rf"(?i)\b({_SECRET_KEYS})\b(\s*[\"']?\s*[:=]\s*)([\"'])[^\"']*\3"
+)
+_SECRET_VALUE = re.compile(
+    rf"(?i)\b({_SECRET_KEYS})\b(\s*[\"']?\s*[:=]\s*)([^\"',\s;&}}]+)"
+)
+_URL_CREDENTIALS = re.compile(r"(?i)(https?://)[^\s/:@]+:[^\s/@]+@")
+
+
+def _redact_secrets(detail: str) -> str:
+    detail = _URL_CREDENTIALS.sub(r"\1[REDACTED]:[REDACTED]@", detail)
+    detail = _AUTHORIZATION_VALUE.sub(r"\1\2[REDACTED]", detail)
+    detail = _AUTH_CREDENTIAL.sub(r"\1 [REDACTED]", detail)
+    detail = _COOKIE_VALUE.sub(r"\1\2[REDACTED]", detail)
+    detail = _QUOTED_SECRET_VALUE.sub(r"\1\2\3[REDACTED]\3", detail)
+    return _SECRET_VALUE.sub(r"\1\2[REDACTED]", detail)
+
+
+def _leaf_exceptions(exc: BaseException) -> Iterator[BaseException]:
+    if isinstance(exc, BaseExceptionGroup):
+        for nested in exc.exceptions:
+            yield from _leaf_exceptions(nested)
+        return
+
+    yield exc
+
+
+def actionable_exception_group(exc: BaseExceptionGroup) -> BaseExceptionGroup:
+    """Return regular exceptions while allowing only cancellation to be discarded."""
+    actionable, remainder = exc.split(Exception)
+    if actionable is None or (
+        remainder is not None
+        and any(
+            not isinstance(item, asyncio.CancelledError)
+            for item in _leaf_exceptions(remainder)
+        )
+    ):
+        raise exc
+    return actionable
+
+
+def _http_status(exc: BaseException) -> int | None:
+    response = getattr(exc, "response", None)
+    status = getattr(response, "status_code", None)
+    if isinstance(status, int):
+        return status
+
+    status = getattr(exc, "status", None)
+    return status if isinstance(status, int) else None
+
+
+def _exception_detail(exc: BaseException) -> str:
+    detail = _redact_secrets(str(exc).strip() or type(exc).__name__)
+    status = _http_status(exc)
+    if status == 401:
+        return f"Authentication failed (HTTP 401): {detail}"
+    if status == 403:
+        return f"Authorization failed (HTTP 403): {detail}"
+    return detail
+
+
+def _exception_priority(exc: BaseException) -> int:
+    status = _http_status(exc)
+    if status == 401:
+        return 0
+    if status == 403:
+        return 1
+    return 2
+
+
+def exception_detail(exc: BaseException) -> str:
+    """Return useful, bounded details from an exception or exception group."""
+    leaves = list(_leaf_exceptions(exc))
+    actionable = [
+        item for item in leaves if not isinstance(item, asyncio.CancelledError)
+    ]
+    if actionable:
+        leaves = actionable
+
+    leaves.sort(key=_exception_priority)
+    details = list(dict.fromkeys(_exception_detail(item) for item in leaves))
+    if len(details) == 1:
+        return details[0]
+
+    visible_details = details[:3]
+    if len(details) > len(visible_details):
+        visible_details.append(
+            f"and {len(details) - len(visible_details)} more error(s)"
+        )
+    return "Multiple errors: " + "; ".join(visible_details)

{hyperforge-1.0.0.post412 → hyperforge-1.0.0.post418}/src/hyperforge/server/session.py

@@ -19,6 +19,7 @@ from hyperforge.broker import Broker
 from hyperforge.configure import load_all_configurations, scan
 from hyperforge.db.agents import AgentManager
 from hyperforge.engine import State, get_state
+from hyperforge.errors import actionable_exception_group, exception_detail
 from hyperforge.interaction import (
     AnswerOperation,
     AragAnswer,
@@ -375,10 +376,16 @@ class SessionManager:
             async with asyncio.timeout(self.settings.question_timeout_seconds):
                 await state.agent(question_memory, state.manager)
 
+        except BaseExceptionGroup as exc:
+            error_group = actionable_exception_group(exc)
+            logger.exception("Answering exception")
+            errors.capture_exception(error_group)
+            error = ARAGException(detail=exception_detail(error_group))
+            observation.set_status("error")
         except Exception as e:
             logger.exception("Answering exception")
             errors.capture_exception(e)
-            error = ARAGException(detail=str(e))
+            error = ARAGException(detail=exception_detail(e))
             observation.set_status("error")
         finally:
             if state.manager is not None:
@@ -387,10 +394,9 @@ class SessionManager:
                 except Exception as e:
                     logger.exception("Error closing Manager")
                     errors.capture_exception(e)
-
-        observation.end()
-        answer_running.dec()
-        keepalive.cancel()
+            observation.end()
+            answer_running.dec()
+            keepalive.cancel()
 
         await self.callback(
             topic,