specsmith 0.3.0.dev128__tar.gz → 0.3.0.dev129__tar.gz

{specsmith-0.3.0.dev128/src/specsmith.egg-info → specsmith-0.3.0.dev129}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.3.0.dev128
+Version: 0.3.0.dev129
 Summary: Applied Epistemic Engineering toolkit — forge epistemically-governed scaffolds, stress-test belief systems, and run AEE pipelines.
 Author: BitConcepts
 License-Expression: MIT
@@ -41,12 +41,14 @@ Requires-Dist: types-pyyaml>=6.0; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: mkdocs>=1.6; extra == "docs"
 Requires-Dist: mkdocs-material>=9.5; extra == "docs"
-Provides-Extra: anthopic
-Requires-Dist: anthropic>=0.56; extra == "anthopic"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.56; extra == "anthropic"
 Provides-Extra: openai
 Requires-Dist: openai>=1.0; extra == "openai"
 Provides-Extra: gemini
 Requires-Dist: google-generativeai>=0.8; extra == "gemini"
+Provides-Extra: mistral
+Requires-Dist: openai>=1.0; extra == "mistral"
 Provides-Extra: agent
 Requires-Dist: anthropic>=0.56; extra == "agent"
 Requires-Dist: openai>=1.0; extra == "agent"

{specsmith-0.3.0.dev128 → specsmith-0.3.0.dev129}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specsmith"
-version = "0.3.0.dev128"
+version = "0.3.0.dev129"
 description = "Applied Epistemic Engineering toolkit — forge epistemically-governed scaffolds, stress-test belief systems, and run AEE pipelines."
 readme = "README.md"
 license = "MIT"
@@ -55,9 +55,10 @@ docs = [
     "mkdocs-material>=9.5",
 ]
 # LLM provider extras for specsmith run (agentic client)
-anthopic = ["anthropic>=0.56"]
+anthropic = ["anthropic>=0.56"]
 openai = ["openai>=1.0"]
 gemini = ["google-generativeai>=0.8"]
+mistral = ["openai>=1.0"]  # Mistral uses the openai SDK pointed at api.mistral.ai
 # Install all optional LLM providers
 agent = ["anthropic>=0.56", "openai>=1.0"]
 # Convenience bundle: everything

{specsmith-0.3.0.dev128 → specsmith-0.3.0.dev129}/src/specsmith/agent/providers/__init__.py

