fj-llm 0.2.0__py3-none-any.whl

fj_llm/__init__.py

@@ -0,0 +1,9 @@
+"""
+FJ_LLM (LLM Tools) - Unified interface for multiple LLM providers
+"""
+
+from .client import LLMClient, LLMResponse
+
+__version__ = "0.2.0"
+__all__ = ["LLMClient", "LLMResponse"]
+

fj_llm/client.py

@@ -0,0 +1,405 @@
+#!/usr/bin/env python3
+"""
+Unified LLM Client Interface
+Supports multiple LLM providers with a consistent API
+"""
+
+import json
+import logging
+import os
+import time
+import yaml
+import requests
+from typing import Dict, Any, Optional
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+_logger = logging.getLogger("fj_llm")
+
+_DEFAULT_COST_LOG = Path("~/.local/share/fj_llm/costs.jsonl").expanduser()
+
+
+class QuotaExceededError(Exception):
+    """API quota exhausted — non-retryable, triggers fallback model."""
+    pass
+
+
+@dataclass
+class LLMResponse:
+    """Standardized response format"""
+    content: str
+    model: str
+    input_tokens: Optional[int] = None
+    output_tokens: Optional[int] = None
+    total_tokens: Optional[int] = None
+    cost: Optional[float] = None
+    success: bool = True
+    error: Optional[str] = None
+
+
+class LLMClient:
+    def __init__(self, config_path: str = "~/.config/fj_llm/config.yaml", config_dict: Optional[Dict] = None):
+        """
+        Initialize LLM Client with flexible config loading.
+        Priority: config_dict → FJ_LLM_CONFIG env var → config file
+        """
+        self.session = requests.Session()
+
+        if config_dict:
+            self.config = config_dict
+        else:
+            self.config_path = Path(config_path).expanduser()
+            self.config = self._load_config()
+
+        cost_log_env = os.getenv("FJ_LLM_COST_LOG")
+        cost_log_cfg = self.config.get("cost_log")
+        if cost_log_env:
+            self._cost_log = Path(cost_log_env)
+        elif cost_log_cfg:
+            self._cost_log = Path(cost_log_cfg).expanduser()
+        else:
+            self._cost_log = _DEFAULT_COST_LOG
+
+    def _load_config(self) -> Dict[str, Any]:
+        env_config = os.getenv("FJ_LLM_CONFIG")
+        if env_config:
+            try:
+                return json.loads(env_config)
+            except json.JSONDecodeError as e:
+                _logger.warning("Failed to parse FJ_LLM_CONFIG: %s", e)
+
+        if not self.config_path.exists():
+            self._create_default_config()
+
+        with open(self.config_path, "r") as f:
+            return yaml.safe_load(f)
+
+    def _create_default_config(self):
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        default_config = {
+            "models": {
+                "deepseek-light": {
+                    "provider": "deepseek",
+                    "model_name": "deepseek-chat",
+                    "api_key_env": "DEEPSEEK_API_KEY",
+                    "base_url": "https://api.deepseek.com/v1",
+                    "max_tokens": 4000,
+                    "temperature": 0.1,
+                    "pricing": {
+                        "input_per_1m_tokens": 0.14,
+                        "output_per_1m_tokens": 0.28,
+                    },
+                },
+                "deepseek-reasoner": {
+                    "provider": "deepseek",
+                    "model_name": "deepseek-reasoner",
+                    "api_key_env": "DEEPSEEK_API_KEY",
+                    "base_url": "https://api.deepseek.com/v1",
+                    "max_tokens": 8000,
+                    "temperature": 0.0,
+                    "pricing": {
+                        "input_per_1m_tokens": 55.0,
+                        "output_per_1m_tokens": 55.0,
+                    },
+                },
+                "claude-sonnet": {
+                    "provider": "anthropic",
+                    "model_name": "claude-sonnet-4-6",
+                    "api_key_env": "ANTHROPIC_API_KEY",
+                    "base_url": "https://api.anthropic.com/v1",
+                    "max_tokens": 4000,
+                    "temperature": 0.1,
+                    "pricing": {
+                        "input_per_1m_tokens": 3.0,
+                        "output_per_1m_tokens": 15.0,
+                    },
+                },
+            },
+            "defaults": {
+                "retry_attempts": 3,
+                "retry_delay": 1.0,
+                "timeout": 30,
+            },
+        }
+
+        with open(self.config_path, "w") as f:
+            yaml.dump(default_config, f, default_flow_style=False)
+
+        print(f"Created default config at {self.config_path}")
+        print("Please update with your API keys!")
+
+    def query(self, model_alias: str, prompt: str, context: Optional[str] = None) -> LLMResponse:
+        """Unified LLM query with automatic timing, logging, and cost tracking."""
+        t0 = time.time()
+        response = self._do_query(model_alias, prompt, context)
+        latency_ms = int((time.time() - t0) * 1000)
+
+        if response.success:
+            _logger.info(
+                "llm/%s ok — %d in + %d out tokens, $%.6f, %dms",
+                model_alias, response.input_tokens or 0, response.output_tokens or 0,
+                response.cost or 0.0, latency_ms,
+            )
+            self._append_cost_log(model_alias, response, latency_ms)
+        else:
+            _logger.error("llm/%s failed — %s", model_alias, response.error)
+
+        return response
+
+    def _append_cost_log(self, alias: str, response: "LLMResponse", latency_ms: int) -> None:
+        try:
+            self._cost_log.parent.mkdir(parents=True, exist_ok=True)
+            record = {
+                "ts": datetime.now(timezone.utc).isoformat(),
+                "alias": alias,
+                "model": response.model,
+                "input_tokens": response.input_tokens,
+                "output_tokens": response.output_tokens,
+                "cost_usd": response.cost,
+                "latency_ms": latency_ms,
+            }
+            with open(self._cost_log, "a") as f:
+                f.write(json.dumps(record) + "\n")
+        except Exception:
+            pass  # never crash the caller over logging
+
+    def _do_query(self, model_alias: str, prompt: str, context: Optional[str] = None, _is_fallback: bool = False) -> LLMResponse:
+        if model_alias not in self.config["models"]:
+            return LLMResponse(content="", model=model_alias, success=False, error=f"Unknown model alias: {model_alias}")
+
+        model_config = self.config["models"][model_alias]
+
+        full_prompt = prompt
+        if context:
+            full_prompt = f"Context:\n{context}\n\nTask:\n{prompt}"
+
+        for attempt in range(self.config["defaults"]["retry_attempts"]):
+            try:
+                provider = model_config["provider"]
+                if provider == "deepseek":
+                    response = self._query_deepseek(model_config, full_prompt)
+                elif provider == "anthropic":
+                    response = self._query_anthropic(model_config, full_prompt)
+                elif provider == "openai":
+                    response = self._query_openai(model_config, full_prompt)
+                elif provider in ("google", "gemini"):
+                    response = self._query_google(model_config, full_prompt)
+                else:
+                    return LLMResponse(content="", model=model_alias, success=False, error=f"Unsupported provider: {provider}")
+
+                if response.success:
+                    return response
+
+            except QuotaExceededError as e:
+                fallback = model_config.get("fallback")
+                if fallback and not _is_fallback:
+                    _logger.warning("llm/%s quota exceeded, falling back to %s", model_alias, fallback)
+                    return self._do_query(fallback, prompt, context, _is_fallback=True)
+                return LLMResponse(content="", model=model_alias, success=False, error=f"Quota exceeded, no fallback: {e}")
+
+            except Exception as e:
+                if attempt == self.config["defaults"]["retry_attempts"] - 1:
+                    return LLMResponse(content="", model=model_alias, success=False, error=f"Failed after {attempt + 1} attempts: {e}")
+                time.sleep(self.config["defaults"]["retry_delay"] * (2 ** attempt))
+
+        return LLMResponse(content="", model=model_alias, success=False, error="Max retries exceeded")
+
+    def _query_deepseek(self, model_config: Dict, prompt: str) -> LLMResponse:
+        api_key = os.getenv(model_config["api_key_env"])
+        if not api_key:
+            raise ValueError(f"API key not found: {model_config['api_key_env']}")
+
+        payload = {
+            "model": model_config["model_name"],
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": model_config["max_tokens"],
+            "temperature": model_config["temperature"],
+        }
+        resp = self.session.post(
+            f"{model_config['base_url']}/chat/completions",
+            json=payload,
+            headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
+            timeout=self.config["defaults"]["timeout"],
+        )
+        if resp.status_code != 200:
+            raise Exception(f"API error: {resp.status_code} - {resp.text}")
+
+        data = resp.json()
+        usage = data.get("usage", {})
+        input_tokens = usage.get("prompt_tokens", 0)
+        output_tokens = usage.get("completion_tokens", 0)
+        return LLMResponse(
+            content=data["choices"][0]["message"]["content"],
+            model=model_config["model_name"],
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            total_tokens=usage.get("total_tokens", input_tokens + output_tokens),
+            cost=self._calculate_cost(input_tokens, output_tokens, model_config["pricing"]),
+            success=True,
+        )
+
+    def _query_openai(self, model_config: Dict, prompt: str) -> LLMResponse:
+        api_key = os.getenv(model_config["api_key_env"])
+        if not api_key:
+            raise ValueError(f"API key not found: {model_config['api_key_env']}")
+
+        model_name = model_config["model_name"]
+        payload: Dict[str, Any] = {
+            "model": model_name,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_completion_tokens": model_config["max_tokens"],
+        }
+        # o-series reasoning models don't accept temperature
+        if not (model_name[0] == "o" and model_name[1:2].isdigit()):
+            payload["temperature"] = model_config["temperature"]
+
+        resp = self.session.post(
+            f"{model_config.get('base_url', 'https://api.openai.com/v1')}/chat/completions",
+            json=payload,
+            headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
+            timeout=self.config["defaults"]["timeout"],
+        )
+        if resp.status_code != 200:
+            if resp.status_code == 429:
+                try:
+                    if resp.json().get("error", {}).get("code") == "insufficient_quota":
+                        raise QuotaExceededError(f"OpenAI quota exceeded ({model_name})")
+                except (ValueError, KeyError):
+                    pass
+            raise Exception(f"API error: {resp.status_code} - {resp.text}")
+
+        data = resp.json()
+        usage = data.get("usage", {})
+        input_tokens = usage.get("prompt_tokens", 0)
+        output_tokens = usage.get("completion_tokens", 0)
+        return LLMResponse(
+            content=data["choices"][0]["message"]["content"],
+            model=model_name,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            total_tokens=usage.get("total_tokens", input_tokens + output_tokens),
+            cost=self._calculate_cost(input_tokens, output_tokens, model_config["pricing"]),
+            success=True,
+        )
+
+    def _query_anthropic(self, model_config: Dict, prompt: str) -> LLMResponse:
+        api_key = os.getenv(model_config["api_key_env"])
+        if not api_key:
+            raise ValueError(f"API key not found: {model_config['api_key_env']}")
+
+        resp = self.session.post(
+            f"{model_config['base_url']}/messages",
+            json={
+                "model": model_config["model_name"],
+                "messages": [{"role": "user", "content": prompt}],
+                "max_tokens": model_config["max_tokens"],
+                "temperature": model_config["temperature"],
+            },
+            headers={
+                "x-api-key": api_key,
+                "Content-Type": "application/json",
+                "anthropic-version": "2023-06-01",
+            },
+            timeout=self.config["defaults"]["timeout"],
+        )
+        if resp.status_code != 200:
+            if resp.status_code in (400, 429):
+                try:
+                    err = resp.json().get("error", {})
+                    if "credit balance" in err.get("message", "") or err.get("type") == "insufficient_quota":
+                        raise QuotaExceededError(f"Anthropic quota exhausted ({model_config['model_name']})")
+                except (ValueError, KeyError):
+                    pass
+            raise Exception(f"API error: {resp.status_code} - {resp.text}")
+
+        data = resp.json()
+        usage = data.get("usage", {})
+        input_tokens = usage.get("input_tokens", 0)
+        output_tokens = usage.get("output_tokens", 0)
+        return LLMResponse(
+            content=data["content"][0]["text"],
+            model=model_config["model_name"],
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            total_tokens=input_tokens + output_tokens,
+            cost=self._calculate_cost(input_tokens, output_tokens, model_config["pricing"]),
+            success=True,
+        )
+
+    def _query_google(self, model_config: Dict, prompt: str) -> LLMResponse:
+        api_key = os.getenv(model_config["api_key_env"])
+        if not api_key:
+            raise ValueError(f"API key not found: {model_config['api_key_env']}")
+
+        url = f"{model_config['base_url']}/models/{model_config['model_name']}:generateContent?key={api_key}"
+        resp = self.session.post(
+            url,
+            json={
+                "contents": [{"parts": [{"text": prompt}]}],
+                "generationConfig": {
+                    "maxOutputTokens": model_config["max_tokens"],
+                    "temperature": model_config["temperature"],
+                },
+            },
+            headers={"Content-Type": "application/json"},
+            timeout=self.config["defaults"]["timeout"],
+        )
+        if resp.status_code != 200:
+            raise Exception(f"API error: {resp.status_code} - {resp.text}")
+
+        data = resp.json()
+        candidates = data.get("candidates", [])
+        if not candidates:
+            raise Exception(f"No candidates in response: {data}")
+        content = candidates[0].get("content", {}).get("parts", [{}])[0].get("text", "")
+
+        usage = data.get("usageMetadata", {})
+        input_tokens = usage.get("promptTokenCount", 0)
+        output_tokens = usage.get("candidatesTokenCount", 0)
+        return LLMResponse(
+            content=content,
+            model=model_config["model_name"],
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            total_tokens=usage.get("totalTokenCount", input_tokens + output_tokens),
+            cost=self._calculate_cost(input_tokens, output_tokens, model_config["pricing"]),
+            success=True,
+        )
+
+    def _calculate_cost(self, input_tokens: int, output_tokens: int, pricing: Dict) -> float:
+        return (input_tokens / 1_000_000) * pricing["input_per_1m_tokens"] + \
+               (output_tokens / 1_000_000) * pricing["output_per_1m_tokens"]
+
+    def list_models(self) -> list:
+        return list(self.config["models"].keys())
+
+    def get_model_info(self, model_alias: str) -> Optional[Dict]:
+        return self.config["models"].get(model_alias)
+
+
+def main():
+    import sys
+
+    client = LLMClient()
+    if len(sys.argv) < 3:
+        print("Usage: llm-query <model_alias> <prompt>")
+        print("Available models:", ", ".join(client.list_models()))
+        sys.exit(1)
+
+    model_alias = sys.argv[1]
+    prompt = " ".join(sys.argv[2:])
+    print(f"Querying {model_alias}...")
+    response = client.query(model_alias, prompt)
+
+    if response.success:
+        print(f"\nResponse ({response.input_tokens} in + {response.output_tokens} out = {response.total_tokens} tokens, ${response.cost:.6f}):")
+        print("-" * 50)
+        print(response.content)
+    else:
+        print(f"Error: {response.error}")
+
+
+if __name__ == "__main__":
+    main()

