GeneralManager 0.79.0__tar.gz → 0.79.2__tar.gz

{generalmanager-0.79.0/src/GeneralManager.egg-info → generalmanager-0.79.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.79.0
+Version: 0.79.2
 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.79.0 → generalmanager-0.79.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.79.0"
+version = "0.79.2"
 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" }]

{generalmanager-0.79.0 → generalmanager-0.79.2/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.79.0
+Version: 0.79.2
 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.79.0 → generalmanager-0.79.2}/src/GeneralManager.egg-info/SOURCES.txt

@@ -96,6 +96,7 @@ src/general_manager/chat/signals.py
 src/general_manager/chat/system_prompt.py
 src/general_manager/chat/tool_metadata.py
 src/general_manager/chat/tools.py
+src/general_manager/chat/turns.py
 src/general_manager/chat/views.py
 src/general_manager/chat/evals/__init__.py
 src/general_manager/chat/evals/__main__.py

{generalmanager-0.79.0 → generalmanager-0.79.2}/src/general_manager/api/graphql_groups.py

@@ -94,7 +94,10 @@ def create_group_types(
                 )
             else:
                 sum_fields[field_name] = map_field(sum_type, field_name, field_info)
-            sum_resolvers[f"resolve_{field_name}"] = _sum_resolver(field_name)
+            sum_resolvers[f"resolve_{field_name}"] = _sum_resolver(
+                field_name,
+                text_values=sum_type is not None and issubclass(sum_type, str),
+            )
 
     key_type = type(
         f"{manager_class.__name__}GroupKeys",
@@ -201,7 +204,7 @@ def _is_sum_type(field_type: object) -> bool:
     return (
         concrete_type is not None
         and not issubclass(concrete_type, bool)
-        and issubclass(concrete_type, (int, float, Decimal, Measurement))
+        and issubclass(concrete_type, (int, float, Decimal, Measurement, str))
     )
 
 
@@ -288,13 +291,22 @@ def _measurement_key_resolver(field_name: str) -> Callable[..., object]:
     return resolver
 
 
-def _sum_resolver(field_name: str) -> Callable[..., object]:
+def _sum_resolver(
+    field_name: str, *, text_values: bool = False
+) -> Callable[..., object]:
     def resolver(
         group: GroupManager[GeneralManager],
         info: GraphQLResolveInfo,
         target_unit: str | None = None,
     ) -> object:
         _validate_group_field_permission(group, info, field_name)
+        if text_values:
+            values = dict.fromkeys(
+                str(value)
+                for member in group.members
+                if (value := getattr(member, field_name)) is not None
+            )
+            return ", ".join(values) if values else None
         value = group.sum(field_name)
         if isinstance(value, Measurement):
             return measurement_to_graphql_payload(value, target_unit)

{generalmanager-0.79.0 → generalmanager-0.79.2}/src/general_manager/chat/consumer.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 from datetime import datetime, timedelta
+import inspect
 import json
 from typing import TYPE_CHECKING, Any
 
@@ -54,6 +55,7 @@ from general_manager.chat.tools import (
     execute_chat_tool,
     get_tool_definitions,
 )
+from general_manager.chat.turns import TurnState
 
 if TYPE_CHECKING:
     from general_manager.chat.models import ChatConversation
@@ -99,14 +101,23 @@ async def _iter_provider_events(
     stream_timeout = float(provider_config.get("stream_timeout_seconds", 30))
     stream = provider.complete(messages, tools).__aiter__()
     first_chunk = True
-    while True:
-        timeout = request_timeout if first_chunk else stream_timeout
-        try:
-            event = await asyncio.wait_for(stream.__anext__(), timeout=timeout)
-        except StopAsyncIteration:
-            return
-        first_chunk = False
-        yield event
+    try:
+        while True:
+            timeout = request_timeout if first_chunk else stream_timeout
+            try:
+                event = await asyncio.wait_for(stream.__anext__(), timeout=timeout)
+            except StopAsyncIteration:
+                return
+            first_chunk = False
+            yield event
+            if isinstance(event, DoneEvent):
+                return
+    finally:
+        close = getattr(stream, "aclose", None)
+        if callable(close):
+            result = close()
+            if inspect.isawaitable(result):
+                await result
 
 
 def _last_user_text(messages: list[Message]) -> str:
@@ -371,6 +382,7 @@ class ChatConsumer(_ChatConsumerBase):
                 {"message": text, "session_key": self.session_key},
             )
             messages = [Message(role="system", content=build_system_prompt())]
+            turn_state = TurnState.from_settings(get_chat_settings())
             if self.conversation is not None:
                 from general_manager.chat.context import prepare_conversation_messages
 
@@ -379,6 +391,7 @@ class ChatConsumer(_ChatConsumerBase):
                     self.provider,
                     allow_summarization=not get_planned_chat_settings().enabled,
                     scope=self.scope,
+                    turn_state=turn_state,
                 )
             else:
                 messages.extend(
@@ -391,7 +404,7 @@ class ChatConsumer(_ChatConsumerBase):
                 conversation_id=getattr(self.conversation, "pk", None),
             )
             started_background_turn = await self._stream_message_turn(
-                text, messages, history
+                text, messages, history, turn_state=turn_state
             )
         except Exception as exc:  # noqa: BLE001
             emit_chat_error(
@@ -416,18 +429,47 @@ class ChatConsumer(_ChatConsumerBase):
         tool_retries: int,
         tool_calls: list[dict[str, Any]] | None = None,
         recovered_missing_tools: bool = False,
+        turn_state: TurnState | None = None,
+        allow_tools: bool = True,
     ) -> None:
         tool_calls = list(tool_calls or [])
         assistant_chunks: list[str] = []
         provider_tool_events: list[ToolCallEvent] = []
-        self._provider_task = asyncio.current_task()
         recover_missing_tools = bool(
             get_chat_settings().get("recover_missing_tool_calls", False)
         )
+        turn_state = turn_state or TurnState.from_settings(get_chat_settings())
+        turn_state.tool_retries = tool_retries
+        if not turn_state.reserve_round():
+            await self.send_json(
+                {
+                    "type": "error",
+                    "message": "Chat turn limit exceeded.",
+                    "code": "turn_limit",
+                }
+            )
+            return
+        rate_limited = await sync_to_async(enforce_chat_rate_limit)(
+            self.scope, count_request=False
+        )
+        if isinstance(rate_limited, dict):
+            await self.send_json(
+                {
+                    "type": "error",
+                    "message": "Chat rate limit exceeded. Try again later.",
+                    "code": "rate_limited",
+                    "retry_after_seconds": rate_limited["retry_after_seconds"],
+                }
+            )
+            return
+        self._provider_task = asyncio.current_task()
+        provider_events = _iter_provider_events(
+            self.provider,
+            messages,
+            self._build_tool_definitions() if allow_tools else [],
+        )
         try:
-            async for event in _iter_provider_events(
-                self.provider, messages, self._build_tool_definitions()
-            ):
+            async for event in provider_events:
                 if isinstance(event, TextChunkEvent):
                     assistant_chunks.append(event.content)
                     if not recover_missing_tools:
@@ -438,13 +480,37 @@ class ChatConsumer(_ChatConsumerBase):
                     provider_tool_events.append(event)
                     continue
                 elif isinstance(event, DoneEvent):
-                    if provider_tool_events:
-                        await sync_to_async(enforce_chat_rate_limit)(
-                            self.scope,
-                            input_tokens=event.usage.input_tokens,
-                            output_tokens=event.usage.output_tokens,
-                            count_request=False,
+                    turn_state.record_usage(event.usage)
+                    rate_limited = await sync_to_async(enforce_chat_rate_limit)(
+                        self.scope,
+                        input_tokens=event.usage.input_tokens,
+                        output_tokens=event.usage.output_tokens,
+                        count_request=False,
+                    )
+                    # Account completion before cleanup, but do not continue or finish first.
+                    await provider_events.aclose()
+                    if isinstance(rate_limited, dict):
+                        await self.send_json(
+                            {
+                                "type": "error",
+                                "message": "Chat rate limit exceeded. Try again later.",
+                                "code": "rate_limited",
+                                "retry_after_seconds": rate_limited[
+                                    "retry_after_seconds"
+                                ],
+                            }
                         )
+                        return
+                    if provider_tool_events:
+                        if not allow_tools:
+                            await self.send_json(
+                                {
+                                    "type": "error",
+                                    "message": "Chat tool retry limit exceeded.",
+                                    "code": "tool_retry_limit",
+                                }
+                            )
+                            return
                         await self._handle_tool_batch(
                             provider_tool_events,
                             messages,
@@ -452,6 +518,7 @@ class ChatConsumer(_ChatConsumerBase):
                             tool_retries=tool_retries,
                             tool_calls=tool_calls,
                             recovered_missing_tools=recovered_missing_tools,
+                            turn_state=turn_state,
                         )
                         return
                     if assistant_chunks:
@@ -480,6 +547,7 @@ class ChatConsumer(_ChatConsumerBase):
                                 tool_retries=tool_retries,
                                 tool_calls=tool_calls,
                                 recovered_missing_tools=True,
+                                turn_state=turn_state,
                             )
                             return
                         if (
@@ -505,6 +573,7 @@ class ChatConsumer(_ChatConsumerBase):
                                 tool_retries=tool_retries,
                                 tool_calls=tool_calls,
                                 recovered_missing_tools=True,
+                                turn_state=turn_state,
                             )
                             return
                         if recover_missing_tools:
@@ -541,24 +610,28 @@ class ChatConsumer(_ChatConsumerBase):
                             tool_retries=tool_retries,
                             tool_calls=tool_calls,
                             recovered_missing_tools=True,
+                            turn_state=turn_state,
                         )
                         return