@@ -37,7 +37,7 @@ def get_provider(
     """Get a configured LLM provider.
 
     Args:
-        provider_name: "anthropic", "openai", "gemini", "ollama", or None (auto-detect)
+        provider_name: "anthropic", "openai", "gemini", "mistral", "ollama", or None (auto-detect)
         model: specific model name, or None (use tier default)
         tier: ModelTier.FAST / BALANCED / POWERFUL
         base_url: override API base URL (for OpenAI-compatible proxies)
@@ -76,6 +76,13 @@ def get_provider(
             model=resolved_model or "gemini-2.5-pro",
             api_key=api_key or os.environ.get("GOOGLE_API_KEY", ""),
         )
+    elif provider_name == "mistral":
+        from specsmith.agent.providers.mistral import MistralProvider
+
+        return MistralProvider(
+            model=resolved_model or "mistral-large-latest",
+            api_key=api_key or os.environ.get("MISTRAL_API_KEY", ""),
+        )
     elif provider_name == "ollama":
         from specsmith.agent.providers.ollama import OllamaProvider
 
@@ -85,7 +92,7 @@ def get_provider(
         )
     else:
         raise ValueError(
-            f"Unknown provider '{provider_name}'. Valid: anthropic, openai, gemini, ollama"
+            f"Unknown provider '{provider_name}'. Valid: anthropic, openai, gemini, mistral, ollama"
         )
 
 
@@ -101,6 +108,8 @@ def _auto_detect_provider() -> str:
         return "openai"
     if os.environ.get("GOOGLE_API_KEY"):
         return "gemini"
+    if os.environ.get("MISTRAL_API_KEY"):
+        return "mistral"
 
     # Try Ollama (no API key needed)
     import urllib.request
@@ -126,6 +135,7 @@ def list_providers() -> list[dict[str, str]]:
         ("anthropic", "ANTHROPIC_API_KEY"),
         ("openai", "OPENAI_API_KEY"),
         ("gemini", "GOOGLE_API_KEY"),
+        ("mistral", "MISTRAL_API_KEY"),
         ("ollama", ""),
     ]:
         if name == "ollama":

specsmith-0.3.0.dev129/src/specsmith/agent/providers/mistral.py

@@ -0,0 +1,175 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 BitConcepts, LLC. All rights reserved.
+"""Mistral AI provider for the specsmith agentic client.
+
+Mistral's API is OpenAI-compatible, so we use the openai SDK pointed at
+Mistral's endpoint.  Pixtral models support vision/OCR.
+
+Requires: pip install specsmith[mistral]
+
+Environment:
+    MISTRAL_API_KEY — your Mistral API key (https://console.mistral.ai/)
+
+Models:
+    mistral-large-latest       — most capable text model
+    mistral-small-latest       — fast, cheap
+    codestral-latest           — code-optimised (FIM support)
+    pixtral-large-latest       — vision + OCR (multimodal)
+    pixtral-12b-2409           — smaller vision model
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Any
+
+from specsmith.agent.core import (
+    CompletionResponse,
+    Message,
+    StreamToken,
+    Tool,
+)
+
+_MISTRAL_BASE_URL = "https://api.mistral.ai/v1"
+
+# Pixtral models that support image/document input (OCR use-cases)
+_VISION_MODELS = {"pixtral-large-latest", "pixtral-12b-2409", "pixtral-large-2411"}
+
+
+class MistralProvider:
+    """Mistral AI provider.  Uses the OpenAI-compatible chat completions API."""
+
+    provider_name = "mistral"
+
+    def __init__(self, model: str = "mistral-large-latest", api_key: str = "") -> None:
+        self.model = model
+        self._api_key = api_key
+        self._client: Any = None
+        self._ensure_client()
+
+    def _ensure_client(self) -> None:
+        try:
+            import openai
+
+            self._client = openai.OpenAI(
+                api_key=self._api_key or "placeholder",
+                base_url=_MISTRAL_BASE_URL,
+            )
+        except ImportError as e:
+            from specsmith.agent.core import ProviderNotAvailable
+
+            raise ProviderNotAvailable("mistral", "openai") from e
+
+    def is_available(self) -> bool:
+        try:
+            import openai  # noqa: F401
+
+            return bool(self._api_key)
+        except ImportError:
+            return False
+
+    @property
+    def supports_vision(self) -> bool:
+        return self.model in _VISION_MODELS
+
+    def complete(
+        self,
+        messages: list[Message],
+        tools: list[Tool] | None = None,
+        max_tokens: int = 4096,
+    ) -> CompletionResponse:
+        msgs = [m.to_dict() for m in messages]
+        kwargs: dict[str, Any] = {
+            "model": self.model,
+            "messages": msgs,
+            "max_tokens": max_tokens,
+        }
+        if tools:
+            kwargs["tools"] = [t.to_openai_schema() for t in tools]
+            kwargs["tool_choice"] = "auto"
+
+        response = self._client.chat.completions.create(**kwargs)
+        choice = response.choices[0]
+        content = choice.message.content or ""
+
+        tool_calls: list[dict[str, Any]] = []
+        if choice.message.tool_calls:
+            for tc in choice.message.tool_calls:
+                import json
+
+                tool_calls.append(
+                    {
+                        "id": tc.id,
+                        "name": tc.function.name,
+                        "input": json.loads(tc.function.arguments or "{}"),
+                    }
+                )
+
+        usage = response.usage
+        return CompletionResponse(
+            content=content,
+            model=response.model,
+            input_tokens=usage.prompt_tokens if usage else 0,
+            output_tokens=usage.completion_tokens if usage else 0,
+            tool_calls=tool_calls,
+            stop_reason=choice.finish_reason or "stop",
+        )
+
+    def stream(
+        self,
+        messages: list[Message],
+        tools: list[Tool] | None = None,
+        max_tokens: int = 4096,
+    ) -> Iterator[StreamToken]:
+        msgs = [m.to_dict() for m in messages]
+        kwargs: dict[str, Any] = {
+            "model": self.model,
+            "messages": msgs,
+            "max_tokens": max_tokens,
+            "stream": True,
+        }
+        stream = self._client.chat.completions.create(**kwargs)
+        for chunk in stream:
+            delta = chunk.choices[0].delta if chunk.choices else None
+            if delta and delta.content:
+                yield StreamToken(text=delta.content)
+        yield StreamToken(text="", is_final=True)
+
+    def ocr_image(self, image_path: str, prompt: str = "Extract all text from this image.") -> str:
+        """Extract text from an image using a Pixtral vision model.
+
+        Automatically switches to pixtral-large-latest if current model is text-only.
+        """
+        import base64
+        from pathlib import Path
+
+        model = self.model if self.supports_vision else "pixtral-large-latest"
+        img_bytes = Path(image_path).read_bytes()
+        b64 = base64.b64encode(img_bytes).decode()
+
+        # Detect MIME type from extension
+        ext = Path(image_path).suffix.lower()
+        mime_map = {
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".png": "image/png",
+            ".gif": "image/gif",
+            ".webp": "image/webp",
+            ".pdf": "application/pdf",
+        }
+        mime = mime_map.get(ext, "image/png")
+
+        response = self._client.chat.completions.create(
+            model=model,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "image_url", "image_url": {"url": f"data:{mime};base64,{b64}"}},
+                        {"type": "text", "text": prompt},
+                    ],
+                }
+            ],
+            max_tokens=4096,
+        )
+        return response.choices[0].message.content or ""

