langroid 0.59.0b3__tar.gz → 0.59.1__tar.gz

{langroid-0.59.0b3 → langroid-0.59.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langroid
-Version: 0.59.0b3
+Version: 0.59.1
 Summary: Harness LLMs with Multi-Agent Programming
 Author-email: Prasad Chalasani <pchalasani@gmail.com>
 License: MIT
@@ -347,6 +347,9 @@ teacher_task.run()
 <details>
 <summary> <b>Click to expand</b></summary>
 
+- **Aug 2025:**
+  - [0.59.0](https://github.com/langroid/langroid/releases/tag/0.59.0) Complete Pydantic V2 Migration - 
+    5-50x faster validation, modern Python patterns, 100% backward compatible.
 - **Jul 2025:**
   - [0.58.0](https://github.com/langroid/langroid/releases/tag/0.58.0) Crawl4AI integration - 
     browser-based web crawling with Playwright for JavaScript-heavy sites, no API key required (thank you @abab-dev!).

{langroid-0.59.0b3 → langroid-0.59.1}/README.md

@@ -143,6 +143,9 @@ teacher_task.run()
 <details>
 <summary> <b>Click to expand</b></summary>
 
+- **Aug 2025:**
+  - [0.59.0](https://github.com/langroid/langroid/releases/tag/0.59.0) Complete Pydantic V2 Migration - 
+    5-50x faster validation, modern Python patterns, 100% backward compatible.
 - **Jul 2025:**
   - [0.58.0](https://github.com/langroid/langroid/releases/tag/0.58.0) Crawl4AI integration - 
     browser-based web crawling with Playwright for JavaScript-heavy sites, no API key required (thank you @abab-dev!).

{langroid-0.59.0b3 → langroid-0.59.1}/langroid/agent/done_sequence_parser.py

@@ -11,16 +11,20 @@ Examples:
 """
 
 import re
-from typing import List, Union
+from typing import Any, Dict, List, Optional, Union
 
 from .task import AgentEvent, DoneSequence, EventType
 
 
-def parse_done_sequence(sequence: Union[str, DoneSequence]) -> DoneSequence:
+def parse_done_sequence(
+    sequence: Union[str, DoneSequence], tools_map: Optional[Dict[str, Any]] = None
+) -> DoneSequence:
     """Parse a string pattern or return existing DoneSequence unchanged.
 
     Args:
         sequence: Either a DoneSequence object or a string pattern to parse
+        tools_map: Optional dict mapping tool names to tool classes
+            (e.g., agent.llm_tools_map)
 
     Returns:
         DoneSequence object
@@ -34,21 +38,25 @@ def parse_done_sequence(sequence: Union[str, DoneSequence]) -> DoneSequence:
     if not isinstance(sequence, str):
         raise ValueError(f"Expected string or DoneSequence, got {type(sequence)}")
 
-    events = _parse_string_pattern(sequence)
+    events = _parse_string_pattern(sequence, tools_map)
     return DoneSequence(events=events)
 
 
-def _parse_string_pattern(pattern: str) -> List[AgentEvent]:
+def _parse_string_pattern(
+    pattern: str, tools_map: Optional[Dict[str, Any]] = None
+) -> List[AgentEvent]:
     """Parse a string pattern into a list of AgentEvent objects.
 
     Pattern format:
         - Single letter codes: T, A, L, U, N, C
-        - Specific tools: T[tool_name]
+        - Specific tools: T[tool_name] or T[ToolClass]
         - Content match: C[regex_pattern]
         - Separated by commas, spaces allowed
 
     Args:
         pattern: String pattern to parse
+        tools_map: Optional dict mapping tool names to tool classes
+            (e.g., agent.llm_tools_map)
 
     Returns:
         List of AgentEvent objects
@@ -65,7 +73,7 @@ def _parse_string_pattern(pattern: str) -> List[AgentEvent]:
         if not part:
             continue
 
-        event = _parse_event_token(part)
+        event = _parse_event_token(part, tools_map)
         events.append(event)
 
     if not events:
@@ -74,11 +82,15 @@ def _parse_string_pattern(pattern: str) -> List[AgentEvent]:
     return events
 
 
-def _parse_event_token(token: str) -> AgentEvent:
+def _parse_event_token(
+    token: str, tools_map: Optional[Dict[str, Any]] = None
+) -> AgentEvent:
     """Parse a single event token into an AgentEvent.
 
     Args:
         token: Single event token (e.g., "T", "T[calc]", "C[quit|exit]")
+        tools_map: Optional dict mapping tool names to tool classes
+            (e.g., agent.llm_tools_map)
 
     Returns:
         AgentEvent object
@@ -94,8 +106,28 @@ def _parse_event_token(token: str) -> AgentEvent:
         param = bracket_match.group(2)
 
         if event_code == "T":
-            # Specific tool: T[tool_name]
-            return AgentEvent(event_type=EventType.SPECIFIC_TOOL, tool_name=param)
+            # Specific tool: T[tool_name] or T[ToolClass]
+            tool_class = None
+            tool_name = param
+
+            # First try direct lookup in tools_map by the param (tool name)
+            if tools_map and param in tools_map:
+                tool_class = tools_map[param]
+                tool_name = param
+            elif tools_map:
+                # If not found, loop through tools_map to find a tool class
+                # whose __name__ matches param
+                for name, cls in tools_map.items():
+                    if hasattr(cls, "__name__") and cls.__name__ == param:
+                        tool_class = cls
+                        tool_name = name
+                        break
+
+            return AgentEvent(
+                event_type=EventType.SPECIFIC_TOOL,
+                tool_name=tool_name,
+                tool_class=tool_class,
+            )
         elif event_code == "C":
             # Content match: C[regex_pattern]
             return AgentEvent(event_type=EventType.CONTENT_MATCH, content_pattern=param)
@@ -136,14 +168,17 @@ def _parse_event_token(token: str) -> AgentEvent:
 
 
 def parse_done_sequences(
-    sequences: List[Union[str, DoneSequence]]
+    sequences: List[Union[str, DoneSequence]],
+    tools_map: Optional[Dict[str, Any]] = None,
 ) -> List[DoneSequence]:
     """Parse a list of mixed string patterns and DoneSequence objects.
 
     Args:
         sequences: List containing strings and/or DoneSequence objects
+        tools_map: Optional dict mapping tool names to tool classes
+            (e.g., agent.llm_tools_map)
 
     Returns:
         List of DoneSequence objects
     """
-    return [parse_done_sequence(seq) for seq in sequences]
+    return [parse_done_sequence(seq, tools_map) for seq in sequences]

{langroid-0.59.0b3 → langroid-0.59.1}/langroid/agent/task.py

@@ -90,6 +90,9 @@ class AgentEvent(BaseModel):
 
     event_type: EventType
     tool_name: Optional[str] = None  # For SPECIFIC_TOOL
+    tool_class: Optional[Type[Any]] = (
+        None  # For storing tool class references when using SPECIFIC_TOOL events
+    )
     content_pattern: Optional[str] = None  # For CONTENT_MATCH (regex)
     responder: Optional[str] = None  # Specific responder name
     # Optionally match only if the responder was specific entity/task
@@ -146,6 +149,7 @@ class TaskConfig(BaseModel):
         done_sequences (List[DoneSequence]): List of event sequences that trigger task
             completion. Task is done if ANY sequence matches the recent event history.
             Each sequence is checked against the message parent chain.
+            Tool classes can be referenced in sequences like "T[MyToolClass]".
 
     """
 
@@ -298,14 +302,8 @@ class Task:
             set_parent_agent=noop_fn,
         )
         self.config = config
-        # Store parsed done sequences
+        # Store parsed done sequences (will be initialized after agent assignment)
         self._parsed_done_sequences: Optional[List[DoneSequence]] = None
-        if self.config.done_sequences:
-            from .done_sequence_parser import parse_done_sequences
-
-            self._parsed_done_sequences = parse_done_sequences(
-                self.config.done_sequences
-            )
         # how to behave as a sub-task; can be overridden by `add_sub_task()`
         self.config_sub_task = copy.deepcopy(config)
         # counts of distinct pending messages in history,
@@ -340,6 +338,21 @@ class Task:
                 self.agent.set_system_message(system_message)
             if user_message:
                 self.agent.set_user_message(user_message)
+
+        # Initialize parsed done sequences now that self.agent is available
+        if self.config.done_sequences:
+            from .done_sequence_parser import parse_done_sequences
+
+            # Pass agent's llm_tools_map directly
+            tools_map = (
+                self.agent.llm_tools_map
+                if hasattr(self.agent, "llm_tools_map")
+                else None
+            )
+            self._parsed_done_sequences = parse_done_sequences(
+                self.config.done_sequences, tools_map
+            )
+
         self.max_cost: float = 0
         self.max_tokens: int = 0
         self.session_id: str = ""
@@ -2331,8 +2344,32 @@ class Task:
         if expected.event_type == EventType.SPECIFIC_TOOL:
             if actual.event_type != EventType.TOOL:
                 return False
+
+            # First try tool_class matching if available
+            if expected.tool_class is not None:
+                # Handle case where actual.tool_class might be a class instance
+                if hasattr(actual, "tool_class") and actual.tool_class is not None:
+                    # If actual.tool_class is an instance, get its class
+                    if isinstance(actual.tool_class, type):
+                        actual_class = actual.tool_class
+                    else:
+                        actual_class = type(actual.tool_class)
+
+                    # Compare the tool classes
+                    if actual_class == expected.tool_class:
+                        return True
+                    # Also check if actual tool is an instance of expected class
+                    if not isinstance(actual.tool_class, type) and isinstance(
+                        actual.tool_class, expected.tool_class
+                    ):
+                        return True
+
+                # If tool_class comparison didn't match, continue to tool_name fallback
+
+            # Fall back to tool_name comparison for backwards compatibility
             if expected.tool_name and actual.tool_name != expected.tool_name:
                 return False
+
         elif actual.event_type != expected.event_type:
             return False
         if expected.sender and actual.sender != expected.sender:

{langroid-0.59.0b3 → langroid-0.59.1}/langroid/language_models/model_info.py

@@ -36,6 +36,9 @@ class OpenAIChatModel(ModelName):
     GPT4_1 = "gpt-4.1"
     GPT4_1_MINI = "gpt-4.1-mini"
     GPT4_1_NANO = "gpt-4.1-nano"
+    GPT5 = "gpt-5"
+    GPT5_MINI = "gpt-5-mini"
+    GPT5_NANO = "gpt-5-nano"
 
 
 class OpenAICompletionModel(str, Enum):
@@ -305,6 +308,54 @@ MODEL_INFO: Dict[str, ModelInfo] = {
         has_tools=False,
         description="O3 Mini Reasoning LM",
     ),
+    OpenAIChatModel.GPT5.value: ModelInfo(
+        name=OpenAIChatModel.GPT5.value,
+        provider=ModelProvider.OPENAI,
+        context_length=400_000,
+        max_output_tokens=128_000,
+        input_cost_per_million=1.25,
+        cached_cost_per_million=0.125,
+        output_cost_per_million=10.00,
+        allows_streaming=False,
+        allows_system_message=False,
+        has_structured_output=True,
+        unsupported_params=["temperature", "stream"],
+        rename_params={"max_tokens": "max_completion_tokens"},
+        has_tools=False,
+        description="GPT-5",
+    ),
+    OpenAIChatModel.GPT5_MINI.value: ModelInfo(
+        name=OpenAIChatModel.GPT5_MINI.value,
+        provider=ModelProvider.OPENAI,
+        context_length=400_000,
+        max_output_tokens=128_000,
+        input_cost_per_million=0.25,
+        cached_cost_per_million=0.025,
+        output_cost_per_million=2.00,
+        allows_streaming=False,
+        allows_system_message=False,
+        has_structured_output=True,
+        unsupported_params=["temperature", "stream"],
+        rename_params={"max_tokens": "max_completion_tokens"},
+        has_tools=False,
+        description="GPT-5 Mini",
+    ),
+    OpenAIChatModel.GPT5_NANO.value: ModelInfo(
+        name=OpenAIChatModel.GPT5_NANO.value,
+        provider=ModelProvider.OPENAI,
+        context_length=400_000,
+        max_output_tokens=128_000,
+        input_cost_per_million=0.05,
+        cached_cost_per_million=0.005,
+        output_cost_per_million=0.40,
+        allows_streaming=False,
+        allows_system_message=False,
+        has_structured_output=True,
+        unsupported_params=["temperature", "stream"],
+        rename_params={"max_tokens": "max_completion_tokens"},
+        has_tools=False,
+        description="GPT-5 Nano",
+    ),
     # Anthropic Models
     AnthropicModel.CLAUDE_3_5_SONNET.value: ModelInfo(
         name=AnthropicModel.CLAUDE_3_5_SONNET.value,

langroid-0.59.1/langroid/mcp/__init__.py

@@ -0,0 +1 @@
+"""MCP (Model Context Protocol) integration for Langroid."""

langroid-0.59.1/langroid/mcp/server/__init__.py

@@ -0,0 +1 @@
+"""MCP server implementation for Langroid."""

{langroid-0.59.0b3 → langroid-0.59.1}/langroid/pydantic_v1/__init__.py

@@ -45,7 +45,7 @@ try:
     from pydantic_settings import BaseSettings  # noqa: F401
 except ImportError:
     # Fallback for older pydantic versions
-    from pydantic import BaseSettings  # noqa: F401
+    from pydantic import BaseSettings  # type: ignore[no-redef] # noqa: F401
 
 # Explicitly export all items for mypy
 __all__ = [

{langroid-0.59.0b3 → langroid-0.59.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langroid"
-version = "0.59.0-b3"
+version = "0.59.1"
 authors = [
     {name = "Prasad Chalasani", email = "pchalasani@gmail.com"},
 ]