GeneralManager 0.76.0__tar.gz → 0.77.1__tar.gz

{generalmanager-0.76.0/src/GeneralManager.egg-info → generalmanager-0.77.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.76.0
+Version: 0.77.1
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.76.0 → generalmanager-0.77.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.76.0"
+version = "0.77.1"
 description = "Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching."
 readme = "README.md"
 authors = [{ name = "Tim Kleindick", email = "tkleindick@yahoo.de" }]
@@ -178,6 +178,8 @@ module = [
     "graphql",
     "graphql.*",
     "numpy",
+    "openai",
+    "openai.*",
     "pint",
     "pint.*",
     "prometheus_client",

{generalmanager-0.76.0 → generalmanager-0.77.1/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.76.0
+Version: 0.77.1
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.76.0 → generalmanager-0.77.1}/src/GeneralManager.egg-info/SOURCES.txt

@@ -106,11 +106,27 @@ src/general_manager/chat/evals/datasets/edge_cases.yaml
 src/general_manager/chat/evals/datasets/follow_ups.yaml
 src/general_manager/chat/evals/datasets/large_schema.yaml
 src/general_manager/chat/evals/datasets/multi_hop.yaml
+src/general_manager/chat/evals/datasets/planned_orchestration.yaml
 src/general_manager/chat/evals/judges/__init__.py
 src/general_manager/chat/evals/judges/answer_quality.py
 src/general_manager/chat/evals/judges/contract.py
 src/general_manager/chat/evals/judges/result_accuracy.py
 src/general_manager/chat/evals/judges/tool_sequence.py
+src/general_manager/chat/planned/__init__.py
+src/general_manager/chat/planned/budget.py
+src/general_manager/chat/planned/calculations.py
+src/general_manager/chat/planned/catalog.py
+src/general_manager/chat/planned/config.py
+src/general_manager/chat/planned/events.py
+src/general_manager/chat/planned/evidence.py
+src/general_manager/chat/planned/models.py
+src/general_manager/chat/planned/planner.py
+src/general_manager/chat/planned/provider_calls.py
+src/general_manager/chat/planned/resolver.py
+src/general_manager/chat/planned/routing.py
+src/general_manager/chat/planned/scheduler.py
+src/general_manager/chat/planned/synthesis.py
+src/general_manager/chat/planned/validation.py
 src/general_manager/chat/providers/__init__.py
 src/general_manager/chat/providers/_shared.py
 src/general_manager/chat/providers/anthropic.py

generalmanager-0.77.1/src/general_manager/chat/audit.py

@@ -0,0 +1,382 @@
+"""Audit helpers for chat interactions."""
+
+from __future__ import annotations
+
+from contextlib import suppress
+import hashlib
+import json
+import math
+from typing import Any
+
+from django.utils.module_loading import import_string
+
+from general_manager.chat.settings import get_chat_settings
+
+
+_PLANNED_ROLES = frozenset(
+    (
+        "planner",
+        "simple_executor",
+        "complex_executor",
+        "synthesizer",
+        "fallback_executor",
+    )
+)
+_PLANNED_MATCH_SOURCES = frozenset(
+    (
+        "exact_name",
+        "exact_alias",
+        "catalog_domain",
+        "catalog_alias",
+        "catalog_use_when",
+        "schema_description",
+        "schema_field",
+        "schema_filter",
+        "schema_relation",
+    )
+)
+_PLANNED_PROGRESS = frozenset(
+    (
+        "candidate_changed",
+        "duplicate_rejected",
+        "evidence_added",
+        "no_progress",
+        "task_blocked",
+        "task_resolved",
+    )
+)
+_PLANNED_EVENT_FIELDS = {
+    "plan": frozenset(("plan_id", "task_count", "role", "trust_group_valid")),
+    "task_progress": frozenset(
+        (
+            "plan_id",
+            "task_id",
+            "root_task_id",
+            "parent_task_id",
+            "role",
+            "match_sources",
+            "canonical_call_identity",
+            "call_hash",
+            "duplicate",
+            "progress",
+            "local_passes",
+            "subtree_rounds_used",
+            "subtree_rounds_remaining",
+            "global_rounds_used",
+            "global_rounds_remaining",
+            "stage_latency_ms",
+            "task_latency_ms",
+            "input_tokens",
+            "output_tokens",
+            "reported_cost",
+            "evidence_counts",
+            "coverage",
+            "terminal_reason",
+        )
+    ),
+    "route": frozenset(
+        (
+            "plan_id",
+            "task_id",
+            "root_task_id",
+            "role",
+            "route",
+            "escalated",
+            "trust_group_valid",
+        )
+    ),
+    "candidate": frozenset(
+        (
+            "plan_id",
+            "task_id",
+            "match_sources",
+            "candidate_count",
+            "local_passes",
+        )
+    ),
+    "tool_call": frozenset(
+        (
+            "plan_id",
+            "task_id",
+            "canonical_call_identity",
+            "call_hash",
+            "duplicate",
+        )
+    ),
+    "tool_result": frozenset(
+        (
+            "plan_id",
+            "task_id",
+            "call_hash",
+            "duplicate",
+            "progress",
+            "evidence_counts",
+        )
+    ),
+    "budget": frozenset(
+        (
+            "plan_id",
+            "task_id",
+            "subtree_rounds_used",
+            "subtree_rounds_remaining",
+            "global_rounds_used",
+            "global_rounds_remaining",
+        )
+    ),
+    "latency": frozenset(
+        ("plan_id", "task_id", "stage", "stage_latency_ms", "task_latency_ms")
+    ),
+    "usage": frozenset(
+        ("plan_id", "task_id", "role", "input_tokens", "output_tokens", "reported_cost")
+    ),
+    "evidence": frozenset(("plan_id", "task_id", "evidence_counts", "progress")),
+    "coverage": frozenset(("plan_id", "coverage", "terminal_reason")),
+    "terminal": frozenset(("plan_id", "coverage", "terminal_reason")),
+}
+_PLANNED_REASONS = frozenset(
+    (
+        "invalid_plan",
+        "manager_unresolved",
+        "dependency_blocked",
+        "budget_exhausted",
+        "deadline_exceeded",
+        "provider_failed",
+        "synthesis_failed",
+    )
+)
+
+
+def _should_emit(event_type: str, level: str) -> bool:
+    if level == "off":
+        return False
+    if level == "messages":
+        return event_type in {"user_message", "assistant_message"}
+    return True
+
+
+def _redact(value: Any, redact_fields: set[str]) -> Any:
+    if isinstance(value, dict):
+        redacted: dict[str, Any] = {}
+        for key, item in value.items():
+            lowered = str(key).lower()
+            if any(field in lowered for field in redact_fields):
+                redacted[str(key)] = "[REDACTED]"
+            else:
+                redacted[str(key)] = _redact(item, redact_fields)
+        return redacted
+    if isinstance(value, list):
+        return [_redact(item, redact_fields) for item in value]
+    return value
+
+
+def _truncate_result(value: Any, max_result_size: int) -> str:
+    serialized = json.dumps(value, sort_keys=True)
+    if len(serialized) <= max_result_size:
+        return serialized
+    return f"{serialized[:max_result_size]}..."
+
+
+def _resolve_sink() -> Any:
+    audit_settings = get_chat_settings()["audit"]
+    logger_path = audit_settings.get("logger")
+    if logger_path is None:
+        return None
+    if callable(logger_path):
+        return logger_path
+    return import_string(str(logger_path))
+
+
+def emit_chat_audit_event(
+    event_type: str,
+    payload: dict[str, Any],
+    *,
+    sink: Any | None = None,
+) -> None:
+    """Emit one sanitized chat audit event when chat audit logging is enabled."""
+    audit_settings = get_chat_settings()["audit"]
+    if not audit_settings.get("enabled"):
+        return
+    level = str(audit_settings.get("level", "off"))
+    if not _should_emit(event_type, level):
+        return
+
+    redact_fields = {
+        str(field).lower() for field in audit_settings.get("redact_fields", [])
+    }
+    sanitized = _redact(payload, redact_fields)
+    if "result" in sanitized:
+        sanitized["result"] = _truncate_result(
+            sanitized["result"],
+            int(audit_settings.get("max_result_size", 4096)),
+        )
+    event = {"event_type": event_type, **sanitized}
+
+    with suppress(Exception):
+        target = sink if sink is not None else _resolve_sink()
+        if target is None:
+            return
+        if callable(target):
+            target(event)
+
+
+def _planned_nonnegative_int(value: object) -> int | None:
+    if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+        return None
+    return value
+
+
+def _planned_identifier(value: object) -> str | None:
+    if not isinstance(value, str) or not value or len(value) > 128:
+        return None
+    return value
+
+
+def planned_audit_lineage_id(value: object) -> str | None:
+    """Return a deterministic opaque audit identifier for planner-controlled IDs."""
+    identifier = _planned_identifier(value)
+    if identifier is None:
+        return None
+    return hashlib.sha256(identifier.encode()).hexdigest()
+
+
+def _planned_count_mapping(value: object, allowed: set[str]) -> dict[str, int] | None:
+    if not isinstance(value, dict):
+        return None
+    safe: dict[str, int] = {}
+    for key, item in value.items():
+        if key not in allowed or (number := _planned_nonnegative_int(item)) is None:
+            return None
+        safe[key] = number
+    return safe
+
+
+def _planned_cost(value: object) -> str | float | int | None:
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        return value if math.isfinite(value) and value >= 0 else None
+    if isinstance(value, str) and len(value) <= 32:
+        try:
+            parsed = float(value)
+        except ValueError:
+            return None
+        return value if math.isfinite(parsed) and parsed >= 0 else None
+    return None
+
+
+def _sanitize_planned_audit_payload(
+    event_type: str, payload: dict[str, Any]
+) -> dict[str, Any]:
+    """Return the category-specific planned audit allowlist, never a copy."""
+    allowed = _PLANNED_EVENT_FIELDS.get(event_type)
+    if allowed is None:
+        return {}
+    sanitized: dict[str, Any] = {}
+    for key in ("plan_id", "task_id", "root_task_id", "parent_task_id"):
+        if (
+            key in allowed
+            and (value := planned_audit_lineage_id(payload.get(key))) is not None
+        ):
+            sanitized[key] = value
+    if "role" in allowed and payload.get("role") in _PLANNED_ROLES:
+        sanitized["role"] = payload["role"]
+    if "route" in allowed and payload.get("route") in {"selected", "escalated"}:
+        sanitized["route"] = payload["route"]
+    for key in ("duplicate", "escalated", "trust_group_valid"):
+        if key in allowed and isinstance(payload.get(key), bool):
+            sanitized[key] = payload[key]
+    if "match_sources" in allowed and isinstance(payload.get("match_sources"), list):
+        sources = payload["match_sources"]
+        if all(
+            isinstance(item, str) and item in _PLANNED_MATCH_SOURCES for item in sources
+        ):
+            sanitized["match_sources"] = list(sources)
+    if "canonical_call_identity" in allowed and isinstance(
+        payload.get("canonical_call_identity"), str
+    ):
+        sanitized["call_hash"] = hashlib.sha256(
+            payload["canonical_call_identity"].encode()
+        ).hexdigest()
+    elif "call_hash" in allowed and isinstance(payload.get("call_hash"), str):
+        call_hash = payload["call_hash"]
+        if len(call_hash) == 64 and all(
+            char in "0123456789abcdef" for char in call_hash
+        ):
+            sanitized["call_hash"] = call_hash
+    if "progress" in allowed and payload.get("progress") in _PLANNED_PROGRESS:
+        sanitized["progress"] = payload["progress"]
+    for key in (
+        "task_count",
+        "candidate_count",
+        "local_passes",
+        "subtree_rounds_used",
+        "subtree_rounds_remaining",
+        "global_rounds_used",
+        "global_rounds_remaining",
+        "stage_latency_ms",
+        "task_latency_ms",
+        "input_tokens",
+        "output_tokens",
+    ):
+        if (
+            key in allowed
+            and (number := _planned_nonnegative_int(payload.get(key))) is not None
+        ):
+            sanitized[key] = number
+    if "stage" in allowed and payload.get("stage") in {
+        "planning",
+        "evidence",
+        "synthesis",
+    }:
+        sanitized["stage"] = payload["stage"]
+    if (
+        "reported_cost" in allowed
+        and (cost := _planned_cost(payload.get("reported_cost"))) is not None
+    ):
+        sanitized["reported_cost"] = cost
+    if (
+        "evidence_counts" in allowed
+        and (
+            evidence_counts := _planned_count_mapping(
+                payload.get("evidence_counts"),
+                {"schema", "path", "query", "calculation"},
+            )
+        )
+        is not None
+    ):
+        sanitized["evidence_counts"] = evidence_counts
+    if (
+        "coverage" in allowed
+        and (
+            coverage := _planned_count_mapping(
+                payload.get("coverage"), {"resolved", "total"}
+            )
+        )
+        is not None
+        and set(coverage) == {"resolved", "total"}
+        and coverage["resolved"] <= coverage["total"]
+    ):
+        sanitized["coverage"] = coverage
+    if (
+        "terminal_reason" in allowed
+        and payload.get("terminal_reason") in _PLANNED_REASONS
+    ):
+        sanitized["terminal_reason"] = payload["terminal_reason"]
+    return sanitized
+
+
+def emit_planned_audit_event(
+    event_type: str,
+    payload: dict[str, Any],
+    *,
+    sink: Any | None = None,
+) -> None:
+    """Emit only category-approved planned diagnostics through the generic sink."""
+    if event_type not in _PLANNED_EVENT_FIELDS:
+        return
+    with suppress(Exception):
+        emit_chat_audit_event(
+            f"planned_{event_type}",
+            _sanitize_planned_audit_payload(event_type, payload),
+            sink=sink,
+        )

{generalmanager-0.76.0 → generalmanager-0.77.1}/src/general_manager/chat/consumer.py

@@ -20,6 +20,13 @@ from general_manager.chat.grounding import (
     should_recover_answer_without_query,
     should_recover_missing_tool_call,
 )
+from general_manager.chat.planned.catalog import load_manager_catalog
+from general_manager.chat.planned.config import get_planned_chat_settings
+from general_manager.chat.planned.scheduler import (
+    SchedulerCallbacks,
+    iter_planned_read_events,
+    prepare_planned_turn,
+)
 from general_manager.chat.providers.base import (
     DoneEvent,
     Message,
@@ -27,6 +34,7 @@ from general_manager.chat.providers.base import (
     ToolCallEvent,
     ToolDefinition,
 )
+from general_manager.chat.schema_index import build_schema_index
 from general_manager.chat.rate_limits import enforce_chat_rate_limit
 from general_manager.chat.signals import (
     emit_chat_error,
@@ -262,6 +270,11 @@ class ChatConsumer(_ChatConsumerBase):
                 await provider_task
             except asyncio.CancelledError:
                 pass
+        if self._provider_task is provider_task:
+            self._provider_task = None
+        active_turn = getattr(self, "_active_turn", None)
+        if active_turn is not None and not active_turn.done():
+            active_turn.set_result(None)
         await self._cancel_confirmation_timeout()
         await super().disconnect(code)
 
@@ -327,6 +340,7 @@ class ChatConsumer(_ChatConsumerBase):
             return
         loop = asyncio.get_running_loop()
         self._active_turn = loop.create_future()
+        started_background_turn = False
         try:
             if self.conversation is None:
                 self.conversation = await self._get_persistent_conversation()
@@ -357,7 +371,9 @@ class ChatConsumer(_ChatConsumerBase):
                 message=text,
                 conversation_id=getattr(self.conversation, "pk", None),
             )
-            await self._stream_provider_turn(messages, history, tool_retries=0)
+            started_background_turn = await self._stream_message_turn(
+                text, messages, history
+            )
         except Exception as exc:  # noqa: BLE001
             emit_chat_error(
                 user=self.scope.get("user"),
@@ -366,7 +382,11 @@ class ChatConsumer(_ChatConsumerBase):
             )
             await self.send_json(public_chat_error(exc).as_event())
         finally:
-            if self._active_turn is not None and not self._active_turn.done():
+            if (
+                not started_background_turn
+                and self._active_turn is not None
+                and not self._active_turn.done()
+            ):
                 self._active_turn.set_result(None)
 
     async def _stream_provider_turn(
@@ -526,6 +546,100 @@ class ChatConsumer(_ChatConsumerBase):
         finally:
             self._provider_task = None
 
+    @staticmethod
+    def _planned_catalog_summary(settings: Any) -> dict[str, Any]:
+        """Build inert catalog/schema reference data for the planner request."""
+        schema_index = build_schema_index()
+        catalog = load_manager_catalog(
+            getattr(settings, "catalog_source", None), schema_index
+        )
+        return {
+            "catalog": {
+                name: {
+                    "domain": entry.domain,
+                    "aliases": list(entry.aliases),
+                    "use_when": entry.use_when,
+                    "distinguish_from": list(entry.distinguish_from),
+                }
+                for name, entry in catalog.entries.items()
+            },
+            "schema": schema_index,
+        }
+
+    async def _stream_message_turn(
+        self,
+        text: str,
+        messages: list[Message],
+        history: list[dict[str, str]],
+    ) -> bool:
+        """Plan after admission, retaining the unchanged legacy turn as fallback."""
+        planned_settings = get_planned_chat_settings()
+        if not planned_settings.enabled:
+            await self._stream_provider_turn(messages, history, tool_retries=0)
+            return False
+        self._provider_task = asyncio.create_task(
+            self._stream_planned_turn(text, messages, history, planned_settings)
+        )
+        return True
+
+    async def _stream_planned_turn(
+        self,
+        text: str,
+        messages: list[Message],
+        history: list[dict[str, str]],
+        planned_settings: Any,
+    ) -> None:
+        """Own planning and execution in one cancellable websocket task."""
+        planned_messages = messages
+        callbacks = SchedulerCallbacks(enforce_rate_limit=enforce_chat_rate_limit)
+        try:
+            if self.conversation is not None:
+                from general_manager.chat.models import build_conversation_context
+
+                context = await sync_to_async(build_conversation_context)(
+                    self.conversation
+                )
+                planned_messages = [
+                    Message(role="system", content=build_system_prompt()),
+                    *(
+                        Message(role=item.role, content=item.content)
+                        for item in context
+                    ),
+                ]
+            planned_turn = await prepare_planned_turn(
+                text,
+                planned_messages,
+                planned_settings,
+                self._planned_catalog_summary(planned_settings),
+                callbacks=callbacks,
+                scope=self.scope,
+            )
+            if planned_turn.mutation_plan is not None:
+                await self._stream_provider_turn(messages, history, tool_retries=0)
+                return
+            async for event in iter_planned_read_events(
+                planned_turn,
+                scope=self.scope,
+                conversation=self.conversation,
+                messages=planned_messages,
+                callbacks=callbacks,
+            ):
+                await self.send_json(event)
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            emit_chat_error(
+                user=self.scope.get("user"),
+                error=exc,
+                context={"transport": "websocket", "session_key": self.session_key},
+            )
+            await self.send_json(public_chat_error(exc).as_event())
+        finally:
+            if self._provider_task is asyncio.current_task():
+                self._provider_task = None
+            if self._active_turn is not None and not self._active_turn.done():
+                self._active_turn.set_result(None)
+
     async def _handle_tool_call(
         self,
         event: ToolCallEvent,

generalmanager-0.77.1/src/general_manager/chat/errors.py

@@ -0,0 +1,46 @@
+"""Public chat error mapping."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+PLANNED_PUBLIC_MESSAGES = {
+    "invalid_plan": "I could not prepare a safe plan for that request.",
+    "manager_unresolved": "I could not resolve the required application data.",
+    "dependency_blocked": "A required part of the request could not be completed.",
+    "budget_exhausted": "The request reached its execution limit.",
+    "deadline_exceeded": "The request reached its time limit.",
+    "provider_failed": "The provider could not complete the request.",
+    "synthesis_failed": "I could not produce a grounded answer from the available data.",
+}
+
+
+@dataclass(frozen=True)
+class PublicChatError:
+    """Sanitized chat error safe to return to clients."""
+
+    code: str
+    message: str
+
+    def as_event(self) -> dict[str, Any]:
+        """Render the error as the public chat event payload."""
+        return {"type": "error", "message": self.message, "code": self.code}
+
+
+def public_chat_error(_exc: Exception) -> PublicChatError:
+    """Map an internal exception to a generic public chat error."""
+    planned_reason = getattr(_exc, "public_reason", None)
+    if isinstance(planned_reason, str):
+        return planned_public_error(planned_reason)
+    if isinstance(_exc, TimeoutError):
+        return planned_public_error("deadline_exceeded")
+    return PublicChatError("chat_error", "Chat request failed.")
+
+
+def planned_public_error(reason: object) -> PublicChatError:
+    """Map a stable planned terminal reason without exposing internal details."""
+    if isinstance(reason, str) and reason in PLANNED_PUBLIC_MESSAGES:
+        return PublicChatError(reason, PLANNED_PUBLIC_MESSAGES[reason])
+    return PublicChatError("chat_error", "Chat request failed.")