{specsmith-0.3.0.dev128 → specsmith-0.3.0.dev129}/src/specsmith/agent/runner.py

@@ -320,26 +320,23 @@ class AgentRunner:
         return final_response
 
     def _call_provider(self, messages: list[Message], silent: bool = False) -> CompletionResponse:
-        """Call the LLM provider, streaming if enabled."""
-        provider: Any = self._provider  # provider is typed as Any at runtime for flexibility
-        if self._stream and not silent:
-            # Stream the response
+        """Call the LLM provider, streaming if enabled.
+
+        Streaming is disabled when tools are registered because the streaming
+        path cannot reliably capture tool_call blocks from the response.
+        Non-streaming is always used for tool-bearing turns.
+        """
+        provider: Any = self._provider
+        use_stream = self._stream and not silent and not self._tools
+        if use_stream:
             accumulated = ""
-            for token in provider.stream(messages, tools=self._tools):
+            for token in provider.stream(messages, tools=None):
                 if token.text:
                     self._print(token.text, end="", flush=True)
                     accumulated += token.text
                 if token.is_final:
                     self._print()
-            # Re-call non-streaming for tool detection (some providers don't support tool streaming)
-            # For now, do a second call if we didn't get tool calls
-            if not accumulated.strip():
-                return cast(CompletionResponse, provider.complete(messages, tools=self._tools))
-            # Return a synthetic response with the streamed content
-            return CompletionResponse(
-                content=accumulated,
-                model=str(provider.model),
-            )
+            return CompletionResponse(content=accumulated, model=str(provider.model))
         else:
             response = cast(CompletionResponse, provider.complete(messages, tools=self._tools))
             if not silent and response.content:

{specsmith-0.3.0.dev128 → specsmith-0.3.0.dev129}/src/specsmith/agent/tools.py

@@ -16,6 +16,10 @@ Tool categories:
 
 from __future__ import annotations
 
+import fnmatch
+import os
+import platform
+import re
 import subprocess
 import sys
 from pathlib import Path
@@ -316,6 +320,100 @@ def build_tool_registry(project_dir: str = ".") -> list[Tool]:
             ],
             handler=lambda path, lines="": _read_file_handler(pd, path, lines),
         ),
