llmshim 0.1.2__py3-none-win_amd64.whl

llmshim/__init__.py

@@ -0,0 +1,17 @@
+"""
+llmshim — Multi-provider LLM gateway for Python.
+
+Usage:
+    import llmshim
+
+    llmshim.configure(anthropic="sk-ant-...", openai="sk-...")
+    resp = llmshim.chat("claude-sonnet-4-6", "Hello!")
+    print(resp["message"]["content"])
+
+The proxy server starts automatically on first use and stops on exit.
+"""
+
+from llmshim._client import chat, stream, models, health, configure
+
+__all__ = ["chat", "stream", "models", "health", "configure"]
+__version__ = "0.1.2"

llmshim/_client.py

@@ -0,0 +1,246 @@
+"""
+llmshim module-level API.
+
+import llmshim
+resp = llmshim.chat("claude-sonnet-4-6", "Hello!")
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Generator, Optional
+
+import httpx
+
+from llmshim._server import ensure_server
+
+_base_url: Optional[str] = None
+_http: Optional[httpx.Client] = None
+_timeout: float = 120.0
+
+
+def _get_base_url() -> str:
+    global _base_url
+    if _base_url is None:
+        _base_url = ensure_server()
+    return _base_url
+
+
+def _get_http() -> httpx.Client:
+    global _http
+    if _http is None:
+        _http = httpx.Client(timeout=_timeout)
+    return _http
+
+
+def configure(
+    *,
+    openai: Optional[str] = None,
+    anthropic: Optional[str] = None,
+    gemini: Optional[str] = None,
+    xai: Optional[str] = None,
+) -> None:
+    """Configure API keys. Writes to ~/.llmshim/config.toml.
+
+    Keys are persistent — configure once, use everywhere.
+    Only provided keys are updated; others are left unchanged.
+
+    Usage:
+        import llmshim
+        llmshim.configure(anthropic="sk-ant-...", openai="sk-...")
+    """
+    config_dir = Path.home() / ".llmshim"
+    config_path = config_dir / "config.toml"
+
+    # Read existing config
+    existing: dict[str, Any] = {}
+    if config_path.exists():
+        try:
+            import tomllib  # Python 3.11+
+        except ImportError:
+            tomllib = None  # type: ignore
+        if tomllib:
+            try:
+                with open(config_path, "rb") as f:
+                    existing = tomllib.load(f)
+            except Exception:
+                pass
+
+    keys = existing.get("keys", {})
+    if openai is not None:
+        keys["openai"] = openai
+    if anthropic is not None:
+        keys["anthropic"] = anthropic
+    if gemini is not None:
+        keys["gemini"] = gemini
+    if xai is not None:
+        keys["xai"] = xai
+
+    # Write back
+    config_dir.mkdir(parents=True, exist_ok=True)
+    lines = ["[keys]"]
+    for key, val in keys.items():
+        if val:
+            lines.append(f'{key} = "{val}"')
+    if "proxy" in existing:
+        lines.append("")
+        lines.append("[proxy]")
+        proxy = existing["proxy"]
+        if "host" in proxy:
+            lines.append(f'host = "{proxy["host"]}"')
+        if "port" in proxy:
+            lines.append(f"port = {proxy['port']}")
+
+    config_path.write_text("\n".join(lines) + "\n")
+
+    # Also set as env vars for the current process (so server picks them up)
+    if openai:
+        os.environ["OPENAI_API_KEY"] = openai
+    if anthropic:
+        os.environ["ANTHROPIC_API_KEY"] = anthropic
+    if gemini:
+        os.environ["GEMINI_API_KEY"] = gemini
+    if xai:
+        os.environ["XAI_API_KEY"] = xai
+
+    # If server is already running, it won't pick up new keys until restart.
+    # Force restart on next call.
+    global _base_url
+    from llmshim._server import _stop_server
+
+    _stop_server()
+    _base_url = None
+
+
+def chat(
+    model: str,
+    messages: str | list[dict[str, Any]],
+    *,
+    max_tokens: Optional[int] = None,
+    temperature: Optional[float] = None,
+    reasoning_effort: Optional[str] = None,
+    provider_config: Optional[dict[str, Any]] = None,
+    fallback: Optional[list[str]] = None,
+) -> dict[str, Any]:
+    """Send a chat completion request.
+
+    Args:
+        model: Model ID (e.g., "anthropic/claude-sonnet-4-6" or "claude-sonnet-4-6")
+        messages: A string (single user message) or list of message dicts
+        max_tokens: Maximum output tokens
+        temperature: Sampling temperature
+        reasoning_effort: "low", "medium", or "high"
+        provider_config: Raw provider-specific JSON
+        fallback: Ordered list of fallback model IDs
+
+    Returns:
+        Response dict with keys: id, model, provider, message, usage, latency_ms
+
+    Usage:
+        resp = llmshim.chat("claude-sonnet-4-6", "What is Rust?")
+        print(resp["message"]["content"])
+    """
+    if isinstance(messages, str):
+        msgs = [{"role": "user", "content": messages}]
+    else:
+        msgs = messages
+
+    body: dict[str, Any] = {"model": model, "messages": msgs}
+
+    config: dict[str, Any] = {}
+    if max_tokens is not None:
+        config["max_tokens"] = max_tokens
+    if temperature is not None:
+        config["temperature"] = temperature
+    if reasoning_effort is not None:
+        config["reasoning_effort"] = reasoning_effort
+    if config:
+        body["config"] = config
+
+    if provider_config is not None:
+        body["provider_config"] = provider_config
+    if fallback is not None:
+        body["fallback"] = fallback
+
+    resp = _get_http().post(f"{_get_base_url()}/v1/chat", json=body)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def stream(
+    model: str,
+    messages: str | list[dict[str, Any]],
+    *,
+    max_tokens: Optional[int] = None,
+    temperature: Optional[float] = None,
+    reasoning_effort: Optional[str] = None,
+    provider_config: Optional[dict[str, Any]] = None,
+) -> Generator[dict[str, Any], None, None]:
+    """Stream a chat completion. Yields typed event dicts.
+
+    Event types: content, reasoning, tool_call, usage, done, error
+
+    Usage:
+        for event in llmshim.stream("claude-sonnet-4-6", "Write a poem"):
+            if event["type"] == "content":
+                print(event["text"], end="")
+    """
+    if isinstance(messages, str):
+        msgs = [{"role": "user", "content": messages}]
+    else:
+        msgs = messages
+
+    body: dict[str, Any] = {"model": model, "messages": msgs}
+
+    config: dict[str, Any] = {}
+    if max_tokens is not None:
+        config["max_tokens"] = max_tokens
+    if temperature is not None:
+        config["temperature"] = temperature
+    if reasoning_effort is not None:
+        config["reasoning_effort"] = reasoning_effort
+    if config:
+        body["config"] = config
+
+    if provider_config is not None:
+        body["provider_config"] = provider_config
+
+    with httpx.stream(
+        "POST",
+        f"{_get_base_url()}/v1/chat/stream",
+        json=body,
+        timeout=_timeout,
+    ) as resp:
+        resp.raise_for_status()
+        current_event = ""
+        for line in resp.iter_lines():
+            if line.startswith("event: "):
+                current_event = line[7:]
+            elif line.startswith("data: "):
+                data = json.loads(line[6:])
+                data["type"] = current_event or data.get("type", "")
+                yield data
+
+
+def models() -> list[dict[str, str]]:
+    """List available models.
+
+    Returns:
+        List of dicts with keys: id, provider, name
+    """
+    resp = _get_http().get(f"{_get_base_url()}/v1/models")
+    resp.raise_for_status()
+    return resp.json()["models"]
+
+
+def health() -> dict[str, Any]:
+    """Health check.
+
+    Returns:
+        Dict with keys: status, providers
+    """
+    resp = _get_http().get(f"{_get_base_url()}/health")
+    resp.raise_for_status()
+    return resp.json()

llmshim/_server.py

@@ -0,0 +1,172 @@
+"""
+Auto-managed llmshim proxy server.
+
+Starts the bundled Rust binary on a random port, waits for it to be ready,
+and stops it on process exit. The server is shared across all LlmShim
+instances in the same process.
+"""
+
+import atexit
+import os
+import platform
+import signal
+import socket
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+_server_process = None
+_server_port = None
+
+
+def _find_binary() -> str:
+    """Find the llmshim binary. Checks in order:
+    1. Bundled in the package (clients/python/llmshim/bin/)
+    2. On PATH (e.g., installed via cargo install)
+    3. In the repo's target/release/ directory
+    """
+    bin_name = "llmshim.exe" if platform.system() == "Windows" else "llmshim"
+    pkg_dir = Path(__file__).parent
+
+    # 1. Python scripts directory (where maturin/pip installs binaries)
+    import sysconfig
+    scripts_dir = sysconfig.get_path("scripts")
+    if scripts_dir:
+        candidate = Path(scripts_dir) / bin_name
+        if candidate.exists() and os.access(str(candidate), os.X_OK):
+            return str(candidate)
+
+    # 2. Bundled in package (dev installs, manual copy)
+    bundled = pkg_dir / "bin" / bin_name
+    if bundled.exists() and os.access(str(bundled), os.X_OK):
+        return str(bundled)
+
+    # 3. On PATH (cargo install)
+    import shutil
+    on_path = shutil.which("llmshim")
+    if on_path:
+        return on_path
+
+    # 4. Repo target directory (development)
+    for root in [pkg_dir.parent.parent.parent, pkg_dir.parent.parent]:
+        for build_dir in ["target/release", "target/debug"]:
+            candidate = root / build_dir / bin_name
+            if candidate.exists() and os.access(str(candidate), os.X_OK):
+                return str(candidate)
+
+    raise FileNotFoundError(
+        "llmshim binary not found. Install with:\n"
+        "  pip install llmshim          (includes the binary)\n"
+        "  cargo install llmshim        (from crates.io)\n"
+        "  cargo build --release --features proxy  (from source)"
+    )
+
+
+def _find_free_port() -> int:
+    """Find a free port on localhost."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def _wait_for_server(port: int, timeout: float = 10.0) -> bool:
+    """Wait until the server is accepting connections."""
+    start = time.time()
+    while time.time() - start < timeout:
+        try:
+            with socket.create_connection(("127.0.0.1", port), timeout=0.5):
+                return True
+        except (ConnectionRefusedError, OSError):
+            time.sleep(0.1)
+    return False
+
+
+def _stop_server():
+    """Stop the server process."""
+    global _server_process, _server_port
+    if _server_process is not None:
+        try:
+            _server_process.terminate()
+            _server_process.wait(timeout=5)
+        except Exception:
+            try:
+                _server_process.kill()
+            except Exception:
+                pass
+        _server_process = None
+        _server_port = None
+
+
+def ensure_server() -> str:
+    """Ensure the proxy server is running. Returns the base URL.
+
+    Starts the server automatically if not already running.
+    The server is stopped automatically on process exit.
+    """
+    global _server_process, _server_port
+
+    # Already running?
+    if _server_process is not None and _server_process.poll() is None:
+        return f"http://127.0.0.1:{_server_port}"
+
+    # Find binary
+    binary = _find_binary()
+
+    # Pick a free port
+    port = _find_free_port()
+
+    # Start the server
+    env = os.environ.copy()
+    env["LLMSHIM_HOST"] = "127.0.0.1"
+    env["LLMSHIM_PORT"] = str(port)
+
+    _server_process = subprocess.Popen(
+        [binary, "proxy"],
+        env=env,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.PIPE,
+    )
+
+    # Register cleanup
+    atexit.register(_stop_server)
+
+    # Also handle SIGTERM
+    try:
+        original_handler = signal.getsignal(signal.SIGTERM)
+        def _handle_sigterm(signum, frame):
+            _stop_server()
+            if callable(original_handler) and original_handler not in (signal.SIG_DFL, signal.SIG_IGN):
+                original_handler(signum, frame)
+            sys.exit(0)
+        signal.signal(signal.SIGTERM, _handle_sigterm)
+    except (ValueError, OSError):
+        pass  # Can't set signal handler in some contexts (e.g., threads)
+
+    # Wait for server to be ready
+    if not _wait_for_server(port):
+        stderr_output = ""
+        try:
+            stderr_output = _server_process.stderr.read().decode() if _server_process.stderr else ""
+        except Exception:
+            pass
+        _stop_server()
+
+        # Detect common errors and give helpful messages
+        if "No API keys found" in stderr_output:
+            raise RuntimeError(
+                "No API keys configured. Set them with:\n\n"
+                "  import llmshim\n"
+                "  llmshim.configure(anthropic='sk-ant-...', openai='sk-...')\n\n"
+                "Or from the command line:\n"
+                "  llmshim configure"
+            )
+
+        raise RuntimeError(
+            f"llmshim proxy failed to start on port {port}.\n"
+            f"Binary: {binary}\n"
+            f"stderr: {stderr_output}"
+        )
+
+    _server_port = port
+    return f"http://127.0.0.1:{port}"