-                    await sync_to_async(enforce_chat_rate_limit)(
-                        self.scope,
-                        input_tokens=event.usage.input_tokens,
-                        output_tokens=event.usage.output_tokens,
-                        count_request=False,
-                    )
                     await self.send_json(
                         {
                             "type": "done",
                             "usage": {
-                                "input_tokens": event.usage.input_tokens,
-                                "output_tokens": event.usage.output_tokens,
+                                "input_tokens": turn_state.usage.input_tokens,
+                                "output_tokens": turn_state.usage.output_tokens,
                             },
                         }
                     )
             if provider_tool_events:
+                if not allow_tools:
+                    await self.send_json(
+                        {
+                            "type": "error",
+                            "message": "Chat tool retry limit exceeded.",
+                            "code": "tool_retry_limit",
+                        }
+                    )
+                    return
                 await self._handle_tool_batch(
                     provider_tool_events,
                     messages,
@@ -566,9 +639,13 @@ class ChatConsumer(_ChatConsumerBase):
                     tool_retries=tool_retries,
                     tool_calls=tool_calls,
                     recovered_missing_tools=recovered_missing_tools,
+                    turn_state=turn_state,
                 )
         finally:
-            self._provider_task = None
+            try:
+                await provider_events.aclose()
+            finally:
+                self._provider_task = None
 
     @staticmethod
     def _planned_catalog_summary(settings: Any) -> dict[str, Any]:
@@ -595,11 +672,15 @@ class ChatConsumer(_ChatConsumerBase):
         text: str,
         messages: list[Message],
         history: list[dict[str, str]],
+        *,
+        turn_state: TurnState | None = None,
     ) -> 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)
+            await self._stream_provider_turn(
+                messages, history, tool_retries=0, turn_state=turn_state
+            )
             return False
         self._provider_task = asyncio.create_task(
             self._stream_planned_turn(text, messages, history, planned_settings)
@@ -669,6 +750,8 @@ class ChatConsumer(_ChatConsumerBase):
         tool_retries: int,
         tool_calls: list[dict[str, Any]] | None = None,
         recovered_missing_tools: bool = False,
+        turn_state: TurnState | None = None,
+        allow_tools: bool = True,
     ) -> bool:
         """Execute a completed non-mutation tool batch before continuing once."""
         if len(events) > 1 and any(event.name == "mutate" for event in events):
@@ -688,6 +771,8 @@ class ChatConsumer(_ChatConsumerBase):
                 tool_retries=tool_retries,
                 tool_calls=tool_calls,
                 recovered_missing_tools=recovered_missing_tools,
+                turn_state=turn_state,
+                allow_tools=allow_tools,
             )
 
         max_retries = int(get_chat_settings().get("max_retries_per_message", 8))
