pyagentic-core 2.12.3.dev1__tar.gz → 2.13.0a1__tar.gz

{pyagentic_core-2.12.3.dev1/pyagentic_core.egg-info → pyagentic_core-2.13.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyagentic-core
-Version: 2.12.3.dev1
+Version: 2.13.0a1
 Summary: Build LLM Agents in a Pythonic way
 Author-email: Ryan Mikulec <rmikulec.dev@gmail.com>
 License: MIT

{pyagentic_core-2.12.3.dev1 → pyagentic_core-2.13.0a1}/docs/policies.md

@@ -154,21 +154,58 @@ class SetEvent:
     timestamp: datetime # When the change occurred
 ```
 
+**`AppendEvent`** — triggered when an item is appended to a list-valued state field or the message context
+
+```python
+@dataclass
+class AppendEvent:
+    name: str           # Field name (or "messages" for the message context)
+    value: Any          # The item being appended
+    timestamp: datetime # When the append occurred
+```
+
+**`CompileEvent`** — triggered right before each LLM inference, over a whole list
+
+```python
+@dataclass
+class CompileEvent:
+    name: str            # Field name (or "messages")
+    value: list          # The list being compiled
+    provider: LLMProvider  # The provider about to be called (e.g. for summarization)
+    last_usage: UsageInfo | None  # Token usage from the previous inference
+    system_message: str | None    # Rendered system prompt (read-only)
+    state: _AgentState   # The owning state
+    timestamp: datetime
+```
+
 ### Handler Semantics
 
-* **Synchronous (`on_get`, `on_set`)**
+* **Synchronous (`on_get`, `on_set`, `on_append`)**
 
   * Run **before** the value is returned/stored and **block** the operation.
   * May **transform** the value by returning a replacement.
-  * May **validate** by raising an exception, which aborts the operation.
+  * May **validate** by raising an exception, which aborts the operation
+    (for `on_append`, a raise skips inserting the item).
+  * `on_set` also fires when a policied list field is mutated in place
+    (item assignment, deletion, `remove`, `pop`, `clear`).
   * **Ordering:** policies run in the order they’re declared; the first exception aborts, and later handlers do not run.
 
-* **Background (`background_get`, `background_set`)**
+* **Async compile (`on_compile`)**
+
+  * Runs right **before every LLM inference**, receiving the whole list.
+  * May return a transformed list; the result is **written back**, so effects
+    like eviction and compaction persist instead of re-running every turn.
+  * Async by design — a compile policy can call the LLM itself
+    (see `CompactionPolicy`).
+
+* **Background (`background_get`, `background_set`, `background_append`)**
 
   * Run **after** sync handlers complete and **must not** mutate stored state.
   * Intended for **side effects only**: logging, metrics, notifications, persistence.
   * Failures should be handled internally (e.g., retries/backoff); they cannot prevent an already-completed operation.
 
+Implement only the handlers you need — missing handlers are skipped.
+
 ### Execution Flow
 
 ```mermaid
@@ -427,6 +464,136 @@ class GameAgent(BaseAgent):
 
 ---
 
+## Message Policies & Context Management
+
+The same `Policy` protocol also manages the agent's **message context** — the
+conversation history sent to the LLM. This is how you keep context small and
+prevent context explosion on long-running agents.
+
+### Attaching message policies
+
+Declare `__message_policies__` on the agent class:
+
+```python
+from pyagentic.policies import (
+    ToolOutputClipPolicy,
+    ToolEvictionPolicy,
+    CompactionPolicy,
+)
+
+class ResearchAgent(BaseAgent):
+    __system_message__ = "You research topics using tools."
+    __message_policies__ = [
+        ToolOutputClipPolicy(max_chars=8000),      # clip huge tool outputs on entry
+        ToolEvictionPolicy(keep_last_n=5),         # stub stale tool results
+        CompactionPolicy(max_input_tokens=80_000), # summarize when context grows
+    ]
+```
+
+`__message_policies__` is inherited by subclasses (and composable via
+`AgentExtension` mixins). Policies fire:
+
+* `on_append` / `background_append` — for each message entering the context
+  (user turns, assistant replies, tool calls/results)
+* `on_compile` — over the whole context, right before every LLM inference
+
+### Dual history: raw log vs. working context
+
+The state keeps **two** message lists:
+
+* `state._messages` — the **raw log**: every message, append-only, never touched
+  by policies. Use `state.raw_messages` (system message included) for
+  debugging and auditing.
+* `state._context` — the **working context** providers actually send. Appends run
+  through `on_append` (clipping, vetoes), and `on_compile` rewrites it in place
+  (eviction stubs, compaction summaries). Use `state.messages` for the compiled
+  view with the system message prepended.
+
+Because compile results are written back, `CompactionPolicy` summarizes once per
+threshold crossing — not on every turn — and the context keeps stable prefixes
+for provider prompt caching.
+
+### Filtering by message type
+
+Context messages are semantic types from `pyagentic.models.llm`, so policies
+filter with `isinstance`:
+
+| Type | Meaning |
+|---|---|
+| `UserMessage` / `AssistantMessage` | Conversation turns |
+| `ToolCallMessage` | LLM requested a tool (`id`, `name`, `arguments`) |
+| `ToolResultMessage` | Tool output (`tool_call_id`, `name`, content) |
+| `AgentCallMessage` / `AgentResultMessage` | Linked-agent calls — subclasses of the tool types, so generic tool policies match them too |
+| `CompactionSummaryMessage` | Summary emitted by `CompactionPolicy` |
+
+```python
+class AgentResultBudgetPolicy(Policy):
+    """Clip linked-agent responses only (a per-link context budget)."""
+
+    def on_append(self, event, item):
+        if isinstance(item, AgentResultMessage) and len(item.content or "") > 2000:
+            return item.model_copy(update={"content": item.content[:2000] + "…"})
+        return None
+```
+
+### Prewritten policies
+
+All in `pyagentic.policies`:
+
+* **`ToolOutputClipPolicy(max_chars, suffix)`** — clips oversized tool results at
+  append time, so a huge output never occupies context.
+* **`ToolEvictionPolicy(keep_last_n, stub, include_agent_results)`** — replaces
+  the content of all but the last N tool results with a stub. The message and
+  its `tool_call_id` survive (providers reject orphaned call/result pairs).
+* **`SlidingWindowPolicy(max_messages)`** — bounds the context to the most
+  recent N messages, never splitting a tool call from its result.
+* **`CompactionPolicy(max_input_tokens, keep_recent, summary_prompt)`** —
+  when the previous inference's input tokens cross the threshold, summarizes
+  older history into a single `CompactionSummaryMessage` via an LLM call.
+
+An observability policy is just an `on_compile` that records metrics and
+returns `None`:
+
+```python
+class ContextMetricsPolicy(Policy):
+    async def on_compile(self, event, items):
+        tool_chars = sum(
+            len(m.content or "") for m in items if isinstance(m, ToolResultMessage)
+        )
+        logger.info(f"context: {len(items)} messages, {tool_chars} tool chars")
+        return None
+```
+
+### List-valued state fields
+
+Policies on list-typed state fields now fire on **in-place mutations**, not just
+assignment. Appends run `on_append`; other mutations (`[i] = x`, `remove`,
+`pop`, `clear`) run `on_set` over the whole list:
+
+```python
+class NotesAgent(BaseAgent):
+    __system_message__ = "You keep notes."
+
+    notes: State[list] = spec.State(
+        default_factory=list,
+        policies=[TrimAndLowerAppendPolicy()],
+    )
+
+# agent.notes.append("  HELLO ")  -> stored as "hello", policy enforced
+```
+
+`on_compile` also runs for policied list fields before each inference, so a
+policy can e.g. cap a scratchpad list the same way it caps messages.
+
+### Statelessness rule
+
+Policy instances are attached at class-definition time and **shared across all
+agent instances and forks**. Keep them config-only: derive anything per-agent
+from the event or the list contents (e.g. `CompactionSummaryMessage` markers),
+never from attributes mutated on the policy itself.
+
+---
+
 ## Next Steps
 
 * Learn about **State Management** to see how policies integrate with state lifecycles.

{pyagentic_core-2.12.3.dev1 → pyagentic_core-2.13.0a1}/pyagentic/_base/_agent/_agent.py

@@ -31,7 +31,15 @@ if TYPE_CHECKING:
     from pyagentic._base._mcp import _MCPDefinition
 
 from pyagentic.models.response import ToolResponse, AgentResponse, ErrorResponse
-from pyagentic.models.llm import Message, ToolCall, LLMResponse
+from pyagentic.models.llm import (
+    AgentCallMessage,
+    AgentResultMessage,
+    AssistantMessage,
+    LLMResponse,
+    ToolCall,
+    ToolCallMessage,
+    ToolResultMessage,
+)
 from pyagentic.models.tracing import SpanKind
 
 from pyagentic.updates import AiUpdate, Status, EmitUpdate, ToolUpdate
@@ -171,6 +179,7 @@ class BaseAgent(metaclass=AgentMeta):
     __description__: ClassVar[str]  # Optional: description for linked agents
     __input_template__: ClassVar[str] = None  # Optional: template for user input
     __response_format__: ClassVar[Type[BaseModel]] = None  # Optional: structured output format
+    __message_policies__: ClassVar[list] = None  # Optional: policies on the message context
     phases: ClassVar[list[tuple[str, str, Callable]]] = None
 
     # Generated Class Attributes (built by metaclass)
@@ -469,12 +478,17 @@ class BaseAgent(metaclass=AgentMeta):
         )
 
         try:
+            # Run attached policies (eviction, compaction, ...) over the message
+            # context and policied list state fields before the provider reads them
+            await self.state.compile_context(self.provider)
+
             response = await self.provider.generate(
                 state=self.state,
                 tool_defs=tool_defs,
                 response_format=self.__response_format__,
                 **kwargs,
             )
+            self.state._last_usage = response.usage
             usage_details = response.usage.model_dump() if response.usage else {}
             self.tracer.set_attributes(
                 usage_details=usage_details, model=self.provider._model
@@ -484,8 +498,8 @@ class BaseAgent(metaclass=AgentMeta):
             # Handle inference errors gracefully
             logger.exception(e)
             # Add error message to conversation history
-            self.state._messages.append(
-                Message(role="assistant", content="Failed to generate a response")
+            self.state.add_message(
+                AssistantMessage(content="Failed to generate a response")
             )
             response = LLMResponse(
                 text=f"The LLM failed to generate a response: {e}", tool_calls=[]
@@ -512,8 +526,10 @@ class BaseAgent(metaclass=AgentMeta):
         )
         logger.info(f"Calling {tool_call.name} with kwargs: {tool_call.arguments}")
 
-        # Add tool call message to conversation history
-        self.state._messages.append(self.provider.to_tool_call_message(tool_call))
+        # Add agent call message to conversation history
+        self.state.add_message(
+            AgentCallMessage(id=tool_call.id, name=tool_call.name, arguments=tool_call.arguments)
+        )
 
         # By default each call runs on a fresh, isolated fork of the linked agent
         # so concurrent/repeated calls neither race nor pollute one another. A
@@ -547,8 +563,10 @@ class BaseAgent(metaclass=AgentMeta):
             if issubclass(result.__class__, BaseModel)
             else str(result)
         )
-        self.state._messages.append(
-            self.provider.to_tool_call_result_message(result=stringified_result, id_=tool_call.id)
+        self.state.add_message(
+            AgentResultMessage(
+                tool_call_id=tool_call.id, name=tool_call.name, content=stringified_result
+            )
         )
         if self.phases:
             self.state._update_state_machine(phases=self.phases)
@@ -575,7 +593,9 @@ class BaseAgent(metaclass=AgentMeta):
             return await self._process_mcp_tool_call(tool_call, call_depth)
 
         # Add tool call message to conversation history
-        self.state._messages.append(self.provider.to_tool_call_message(tool_call))
+        self.state.add_message(
+            ToolCallMessage(id=tool_call.id, name=tool_call.name, arguments=tool_call.arguments)
+        )
 
         # Look up the tool definition and bound method
         try:
@@ -622,8 +642,8 @@ class BaseAgent(metaclass=AgentMeta):
                 if issubclass(result.__class__, BaseModel)
                 else str(result)
             )
-        self.state._messages.append(
-            self.provider.to_tool_call_result_message(result=message, id_=tool_call.id)
+        self.state.add_message(
+            ToolResultMessage(tool_call_id=tool_call.id, name=tool_call.name, content=message)
         )
 
         if self.phases:
@@ -652,8 +672,10 @@ class BaseAgent(metaclass=AgentMeta):
         Returns:
             ToolResponse: The response from the MCP tool execution.
         """
-        # Add tool call to conversation history (provider-specific format)
-        self.state._messages.append(self.provider.to_tool_call_message(tool_call))
+        # Add tool call to conversation history
+        self.state.add_message(
+            ToolCallMessage(id=tool_call.id, name=tool_call.name, arguments=tool_call.arguments)
+        )
 
         client, original_name = self._mcp_tool_routing[tool_call.name]
         kwargs = json.loads(tool_call.arguments)
@@ -676,9 +698,11 @@ class BaseAgent(metaclass=AgentMeta):
             error = f"MCP tool `{tool_call.name}` failed: {e}. Please kindly state to the user that it failed, provide state, and ask if they want to try again."  # noqa E501
 
         # Add result (or error) to conversation history
-        self.state._messages.append(
-            self.provider.to_tool_call_result_message(
-                result=error if error is not None else result, id_=tool_call.id
+        self.state.add_message(
+            ToolResultMessage(
+                tool_call_id=tool_call.id,
+                name=tool_call.name,
+                content=error if error is not None else result,
             )
         )
 
@@ -807,7 +831,7 @@ class BaseAgent(metaclass=AgentMeta):
                 # If the model produced final text without tool calls, we're done
                 if not response.tool_calls:
                     final_ai_output = response.parsed if response.parsed else response.text
-                    self.state._messages.append(Message(role="assistant", content=response.text))
+                    self.state.add_message(AssistantMessage(content=response.text))
                     break
 
                 tasks = []

{pyagentic_core-2.12.3.dev1 → pyagentic_core-2.13.0a1}/pyagentic/_base/_agent/_agent_state.py

@@ -9,9 +9,10 @@ from transitions import Machine
 from pyagentic._base._exceptions import InvalidStateRefNotFoundInState
 from pyagentic._base._state import _StateDefinition
 from pyagentic.policies._policy import Policy
-from pyagentic.policies._events import Event, EventKind, GetEvent, SetEvent
+from pyagentic.policies._events import Event, EventKind, GetEvent, SetEvent, CompileEvent
+from pyagentic.policies._list import PolicyList
 
-from pyagentic.models.llm import Message
+from pyagentic.models.llm import Message, SystemMessage, UserMessage, UsageInfo
 
 
 class _AgentState(BaseModel):
@@ -25,13 +26,18 @@ class _AgentState(BaseModel):
         ("background", EventKind.GET): "background_get",
         ("on", EventKind.SET): "on_set",
         ("background", EventKind.SET): "background_set",
+        ("on", EventKind.APPEND): "on_append",
+        ("background", EventKind.APPEND): "background_append",
     }
-    __policies__: ClassVar[dict[str, list[Policy]]]
+    __policies__: ClassVar[dict[str, list[Policy]]] = {}
 
     instructions: str
     input_template: Optional[str] = "{{ user_message }}"
+
     _machine: Machine = PrivateAttr(default=None)
     _messages: list[Message] = PrivateAttr(default_factory=list)
+    _context: list[Message] = PrivateAttr(default_factory=list)
+    _last_usage: Optional[UsageInfo] = PrivateAttr(default=None)
     _instructions_template: Template = PrivateAttr(default_factory=lambda: Template(source=""))
     _input_template: Template = PrivateAttr(
         default_factory=lambda: Template(source="{{ user_message }}")
@@ -72,6 +78,20 @@ class _AgentState(BaseModel):
             self._input_template = Template(source=self.input_template)
 
         self._state_lock = threading.Lock()
+
+        # Bind the message context to the "messages" policy key so appends and
+        # compiles route through any attached message policies
+        self._context = PolicyList(self._context, state=self, name="messages")
+
+        # Wrap list-valued state fields that have policies attached, so in-place
+        # mutations (append, etc.) trigger the policy pipeline
+        for field_name, policies in self.__policies__.items():
+            if field_name == "messages" or not policies:
+                continue
+            value = getattr(self, field_name, None)
+            if isinstance(value, list) and not isinstance(value, PolicyList):
+                setattr(self, field_name, PolicyList(value, state=self, name=field_name))
+
         return super().model_post_init(state)
 
     def get_policies(self, state_name: str) -> list[Policy]:
@@ -84,7 +104,7 @@ class _AgentState(BaseModel):
         Returns:
             list[Policy]: List of policies for the field, or empty list if none
         """
-        return self.__policies__.get(state_name, [])
+        return self.__policies__.get(state_name) or []
 
     def _run_policies(self, event: Event, policy_type: Literal["on", "background"]) -> Any:
         """
@@ -114,7 +134,9 @@ class _AgentState(BaseModel):
             if not handler_name:
                 raise ValueError(f"No handler for ({policy_type}, {event.kind})")
 
-            handler = getattr(policy, handler_name)
+            handler = getattr(policy, handler_name, None)
+            if handler is None:
+                continue
 
             if policy_type != "on":
                 raise RuntimeError("_run_policies is only for synchronous 'on' policies")
@@ -154,7 +176,9 @@ class _AgentState(BaseModel):
             if not handler_name:
                 raise ValueError(f"No handler for ({policy_type}, {event.kind})")
 
-            handler = getattr(policy, handler_name)
+            handler = getattr(policy, handler_name, None)
+            if handler is None:
+                continue
 
             try:
                 maybe_new_value = await handler(event, value)
@@ -188,9 +212,19 @@ class _AgentState(BaseModel):
 
         event = GetEvent(name=name, value=stored_value)
         transformed_value = self._run_policies(event, "on")
-        asyncio.create_task(self._dispatch_policies(event, "background"))
+        self._schedule_background(event)
         return transformed_value
 
+    def _schedule_background(self, event: Event):
+        """Schedule background policies on the running loop; skip in sync contexts."""
+        if not self.get_policies(event.name):
+            return
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            return
+        loop.create_task(self._dispatch_policies(event, "background"))
+
     def set(self, name: str, value: Any):
         """
         Sets a value via SET policies (transform, validate, store).
@@ -210,9 +244,87 @@ class _AgentState(BaseModel):
         event = SetEvent(name=name, previous=previous, value=value)
         final_value = self._run_policies(event, "on")
 
+        # Keep policied list fields observable so in-place mutations keep
+        # routing through the policy pipeline
+        if (
+            isinstance(final_value, list)
+            and not isinstance(final_value, PolicyList)
+            and self.get_policies(name)
+        ):
+            final_value = PolicyList(final_value, state=self, name=name)
+
         with self._state_lock:
             setattr(self, name, final_value)
-        asyncio.create_task(self._dispatch_policies(event, "background"))
+        self._schedule_background(event)
+
+    async def _run_compile(self, event: CompileEvent, items: list) -> list:
+        """
+        Run the async on_compile pipeline for one list. Each policy may return a
+        transformed list (or None for no change); exceptions are logged and skipped.
+        """
+        value = items
+        for policy in self.get_policies(event.name):
+            handler = getattr(policy, "on_compile", None)
+            if handler is None:
+                continue
+            try:
+                new_value = await handler(event, value)
+                if new_value is not None:
+                    value = new_value
+            except Exception as e:
+                print(f"[PolicyError] {policy.__class__.__name__}.on_compile failed: {e}")
+        return value
+
+    async def compile_context(self, provider) -> list[Message]:
+        """
+        Compiles the message context (and any policied list-valued state fields)
+        by running attached policies' on_compile handlers. Called right before
+        each LLM inference; the transformed lists are written back, so policies
+        like eviction and compaction persist their effect.
+
+        Args:
+            provider: The LLM provider about to be called, exposed to policies
+                via CompileEvent (e.g. for summarization calls).
+
+        Returns:
+            list[Message]: The compiled message context providers should send.
+        """
+        # Compile policied list-valued state fields first so the system message
+        # (rendered from state) reflects their final contents
+        for field_name, policies in self.__policies__.items():
+            if field_name == "messages" or not policies:
+                continue
+            value = getattr(self, field_name, None)
+            if not isinstance(value, list):
+                continue
+            event = CompileEvent(
+                name=field_name,
+                value=list(value),
+                provider=provider,
+                last_usage=self._last_usage,
+                state=self,
+            )
+            result = await self._run_compile(event, list(value))
+            with self._state_lock:
+                if isinstance(value, PolicyList):
+                    value._set_contents(result)
+                else:
+                    setattr(self, field_name, result)
+
+        if self.get_policies("messages"):
+            event = CompileEvent(
+                name="messages",
+                value=list(self._context),
+                provider=provider,
+                last_usage=self._last_usage,
+                system_message=self.system_message,
+                state=self,
+            )
+            result = await self._run_compile(event, list(self._context))
+            with self._state_lock:
+                self._context._set_contents(result)
+
+        return self._context
 
     @classmethod
     def make_state_model(
@@ -287,15 +399,43 @@ class _AgentState(BaseModel):
     @property
     def messages(self) -> list[Message]:
         """
-        Returns a list of OpenAI-ready messages with the most up-to-date system message.
+        Returns the compiled message context with the most up-to-date system message.
+
+        This is the policy-shaped view providers consume; see `raw_messages` for the
+        untouched history.
+
+        Returns:
+            list[Message]: Compiled message context with system message prepended
+        """
+        messages = self._context.copy()
+        messages.insert(0, SystemMessage(content=self.system_message))
+        return messages
+
+    @property
+    def raw_messages(self) -> list[Message]:
+        """
+        Returns the raw, append-only message history with the most up-to-date
+        system message. Policies never modify this list; use it for debugging
+        and auditing what actually happened.
 
         Returns:
-            list[Message]: Complete message list with system message prepended
+            list[Message]: Raw message history with system message prepended
         """
         messages = self._messages.copy()
-        messages.insert(0, Message(role="system", content=self.system_message))
+        messages.insert(0, SystemMessage(content=self.system_message))
         return messages
 
+    def add_message(self, message: Message) -> None:
+        """
+        Adds a message to both histories: the raw append-only log (`_messages`)
+        and the working context (`_context`) that providers consume.
+
+        Args:
+            message (Message): The message to record.
+        """
+        self._messages.append(message)
+        self._context.append(message)
+
     def add_user_message(self, message: str):
         """
         Adds a user message to the message list. If an `input_template` is given then
@@ -311,9 +451,9 @@ class _AgentState(BaseModel):
             data = self.model_dump()
             data["user_message"] = message
             if self.phase:
-                content = self._input_template.render(phase=self.phase, **self.model_dump())
+                content = self._input_template.render(phase=self.phase, **data)
             else:
-                content = self._input_template.render(**self.model_dump())
+                content = self._input_template.render(**data)
         else:
             content = message
-        self._messages.append(Message(role="user", content=content))
+        self.add_message(UserMessage(content=content))

{pyagentic_core-2.12.3.dev1 → pyagentic_core-2.13.0a1}/pyagentic/_base/_metaclasses.py

@@ -756,13 +756,24 @@ class AgentMeta(type):
         ]
 
         # Create a Pydantic model for the agent's state
+        if "messages" in cls.__state_defs__:
+            raise ValueError(
+                f"Agent '{cls.__name__}' declares a state field named 'messages', which is "
+                "reserved for the message context (it collides with the `messages` property "
+                "and the message-policy registry). Rename the field."
+            )
         StateClass = _AgentState.make_state_model(
             name=cls.__name__, state_definitions=cls.__state_defs__
         )
-        # Attach policies to the state class for runtime policy enforcement
+        # Attach policies to the state class for runtime policy enforcement.
+        # Message policies (from __message_policies__) register under the
+        # reserved "messages" key, alongside per-field state policies.
         StateClass.__policies__ = {
             name: def_.info.policies for name, def_ in cls.__state_defs__.items()
         }
+        StateClass.__policies__["messages"] = tuple(
+            (inherited_namespace | namespace).get("__message_policies__") or ()
+        )
 
         # Create the final agent response model
         ResponseModel = AgentResponse.from_agent_class(

{pyagentic_core-2.12.3.dev1 → pyagentic_core-2.13.0a1}/pyagentic/llm/__init__.py

@@ -8,7 +8,6 @@ Anthropic, and mock providers for testing purposes.
 from enum import Enum
 
 from pyagentic.llm._openai import OpenAIProvider
-from pyagentic.llm._openaiv1 import OpenAIV1Provider
 from pyagentic.llm._anthropic import AnthropicProvider
 from pyagentic.llm._gemini import GeminiProvider
 from pyagentic.llm._mock import _MockProvider
@@ -26,7 +25,6 @@ class LLMProviders(Enum):
     """
 
     OPENAI = OpenAIProvider
-    OPENAIV1 = OpenAIV1Provider
     ANTHROPIC = AnthropicProvider
     GEMINI = GeminiProvider
     _MOCK = _MockProvider