+        # ----------------------------------------------------------------
+        # File system write tools
+        # ----------------------------------------------------------------
+        Tool(
+            name="write_file",
+            description=(
+                "Write content to a file (creates or overwrites). "
+                "Use for editing source code, docs, config files, etc. "
+                "Path is relative to project root."
+            ),
+            params=[
+                ToolParam("path", "File path relative to project root"),
+                ToolParam("content", "Full content to write to the file"),
+            ],
+            handler=lambda path, content: _write_file_handler(pd, path, content),
+        ),
+        Tool(
+            name="list_dir",
+            description=(
+                "List files and directories. Shows names, sizes, and types. "
+                "Use to explore project structure before reading files."
+            ),
+            params=[
+                ToolParam(
+                    "path",
+                    "Directory path relative to project root (default: root)",
+                    required=False,
+                ),
+                ToolParam(
+                    "pattern",
+                    "Glob pattern to filter (e.g. '*.py', '*.md')",
+                    required=False,
+                ),
+            ],
+            handler=lambda path=".", pattern="": _list_dir_handler(pd, path, pattern),
+        ),
+        Tool(
+            name="grep_files",
+            description=(
+                "Search for a regex pattern across files in the project. "
+                "Returns matching lines with file:line references. "
+                "Essential for finding where things are defined or used."
+            ),
+            params=[
+                ToolParam("pattern", "Regex pattern to search for"),
+                ToolParam(
+                    "path",
+                    "Directory or file to search (relative to root, default: root)",
+                    required=False,
+                ),
+                ToolParam(
+                    "glob",
+                    "File glob filter e.g. '*.py' (default: all text files)",
+                    required=False,
+                ),
+                ToolParam(
+                    "ignore_case",
+                    "'true' for case-insensitive search",
+                    required=False,
+                ),
+            ],
+            handler=lambda pattern, path=".", glob="", ignore_case="false": _grep_handler(
+                pd, pattern, path, glob, ignore_case
+            ),
+        ),
+        # ----------------------------------------------------------------
+        # Shell execution — the most powerful tool
+        # ----------------------------------------------------------------
+        Tool(
+            name="run_command",
+            description=(
+                "Execute a shell command in the project directory and return stdout+stderr. "
+                "Use for: running tests (pytest), linting (ruff), building, git operations, "
+                "installing packages, checking file contents with CLI tools, anything. "
+                "Cross-platform: automatically uses PowerShell on Windows, bash on Linux/macOS. "
+                "Commands run with a 120-second timeout."
+            ),
+            params=[
+                ToolParam("command", "The shell command to execute"),
+                ToolParam(
+                    "working_dir",
+                    "Working directory relative to project root (default: root)",
+                    required=False,
+                ),
+                ToolParam(
+                    "timeout",
+                    "Timeout in seconds (default 120, max 300)",
+                    required=False,
+                ),
+            ],
+            handler=lambda command, working_dir=".", timeout="120": _run_command_handler(
+                pd, command, working_dir, timeout
+            ),
+        ),
     ]
 
     return tools
@@ -350,5 +448,207 @@ def _read_file_handler(project_dir: str, path: str, lines: str = "") -> str:
         return f"[ERROR] {e}"
 
 
+def _write_file_handler(project_dir: str, path: str, content: str) -> str:
+    """Write content to a file within the project directory."""
+    root = Path(project_dir).resolve()
+    target = (root / path).resolve()
+    try:
+        target.relative_to(root)
+    except ValueError:
+        return f"[ERROR] Path '{path}' is outside the project directory"
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(content, encoding="utf-8")
+        size = len(content.encode("utf-8"))
+        lines = content.count("\n") + 1
+        return f"Written: {path} ({lines} lines, {size} bytes)"
+    except Exception as e:  # noqa: BLE001
+        return f"[ERROR] {e}"
+
+
+def _list_dir_handler(project_dir: str, path: str = ".", pattern: str = "") -> str:
+    """List directory contents within the project."""
+    root = Path(project_dir).resolve()
+    target = (root / path).resolve()
+    try:
+        target.relative_to(root)
+    except ValueError:
+        return f"[ERROR] Path '{path}' is outside the project directory"
+    if not target.exists():
+        return f"[NOT FOUND] {path}"
+    if not target.is_dir():
+        return f"[NOT A DIR] {path}"
+    try:
+        entries = sorted(target.iterdir(), key=lambda p: (p.is_file(), p.name.lower()))
+        lines = []
+        for entry in entries:
+            if pattern and not fnmatch.fnmatch(entry.name, pattern):
+                continue
+            if entry.is_dir():
+                lines.append(f"  {'DIR':>6}  {entry.name}/")
+            else:
+                size = entry.stat().st_size
+                size_str = f"{size:,}" if size < 1_000_000 else f"{size // 1024:,}K"
+                lines.append(f"  {size_str:>6}  {entry.name}")
+        header = f"{path}/" if not path.endswith("/") else path
+        return f"{header}\n" + "\n".join(lines) if lines else f"{header} (empty)"
+    except Exception as e:  # noqa: BLE001
+        return f"[ERROR] {e}"
+
+
+def _grep_handler(
+    project_dir: str,
+    pattern: str,
+    path: str = ".",
+    glob: str = "",
+    ignore_case: str = "false",
+) -> str:
+    """Search for a regex pattern in files within the project."""
+    root = Path(project_dir).resolve()
+    target = (root / path).resolve()
+    try:
+        target.relative_to(root)
+    except ValueError:
+        return f"[ERROR] Path '{path}' is outside the project directory"
+
+    flags = re.IGNORECASE if ignore_case.lower() == "true" else 0
+    try:
+        compiled = re.compile(pattern, flags)
+    except re.error as e:
+        return f"[ERROR] Invalid regex: {e}"
+
+    _TEXT_EXTENSIONS = {
+        ".py",
+        ".md",
+        ".txt",
+        ".yml",
+        ".yaml",
+        ".toml",
+        ".json",
+        ".js",
+        ".ts",
+        ".html",
+        ".css",
+        ".sh",
+        ".ps1",
+        ".cmd",
+        ".bat",
+        ".rs",
+        ".go",
+        ".c",
+        ".cpp",
+        ".h",
+        ".java",
+        ".rb",
+        ".php",
+        ".tf",
+        ".ini",
+        ".cfg",
+        ".conf",
+    }
+    _SKIP_DIRS = {".git", "__pycache__", ".venv", "node_modules", ".mypy_cache", "dist", "build"}
+
+    results: list[str] = []
+    files_searched = 0
+
+    def search_file(fp: Path) -> None:
+        nonlocal files_searched
+        if glob and not fnmatch.fnmatch(fp.name, glob):
+            return
+        if not glob and fp.suffix.lower() not in _TEXT_EXTENSIONS:
+            return
+        try:
+            text = fp.read_text(encoding="utf-8", errors="ignore")
+            files_searched += 1
+            rel = fp.relative_to(root)
+            for i, line in enumerate(text.splitlines(), 1):
+                if compiled.search(line):
+                    results.append(f"{rel}:{i}: {line.rstrip()}")
+                    if len(results) >= 200:
+                        return
+        except Exception:  # noqa: BLE001
+            pass
+
+    if target.is_file():
+        search_file(target)
+    else:
+        for dirpath, dirnames, filenames in os.walk(target):
+            dirnames[:] = [d for d in dirnames if d not in _SKIP_DIRS]
+            for fname in sorted(filenames):
+                search_file(Path(dirpath) / fname)
+                if len(results) >= 200:
+                    break
+            if len(results) >= 200:
+                break
+
+    if not results:
+        return f"No matches for '{pattern}' in {files_searched} file(s) searched."
+    summary = f"{len(results)} match(es) across {files_searched} file(s):"
+    if len(results) >= 200:
+        summary += " (truncated at 200)"
+    return summary + "\n" + "\n".join(results)
+
+
+def _run_command_handler(
+    project_dir: str,
+    command: str,
+    working_dir: str = ".",
+    timeout: str = "120",
+) -> str:
+    """Execute a shell command and return combined stdout+stderr."""
+    root = Path(project_dir).resolve()
+    cwd = (root / working_dir).resolve()
+    try:
+        cwd.relative_to(root)
+    except ValueError:
+        return f"[ERROR] working_dir '{working_dir}' is outside the project directory"
+
+    try:
+        timeout_secs = min(int(timeout), 300)
+    except (ValueError, TypeError):
+        timeout_secs = 120
+
+    # Choose shell based on platform
+    is_windows = platform.system() == "Windows"
+    if is_windows:
+        shell_cmd = ["powershell", "-NoProfile", "-NonInteractive", "-Command", command]
+    else:
+        shell_cmd = ["bash", "-c", command]
+
+    try:
+        result = subprocess.run(
+            shell_cmd,
+            capture_output=True,
+            text=True,
+            cwd=str(cwd),
+            timeout=timeout_secs,
+        )
+        output = (result.stdout + result.stderr).strip()
+        exit_info = f"[exit {result.returncode}]" if result.returncode != 0 else "[exit 0]"
+        if len(output) > 12000:
+            output = output[:12000] + f"\n...(truncated, {len(output)} total chars)"
+        return f"{exit_info}\n{output}" if output else exit_info
+    except subprocess.TimeoutExpired:
+        return f"[TIMEOUT] Command exceeded {timeout_secs}s"
+    except FileNotFoundError:
+        # Shell not found (e.g. bash on Windows) — fall back
+        try:
+            result = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                cwd=str(cwd),
+                timeout=timeout_secs,
+                shell=True,  # noqa: S602
+            )
+            output = (result.stdout + result.stderr).strip()
+            rc = result.returncode
+            return f"[exit {rc}]\n{output}" if output else f"[exit {rc}]"
+        except Exception as e2:  # noqa: BLE001
+            return f"[ERROR] {e2}"
+    except Exception as e:  # noqa: BLE001
+        return f"[ERROR] {e}"
+
+
 def get_tool_by_name(tools: list[Tool], name: str) -> Tool | None:
     return next((t for t in tools if t.name == name), None)