@@ -704,6 +789,19 @@ class ChatConsumer(_ChatConsumerBase):
         tool_calls = list(tool_calls or [])
         results: list[tuple[ToolCallEvent, Any]] = []
         for event in events:
+            rate_limited = await sync_to_async(enforce_chat_rate_limit)(
+                self.scope, count_request=False
+            )
+            if isinstance(rate_limited, dict):
+                await self.send_json(
+                    {
+                        "type": "error",
+                        "message": "Chat rate limit exceeded. Try again later.",
+                        "code": "rate_limited",
+                        "retry_after_seconds": rate_limited["retry_after_seconds"],
+                    }
+                )
+                return False
             emit_chat_audit_event(
                 "tool_call",
                 {
@@ -778,21 +876,14 @@ class ChatConsumer(_ChatConsumerBase):
                 tool_call_id=event.id,
             )
 
-        if tool_retries + len(events) >= max_retries:
-            await self.send_json(
-                {
-                    "type": "error",
-                    "message": "Chat tool retry limit exceeded.",
-                    "code": "tool_retry_limit",
-                }
-            )
-            return True
         await self._stream_provider_turn(
             messages,
             history,
             tool_retries=tool_retries + len(events),
             tool_calls=tool_calls,
             recovered_missing_tools=recovered_missing_tools,
+            turn_state=turn_state,
+            allow_tools=tool_retries + len(events) < max_retries,
         )
         return True
 
@@ -805,6 +896,8 @@ class ChatConsumer(_ChatConsumerBase):
         tool_retries: int,
         tool_calls: list[dict[str, Any]] | None = None,
         recovered_missing_tools: bool = False,
+        turn_state: TurnState | None = None,
+        allow_tools: bool = True,
     ) -> bool:
         """Retain the single-call compatibility entry point."""
         return await self._handle_tool_batch(
@@ -814,6 +907,8 @@ class ChatConsumer(_ChatConsumerBase):
             tool_retries=tool_retries,
             tool_calls=tool_calls,
             recovered_missing_tools=recovered_missing_tools,
+            turn_state=turn_state,
+            allow_tools=allow_tools,
         )
 
     async def _handle_single_tool_call(
@@ -825,8 +920,43 @@ class ChatConsumer(_ChatConsumerBase):
         tool_retries: int,
         tool_calls: list[dict[str, Any]] | None = None,
         recovered_missing_tools: bool = False,
+        turn_state: TurnState | None = None,
+        allow_tools: bool = True,
     ) -> bool:
         tool_calls = list(tool_calls or [])
