langroid 0.52.0__tar.gz → 0.52.2__tar.gz

{langroid-0.52.0 → langroid-0.52.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langroid
-Version: 0.52.0
+Version: 0.52.2
 Summary: Harness LLMs with Multi-Agent Programming
 Author-email: Prasad Chalasani <pchalasani@gmail.com>
 License: MIT

{langroid-0.52.0 → langroid-0.52.2}/langroid/language_models/model_info.py

@@ -31,6 +31,8 @@ class OpenAIChatModel(ModelName):
     O1 = "o1"
     O1_MINI = "o1-mini"
     O3_MINI = "o3-mini"
+    O3 = "o3"
+    O4_MINI = "o4-mini"
     GPT4_1 = "gpt-4.1"
     GPT4_1_MINI = "gpt-4.1-mini"
     GPT4_1_NANO = "gpt-4.1-nano"
@@ -226,6 +228,20 @@ MODEL_INFO: Dict[str, ModelInfo] = {
         has_tools=False,
         description="O1 Reasoning LM",
     ),
+    OpenAIChatModel.O3.value: ModelInfo(
+        name=OpenAIChatModel.O3.value,
+        provider=ModelProvider.OPENAI,
+        context_length=200_000,
+        max_output_tokens=100_000,
+        input_cost_per_million=10.0,
+        output_cost_per_million=40.0,
+        allows_streaming=True,
+        allows_system_message=False,
+        unsupported_params=["temperature"],
+        rename_params={"max_tokens": "max_completion_tokens"},
+        has_tools=False,
+        description="O1 Reasoning LM",
+    ),
     OpenAIChatModel.O1_MINI.value: ModelInfo(
         name=OpenAIChatModel.O1_MINI.value,
         provider=ModelProvider.OPENAI,
@@ -254,6 +270,20 @@ MODEL_INFO: Dict[str, ModelInfo] = {
         has_tools=False,
         description="O3 Mini Reasoning LM",
     ),
+    OpenAIChatModel.O4_MINI.value: ModelInfo(
+        name=OpenAIChatModel.O4_MINI.value,
+        provider=ModelProvider.OPENAI,
+        context_length=200_000,
+        max_output_tokens=100_000,
+        input_cost_per_million=1.10,
+        output_cost_per_million=4.40,
+        allows_streaming=False,
+        allows_system_message=False,
+        unsupported_params=["temperature", "stream"],
+        rename_params={"max_tokens": "max_completion_tokens"},
+        has_tools=False,
+        description="O3 Mini Reasoning LM",
+    ),
     # Anthropic Models
     AnthropicModel.CLAUDE_3_5_SONNET.value: ModelInfo(
         name=AnthropicModel.CLAUDE_3_5_SONNET.value,

{langroid-0.52.0 → langroid-0.52.2}/langroid/parsing/file_attachment.py

@@ -3,6 +3,7 @@ import mimetypes
 import uuid
 from pathlib import Path
 from typing import Any, BinaryIO, Dict, Optional, Union
+from urllib.parse import urlparse
 
 from langroid.pydantic_v1 import BaseModel
 
@@ -13,6 +14,8 @@ class FileAttachment(BaseModel):
     content: bytes
     filename: Optional[str] = None
     mime_type: str = "application/octet-stream"
+    url: str | None = None
+    detail: str | None = None
 
     def __init__(self, **data: Any) -> None:
         """Initialize with sensible defaults for filename if not provided."""
@@ -23,7 +26,11 @@ class FileAttachment(BaseModel):
         super().__init__(**data)
 
     @classmethod
-    def from_path(cls, file_path: Union[str, Path]) -> "FileAttachment":
+    def _from_path(
+        cls,
+        file_path: Union[str, Path],
+        detail: Optional[str] = None,
+    ) -> "FileAttachment":
         """Create a FileAttachment from a file path.
 
         Args:
@@ -40,7 +47,74 @@ class FileAttachment(BaseModel):
         if mime_type is None:
             mime_type = "application/octet-stream"
 
-        return cls(content=content, filename=path.name, mime_type=mime_type)
+        return cls(
+            content=content,
+            filename=path.name,
+            mime_type=mime_type,
+            detail=detail,
+        )
+
+    @classmethod
+    def _from_url(
+        cls,
+        url: str,
+        content: Optional[bytes] = None,
+        filename: Optional[str] = None,
+        mime_type: Optional[str] = None,
+        detail: Optional[str] = None,
+    ) -> "FileAttachment":
+        """Create a FileAttachment from a URL.
+
+        Args:
+            url: URL to the file
+            content: Optional raw bytes content (if already fetched)
+            filename: Optional name to use for the file
+            mime_type: MIME type of the content, guessed from filename or url
+
+        Returns:
+            FileAttachment instance
+        """
+        if filename is None and url:
+            # Extract filename from URL if possible
+
+            parsed_url = urlparse(url)
+            path = parsed_url.path
+            filename = path.split("/")[-1] if path else None
+
+        if mime_type is None and filename:
+            mime_type, _ = mimetypes.guess_type(filename)
+
+        return cls(
+            content=content or b"",  # Empty bytes if no content provided
+            filename=filename,
+            mime_type=mime_type or "application/octet-stream",
+            url=url,
+            detail=detail,
+        )
+
+    @classmethod
+    def from_path(
+        cls,
+        path: Union[str, Path],
+        detail: str | None = None,
+    ) -> "FileAttachment":
+        """Create a FileAttachment from either a local file path or a URL.
+
+        Args:
+            path_or_url: Path to the file or URL to fetch
+
+        Returns:
+            FileAttachment instance
+        """
+        # Convert to string if Path object
+        path_str = str(path)
+
+        # Check if it's a URL
+        if path_str.startswith(("http://", "https://", "ftp://")):
+            return cls._from_url(url=path_str, detail=detail)
+        else:
+            # Assume it's a local file path
+            return cls._from_path(path_str, detail=detail)
 
     @classmethod
     def from_bytes(
@@ -137,21 +211,37 @@ class FileAttachment(BaseModel):
         """
         if "gemini" in model.lower():
             return dict(type="image_url", image_url=dict(url=self.to_data_uri()))
-        elif "claude" in model.lower():
+        else:
             # optimistically try this: some API proxies like litellm
             # support this, and others may not.
-            return dict(
-                type="file",
-                file=dict(
-                    file_data=self.to_data_uri(),
-                ),
-            )
-        else:
-            # fallback: assume file upload is similar to OpenAI API
-            return dict(
-                type="file",
-                file=dict(
-                    filename=self.filename,
-                    file_data=self.to_data_uri(),
-                ),
-            )
+            # For OpenAI models, handle images differently than other files
+            # For OpenAI models, handle images differently than other files
+            if self.mime_type and self.mime_type.startswith("image/"):
+                image_url_dict = {}
+
+                # If we have a URL and it's a full http/https URL, use it directly
+                if self.url and (
+                    self.url.startswith("http://") or self.url.startswith("https://")
+                ):
+                    image_url_dict["url"] = self.url
+                # Otherwise use base64 data URI
+                else:
+                    image_url_dict["url"] = self.to_data_uri()
+
+                # Add detail parameter if specified
+                if self.detail:
+                    image_url_dict["detail"] = self.detail
+
+                return dict(
+                    type="image_url",
+                    image_url=image_url_dict,
+                )
+            else:
+                # For non-image files
+                return dict(
+                    type="file",
+                    file=dict(
+                        filename=self.filename,
+                        file_data=self.to_data_uri(),
+                    ),
+                )

{langroid-0.52.0 → langroid-0.52.2}/pyproject.toml

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