fj_llm/ping.py

@@ -0,0 +1,112 @@
+"""
+Quick connectivity check for each supported provider.
+Uses hardcoded minimal configs so it works independently of the user's config file.
+Requires only the relevant API key env var to be set.
+"""
+
+import os
+import sys
+from typing import Optional
+from fj_llm.client import LLMClient, LLMResponse
+
+PING_PROMPT = "Reply with exactly one word: pong"
+
+_PING_CONFIGS = {
+    "openai": {
+        "models": {
+            "ping": {
+                "provider": "openai",
+                "model_name": "gpt-4o-mini",
+                "api_key_env": "OPENAI_API_KEY",
+                "base_url": "https://api.openai.com/v1",
+                "max_tokens": 10,
+                "temperature": 0.0,
+                "pricing": {"input_per_1m_tokens": 0.15, "output_per_1m_tokens": 0.60},
+            }
+        },
+        "defaults": {"retry_attempts": 1, "retry_delay": 0.0, "timeout": 15},
+    },
+    "anthropic": {
+        "models": {
+            "ping": {
+                "provider": "anthropic",
+                "model_name": "claude-haiku-4-5-20251001",
+                "api_key_env": "ANTHROPIC_API_KEY",
+                "base_url": "https://api.anthropic.com/v1",
+                "max_tokens": 10,
+                "temperature": 0.0,
+                "pricing": {"input_per_1m_tokens": 0.80, "output_per_1m_tokens": 4.00},
+            }
+        },
+        "defaults": {"retry_attempts": 1, "retry_delay": 0.0, "timeout": 15},
+    },
+    "deepseek": {
+        "models": {
+            "ping": {
+                "provider": "deepseek",
+                "model_name": "deepseek-chat",
+                "api_key_env": "DEEPSEEK_API_KEY",
+                "base_url": "https://api.deepseek.com/v1",
+                "max_tokens": 10,
+                "temperature": 0.0,
+                "pricing": {"input_per_1m_tokens": 0.14, "output_per_1m_tokens": 0.28},
+            }
+        },
+        "defaults": {"retry_attempts": 1, "retry_delay": 0.0, "timeout": 15},
+    },
+    "google": {
+        "models": {
+            "ping": {
+                "provider": "google",
+                "model_name": "gemini-2.5-flash",
+                "api_key_env": "GEMINI_API_KEY",
+                "base_url": "https://generativelanguage.googleapis.com/v1beta",
+                "max_tokens": 100,
+                "temperature": 0.0,
+                "pricing": {"input_per_1m_tokens": 0.075, "output_per_1m_tokens": 0.30},
+            }
+        },
+        "defaults": {"retry_attempts": 1, "retry_delay": 0.0, "timeout": 15},
+    },
+}
+
+SUPPORTED_PROVIDERS = list(_PING_CONFIGS.keys())
+
+
+def ping(provider: str) -> LLMResponse:
+    """Send a minimal prompt to the given provider. Raises ValueError for unknown providers."""
+    if provider not in _PING_CONFIGS:
+        raise ValueError(f"Unknown provider '{provider}'. Choose from: {', '.join(SUPPORTED_PROVIDERS)}")
+    client = LLMClient(config_dict=_PING_CONFIGS[provider])
+    return client.query("ping", PING_PROMPT)
+
+
+def main():
+    """CLI entry point: llm-ping [provider ...]"""
+    targets = sys.argv[1:] if len(sys.argv) > 1 else SUPPORTED_PROVIDERS
+
+    unknown = [t for t in targets if t not in _PING_CONFIGS]
+    if unknown:
+        print(f"Unknown provider(s): {', '.join(unknown)}")
+        print(f"Supported: {', '.join(SUPPORTED_PROVIDERS)}")
+        sys.exit(1)
+
+    results = {}
+    for provider in targets:
+        key_env = _PING_CONFIGS[provider]["models"]["ping"]["api_key_env"]
+        if not os.getenv(key_env):
+            print(f"  {provider:<12} SKIP  ({key_env} not set)")
+            results[provider] = None
+            continue
+
+        resp = ping(provider)
+        if resp.success:
+            snippet = resp.content.strip().replace("\n", " ")[:40]
+            print(f"  {provider:<12} OK    '{snippet}'  ({resp.input_tokens}in/{resp.output_tokens}out  ${resp.cost:.6f})")
+        else:
+            print(f"  {provider:<12} FAIL  {resp.error}")
+        results[provider] = resp
+
+    failed = [p for p, r in results.items() if r is not None and not r.success]
+    if failed:
+        sys.exit(1)

fj_llm-0.2.0.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: fj-llm
+Version: 0.2.0
+Summary: Lightweight, config-driven client for multiple LLM providers
+Author-email: Simon Bloch <simon.j.bloch@gmail.com>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Requires-Dist: pyyaml>=5.4.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+
+# fj-llm
+
+Lightweight, config-driven Python client for multiple LLM providers. One interface, any provider — no provider SDK required.
+
+## Install
+
+```
+pip install fj-llm
+```
+
+## Providers
+
+| Provider  | Config key   | Env var              |
+|-----------|--------------|----------------------|
+| OpenAI    | `openai`     | `OPENAI_API_KEY`     |
+| Anthropic | `anthropic`  | `ANTHROPIC_API_KEY`  |
+| DeepSeek  | `deepseek`   | `DEEPSEEK_API_KEY`   |
+| Google    | `google`     | `GOOGLE_API_KEY`     |
+
+## Configuration
+
+On first use, a default config is created at `~/.config/fj_llm/config.yaml`. Edit it to add your API keys and define model aliases:
+
+```yaml
+models:
+  gpt-best:
+    provider: openai
+    model_name: gpt-4o
+    api_key_env: OPENAI_API_KEY
+    base_url: https://api.openai.com/v1
+    max_tokens: 4000
+    temperature: 0.1
+    pricing:
+      input_per_1m_tokens: 2.50
+      output_per_1m_tokens: 10.00
+    fallback: gpt-light        # optional: alias to use on quota exhaustion
+
+  gpt-light:
+    provider: openai
+    model_name: gpt-4o-mini
+    api_key_env: OPENAI_API_KEY
+    base_url: https://api.openai.com/v1
+    max_tokens: 4000
+    temperature: 0.1
+    pricing:
+      input_per_1m_tokens: 0.15
+      output_per_1m_tokens: 0.60
+
+defaults:
+  retry_attempts: 3
+  retry_delay: 1.0
+  timeout: 30
+```
+
+For Cloud Functions or other environments without filesystem access, set the `FJ_LLM_CONFIG` environment variable to a JSON string of the same structure.
+
+## Usage
+
+```python
+from fj_llm import LLMClient
+
+client = LLMClient()
+response = client.query("gpt-best", "Summarise this in one sentence.", context=long_text)
+
+if response.success:
+    print(response.content)
+    print(f"Cost: ${response.cost:.6f}")
+else:
+    print(f"Error: {response.error}")
+```
+
+### Cost logging
+
+Every successful call is appended as a JSONL record to `~/.local/share/fj_llm/costs.jsonl`. Override the path via the `FJ_LLM_COST_LOG` env var, or set `cost_log` in the config file.
+
+### CLI
+
+```
+llm-query gpt-best "What is the capital of France?"
+```
+
+## License
+
+MIT

fj_llm-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+fj_llm/__init__.py,sha256=Pt_qkB6mvzMS5WFYcYnH_0XtuA1pftkIJahoD3oBqKE,181
+fj_llm/client.py,sha256=jsIQxfKlGd3MBQo4rfvTd6hcj4RL_NSe6NzWw5zajHE,16401
+fj_llm/ping.py,sha256=CMIBfIHqiCgjvRO0Tg21Re4oY4KgBQ2JycHLBvBY324,4040
+fj_llm-0.2.0.dist-info/METADATA,sha256=OOG0veGcMMsKSua_S1rOvv-69Fg33AqJEd8dU6uIy9o,2438
+fj_llm-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+fj_llm-0.2.0.dist-info/entry_points.txt,sha256=vfmtI70Sf76A3ImHQrhNlVxpCU7ObhgxA2K9nn8WxhA,77
+fj_llm-0.2.0.dist-info/top_level.txt,sha256=4-qWPKJSQX3YMzv9DvsEflTbrjvTOtdlw2Gr5rAdBSc,7
+fj_llm-0.2.0.dist-info/RECORD,,

fj_llm-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fj_llm-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+llm-ping = fj_llm.ping:main
+llm-query = fj_llm.client:main

fj_llm-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fj_llm