+        turn_state = turn_state or TurnState.from_settings(get_chat_settings())
+        rate_limited = await sync_to_async(enforce_chat_rate_limit)(
+            self.scope, count_request=False
+        )
+        if isinstance(rate_limited, dict):
+            await self.send_json(
+                {
+                    "type": "error",
+                    "message": "Chat rate limit exceeded. Try again later.",
+                    "code": "rate_limited",
+                    "retry_after_seconds": rate_limited["retry_after_seconds"],
+                }
+            )
+            return False
+        max_retries = int(get_chat_settings().get("max_retries_per_message", 8))
+        if event.name != "mutate" and tool_retries >= max_retries:
+            await self.send_json(
+                {
+                    "type": "error",
+                    "message": "Chat tool retry limit exceeded.",
+                    "code": "tool_retry_limit",
+                }
+            )
+            return False
+        if event.name == "mutate" and not turn_state.reserve_mutation():
+            await self.send_json(
+                {
+                    "type": "error",
+                    "message": "Chat mutation limit exceeded.",
+                    "code": "mutation_limit",
+                }
+            )
+            return False
         emit_chat_audit_event(
             "tool_call",
             {
@@ -887,7 +1017,10 @@ class ChatConsumer(_ChatConsumerBase):
                         self.conversation,
                         confirmation_id=event.id,
                         mutation_name=str(result["mutation"]),
-                        payload={"input": result["input"]},
+                        payload={
+                            "input": result["input"],
+                            "_gm_turn_state": turn_state.as_payload(),
+                        },
                         timeout_seconds=timeout_seconds,
                     )
                 except Exception as exc:  # noqa: BLE001
@@ -922,6 +1055,7 @@ class ChatConsumer(_ChatConsumerBase):
                 "history": history,
                 "expires_at": timezone.now() + timedelta(seconds=timeout_seconds),
                 "durable": durable,
+                "turn_state": turn_state,
             }
             self._confirmation_waiter = asyncio.get_running_loop().create_future()
             self._confirmation_timeout_task = asyncio.create_task(
@@ -985,21 +1119,14 @@ class ChatConsumer(_ChatConsumerBase):
         )
         next_tool_retries = tool_retries + (0 if event.name == "mutate" else 1)
         max_retries = int(get_chat_settings().get("max_retries_per_message", 8))
-        if event.name != "mutate" and next_tool_retries >= max_retries:
-            await self.send_json(
-                {
-                    "type": "error",
-                    "message": "Chat tool retry limit exceeded.",
-                    "code": "tool_retry_limit",
-                }
-            )
-            return True
         await self._stream_provider_turn(
             messages,
             history,
             tool_retries=next_tool_retries,
             tool_calls=tool_calls,
             recovered_missing_tools=recovered_missing_tools,
+            turn_state=turn_state,
+            allow_tools=next_tool_retries < max_retries,
         )
         return True
 
@@ -1150,9 +1277,18 @@ class ChatConsumer(_ChatConsumerBase):
                         self.conversation,
                         self.provider,
                         scope=self.scope,
+                        turn_state=pending.get("turn_state"),
                     )
                     history = await self._load_history()
-            await self._stream_provider_turn(messages, history, tool_retries=0)
+            await self._stream_provider_turn(
+                messages,
+                history,
+                tool_retries=(
+                    pending.get("turn_state")
+                    or TurnState.from_settings(get_chat_settings())
+                ).tool_retries,
+                turn_state=pending.get("turn_state"),
+            )
         finally:
             if not followup_turn.done():
                 followup_turn.set_result(None)
@@ -1171,6 +1307,21 @@ class ChatConsumer(_ChatConsumerBase):
 
         from general_manager.chat.models import ChatPendingConfirmation
 
+        if confirmed:
+            rate_limited = await sync_to_async(enforce_chat_rate_limit)(
+                self.scope, count_request=False
+            )
+            if isinstance(rate_limited, dict):
+                await self.send_json(
+                    {
+                        "type": "error",
+                        "message": "Chat rate limit exceeded. Try again later.",
+                        "code": "rate_limited",
+                        "retry_after_seconds": rate_limited["retry_after_seconds"],
+                    }
+                )
+                return
+
         db_pending: Any | None = None
         if pending is None and self.conversation is not None:
             db_pending = await sync_to_async(
@@ -1196,6 +1347,9 @@ class ChatConsumer(_ChatConsumerBase):
                     "history": history,
                     "expires_at": db_pending.expires_at,
                     "durable": False,
+                    "turn_state": TurnState.from_payload(
+                        get_chat_settings(), db_pending.payload
+                    ),
                     "rebuild_context_after_tool_result": True,
                 }
         if pending is None or confirmation_id != pending.get("id"):