{specsmith-0.3.0.dev128 → specsmith-0.3.0.dev129/src/specsmith.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specsmith
-Version: 0.3.0.dev128
+Version: 0.3.0.dev129
 Summary: Applied Epistemic Engineering toolkit — forge epistemically-governed scaffolds, stress-test belief systems, and run AEE pipelines.
 Author: BitConcepts
 License-Expression: MIT
@@ -41,12 +41,14 @@ Requires-Dist: types-pyyaml>=6.0; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: mkdocs>=1.6; extra == "docs"
 Requires-Dist: mkdocs-material>=9.5; extra == "docs"
-Provides-Extra: anthopic
-Requires-Dist: anthropic>=0.56; extra == "anthopic"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.56; extra == "anthropic"
 Provides-Extra: openai
 Requires-Dist: openai>=1.0; extra == "openai"
 Provides-Extra: gemini
 Requires-Dist: google-generativeai>=0.8; extra == "gemini"
+Provides-Extra: mistral
+Requires-Dist: openai>=1.0; extra == "mistral"
 Provides-Extra: agent
 Requires-Dist: anthropic>=0.56; extra == "agent"
 Requires-Dist: openai>=1.0; extra == "agent"

{specsmith-0.3.0.dev128 → specsmith-0.3.0.dev129}/src/specsmith.egg-info/SOURCES.txt

@@ -58,6 +58,7 @@ src/specsmith/agent/profiles/verifier.md
 src/specsmith/agent/providers/__init__.py
 src/specsmith/agent/providers/anthropic.py
 src/specsmith/agent/providers/gemini.py
+src/specsmith/agent/providers/mistral.py
 src/specsmith/agent/providers/ollama.py
 src/specsmith/agent/providers/openai.py
 src/specsmith/commands/__init__.py

{specsmith-0.3.0.dev128 → specsmith-0.3.0.dev129}/src/specsmith.egg-info/requires.txt

@@ -16,7 +16,7 @@ pytest-cov>=4.0
 ruff>=0.4
 mypy>=1.10
 
-[anthopic]
+[anthropic]
 anthropic>=0.56
 
 [dev]
@@ -34,5 +34,8 @@ mkdocs-material>=9.5
 [gemini]
 google-generativeai>=0.8
 
+[mistral]
+openai>=1.0
+
 [openai]
 openai>=1.0