quantalogic 0.31.1__tar.gz → 0.32.0__tar.gz

{quantalogic-0.31.1 → quantalogic-0.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.31.1
+Version: 0.32.0
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com
@@ -184,12 +184,25 @@ See our [Release Notes](RELEASE_NOTES.MD) for detailed version history and chang
 | openrouter/openai/gpt-4o | OPENROUTER_API_KEY | OpenAI's GPT-4o model accessible through OpenRouter platform. |
 | openrouter/mistralai/mistral-large-2411 | OPENROUTER_API_KEY | Mistral's large model optimized for complex reasoning tasks, available through OpenRouter with enhanced multilingual capabilities. |
 | mistral/mistral-large-2407 | MISTRAL_API_KEY | Mistral's high-performance model designed for enterprise-grade applications, offering advanced reasoning and multilingual support. |
+| nvidia/deepseek-ai/deepseek-r1 | NVIDIA_API_KEY | NVIDIA's DeepSeek R1 model optimized for high-performance AI tasks and advanced reasoning capabilities. |
+| lm_studio/mistral-small-24b-instruct-2501 | LM_STUDIO_API_KEY | LM Studio's Mistral Small model optimized for local inference with advanced reasoning capabilities. |
 | dashscope/qwen-max | DASHSCOPE_API_KEY | Alibaba's Qwen-Max model optimized for maximum performance and extensive reasoning capabilities. |
 | dashscope/qwen-plus | DASHSCOPE_API_KEY | Alibaba's Qwen-Plus model offering balanced performance and cost-efficiency for a variety of tasks. |
 | dashscope/qwen-turbo | DASHSCOPE_API_KEY | Alibaba's Qwen-Turbo model designed for fast and efficient responses, ideal for high-throughput scenarios. |
 
 To configure the environment API key for Quantalogic using LiteLLM, set the required environment variable for your chosen provider and any optional variables like `OPENAI_API_BASE` or `OPENROUTER_REFERRER`. Use a `.env` file or a secrets manager to securely store these keys, and load them in your code using `python-dotenv`. For advanced configurations, refer to the [LiteLLM documentation](https://docs.litellm.ai/docs/).
 
+### LM Studio Local Setup
+
+To use LM Studio with the Mistral model locally, set the following environment variables:
+
+```bash
+export LM_STUDIO_API_BASE="http://localhost:1234/v1"
+export LM_STUDIO_API_KEY="your-api-key-here"
+```
+
+Replace `http://localhost:1234/v1` with your LM Studio server URL and `your-api-key-here` with your actual API key.
+
 
 ## 📦 Installation
 

{quantalogic-0.31.1 → quantalogic-0.32.0}/README.md

@@ -124,12 +124,25 @@ See our [Release Notes](RELEASE_NOTES.MD) for detailed version history and chang
 | openrouter/openai/gpt-4o | OPENROUTER_API_KEY | OpenAI's GPT-4o model accessible through OpenRouter platform. |
 | openrouter/mistralai/mistral-large-2411 | OPENROUTER_API_KEY | Mistral's large model optimized for complex reasoning tasks, available through OpenRouter with enhanced multilingual capabilities. |
 | mistral/mistral-large-2407 | MISTRAL_API_KEY | Mistral's high-performance model designed for enterprise-grade applications, offering advanced reasoning and multilingual support. |
+| nvidia/deepseek-ai/deepseek-r1 | NVIDIA_API_KEY | NVIDIA's DeepSeek R1 model optimized for high-performance AI tasks and advanced reasoning capabilities. |
+| lm_studio/mistral-small-24b-instruct-2501 | LM_STUDIO_API_KEY | LM Studio's Mistral Small model optimized for local inference with advanced reasoning capabilities. |
 | dashscope/qwen-max | DASHSCOPE_API_KEY | Alibaba's Qwen-Max model optimized for maximum performance and extensive reasoning capabilities. |
 | dashscope/qwen-plus | DASHSCOPE_API_KEY | Alibaba's Qwen-Plus model offering balanced performance and cost-efficiency for a variety of tasks. |
 | dashscope/qwen-turbo | DASHSCOPE_API_KEY | Alibaba's Qwen-Turbo model designed for fast and efficient responses, ideal for high-throughput scenarios. |
 
 To configure the environment API key for Quantalogic using LiteLLM, set the required environment variable for your chosen provider and any optional variables like `OPENAI_API_BASE` or `OPENROUTER_REFERRER`. Use a `.env` file or a secrets manager to securely store these keys, and load them in your code using `python-dotenv`. For advanced configurations, refer to the [LiteLLM documentation](https://docs.litellm.ai/docs/).
 
+### LM Studio Local Setup
+
+To use LM Studio with the Mistral model locally, set the following environment variables:
+
+```bash
+export LM_STUDIO_API_BASE="http://localhost:1234/v1"
+export LM_STUDIO_API_KEY="your-api-key-here"
+```
+
+Replace `http://localhost:1234/v1` with your LM Studio server URL and `your-api-key-here` with your actual API key.
+
 
 ## 📦 Installation
 

{quantalogic-0.31.1 → quantalogic-0.32.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "quantalogic"
-version = "0.31.1"
+version = "0.32.0"
 description = "QuantaLogic ReAct Agents"
 authors = ["Raphaël MANSUY <raphael.mansuy@gmail.com>"]
 readme = "README.md"

{quantalogic-0.31.1 → quantalogic-0.32.0}/quantalogic/agent.py

@@ -751,6 +751,8 @@ class Agent(BaseModel):
             str: Generated task summary
         """
         try:
+            if len(content) < 200:
+                return content
             prompt = (
                 "Create an ultra-concise task summary that captures ONLY: \n"
                 "1. Primary objective/purpose\n"

quantalogic-0.32.0/quantalogic/get_model_info.py

@@ -0,0 +1,83 @@
+import loguru
+
+from quantalogic.model_info_list import model_info
+from quantalogic.model_info_litellm import litellm_get_model_max_input_tokens, litellm_get_model_max_output_tokens
+from quantalogic.utils.lm_studio_model_info import ModelInfo, get_model_list
+
+DEFAULT_MAX_OUTPUT_TOKENS = 4 * 1024  # Reasonable default for most models
+DEFAULT_MAX_INPUT_TOKENS = 32 * 1024  # Reasonable default for most models
+
+
+def validate_model_name(model_name: str) -> None:
+    if not isinstance(model_name, str) or not model_name.strip():
+        raise ValueError(f"Invalid model name: {model_name}")
+
+
+def print_model_info():
+    for info in model_info.values():
+        print(f"\n{info.model_name}:")
+        print(f"  Max Input Tokens: {info.max_input_tokens:,}")
+        print(f"  Max Output Tokens: {info.max_output_tokens:,}")
+
+
+def get_max_output_tokens(model_name: str) -> int:
+    """Get max output tokens with safe fallback"""
+    validate_model_name(model_name)
+
+    if model_name.startswith('lm_studio/'):
+        try:
+            models = get_model_list()
+            for model in models.data:
+                if model.id == model_name[len('lm_studio/'):]:
+                    return model.max_context_length
+        except Exception:
+            loguru.logger.warning(f"Could not fetch LM Studio model info for {model_name}, using default")
+
+    if model_name in model_info:
+        return model_info[model_name].max_output_tokens
+
+    try:
+        return litellm_get_model_max_output_tokens(model_name)
+    except Exception as e:
+        loguru.logger.warning(f"Model {model_name} not found in LiteLLM registry, using default")
+        return DEFAULT_MAX_OUTPUT_TOKENS
+
+
+def get_max_input_tokens(model_name: str) -> int:
+    """Get max input tokens with safe fallback"""
+    validate_model_name(model_name)
+
+    if model_name.startswith('lm_studio/'):
+        try:
+            models = get_model_list()
+            for model in models.data:
+                if model.id == model_name[len('lm_studio/'):]:
+                    return model.max_context_length
+        except Exception:
+            loguru.logger.warning(f"Could not fetch LM Studio model info for {model_name}, using default")
+
+    if model_name in model_info:
+        return model_info[model_name].max_input_tokens
+
+    try:
+        return litellm_get_model_max_input_tokens(model_name)
+    except Exception:
+        loguru.logger.warning(f"Model {model_name} not found in LiteLLM registry, using default")
+        return DEFAULT_MAX_INPUT_TOKENS
+
+
+def get_max_tokens(model_name: str) -> int:
+    """Get total maximum tokens (input + output)"""
+    validate_model_name(model_name)
+
+    # Get input and output tokens separately
+    input_tokens = get_max_input_tokens(model_name)
+    output_tokens = get_max_output_tokens(model_name)
+
+    return input_tokens + output_tokens
+
+
+if __name__ == "__main__":
+    print_model_info()
+    print(get_max_input_tokens("gpt-4o-mini"))
+    print(get_max_output_tokens("openrouter/openai/gpt-4o-mini"))

{quantalogic-0.31.1 → quantalogic-0.32.0}/quantalogic/llm.py

@@ -30,18 +30,50 @@ def get_model_info(model_name: str) -> dict | None:
     return model_info.get(model_name, None)
 
 
+class ModelProviderConfig:
+    def __init__(self, prefix: str, provider: str, base_url: str, env_var: str):
+        self.prefix = prefix
+        self.provider = provider
+        self.base_url = base_url
+        self.env_var = env_var
+
+    def configure(self, model: str, kwargs: Dict[str, Any]) -> None:
+        kwargs["model"] = model.replace(self.prefix, "")
+        kwargs["custom_llm_provider"] = self.provider
+        kwargs["base_url"] = self.base_url
+        api_key = os.getenv(self.env_var)
+        if not api_key:
+            raise ValueError(f"{self.env_var} is not set in the environment variables.")
+        kwargs["api_key"] = api_key
+
+
+# Default provider configurations
+PROVIDERS = {
+    "dashscope": ModelProviderConfig(
+        prefix="dashscope/",
+        provider="openai",
+        base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+        env_var="DASHSCOPE_API_KEY"
+    ),
+    "nvidia": ModelProviderConfig(
+        prefix="nvidia/",
+        provider="openai",
+        base_url="https://integrate.api.nvidia.com/v1",
+        env_var="NVIDIA_API_KEY"
+    )
+}
+
+
 def generate_completion(**kwargs: Dict[str, Any]) -> Any:
     """Wraps litellm completion with proper type hints."""
     model = kwargs.get("model", "")
-    if model.startswith("dashscope/"):
-        # Remove prefix and configure for OpenAI-compatible endpoint
-        kwargs["model"] = model.replace("dashscope/", "")
-        kwargs["custom_llm_provider"] = "openai"  # Explicitly specify OpenAI provider
-        kwargs["base_url"] = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
-        api_key = os.getenv("DASHSCOPE_API_KEY")
-        if not api_key:
-            raise ValueError("DASHSCOPE_API_KEY is not set in the environment variables.")
-        kwargs["api_key"] = api_key
+    
+    # Find matching provider
+    for provider_name, provider_config in PROVIDERS.items():
+        if model.startswith(provider_config.prefix):
+            provider_config.configure(model, kwargs)
+            break
+    
     return completion(**kwargs)
 
 

quantalogic-0.32.0/quantalogic/model_info.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+
+
+class ModelInfo(BaseModel):
+    model_name: str
+    max_input_tokens: int
+    max_output_tokens: int
+    max_cot_tokens: int | None = None
+
+
+class ModelNotFoundError(Exception):
+    """Raised when a model is not found in local registry"""

quantalogic-0.32.0/quantalogic/model_info_list.py

@@ -0,0 +1,57 @@
+from quantalogic.model_info import ModelInfo
+
+model_info = {
+    "dashscope/qwen-max": ModelInfo(
+        model_name="dashscope/qwen-max",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=32 * 1024,
+    ),
+    "dashscope/qwen-plus": ModelInfo(
+        model_name="dashscope/qwen-plus",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=131072,
+    ),
+    "dashscope/qwen-turbo": ModelInfo(
+        model_name="dashscope/qwen-turbo",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=1000000,
+    ),
+    "deepseek-reasoner": ModelInfo(
+        model_name="deepseek-reasoner",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=1024 * 128,
+    ),
+    "openrouter/deepseek/deepseek-r1": ModelInfo(
+        model_name="openrouter/deepseek/deepseek-r1",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=1024 * 128,
+    ),
+    "openrouter/mistralai/mistral-large-2411": ModelInfo(
+        model_name="openrouter/mistralai/mistral-large-2411",
+        max_output_tokens=128 * 1024,
+        max_input_tokens=1024 * 128,
+    ),
+    "mistralai/mistral-large-2411": ModelInfo(
+        model_name="mistralai/mistral-large-2411",
+        max_output_tokens=128 * 1024,
+        max_input_tokens=1024 * 128,
+    ),
+    "deepseek/deepseek-chat": ModelInfo(
+        model_name="deepseek/deepseek-chat",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=1024 * 64,
+    ),
+    "deepseek/deepseek-reasoner": ModelInfo(
+        model_name="deepseek/deepseek-reasoner",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=1024 * 64,
+        max_cot_tokens=1024 * 32,
+    ),
+    "nvidia/deepseek-ai/deepseek-r1": ModelInfo(
+        model_name="nvidia/deepseek-ai/deepseek-r1",
+        max_output_tokens=8 * 1024,
+        max_input_tokens=1024 * 64,
+    ),
+    
+
+}

quantalogic-0.32.0/quantalogic/model_info_litellm.py

@@ -0,0 +1,70 @@
+import functools
+
+import litellm
+
+
+@functools.lru_cache(maxsize=32)
+def litellm_get_model_info(model_name: str) -> dict | None:
+    """Get model information with prefix fallback logic using only litellm.
+    
+    Args:
+        model_name: The model identifier to get information for
+        
+    Returns:
+        Dictionary containing model information
+        
+    Raises:
+        ValueError: If model info cannot be found after prefix fallbacks
+    """
+    tried_models = [model_name]
+    
+    while True:
+        try:
+            # Attempt to get model info through litellm
+            info = litellm.get_model_info(model_name)
+            if info:
+                return info
+        except Exception:
+            pass
+        
+        # Try removing one prefix level
+        parts = model_name.split("/")
+        if len(parts) <= 1:
+            break
+            
+        model_name = "/".join(parts[1:])
+        tried_models.append(model_name)
+
+    return None    
+
+
+def litellm_get_model_max_input_tokens(model_name: str) -> int | None:
+    """Get maximum input tokens for a model using litellm.
+    
+    Args:
+        model_name: The model identifier
+        
+    Returns:
+        Maximum input tokens or None if not found
+    """
+    try:
+        info = litellm_get_model_info(model_name)
+        return info.get("max_input_tokens", 8192)
+    except Exception as e:
+        return 8192  # Default for many modern models
+
+
+def litellm_get_model_max_output_tokens(model_name: str) -> int | None:
+    """Get maximum output tokens for a model using litellm.
+    
+    Args:
+        model_name: The model identifier
+        
+    Returns:
+        Maximum output tokens or None if not found
+    """
+    try:
+        info = litellm_get_model_info(model_name)
+        return info.get("max_output_tokens", 4096)
+    except Exception as e:
+        return 4096  # Conservative default

{quantalogic-0.31.1 → quantalogic-0.32.0}/quantalogic/task_runner.py

@@ -233,6 +233,12 @@ def task_runner(
                 "memory_summary",
             ]
 
+            #def ask_continue(event: str, data: any) -> None:
+            #    ## Ask for ctrl+return
+            #    if event == "task_think_end":
+            #        ## Wait return on the keyboard
+            #        input("Press [Enter] to continue...")
+
             # Add spinner control to event handlers
             def handle_task_think_start(*args, **kwargs):
                 start_spinner(console)
@@ -246,6 +252,11 @@ def task_runner(
                 if data is not None:
                     console.print(data, end="", markup=False)
 
+            #agent.event_emitter.on(
+            #    event="task_think_end",
+            #    listener=ask_continue,
+            #)
+
             agent.event_emitter.on(
                 event=events,
                 listener=console_print_events,

{quantalogic-0.31.1 → quantalogic-0.32.0}/quantalogic/utils/__init__.py

@@ -5,6 +5,7 @@ from .git_ls import git_ls
 from .get_environment import get_environment
 from .get_coding_environment import get_coding_environment
 from .get_quantalogic_rules_content import get_quantalogic_rules_file_content
+from .lm_studio_model_info import get_model_list
 
 __all__ = [
     "download_http_file",
@@ -14,4 +15,5 @@ __all__ = [
     "get_environment",
     "get_coding_environment",
     "get_quantalogic_rules_file_content",
+    "get_model_list",
 ]

{quantalogic-0.31.1 → quantalogic-0.32.0}/quantalogic/utils/get_all_models.py

@@ -1,8 +1,8 @@
 import litellm
 
-
 from quantalogic.get_model_info import model_info
 
+
 def get_all_models() -> list[str]:
     """
     Retrieves a unified list of all model names supported by LiteLLM and Quantalogic.

quantalogic-0.32.0/quantalogic/utils/lm_studio_model_info.py

@@ -0,0 +1,48 @@
+from enum import Enum
+from typing import List, Literal, Optional
+
+from pydantic import BaseModel, Field
+
+
+class ModelType(str, Enum):
+    LLM = "llm"
+    EMBEDDINGS = "embeddings"
+    VLM = "vlm"
+
+class CompatibilityType(str, Enum):
+    MLX = "mlx"
+    GGUF = "gguf"
+
+class ModelState(str, Enum):
+    LOADED = "loaded"
+    NOT_LOADED = "not-loaded"
+
+class ModelInfo(BaseModel):
+    id: str = Field(..., description="Unique model identifier in LM Studio's namespace")
+    object: Literal["model"] = Field("model", description="Always 'model' for model objects")
+    type: ModelType = Field(..., description="Type of AI model")
+    publisher: str = Field(..., description="Organization or user who published the model")
+    arch: str = Field(..., description="Base architecture family")
+    compatibility_type: CompatibilityType = Field(..., alias="compatibility_type")
+    quantization: Optional[str] = Field(None, description="Quantization method if applicable")
+    state: ModelState = Field(..., description="Current loading state in LM Studio")
+    max_context_length: int = Field(..., alias="max_context_length", ge=0)
+    loaded_context_length: Optional[int] = Field(
+        None, 
+        alias="loaded_context_length",
+        description="Currently allocated context length (only when loaded)",
+        ge=0
+    )
+
+class ModelListResponse(BaseModel):
+    data: List[ModelInfo] = Field(..., description="List of available models")
+    object: Literal["list"] = Field("list", description="Always 'list' for list responses")
+
+def get_model_list() -> ModelListResponse:
+    """Fetch and validate model information from LM Studio's API"""
+    import requests
+    
+    response = requests.get("http://localhost:1234/api/v0/models")
+    response.raise_for_status()
+    
+    return ModelListResponse(**response.json())

quantalogic-0.31.1/quantalogic/get_model_info.py

@@ -1,44 +0,0 @@
-model_info = {
-    "dashscope/qwen-max": {"max_output_tokens": 8 * 1024, "max_input_tokens": 32 * 1024},
-    "dashscope/qwen-plus": {"max_output_tokens": 8 * 1024, "max_input_tokens": 131072},
-    "dashscope/qwen-turbo": {"max_output_tokens": 8 * 1024, "max_input_tokens": 1000000},
-    "deepseek-reasoner": {"max_output_tokens": 8 * 1024, "max_input_tokens": 1024 * 128},
-    "openrouter/deepseek/deepseek-r1": {"max_output_tokens": 8 * 1024, "max_input_tokens": 1024 * 128},
-    "openrouter/mistralai/mistral-large-2411": {"max_output_tokens": 128 * 1024, "max_input_tokens": 1024 * 128},
-    "mistralai/mistral-large-2411": {"max_output_tokens": 128 * 1024, "max_input_tokens": 1024 * 128},
-    "deepseek/deepseek-chat": {"max_output_tokens": 8* 1024, "max_input_tokens": 1024*64},
-    "deepseek/deepseek-reasoner": {"max_output_tokens": 8* 1024, "max_input_tokens": 1024*64, "max_cot_tokens": 1024*32 },
-}
-
-
-def print_model_info():
-    for model, info in model_info.items():
-        print(f"\n{model}:")
-        print(f"  Max Input Tokens: {info['max_input_tokens']:,}")
-        print(f"  Max Output Tokens: {info['max_output_tokens']:,}")
-
-
-if __name__ == "__main__":
-    print_model_info()
-
-
-def get_max_output_tokens(model_name: str) -> int | None:
-    """Get the maximum output tokens for a given model name."""
-    return model_info.get(model_name, {}).get("max_output_tokens", None)
-
-
-def get_max_input_tokens(model_name: str) -> int | None:
-    """Get the maximum input tokens for a given model name."""
-    return model_info.get(model_name, {}).get("max_input_tokens", None)
-
-
-def get_max_tokens(model_name: str) -> int | None:
-    """Get the maximum total tokens (input + output) for a given model name."""
-    model_data = model_info.get(model_name, {})
-    max_input = model_data.get("max_input_tokens")
-    max_output = model_data.get("max_output_tokens")
-
-    if max_input is None or max_output is None:
-        return None
-
-    return max_input + max_output