{generalmanager-0.79.0 → generalmanager-0.79.2}/src/general_manager/chat/context.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import Awaitable, Callable, Mapping
+import inspect
 from typing import Any
 
 from asgiref.sync import sync_to_async
@@ -19,6 +20,17 @@ from general_manager.chat.providers.base import DoneEvent, Message, TextChunkEve
 from general_manager.chat.rate_limits import enforce_chat_rate_limit
 from general_manager.chat.settings import get_chat_settings
 from general_manager.chat.system_prompt import build_system_prompt
+from general_manager.chat.turns import TurnState
+
+
+class ChatSummaryRateLimitExceeded(RuntimeError):
+    """Stop a request when history compression consumes its token allowance."""
+
+    public_reason = "rate_limited"
+
+    def __init__(self, retry_after_seconds: int) -> None:
+        super().__init__("Chat summary token budget exhausted.")
+        self.retry_after_seconds = retry_after_seconds
 
 
 async def summarize_messages_with_provider(
@@ -26,6 +38,7 @@ async def summarize_messages_with_provider(
     messages: list[Any],
     *,
     scope: dict[str, Any] | None = None,
+    turn_state: TurnState | None = None,
 ) -> str:
     """Summarize one history prefix within a whole-request provider deadline."""
     prompt_messages = [
@@ -45,16 +58,40 @@ async def summarize_messages_with_provider(
     chunks: list[str] = []
 
     async def consume() -> None:
-        async for event in provider.complete(prompt_messages, []):
-            if isinstance(event, TextChunkEvent):
-                chunks.append(event.content)
-            elif isinstance(event, DoneEvent) and scope is not None:
-                await sync_to_async(enforce_chat_rate_limit)(
-                    scope,
-                    input_tokens=event.usage.input_tokens,
-                    output_tokens=event.usage.output_tokens,
-                    count_request=False,
-                )
+        if turn_state is not None and not turn_state.reserve_round():
+            return
+        if scope is not None:
+            rate_limited = await sync_to_async(enforce_chat_rate_limit)(
+                scope, count_request=False
+            )
+            if isinstance(rate_limited, dict):
+                raise ChatSummaryRateLimitExceeded(rate_limited["retry_after_seconds"])
+        events = provider.complete(prompt_messages, [])
+        try:
+            async for event in events:
+                if isinstance(event, TextChunkEvent):
+                    chunks.append(event.content)
+                elif isinstance(event, DoneEvent):
+                    if turn_state is not None:
+                        turn_state.record_usage(event.usage)
+                    if scope is not None:
+                        rate_limited = await sync_to_async(enforce_chat_rate_limit)(
+                            scope,
+                            input_tokens=event.usage.input_tokens,
+                            output_tokens=event.usage.output_tokens,
+                            count_request=False,
+                        )
+                        if isinstance(rate_limited, dict):
+                            raise ChatSummaryRateLimitExceeded(
+                                rate_limited["retry_after_seconds"]
+                            )
+                    return
+        finally:
+            close = getattr(events, "aclose", None)
+            if callable(close):
+                result = close()
+                if inspect.isawaitable(result):
+                    await result
 
     await asyncio.wait_for(consume(), timeout=timeout_seconds)
     return "".join(chunks).strip()
@@ -67,6 +104,7 @@ async def prepare_conversation_messages(
     allow_summarization: bool = True,
     scope: dict[str, Any] | None = None,
     summarize: Callable[[Any, list[Any]], Awaitable[str]] | None = None,
+    turn_state: TurnState | None = None,
 ) -> list[Message]:
     """Return system plus bounded durable history for a legacy provider turn."""
     settings = get_chat_settings()
@@ -86,7 +124,7 @@ async def prepare_conversation_messages(
                     await summarize(provider, older_messages)
                     if summarize is not None
                     else await summarize_messages_with_provider(
-                        provider, older_messages, scope=scope
+                        provider, older_messages, scope=scope, turn_state=turn_state
                     )
                 )
                 if summary_text: