mojentic 1.0.1__py3-none-any.whl → 1.1.1__py3-none-any.whl

_examples/audit_openai_capabilities.py

@@ -0,0 +1,561 @@
+"""
+Audit script that probes OpenAI models for their actual capabilities
+and compares against our hardcoded model registry.
+
+Usage:
+    OPENAI_API_KEY=sk-... python src/_examples/audit_openai_capabilities.py
+    OPENAI_API_KEY=sk-... python src/_examples/audit_openai_capabilities.py --cheap
+
+The --cheap flag skips expensive model families and infers capabilities
+from their -mini variants instead.
+"""
+
+import base64
+import json
+import os
+import sys
+import time
+from datetime import datetime, timezone
+from typing import Optional
+
+from openai import OpenAI, BadRequestError, APIError, RateLimitError
+
+from mojentic.llm.gateways.openai_model_registry import (
+    OpenAIModelRegistry, ModelType
+)
+
+# Models that use different API endpoints (not chat-compatible)
+SKIP_PREFIXES = [
+    "tts-", "whisper-", "dall-e-", "text-moderation-",
+    "davinci-", "babbage-", "canary-",
+    "codex-", "computer-",
+]
+SKIP_CONTAINS = [
+    "-realtime-", "-transcribe", "-tts",
+]
+
+# Expensive model families to skip in --cheap mode
+EXPENSIVE_FAMILIES = [
+    "o1-pro", "o3-pro", "o3-deep-research", "o4-mini-deep-research",
+    "gpt-5-codex",
+]
+
+# 1x1 white PNG for vision testing
+TINY_PNG_B64 = (
+    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4"
+    "nGP4z8BQDwAEgAF/pooBPQAAAABJRU5ErkJggg=="
+)
+
+MINIMAL_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "get_weather",
+        "description": "Get weather for a city",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "city": {"type": "string", "description": "City name"}
+            },
+            "required": ["city"]
+        }
+    }
+}
+
+
+def should_skip_model(model_id: str) -> bool:
+    """Check if a model should be skipped (non-chat endpoint)."""
+    model_lower = model_id.lower()
+    for prefix in SKIP_PREFIXES:
+        if model_lower.startswith(prefix):
+            return True
+    for pattern in SKIP_CONTAINS:
+        if pattern in model_lower:
+            return True
+    return False
+
+
+def is_chat_model_candidate(model_id: str) -> bool:
+    """Check if a model is a candidate for chat API probing."""
+    model_lower = model_id.lower()
+    chat_patterns = [
+        "gpt-3.5", "gpt-4", "gpt-5",
+        "o1", "o3", "o4",
+        "chatgpt",
+    ]
+    return any(p in model_lower for p in chat_patterns)
+
+
+def is_embedding_model(model_id: str) -> bool:
+    """Check if a model is an embedding model."""
+    return "embedding" in model_id.lower()
+
+
+def is_expensive(model_id: str) -> bool:
+    """Check if a model is in an expensive family."""
+    model_lower = model_id.lower()
+    return any(family in model_lower for family in EXPENSIVE_FAMILIES)
+
+
+def rate_limited_call(func, *args, **kwargs):
+    """Call a function with rate limit handling and backoff."""
+    max_retries = 3
+    delay = 1.0
+    for attempt in range(max_retries):
+        try:
+            return func(*args, **kwargs)
+        except RateLimitError:
+            if attempt < max_retries - 1:
+                print(f"    Rate limited, waiting {delay}s...")
+                time.sleep(delay)
+                delay *= 2
+            else:
+                raise
+
+
+def probe_basic_chat(client: OpenAI, model_id: str) -> dict:
+    """Test basic chat completion and determine token parameter name."""
+    result = {"works": False, "uses_max_tokens": None, "error": None}
+
+    # Try with max_tokens first (standard chat models)
+    try:
+        response = rate_limited_call(
+            client.chat.completions.create,
+            model=model_id,
+            messages=[{"role": "user", "content": "Say hi"}],
+            max_tokens=10,
+        )
+        result["works"] = True
+        result["uses_max_tokens"] = True
+        return result
+    except BadRequestError as e:
+        error_msg = str(e).lower()
+        if "max_completion_tokens" in error_msg:
+            # Reasoning model - retry with max_completion_tokens
+            try:
+                response = rate_limited_call(
+                    client.chat.completions.create,
+                    model=model_id,
+                    messages=[{"role": "user", "content": "Say hi"}],
+                    max_completion_tokens=10,
+                )
+                result["works"] = True
+                result["uses_max_tokens"] = False
+                return result
+            except (BadRequestError, APIError) as e2:
+                result["error"] = str(e2)
+                return result
+        else:
+            result["error"] = str(e)
+            return result
+    except APIError as e:
+        result["error"] = str(e)
+        return result
+
+
+def probe_tool_calling(client: OpenAI, model_id: str, uses_max_tokens: bool) -> dict:
+    """Test if a model supports tool calling."""
+    result = {"supports_tools": False, "error": None}
+
+    token_kwargs = {}
+    if uses_max_tokens:
+        token_kwargs["max_tokens"] = 10
+    else:
+        token_kwargs["max_completion_tokens"] = 100
+
+    try:
+        response = rate_limited_call(
+            client.chat.completions.create,
+            model=model_id,
+            messages=[{"role": "user", "content": "What is the weather in London?"}],
+            tools=[MINIMAL_TOOL],
+            **token_kwargs,
+        )
+        result["supports_tools"] = True
+        return result
+    except BadRequestError as e:
+        error_msg = str(e).lower()
+        if "tool" in error_msg or "function" in error_msg:
+            result["supports_tools"] = False
+        else:
+            result["error"] = str(e)
+            result["supports_tools"] = False
+        return result
+    except APIError as e:
+        result["error"] = str(e)
+        return result
+
+
+def probe_streaming(client: OpenAI, model_id: str, uses_max_tokens: bool) -> dict:
+    """Test if a model supports streaming."""
+    result = {"supports_streaming": False, "error": None}
+
+    token_kwargs = {}
+    if uses_max_tokens:
+        token_kwargs["max_tokens"] = 10
+    else:
+        token_kwargs["max_completion_tokens"] = 50
+
+    try:
+        stream = rate_limited_call(
+            client.chat.completions.create,
+            model=model_id,
+            messages=[{"role": "user", "content": "Say hi"}],
+            stream=True,
+            **token_kwargs,
+        )
+        # Consume the stream to verify it works
+        for chunk in stream:
+            pass
+        result["supports_streaming"] = True
+        return result
+    except BadRequestError as e:
+        error_msg = str(e).lower()
+        if "stream" in error_msg:
+            result["supports_streaming"] = False
+        else:
+            result["error"] = str(e)
+            result["supports_streaming"] = False
+        return result
+    except APIError as e:
+        result["error"] = str(e)
+        return result
+
+
+def probe_vision(client: OpenAI, model_id: str, uses_max_tokens: bool) -> dict:
+    """Test if a model supports vision (image input)."""
+    result = {"supports_vision": False, "error": None}
+
+    token_kwargs = {}
+    if uses_max_tokens:
+        token_kwargs["max_tokens"] = 10
+    else:
+        token_kwargs["max_completion_tokens"] = 50
+
+    try:
+        response = rate_limited_call(
+            client.chat.completions.create,
+            model=model_id,
+            messages=[{
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": "Describe this image in one word."},
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/png;base64,{TINY_PNG_B64}",
+                            "detail": "low"
+                        }
+                    }
+                ]
+            }],
+            **token_kwargs,
+        )
+        result["supports_vision"] = True
+        return result
+    except BadRequestError as e:
+        error_msg = str(e).lower()
+        if "image" in error_msg or "vision" in error_msg or "content" in error_msg:
+            result["supports_vision"] = False
+        else:
+            result["error"] = str(e)
+            result["supports_vision"] = False
+        return result
+    except APIError as e:
+        result["error"] = str(e)
+        return result
+
+
+def probe_temperature(client: OpenAI, model_id: str, uses_max_tokens: bool) -> dict:
+    """Test which temperature values a model supports."""
+    result = {"supported_temperatures": None, "error": None}
+    test_temps = [0.0, 0.5, 1.0]
+    supported = []
+
+    token_kwargs = {}
+    if uses_max_tokens:
+        token_kwargs["max_tokens"] = 5
+    else:
+        token_kwargs["max_completion_tokens"] = 20
+
+    for temp in test_temps:
+        try:
+            response = rate_limited_call(
+                client.chat.completions.create,
+                model=model_id,
+                messages=[{"role": "user", "content": "Say ok"}],
+                temperature=temp,
+                **token_kwargs,
+            )
+            supported.append(temp)
+        except BadRequestError as e:
+            error_msg = str(e).lower()
+            if "temperature" in error_msg:
+                pass  # This temperature not supported
+            else:
+                result["error"] = str(e)
+                break
+        except APIError as e:
+            result["error"] = str(e)
+            break
+        time.sleep(0.3)
+
+    if len(supported) == len(test_temps):
+        result["supported_temperatures"] = None  # All supported
+    elif len(supported) == 0:
+        result["supported_temperatures"] = []  # None supported
+    else:
+        result["supported_temperatures"] = supported
+
+    return result
+
+
+def probe_embedding(client: OpenAI, model_id: str) -> dict:
+    """Test if a model works as an embedding model."""
+    result = {"is_embedding": False, "error": None}
+    try:
+        response = rate_limited_call(
+            client.embeddings.create,
+            model=model_id,
+            input="test",
+        )
+        result["is_embedding"] = True
+        return result
+    except (BadRequestError, APIError) as e:
+        result["error"] = str(e)
+        return result
+
+
+def probe_model(client: OpenAI, model_id: str, cheap_mode: bool = False) -> Optional[dict]:
+    """Run all capability probes against a single model."""
+    if should_skip_model(model_id):
+        return None
+
+    if cheap_mode and is_expensive(model_id):
+        print(f"  Skipping {model_id} (expensive, --cheap mode)")
+        return None
+
+    # Handle embedding models separately
+    if is_embedding_model(model_id):
+        print(f"  Probing {model_id} (embedding)...")
+        embed_result = probe_embedding(client, model_id)
+        return {
+            "model_type": "embedding" if embed_result["is_embedding"] else "unknown",
+            "supports_tools": False,
+            "supports_streaming": False,
+            "supports_vision": False,
+            "supported_temperatures": None,
+            "uses_max_tokens": None,
+            "errors": [embed_result["error"]] if embed_result["error"] else []
+        }
+
+    if not is_chat_model_candidate(model_id):
+        return None
+
+    print(f"  Probing {model_id}...")
+
+    # Test 1: Basic chat
+    basic = probe_basic_chat(client, model_id)
+    if not basic["works"]:
+        print(f"    Basic chat failed: {basic['error']}")
+        return {
+            "model_type": "unknown",
+            "supports_tools": False,
+            "supports_streaming": False,
+            "supports_vision": False,
+            "supported_temperatures": None,
+            "uses_max_tokens": None,
+            "errors": [basic["error"]]
+        }
+
+    uses_max_tokens = basic["uses_max_tokens"]
+    model_type = "chat" if uses_max_tokens else "reasoning"
+    time.sleep(0.5)
+
+    # Test 2: Tool calling
+    tools_result = probe_tool_calling(client, model_id, uses_max_tokens)
+    time.sleep(0.5)
+
+    # Test 3: Streaming
+    stream_result = probe_streaming(client, model_id, uses_max_tokens)
+    time.sleep(0.5)
+
+    # Test 4: Vision
+    vision_result = probe_vision(client, model_id, uses_max_tokens)
+    time.sleep(0.5)
+
+    # Test 5: Temperature
+    temp_result = probe_temperature(client, model_id, uses_max_tokens)
+
+    errors = [r["error"] for r in [tools_result, stream_result, vision_result, temp_result]
+              if r.get("error")]
+
+    return {
+        "model_type": model_type,
+        "supports_tools": tools_result["supports_tools"],
+        "supports_streaming": stream_result["supports_streaming"],
+        "supports_vision": vision_result["supports_vision"],
+        "supported_temperatures": temp_result["supported_temperatures"],
+        "uses_max_tokens": uses_max_tokens,
+        "errors": errors if errors else []
+    }
+
+
+def compare_with_registry(probed_models: dict, registry: OpenAIModelRegistry) -> dict:
+    """Compare probed results with current registry."""
+    registered_models = set(registry.get_registered_models())
+    probed_model_names = set(probed_models.keys())
+
+    # Find new models (in API but not registry)
+    new_models = sorted(probed_model_names - registered_models)
+
+    # Find removed models (in registry but not in any API model)
+    removed_models = sorted(registered_models - probed_model_names)
+
+    # Find capability changes for models in both sets
+    capability_changes = {}
+    for model_name in sorted(probed_model_names & registered_models):
+        probed = probed_models[model_name]
+        registered_caps = registry.get_model_capabilities(model_name)
+
+        changes = {}
+
+        # Compare model type
+        reg_type = registered_caps.model_type.value
+        if probed["model_type"] != reg_type and probed["model_type"] != "unknown":
+            changes["model_type"] = {"was": reg_type, "now": probed["model_type"]}
+
+        # Compare tools support
+        if probed["supports_tools"] != registered_caps.supports_tools:
+            changes["supports_tools"] = {
+                "was": registered_caps.supports_tools,
+                "now": probed["supports_tools"]
+            }
+
+        # Compare streaming support
+        if probed["supports_streaming"] != registered_caps.supports_streaming:
+            changes["supports_streaming"] = {
+                "was": registered_caps.supports_streaming,
+                "now": probed["supports_streaming"]
+            }
+
+        # Compare vision support
+        if probed["supports_vision"] != registered_caps.supports_vision:
+            changes["supports_vision"] = {
+                "was": registered_caps.supports_vision,
+                "now": probed["supports_vision"]
+            }
+
+        # Compare temperature support
+        reg_temps = registered_caps.supported_temperatures
+        probed_temps = probed["supported_temperatures"]
+        if reg_temps != probed_temps:
+            changes["supported_temperatures"] = {
+                "was": reg_temps,
+                "now": probed_temps
+            }
+
+        if changes:
+            capability_changes[model_name] = changes
+
+    return {
+        "new_models": new_models,
+        "removed_models": removed_models,
+        "capability_changes": capability_changes
+    }
+
+
+def main():
+    cheap_mode = "--cheap" in sys.argv
+
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        print("ERROR: OPENAI_API_KEY environment variable not set")
+        sys.exit(1)
+
+    client = OpenAI(api_key=api_key)
+
+    print("Fetching available OpenAI models...")
+    all_models = sorted([m.id for m in client.models.list()])
+    print(f"Found {len(all_models)} models total")
+
+    # Separate into categories
+    models_to_probe = []
+    models_skipped = []
+
+    for model_id in all_models:
+        if should_skip_model(model_id):
+            models_skipped.append(model_id)
+        elif is_chat_model_candidate(model_id) or is_embedding_model(model_id):
+            models_to_probe.append(model_id)
+        else:
+            models_skipped.append(model_id)
+
+    print(f"\nWill probe {len(models_to_probe)} models, skipping {len(models_skipped)}")
+    if cheap_mode:
+        print("Running in --cheap mode (skipping expensive model families)")
+
+    # Probe each model
+    probed_results = {}
+    for model_id in models_to_probe:
+        result = probe_model(client, model_id, cheap_mode)
+        if result is not None:
+            probed_results[model_id] = result
+        time.sleep(0.5)  # Rate limit between models
+
+    # Compare with registry
+    print("\nComparing with current registry...")
+    registry = OpenAIModelRegistry()
+    comparison = compare_with_registry(probed_results, registry)
+
+    # Build report
+    report = {
+        "audit_date": datetime.now(timezone.utc).isoformat(),
+        "cheap_mode": cheap_mode,
+        "api_models_available": all_models,
+        "models_skipped": models_skipped,
+        "models_probed": probed_results,
+        "comparison": comparison
+    }
+
+    # Write report
+    report_path = os.path.join(
+        os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+        "openai_model_audit_report.json"
+    )
+    with open(report_path, "w") as f:
+        json.dump(report, f, indent=2, default=str)
+
+    print(f"\nReport written to: {report_path}")
+
+    # Print summary
+    print("\n=== AUDIT SUMMARY ===")
+    print(f"Models in API: {len(all_models)}")
+    print(f"Models probed: {len(probed_results)}")
+    print(f"Models skipped: {len(models_skipped)}")
+
+    if comparison["new_models"]:
+        print(f"\nNew models (not in registry): {len(comparison['new_models'])}")
+        for m in comparison["new_models"]:
+            caps = probed_results.get(m, {})
+            print(f"  + {m} (type={caps.get('model_type', '?')}, "
+                  f"tools={caps.get('supports_tools', '?')}, "
+                  f"stream={caps.get('supports_streaming', '?')})")
+
+    if comparison["removed_models"]:
+        print(f"\nRemoved models (in registry, not in API): {len(comparison['removed_models'])}")
+        for m in comparison["removed_models"]:
+            print(f"  - {m}")
+
+    if comparison["capability_changes"]:
+        print(f"\nCapability changes: {len(comparison['capability_changes'])}")
+        for model, changes in comparison["capability_changes"].items():
+            print(f"  ~ {model}:")
+            for field, diff in changes.items():
+                print(f"      {field}: {diff['was']} -> {diff['now']}")
+
+    if not comparison["new_models"] and not comparison["removed_models"] and not comparison["capability_changes"]:
+        print("\nNo discrepancies found - registry is up to date!")
+
+
+if __name__ == "__main__":
+    main()

mojentic/llm/gateways/openai_model_registry.py

@@ -35,6 +35,9 @@ class ModelCapabilities:
     max_context_tokens: Optional[int] = None
     max_output_tokens: Optional[int] = None
     supported_temperatures: Optional[List[float]] = None  # None means all temperatures supported
+    supports_chat_api: bool = True
+    supports_completions_api: bool = False
+    supports_responses_api: bool = False
 
     def get_token_limit_param(self) -> str:
         """Get the correct parameter name for token limits based on model type."""
@@ -67,30 +70,34 @@ class OpenAIModelRegistry:
     def _initialize_default_models(self):
         """Initialize the registry with known OpenAI models and their capabilities."""
 
-        # Reasoning Models (o1, o3, o4, gpt-5 series) - Updated 2025-09-28
+        # Reasoning Models (o1, o3, o4, gpt-5 series) - Updated 2026-02-04
         reasoning_models = [
-            "o1", "o1-2024-12-17", "o1-mini", "o1-mini-2024-09-12",
+            "o1", "o1-2024-12-17",
             "o1-pro", "o1-pro-2025-03-19",
             "o3", "o3-2025-04-16", "o3-deep-research", "o3-deep-research-2025-06-26",
             "o3-mini", "o3-mini-2025-01-31", "o3-pro", "o3-pro-2025-06-10",
             "o4-mini", "o4-mini-2025-04-16", "o4-mini-deep-research",
             "o4-mini-deep-research-2025-06-26",
-            "gpt-5", "gpt-5-2025-08-07", "gpt-5-chat-latest", "gpt-5-codex",
-            "gpt-5-mini", "gpt-5-mini-2025-08-07", "gpt-5-nano", "gpt-5-nano-2025-08-07"
+            "gpt-5", "gpt-5-2025-08-07", "gpt-5-codex",
+            "gpt-5-mini", "gpt-5-mini-2025-08-07", "gpt-5-nano", "gpt-5-nano-2025-08-07",
+            "gpt-5-pro", "gpt-5-pro-2025-10-06",
+            "gpt-5.1", "gpt-5.1-2025-11-13", "gpt-5.1-chat-latest",
+            "gpt-5.2", "gpt-5.2-2025-12-11", "gpt-5.2-chat-latest"
         ]
 
         for model in reasoning_models:
             # Deep research models and GPT-5 might have different capabilities
             is_deep_research = "deep-research" in model
             is_gpt5 = "gpt-5" in model
-            is_o1_series = model.startswith("o1")
-            is_o3_series = model.startswith("o3")
-            is_o4_series = model.startswith("o4")
+            is_gpt5_1 = "gpt-5.1" in model
+            is_gpt5_2 = "gpt-5.2" in model
+            is_gpt5_pro = "gpt-5-pro" in model and not is_gpt5_2
             is_mini_or_nano = ("mini" in model or "nano" in model)
+            is_chat_latest = "chat-latest" in model
 
-            # GPT-5 models may support more features than o1/o3/o4
-            supports_tools = is_gpt5  # GPT-5 might support tools
-            supports_streaming = is_gpt5  # GPT-5 might support streaming
+            # ALL reasoning models now support tools and streaming (except gpt-5-pro which is responses-only)
+            supports_tools = not is_gpt5_pro
+            supports_streaming = not is_gpt5_pro
 
             # Set context and output tokens based on model tier
             if is_gpt5:
@@ -104,15 +111,20 @@ class OpenAIModelRegistry:
                 output_tokens = 32768
 
             # Temperature restrictions based on model series
-            if is_gpt5 or is_o1_series or is_o4_series:
-                # GPT-5, o1, and o4 series only support temperature=1.0
-                supported_temps = [1.0]
-            elif is_o3_series:
-                # o3 series doesn't support temperature parameter at all
-                supported_temps = []
-            else:
-                # Other reasoning models support all temperatures
+            # All reasoning models now support only temperature=1.0 (o3 now supports it too)
+            if is_gpt5_1 and not is_chat_latest:
+                # gpt-5.1 and gpt-5.1-2025-11-13 support all temperatures
+                supported_temps = None
+            elif is_gpt5_2 and not is_chat_latest:
+                # gpt-5.2 and gpt-5.2-2025-12-11 support all temperatures
                 supported_temps = None
+            else:
+                # All other reasoning models (including o1, o3, o4, gpt-5, and *-chat-latest) support only temp=1.0
+                supported_temps = [1.0]
+
+            # API endpoint support flags
+            is_responses_only = "pro" in model or "deep-research" in model or model == "gpt-5-codex"
+            is_both_endpoint = model in ("gpt-5.1", "gpt-5.1-2025-11-13")
 
             self._models[model] = ModelCapabilities(
                 model_type=ModelType.REASONING,
@@ -121,11 +133,14 @@ class OpenAIModelRegistry:
                 supports_vision=False,  # Vision support would need to be confirmed for GPT-5
                 max_context_tokens=context_tokens,
                 max_output_tokens=output_tokens,
-                supported_temperatures=supported_temps
+                supported_temperatures=supported_temps,
+                supports_chat_api=not is_responses_only,
+                supports_completions_api=is_both_endpoint,
+                supports_responses_api=is_responses_only
             )
 
-        # Chat Models (GPT-4 and GPT-4.1 series) - Updated 2025-09-28
-        # Note: GPT-5 series moved to reasoning models
+        # Chat Models (GPT-4 and GPT-4.1 series) - Updated 2026-02-04
+        # Note: Most GPT-5 series moved to reasoning models; gpt-5-chat-latest is chat
         gpt4_and_newer_models = [
             "chatgpt-4o-latest",
             "gpt-4", "gpt-4-0125-preview", "gpt-4-0613", "gpt-4-1106-preview",
@@ -133,7 +148,7 @@ class OpenAIModelRegistry:
             "gpt-4.1", "gpt-4.1-2025-04-14", "gpt-4.1-mini", "gpt-4.1-mini-2025-04-14",
             "gpt-4.1-nano", "gpt-4.1-nano-2025-04-14",
             "gpt-4o", "gpt-4o-2024-05-13", "gpt-4o-2024-08-06", "gpt-4o-2024-11-20",
-            "gpt-4o-audio-preview", "gpt-4o-audio-preview-2024-10-01",
+            "gpt-4o-audio-preview",
             "gpt-4o-audio-preview-2024-12-17", "gpt-4o-audio-preview-2025-06-03",
             "gpt-4o-mini", "gpt-4o-mini-2024-07-18",
             "gpt-4o-mini-audio-preview", "gpt-4o-mini-audio-preview-2024-12-17",
@@ -143,18 +158,37 @@ class OpenAIModelRegistry:
             "gpt-4o-realtime-preview", "gpt-4o-realtime-preview-2024-10-01",
             "gpt-4o-realtime-preview-2024-12-17", "gpt-4o-realtime-preview-2025-06-03",
             "gpt-4o-search-preview", "gpt-4o-search-preview-2025-03-11",
-            "gpt-4o-transcribe"
+            "gpt-4o-transcribe",
+            "gpt-5-chat-latest",
+            "gpt-5-search-api", "gpt-5-search-api-2025-10-14"
         ]
 
         for model in gpt4_and_newer_models:
             # Determine capabilities based on model features
-            vision_support = ("gpt-4o" in model or "audio-preview" in model or "realtime" in model)
+            is_chatgpt_latest = model == "chatgpt-4o-latest"
             is_mini_or_nano = ("mini" in model or "nano" in model)
-            is_audio = "audio" in model or "realtime" in model or "transcribe" in model
+            is_audio = "audio" in model or "realtime" in model or "transcribe" in model or "tts" in model
+            is_search = "search" in model
             is_gpt41 = "gpt-4.1" in model
+            is_gpt5_chat = model == "gpt-5-chat-latest"
+            is_gpt5_search = "gpt-5-search-api" in model
+            is_nano_base = model == "gpt-4.1-nano"
+            # Note: Keep vision=True for gpt-4o models (audit probe limitation with 1x1 PNG)
+            # Exclude chatgpt-4o-latest, audio/search/transcribe/tts/realtime variants
+            vision_support = ("gpt-4o" in model and not is_chatgpt_latest and not is_audio and not is_search)
+
+            # Tool support: disabled for audio models, search models, chatgpt-4o-latest, and gpt-4.1-nano
+            supports_tools = not (is_audio or is_search or is_chatgpt_latest or is_nano_base)
+            # Streaming: disabled for audio models only
+            supports_streaming = not is_audio
+            # Temperature restrictions for search models
+            supported_temps = [] if is_search else None
 
             # Set context and output tokens based on model tier
-            if is_gpt41:
+            if is_gpt5_chat or is_gpt5_search:
+                context_tokens = 300000
+                output_tokens = 50000
+            elif is_gpt41:
                 context_tokens = 200000 if not is_mini_or_nano else 128000
                 output_tokens = 32768 if not is_mini_or_nano else 16384
             elif "gpt-4o" in model:
@@ -164,33 +198,42 @@ class OpenAIModelRegistry:
                 context_tokens = 32000
                 output_tokens = 8192
 
+            # API endpoint support flags
+            is_both_endpoint = model in ("gpt-4.1-nano", "gpt-4.1-nano-2025-04-14",
+                                         "gpt-4o-mini", "gpt-4o-mini-2024-07-18")
+
             self._models[model] = ModelCapabilities(
                 model_type=ModelType.CHAT,
-                supports_tools=True,
-                supports_streaming=not is_audio,  # Audio models may not support streaming
+                supports_tools=supports_tools,
+                supports_streaming=supports_streaming,
                 supports_vision=vision_support,
                 max_context_tokens=context_tokens,
-                max_output_tokens=output_tokens
+                max_output_tokens=output_tokens,
+                supported_temperatures=supported_temps,
+                supports_completions_api=is_both_endpoint
             )
 
-        # Chat Models (GPT-3.5 series) - Updated 2025-09-28
+        # Chat Models (GPT-3.5 series) - Updated 2026-02-04
         gpt35_models = [
             "gpt-3.5-turbo", "gpt-3.5-turbo-0125", "gpt-3.5-turbo-1106",
             "gpt-3.5-turbo-16k", "gpt-3.5-turbo-instruct", "gpt-3.5-turbo-instruct-0914"
         ]
 
         for model in gpt35_models:
+            is_instruct = "instruct" in model
             context_tokens = 16385 if "16k" not in model else 16385
             self._models[model] = ModelCapabilities(
                 model_type=ModelType.CHAT,
-                supports_tools="instruct" not in model,  # Instruct models don't support tools
-                supports_streaming="instruct" not in model,  # Instruct models don't support streaming
+                supports_tools=not is_instruct,  # Instruct models don't support tools
+                supports_streaming=not is_instruct,  # Instruct models don't support streaming
                 supports_vision=False,
                 max_context_tokens=context_tokens,
-                max_output_tokens=4096
+                max_output_tokens=4096,
+                supports_chat_api=not is_instruct,
+                supports_completions_api=is_instruct
             )
 
-        # Embedding Models - Updated 2025-09-28
+        # Embedding Models - Updated 2026-02-04
         embedding_models = [
             "text-embedding-3-large", "text-embedding-3-small", "text-embedding-ada-002"
         ]
@@ -200,15 +243,61 @@ class OpenAIModelRegistry:
                 model_type=ModelType.EMBEDDING,
                 supports_tools=False,
                 supports_streaming=False,
-                supports_vision=False
+                supports_vision=False,
+                supports_chat_api=False
             )
 
-        # Pattern mappings for unknown models - Updated 2025-09-28
+        # Legacy & Codex Models - Updated 2026-02-05
+        self._models["babbage-002"] = ModelCapabilities(
+            model_type=ModelType.CHAT,
+            supports_tools=False,
+            supports_streaming=False,
+            supports_vision=False,
+            supports_chat_api=False,
+            supports_completions_api=True
+        )
+
+        self._models["davinci-002"] = ModelCapabilities(
+            model_type=ModelType.CHAT,
+            supports_tools=False,
+            supports_streaming=False,
+            supports_vision=False,
+            supports_chat_api=False,
+            supports_completions_api=True
+        )
+
+        self._models["gpt-5.1-codex-mini"] = ModelCapabilities(
+            model_type=ModelType.REASONING,
+            supports_tools=False,
+            supports_streaming=False,
+            supports_vision=False,
+            max_context_tokens=128000,
+            max_output_tokens=32768,
+            supported_temperatures=[1.0],
+            supports_chat_api=False,
+            supports_completions_api=True
+        )
+
+        self._models["codex-mini-latest"] = ModelCapabilities(
+            model_type=ModelType.REASONING,
+            supports_tools=False,
+            supports_streaming=False,
+            supports_vision=False,
+            max_context_tokens=128000,
+            max_output_tokens=32768,
+            supported_temperatures=[1.0],
+            supports_chat_api=False,
+            supports_responses_api=True
+        )
+
+        # Pattern mappings for unknown models - Updated 2026-02-04
         self._pattern_mappings = {
             "o1": ModelType.REASONING,
             "o3": ModelType.REASONING,
             "o4": ModelType.REASONING,
             "gpt-5": ModelType.REASONING,  # GPT-5 is a reasoning model
+            "gpt-5.1": ModelType.REASONING,
+            "gpt-5.2": ModelType.REASONING,
             "gpt-4": ModelType.CHAT,
             "gpt-4.1": ModelType.CHAT,
             "gpt-3.5": ModelType.CHAT,
@@ -262,28 +351,40 @@ class OpenAIModelRegistry:
                 model_type=ModelType.REASONING,
                 supports_tools=False,
                 supports_streaming=False,
-                supports_vision=False
+                supports_vision=False,
+                supports_chat_api=True,
+                supports_completions_api=False,
+                supports_responses_api=False
             )
         elif model_type == ModelType.CHAT:
             return ModelCapabilities(
                 model_type=ModelType.CHAT,
                 supports_tools=True,
                 supports_streaming=True,
-                supports_vision=False
+                supports_vision=False,
+                supports_chat_api=True,
+                supports_completions_api=False,
+                supports_responses_api=False
             )
         elif model_type == ModelType.EMBEDDING:
             return ModelCapabilities(
                 model_type=ModelType.EMBEDDING,
                 supports_tools=False,
                 supports_streaming=False,
-                supports_vision=False
+                supports_vision=False,
+                supports_chat_api=False,
+                supports_completions_api=False,
+                supports_responses_api=False
             )
         else:  # MODERATION
             return ModelCapabilities(
                 model_type=ModelType.MODERATION,
                 supports_tools=False,
                 supports_streaming=False,
-                supports_vision=False
+                supports_vision=False,
+                supports_chat_api=False,
+                supports_completions_api=False,
+                supports_responses_api=False
             )
 
     def is_reasoning_model(self, model_name: str) -> bool:

mojentic/llm/gateways/openai_model_registry_spec.py

@@ -22,9 +22,10 @@ class DescribeOpenAIModelRegistry:
         registry = OpenAIModelRegistry()
         registered_models = registry.get_registered_models()
 
-        # Check that we have reasoning models
+        # Check that we have reasoning models (o1-mini removed in 2026-02-04 audit)
         assert "o1" in registered_models
-        assert "o1-mini" in registered_models
+        assert "o3" in registered_models
+        assert "gpt-5" in registered_models
 
         # Check that we have chat models
         assert "gpt-4o" in registered_models
@@ -43,15 +44,17 @@ class DescribeOpenAIModelRegistry:
         """
         registry = OpenAIModelRegistry()
 
-        # Test known reasoning models
-        assert registry.is_reasoning_model("o1-preview") is True
-        assert registry.is_reasoning_model("o1-mini") is True
+        # Test known reasoning models (o1-mini removed, o1-preview uses pattern matching)
+        assert registry.is_reasoning_model("o1") is True
         assert registry.is_reasoning_model("o3-mini") is True
+        assert registry.is_reasoning_model("gpt-5") is True
+        assert registry.is_reasoning_model("gpt-5.1") is True
 
         # Test chat models
         assert registry.is_reasoning_model("gpt-4o") is False
         assert registry.is_reasoning_model("gpt-4o-mini") is False
         assert registry.is_reasoning_model("gpt-3.5-turbo") is False
+        assert registry.is_reasoning_model("gpt-5-chat-latest") is False
 
     def should_use_pattern_matching_for_unknown_models(self):
         """
@@ -80,7 +83,7 @@ class DescribeOpenAIModelRegistry:
         registry = OpenAIModelRegistry()
 
         # Reasoning models should use max_completion_tokens
-        o1_capabilities = registry.get_model_capabilities("o1-mini")
+        o1_capabilities = registry.get_model_capabilities("o1")
         assert o1_capabilities.get_token_limit_param() == "max_completion_tokens"
 
         # Chat models should use max_tokens
@@ -178,3 +181,167 @@ class DescribeOpenAIModelRegistry:
         assert ModelType.CHAT.value == "chat"
         assert ModelType.EMBEDDING.value == "embedding"
         assert ModelType.MODERATION.value == "moderation"
+
+    def should_support_tools_and_streaming_for_all_reasoning_models(self):
+        """
+        Given reasoning models as of 2026-02-04 audit
+        When checking their capabilities
+        Then all should support tools and streaming except gpt-5-pro
+        """
+        registry = OpenAIModelRegistry()
+
+        # All o1/o3/o4 models now support tools and streaming
+        o1_caps = registry.get_model_capabilities("o1")
+        assert o1_caps.supports_tools is True
+        assert o1_caps.supports_streaming is True
+
+        o3_caps = registry.get_model_capabilities("o3")
+        assert o3_caps.supports_tools is True
+        assert o3_caps.supports_streaming is True
+
+        o3_mini_caps = registry.get_model_capabilities("o3-mini")
+        assert o3_mini_caps.supports_tools is True
+        assert o3_mini_caps.supports_streaming is True
+
+        # GPT-5 family (except gpt-5-pro) supports tools and streaming
+        gpt5_caps = registry.get_model_capabilities("gpt-5")
+        assert gpt5_caps.supports_tools is True
+        assert gpt5_caps.supports_streaming is True
+
+        # gpt-5-pro is responses-only, no tools/streaming
+        gpt5_pro_caps = registry.get_model_capabilities("gpt-5-pro")
+        assert gpt5_pro_caps.supports_tools is False
+        assert gpt5_pro_caps.supports_streaming is False
+
+    def should_support_temperature_1_0_only_for_most_reasoning_models(self):
+        """
+        Given reasoning models as of 2026-02-04 audit
+        When checking temperature support
+        Then most should support only temperature=1.0, except gpt-5.1/5.2 base models
+        """
+        registry = OpenAIModelRegistry()
+
+        # o1/o3/o4 series support only temperature=1.0
+        o1_caps = registry.get_model_capabilities("o1")
+        assert o1_caps.supported_temperatures == [1.0]
+        assert o1_caps.supports_temperature(1.0) is True
+        assert o1_caps.supports_temperature(0.7) is False
+
+        o3_caps = registry.get_model_capabilities("o3")
+        assert o3_caps.supported_temperatures == [1.0]
+
+        # gpt-5.1 and gpt-5.1-2025-11-13 support all temperatures
+        gpt5_1_caps = registry.get_model_capabilities("gpt-5.1")
+        assert gpt5_1_caps.supported_temperatures is None
+        assert gpt5_1_caps.supports_temperature(0.7) is True
+        assert gpt5_1_caps.supports_temperature(1.0) is True
+
+        # gpt-5.1-chat-latest supports only temperature=1.0
+        gpt5_1_chat_caps = registry.get_model_capabilities("gpt-5.1-chat-latest")
+        assert gpt5_1_chat_caps.supported_temperatures == [1.0]
+
+        # gpt-5.2 and gpt-5.2-2025-12-11 support all temperatures
+        gpt5_2_caps = registry.get_model_capabilities("gpt-5.2")
+        assert gpt5_2_caps.supported_temperatures is None
+
+        # gpt-5.2-chat-latest supports only temperature=1.0
+        gpt5_2_chat_caps = registry.get_model_capabilities("gpt-5.2-chat-latest")
+        assert gpt5_2_chat_caps.supported_temperatures == [1.0]
+
+    def should_disable_tools_for_specific_chat_models(self):
+        """
+        Given chat models as of 2026-02-04 audit
+        When checking tool support
+        Then specific models should have tools disabled
+        """
+        registry = OpenAIModelRegistry()
+
+        # chatgpt-4o-latest does not support tools
+        chatgpt_caps = registry.get_model_capabilities("chatgpt-4o-latest")
+        assert chatgpt_caps.supports_tools is False
+        assert chatgpt_caps.supports_vision is False
+
+        # gpt-4.1-nano does not support tools
+        nano_caps = registry.get_model_capabilities("gpt-4.1-nano")
+        assert nano_caps.supports_tools is False
+
+        # Search models do not support tools and have no temperature support
+        search_caps = registry.get_model_capabilities("gpt-4o-search-preview")
+        assert search_caps.supports_tools is False
+        assert search_caps.supported_temperatures == []
+        assert search_caps.supports_temperature(1.0) is False
+
+        gpt5_search_caps = registry.get_model_capabilities("gpt-5-search-api")
+        assert gpt5_search_caps.supports_tools is False
+        assert gpt5_search_caps.supported_temperatures == []
+
+        # Audio models do not support tools or streaming
+        audio_caps = registry.get_model_capabilities("gpt-4o-audio-preview")
+        assert audio_caps.supports_tools is False
+        assert audio_caps.supports_streaming is False
+
+
+class DescribeAPIEndpointSupport:
+
+    def should_flag_chat_only_model(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("gpt-4")
+        assert caps.supports_chat_api is True
+        assert caps.supports_completions_api is False
+        assert caps.supports_responses_api is False
+
+    def should_flag_both_endpoint_model(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("gpt-4o-mini")
+        assert caps.supports_chat_api is True
+        assert caps.supports_completions_api is True
+        assert caps.supports_responses_api is False
+
+    def should_flag_completions_only_model(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("gpt-3.5-turbo-instruct")
+        assert caps.supports_chat_api is False
+        assert caps.supports_completions_api is True
+        assert caps.supports_responses_api is False
+
+    def should_flag_responses_only_model(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("gpt-5-pro")
+        assert caps.supports_chat_api is False
+        assert caps.supports_completions_api is False
+        assert caps.supports_responses_api is True
+
+    def should_flag_legacy_completions_model(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("babbage-002")
+        assert caps.supports_chat_api is False
+        assert caps.supports_completions_api is True
+        assert caps.supports_responses_api is False
+
+    def should_flag_embedding_model_with_no_endpoints(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("text-embedding-3-large")
+        assert caps.supports_chat_api is False
+        assert caps.supports_completions_api is False
+        assert caps.supports_responses_api is False
+
+    def should_flag_codex_mini_latest_as_responses_only(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("codex-mini-latest")
+        assert caps.supports_chat_api is False
+        assert caps.supports_completions_api is False
+        assert caps.supports_responses_api is True
+
+    def should_flag_gpt51_as_both_chat_and_completions(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("gpt-5.1")
+        assert caps.supports_chat_api is True
+        assert caps.supports_completions_api is True
+        assert caps.supports_responses_api is False
+
+    def should_include_endpoint_flags_in_default_capabilities(self):
+        registry = OpenAIModelRegistry()
+        caps = registry.get_model_capabilities("completely-unknown-model-xyz")
+        assert caps.supports_chat_api is True
+        assert caps.supports_completions_api is False
+        assert caps.supports_responses_api is False

mojentic/llm/gateways/openai_temperature_handling_spec.py

@@ -88,16 +88,16 @@ class DescribeOpenAIGatewayTemperatureHandling:
             call_args = mock_openai_client.chat.completions.create.call_args
             assert call_args[1]['temperature'] == 0.1
 
-        def should_automatically_adjust_unsupported_temperature_for_o1_mini(self, openai_gateway, mock_openai_client):
+        def should_automatically_adjust_unsupported_temperature_for_o1(self, openai_gateway, mock_openai_client):
             """
-            Given an o1-mini model that only supports temperature=1.0
+            Given an o1 model that only supports temperature=1.0
             When calling complete with temperature=0.1 (unsupported)
             Then it should automatically adjust to temperature=1.0
             """
             messages = [LLMMessage(role=MessageRole.User, content="Test message")]
 
             openai_gateway.complete(
-                model="o1-mini",
+                model="o1",
                 messages=messages,
                 temperature=0.1
             )
@@ -124,11 +124,11 @@ class DescribeOpenAIGatewayTemperatureHandling:
             call_args = mock_openai_client.chat.completions.create.call_args
             assert call_args[1]['temperature'] == 1.0
 
-        def should_remove_temperature_parameter_for_o3_mini(self, openai_gateway, mock_openai_client):
+        def should_automatically_adjust_unsupported_temperature_for_o3_mini(self, openai_gateway, mock_openai_client):
             """
-            Given an o3-mini model that doesn't support temperature parameter at all
-            When calling complete with temperature=0.1
-            Then it should remove the temperature parameter entirely
+            Given an o3-mini model that only supports temperature=1.0
+            When calling complete with temperature=0.1 (unsupported)
+            Then it should automatically adjust to temperature=1.0
             """
             messages = [LLMMessage(role=MessageRole.User, content="Test message")]
 
@@ -138,9 +138,9 @@ class DescribeOpenAIGatewayTemperatureHandling:
                 temperature=0.1
             )
 
-            # Verify the API was called without temperature parameter
+            # Verify the API was called with temperature=1.0, not 0.1
             call_args = mock_openai_client.chat.completions.create.call_args
-            assert 'temperature' not in call_args[1]
+            assert call_args[1]['temperature'] == 1.0
 
 
 class DescribeModelCapabilitiesTemperatureRestrictions:
@@ -178,14 +178,14 @@ class DescribeModelCapabilitiesTemperatureRestrictions:
     def should_identify_all_gpt5_variants_temperature_restrictions(self):
         """
         Given the model registry
-        When checking all GPT-5 variant models
-        Then they should all have temperature restrictions to 1.0 only
+        When checking GPT-5 reasoning variant models
+        Then they should have temperature restrictions to 1.0 only
+        Note: gpt-5-chat-latest is a CHAT model and supports all temperatures
         """
         registry = get_model_registry()
-        gpt5_models = [
+        gpt5_reasoning_models = [
             "gpt-5",
             "gpt-5-2025-08-07",
-            "gpt-5-chat-latest",
             "gpt-5-codex",
             "gpt-5-mini",
             "gpt-5-mini-2025-08-07",
@@ -193,7 +193,7 @@ class DescribeModelCapabilitiesTemperatureRestrictions:
             "gpt-5-nano-2025-08-07"
         ]
 
-        for model in gpt5_models:
+        for model in gpt5_reasoning_models:
             capabilities = registry.get_model_capabilities(model)
             assert capabilities.supports_temperature(1.0) is True
             assert capabilities.supports_temperature(0.1) is False
@@ -204,9 +204,10 @@ class DescribeModelCapabilitiesTemperatureRestrictions:
         Given the model registry
         When checking o1 series models
         Then they should have temperature restrictions to 1.0 only
+        Note: o1-mini removed from API as of 2026-02-04 audit
         """
         registry = get_model_registry()
-        o1_models = ["o1", "o1-mini", "o1-pro", "o1-2024-12-17"]
+        o1_models = ["o1", "o1-pro", "o1-2024-12-17", "o1-pro-2025-03-19"]
 
         for model in o1_models:
             capabilities = registry.get_model_capabilities(model)
@@ -214,20 +215,21 @@ class DescribeModelCapabilitiesTemperatureRestrictions:
             assert capabilities.supports_temperature(0.1) is False
             assert capabilities.supported_temperatures == [1.0]
 
-    def should_identify_o3_series_no_temperature_support(self):
+    def should_identify_o3_series_temperature_restrictions(self):
         """
         Given the model registry
         When checking o3 series models
-        Then they should not support temperature parameter at all
+        Then they should now support temperature=1.0 only (as of 2026-02-04 audit)
         """
         registry = get_model_registry()
-        o3_models = ["o3", "o3-mini", "o3-pro", "o3-deep-research"]
+        o3_models = ["o3", "o3-mini", "o3-pro", "o3-deep-research", "o3-2025-04-16",
+                     "o3-mini-2025-01-31", "o3-pro-2025-06-10", "o3-deep-research-2025-06-26"]
 
         for model in o3_models:
             capabilities = registry.get_model_capabilities(model)
-            assert capabilities.supports_temperature(1.0) is False
+            assert capabilities.supports_temperature(1.0) is True
             assert capabilities.supports_temperature(0.1) is False
-            assert capabilities.supported_temperatures == []
+            assert capabilities.supported_temperatures == [1.0]
 
     def should_identify_o4_series_temperature_restrictions(self):
         """

{mojentic-1.0.1.dist-info → mojentic-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mojentic
-Version: 1.0.1
+Version: 1.1.1
 Summary: Mojentic is an agentic framework that aims to provide a simple and flexible way to assemble teams of agents to solve complex problems.
 Author-email: Stacey Vetzal <stacey@vetzal.com>
 Project-URL: Homepage, https://github.com/svetzal/mojentic
@@ -13,15 +13,17 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: structlog>=25.5.0
-Requires-Dist: numpy>=2.3.5
+Requires-Dist: numpy>=2.4.2
 Requires-Dist: ollama>=0.6.1
-Requires-Dist: openai>=2.12.0
-Requires-Dist: anthropic>=0.75.0
+Requires-Dist: openai>=2.16.0
+Requires-Dist: anthropic>=0.77.1
 Requires-Dist: tiktoken>=0.12.0
 Requires-Dist: parsedatetime>=2.6
 Requires-Dist: pytz>=2025.2
 Requires-Dist: serpapi>=0.1.5
 Requires-Dist: colorama>=0.4.6
+Requires-Dist: filelock>=3.20.1
+Requires-Dist: urllib3>=2.6.0
 Provides-Extra: dev
 Requires-Dist: pytest>=9.0.2; extra == "dev"
 Requires-Dist: pytest-asyncio>=1.3.0; extra == "dev"
@@ -29,14 +31,14 @@ Requires-Dist: pytest-spec>=5.2.0; extra == "dev"
 Requires-Dist: pytest-cov>=7.0.0; extra == "dev"
 Requires-Dist: pytest-mock>=3.15.0; extra == "dev"
 Requires-Dist: flake8>=7.3.0; extra == "dev"
-Requires-Dist: bandit>=1.9.2; extra == "dev"
+Requires-Dist: bandit>=1.9.3; extra == "dev"
 Requires-Dist: pip-audit>=2.10.0; extra == "dev"
 Requires-Dist: mkdocs>=1.6.1; extra == "dev"
-Requires-Dist: mkdocs-material>=9.7.0; extra == "dev"
+Requires-Dist: mkdocs-material>=9.7.1; extra == "dev"
 Requires-Dist: mkdocs-llmstxt>=0.4.0; extra == "dev"
-Requires-Dist: mkdocstrings[python]>=0.21.0; extra == "dev"
-Requires-Dist: griffe-fieldz>=0.3.0; extra == "dev"
-Requires-Dist: pymdown-extensions>=10.3; extra == "dev"
+Requires-Dist: mkdocstrings[python]>=1.0.2; extra == "dev"
+Requires-Dist: griffe-fieldz>=0.4.0; extra == "dev"
+Requires-Dist: pymdown-extensions>=10.20.1; extra == "dev"
 Dynamic: license-file
 
 # Mojentic

{mojentic-1.0.1.dist-info → mojentic-1.1.1.dist-info}/RECORD

@@ -1,6 +1,7 @@
 _examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 _examples/async_dispatcher_example.py,sha256=Iy01lFd3NTKdgeFc6wMRGFD9FTNH7LEd9nGMtzrbXVo,8592
 _examples/async_llm_example.py,sha256=WPb6ML_xXCSuRMbYWs-w2X28tzj9EosFiQv31gAAPBo,8627
+_examples/audit_openai_capabilities.py,sha256=RqTveROc1EZRi-2ilO79Qn7qRzTwpfeIr6VjycZ70zc,18492
 _examples/broker_as_tool.py,sha256=ixcz8wuhdTZS-0OR9L1CeBMsrKz6SBBAaDhwAoD60e4,3195
 _examples/broker_examples.py,sha256=eheXbzoslI9x_sPEt399hkxpDRI_VkscHL-br1LJqD4,2388
 _examples/broker_image_examples.py,sha256=NGuZQ0x28winv0Sxw7ClBvqj8oD1tdbADITVjXIF0yk,1126
@@ -93,10 +94,10 @@ mojentic/llm/gateways/ollama_messages_adapter_spec.py,sha256=gVRbWDrHOa1EiZ0CkEW
 mojentic/llm/gateways/openai.py,sha256=S19AIooYoBZYELVPrSeOwKslpYc7jrhu-sLjDXUFF3w,23161
 mojentic/llm/gateways/openai_message_adapter_spec.py,sha256=3nObWsf6cPuWuCK_IhrQoRdQdz7gndqeSSvJIxtQkp8,6609
 mojentic/llm/gateways/openai_messages_adapter.py,sha256=Scal68JKKdBHB35ok1c5DeWYdD6Wra5oXSsPxJyyXSQ,3947
-mojentic/llm/gateways/openai_model_registry.py,sha256=0_X7YE48Hri9Sp8Ao440-2gqUoPl9xY5M0wMn733u2U,14041
-mojentic/llm/gateways/openai_model_registry_spec.py,sha256=p7eiGZrgX7NIkRkraqFXA3WODnGAsIhqq9rVM98Z5qA,6698
+mojentic/llm/gateways/openai_model_registry.py,sha256=2tIT_L8g4opEgLRvhpOy_w47W83Xp_slki2rl3xnteo,18585
+mojentic/llm/gateways/openai_model_registry_spec.py,sha256=w9nkWRnND_Bhzb061O1UKD9nCsUJsqgclP0tPbmbHzs,14192
 mojentic/llm/gateways/openai_spec.py,sha256=eazIk8bLQ2d9CNPGhcw0WedX7CZz-TEkmwGz74c39CM,4161
-mojentic/llm/gateways/openai_temperature_handling_spec.py,sha256=9KU4L9Zqdvot0yBfGPNREOsSIAOjvR7v88s_f_bq1kw,9928
+mojentic/llm/gateways/openai_temperature_handling_spec.py,sha256=jK4R3w6xhxEB8C-vdAGFjGNSH7qdrq3B5OABjZf8868,10199
 mojentic/llm/gateways/tokenizer_gateway.py,sha256=ztuqfunlJ6xmyUPPHcC_69-kegiNJD6jdSEde7hDh2w,485
 mojentic/llm/registry/__init__.py,sha256=FFokdoVYhtHslv-hZekONfG8ZdNA11Tto9chFLFVImE,71
 mojentic/llm/registry/llm_registry.py,sha256=beyrgGrkXx5ZckUJzC1nQ461vra0fF6s_qRaEdi5bsg,2508
@@ -142,8 +143,8 @@ mojentic/tracer/tracer_system.py,sha256=KPSVIfGVOjSx6Vj_SvrisqJXKT6ddwBc_UCMQC6D
 mojentic/tracer/tracer_system_spec.py,sha256=8hpQlmAWyjUvk7ihy339L0buQ-eH5rluaFvyMl-mSH4,8830
 mojentic/utils/__init__.py,sha256=WvNYbtVeliMZn2sMX53CrOQlQLJBXi4mJNoocG7s_kI,116
 mojentic/utils/formatting.py,sha256=YtXh0aYzLB9GKP8ZD6u1By1OBqPOXUtHirtq0GmHNag,948
-mojentic-1.0.1.dist-info/licenses/LICENSE.md,sha256=txSgV8n5zY1W3NiF5HHsCwlaW0e8We1cSC6TuJUqxXA,1060
-mojentic-1.0.1.dist-info/METADATA,sha256=-5_SMLRWZTgDjAMo4DNnkdaGyDIjxxtER_4dOFvlpKk,8711
-mojentic-1.0.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-mojentic-1.0.1.dist-info/top_level.txt,sha256=Q-BvPQ8Eu1jnEqK8Xkr6A9C8Xa1z38oPZRHuA5MCTqg,19
-mojentic-1.0.1.dist-info/RECORD,,
+mojentic-1.1.1.dist-info/licenses/LICENSE.md,sha256=txSgV8n5zY1W3NiF5HHsCwlaW0e8We1cSC6TuJUqxXA,1060
+mojentic-1.1.1.dist-info/METADATA,sha256=eb6l0htqFLfD-plqA90rn9UrdN_bHSUVSGsoB7-ILuY,8775
+mojentic-1.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+mojentic-1.1.1.dist-info/top_level.txt,sha256=Q-BvPQ8Eu1jnEqK8Xkr6A9C8Xa1z38oPZRHuA5MCTqg,19
+mojentic-1.1.1.dist-info/RECORD,,