llmshim-0.1.2.dist-info/METADATA

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: llmshim
+Version: 0.1.2
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: httpx>=0.24
+Summary: Multi-provider LLM gateway — one interface, every provider
+Home-Page: https://github.com/sanjay920/llmshim
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Project-URL: Homepage, https://github.com/sanjay920/llmshim
+Project-URL: Repository, https://github.com/sanjay920/llmshim
+
+# llmshim
+
+One interface, every LLM provider. The proxy server starts automatically — no setup needed.
+
+## Install
+
+```bash
+pip install llmshim
+```
+
+## Configure
+
+```python
+import llmshim
+
+# Set API keys (writes to ~/.llmshim/config.toml — only needed once)
+llmshim.configure(
+    anthropic="sk-ant-...",
+    openai="sk-...",
+    gemini="AIza...",
+    xai="xai-...",
+)
+```
+
+Or from the CLI: `llmshim configure`
+
+## Chat
+
+```python
+import llmshim
+
+resp = llmshim.chat("claude-sonnet-4-6", "What is Rust?")
+print(resp["message"]["content"])
+```
+
+With options:
+
+```python
+resp = llmshim.chat(
+    "openai/gpt-5.4",
+    "Explain quicksort",
+    max_tokens=500,
+    temperature=0.7,
+)
+```
+
+With message history:
+
+```python
+resp = llmshim.chat("claude-sonnet-4-6", [
+    {"role": "system", "content": "You are a pirate."},
+    {"role": "user", "content": "Hello!"},
+], max_tokens=500)
+```
+
+## Streaming
+
+```python
+for event in llmshim.stream("claude-sonnet-4-6", "Write a poem"):
+    if event["type"] == "content":
+        print(event["text"], end="", flush=True)
+    elif event["type"] == "reasoning":
+        pass  # thinking tokens
+    elif event["type"] == "usage":
+        print(f"\n[↑{event['input_tokens']} ↓{event['output_tokens']}]")
+```
+
+## Multi-Model Conversations
+
+Switch models mid-conversation. History carries over.
+
+```python
+messages = [{"role": "user", "content": "What is a closure?"}]
+
+r1 = llmshim.chat("claude-sonnet-4-6", messages, max_tokens=500)
+print(f"Claude: {r1['message']['content']}")
+
+messages.append({"role": "assistant", "content": r1["message"]["content"]})
+messages.append({"role": "user", "content": "Now explain differently."})
+
+r2 = llmshim.chat("gpt-5.4", messages, max_tokens=500)
+print(f"GPT: {r2['message']['content']}")
+```
+
+## Reasoning / Thinking
+
+```python
+resp = llmshim.chat(
+    "claude-sonnet-4-6",
+    "Solve: x^2 - 5x + 6 = 0",
+    max_tokens=4000,
+    reasoning_effort="high",
+)
+print(resp["reasoning"])        # thinking content
+print(resp["message"]["content"])  # answer
+```
+
+## Fallback Chains
+
+```python
+resp = llmshim.chat(
+    "anthropic/claude-sonnet-4-6",
+    "Hello",
+    max_tokens=100,
+    fallback=["openai/gpt-5.4", "gemini/gemini-3-flash-preview"],
+)
+```
+
+## Other
+
+```python
+llmshim.models()   # list available models
+llmshim.health()   # {"status": "ok", "providers": [...]}
+```
+
+## How It Works
+
+On first call, the package:
+1. Finds the `llmshim` binary (bundled, on PATH, or in repo)
+2. Starts the proxy on a random localhost port
+3. Routes your request through it
+4. Server stops automatically when Python exits
+
+No Docker, no background services, no manual server management.
+
+## Supported Models
+
+| Provider | Models |
+|----------|--------|
+| OpenAI | `gpt-5.4` |
+| Anthropic | `claude-opus-4-6`, `claude-sonnet-4-6`, `claude-haiku-4-5-20251001` |
+| Gemini | `gemini-3.1-pro-preview`, `gemini-3-flash-preview`, `gemini-3.1-flash-lite-preview` |
+| xAI | `grok-4-1-fast-reasoning`, `grok-4-1-fast-non-reasoning` |
+

llmshim-0.1.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+llmshim/__init__.py,sha256=IkkeWimsM5SKVQHTjYt7vzTEe_NKjGAuV4tmopq6BQA,485
+llmshim/_client.py,sha256=2PMEBY-iIBaFwB4hp2Gi-Rb6uTdPjbYm8I9CgGV_1bc,7162
+llmshim/_server.py,sha256=RNbopsB83BhYst9Yfbiu_b2m9iJOHWF6nxZkhUX7AeY,5500
+llmshim-0.1.2.data/scripts/llmshim.exe,sha256=_bL6XAePCHXVPISFeKgoZg5yQijZ-wdJBGgRV86AHfg,5669376
+llmshim-0.1.2.dist-info/METADATA,sha256=UNcWHAVX_SuWuXuLyFSbXLguJrNZlPBM-e-Q5BkUSaw,3802
+llmshim-0.1.2.dist-info/WHEEL,sha256=uJOc2U-Q1x95AlblQcqMRb3iR4QnPtdI7X2ycPN99rM,94
+llmshim-0.1.2.dist-info/sboms/llmshim.cyclonedx.json,sha256=jd2OJlouFEf0x-NhDGHqC3jDc8lhQxKRBoQYsjAe_Pc,186159
+llmshim-0.1.2.dist-info/RECORD,,

llmshim-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.12.6)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64