mhub_proxy 1.0.0__tar.gz

mhub_proxy-1.0.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: mhub_proxy
+Version: 1.0.0
+Summary: OpenAI-compatible local proxy for enterprise LLM endpoints
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.133.1
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: uvicorn>=0.41.0
+
+# mhub_proxy
+
+`mhub_proxy` is a local OpenAI-compatible proxy that lets CLI tools (for example, Opencode) send OpenAI-style requests to SecureGPT.
+
+## Requirements:
+
+`uv` is required to install and run the proxy.
+
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+Or, using `pip`:
+
+```bash
+pip install uv
+```
+## Install `mhub_proxy`
+
+Install as a `uv` tool:
+
+```bash
+uv tool install mhub_proxy
+```
+
+## Required environment variables
+
+Before starting the proxy, define the variables used by `mhub_proxy/config.py`:
+
+- `MHUB_API_URL` : URL of the Model Hub API
+- `MHUB_CLIENT_ID` : Client ID for the Model Hub API
+- `MHUB_CLIENT_SECRET` : Client Secret for the Model Hub API
+- `ONEACCOUNT_LOGIN_URL` : URL of the OneAccount login API
+
+Optional:
+
+- `MHUB_PROXY_HOST` (default: `127.0.0.1`)
+- `MHUB_PROXY_PORT` (default: `8123`)
+- `MHUB_PROXY_LOG_LEVEL` (default: `info`)
+
+## Run the proxy
+
+Start the proxy with:
+
+```bash
+uvx mhub_proxy
+```
+
+By default, the proxy runs on `http://127.0.0.1:8123`.
+
+## Use with Opencode
+
+1. Add an `opencode.json` file to the root of your project.
+2. Use the configuration in this repository as your example (`/opencode.json`).
+
+**IMPORTANT: Notice how the API version is included in the model ID, e.g. `gpt-5.1-2025-11-13@2025-01-01-preview`.**
+This is required for the proxy to correctly route requests to the Model Hub API.
+
+3. Optionally: Install the OpenCode plugin (see below) in your project (`uvx mhub_proxy --install-plugin`).
+4. Start Opencode from a terminal **inside your project directory**.
+
+The included `opencode.json` points Opencode to the local proxy URL:
+
+```json
+"baseURL": "http://127.0.0.1:8123/openai"
+```
+
+When Opencode asks for an API key, you can enter any value.
+
+Reference: [OpenCode plugin docs](https://opencode.ai/docs/plugins/#create-a-plugin)
+
+## Install the OpenCode plugin
+
+A plugin is included to automatically start the proxy when Opencode starts (if not started already).
+Optionally, you may install the bundled plugin into your project:
+
+```bash
+uvx mhub_proxy --install-plugin
+```
+
+This copies plugin files into:
+
+```text
+<project_root>/.opencode/plugins
+```
+
+You can also install into a specific project root:
+
+```bash
+uvx mhub_proxy --install-plugin --project-root /path/to/project
+```
+
+## Notes
+
+- The proxy expects OpenAI chat-completions style traffic from your CLI tool.
+- If startup fails, first verify that all required environment variables are set.
+- The installed OpenCode plugin checks proxy health at session start and will launch `uvx mhub_proxy` in the background when needed.

mhub_proxy-1.0.0/README.md

@@ -0,0 +1,97 @@
+# mhub_proxy
+
+`mhub_proxy` is a local OpenAI-compatible proxy that lets CLI tools (for example, Opencode) send OpenAI-style requests to SecureGPT.
+
+## Requirements:
+
+`uv` is required to install and run the proxy.
+
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+Or, using `pip`:
+
+```bash
+pip install uv
+```
+## Install `mhub_proxy`
+
+Install as a `uv` tool:
+
+```bash
+uv tool install mhub_proxy
+```
+
+## Required environment variables
+
+Before starting the proxy, define the variables used by `mhub_proxy/config.py`:
+
+- `MHUB_API_URL` : URL of the Model Hub API
+- `MHUB_CLIENT_ID` : Client ID for the Model Hub API
+- `MHUB_CLIENT_SECRET` : Client Secret for the Model Hub API
+- `ONEACCOUNT_LOGIN_URL` : URL of the OneAccount login API
+
+Optional:
+
+- `MHUB_PROXY_HOST` (default: `127.0.0.1`)
+- `MHUB_PROXY_PORT` (default: `8123`)
+- `MHUB_PROXY_LOG_LEVEL` (default: `info`)
+
+## Run the proxy
+
+Start the proxy with:
+
+```bash
+uvx mhub_proxy
+```
+
+By default, the proxy runs on `http://127.0.0.1:8123`.
+
+## Use with Opencode
+
+1. Add an `opencode.json` file to the root of your project.
+2. Use the configuration in this repository as your example (`/opencode.json`).
+
+**IMPORTANT: Notice how the API version is included in the model ID, e.g. `gpt-5.1-2025-11-13@2025-01-01-preview`.**
+This is required for the proxy to correctly route requests to the Model Hub API.
+
+3. Optionally: Install the OpenCode plugin (see below) in your project (`uvx mhub_proxy --install-plugin`).
+4. Start Opencode from a terminal **inside your project directory**.
+
+The included `opencode.json` points Opencode to the local proxy URL:
+
+```json
+"baseURL": "http://127.0.0.1:8123/openai"
+```
+
+When Opencode asks for an API key, you can enter any value.
+
+Reference: [OpenCode plugin docs](https://opencode.ai/docs/plugins/#create-a-plugin)
+
+## Install the OpenCode plugin
+
+A plugin is included to automatically start the proxy when Opencode starts (if not started already).
+Optionally, you may install the bundled plugin into your project:
+
+```bash
+uvx mhub_proxy --install-plugin
+```
+
+This copies plugin files into:
+
+```text
+<project_root>/.opencode/plugins
+```
+
+You can also install into a specific project root:
+
+```bash
+uvx mhub_proxy --install-plugin --project-root /path/to/project
+```
+
+## Notes
+
+- The proxy expects OpenAI chat-completions style traffic from your CLI tool.
+- If startup fails, first verify that all required environment variables are set.
+- The installed OpenCode plugin checks proxy health at session start and will launch `uvx mhub_proxy` in the background when needed.

mhub_proxy-1.0.0/mhub_proxy/__init__.py

@@ -0,0 +1,3 @@
+from .app import app
+
+__all__ = ["app"]

mhub_proxy-1.0.0/mhub_proxy/app.py

@@ -0,0 +1,20 @@
+import asyncio
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+
+from .proxy import router as proxy_router
+
+@asynccontextmanager
+async def lifespan(app_instance: FastAPI):
+
+    app_instance.state.token_lock = asyncio.Lock()
+    app_instance.state.cached_auth_header = ""
+    app_instance.state.cached_auth_expires_at = 0.0
+    try:
+        yield
+    finally:
+        pass
+
+app = FastAPI(title="SecureGPT MHUB Proxy", version="0.1.0", lifespan=lifespan)
+app.include_router(proxy_router)

mhub_proxy-1.0.0/mhub_proxy/auth.py

@@ -0,0 +1,41 @@
+import time
+
+import httpx
+from fastapi import Request
+
+from .config import oneaccount_login_url, mhub_client_id, mhub_client_secret
+
+async def _authenticate(request: Request) -> None:
+    """
+    Authenticate with OneAccount and return the access token.
+    """
+    access_token = request.app.state.cached_auth_header
+    token_expiry = request.app.state.cached_auth_expires_at
+    if access_token and token_expiry > time.time():
+        return access_token
+
+    headers = {
+        "Content-Type": "application/x-www-form-urlencoded",
+    }
+    payload = {
+        "grant_type": "client_credentials",
+        "client_id": mhub_client_id(),
+        "client_secret": mhub_client_secret(),
+        "scope": "urn:grp:chatgpt",
+    }
+
+    async with httpx.AsyncClient(verify=False) as client:
+        response = await client.post(
+            f"{oneaccount_login_url()}/as/token.oauth2",
+            headers=headers,
+            data=payload,
+            timeout=15,
+        )
+    response.raise_for_status()
+    response_json = response.json()
+    access_token = response_json.get("access_token")
+    request.app.state.cached_auth_header = access_token
+    request.app.state.cached_auth_expires_at = time.time() + response_json.get(
+        "expires_in"
+    )
+    return access_token

mhub_proxy-1.0.0/mhub_proxy/cli.py

@@ -0,0 +1,67 @@
+import argparse
+from importlib import resources
+from pathlib import Path
+import uvicorn
+
+from .config import verify_config, log_level, host, port
+
+# def setup_logging() -> None:
+#    file_handler = logging.FileHandler("mhub_proxy.log")
+#    file_handler.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
+#    root_logger = logging.getLogger("mhub_proxy.requests")
+#    root_logger.addHandler(file_handler)
+#    root_logger.setLevel(log_level().upper())
+
+
+def _copy_plugin_dir(project_root: Path) -> list[Path]:
+    source_plugins = resources.files("mhub_proxy").joinpath(".opencode").joinpath("plugins")
+    destination_plugins = project_root / ".opencode" / "plugins"
+    destination_plugins.mkdir(parents=True, exist_ok=True)
+
+    copied_files: list[Path] = []
+    for entry in source_plugins.iterdir():
+        if not entry.is_file():
+            continue
+
+        destination = destination_plugins / entry.name
+        destination.write_bytes(entry.read_bytes())
+        copied_files.append(destination)
+
+    return copied_files
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="mhub_proxy")
+    parser.add_argument(
+        "--install-plugin",
+        action="store_true",
+        help="Install bundled OpenCode plugin(s) into <project_root>/.opencode/plugins.",
+    )
+    parser.add_argument(
+        "--project-root",
+        default=".",
+        help="Project root used by --install-plugin (default: current directory).",
+    )
+    args = parser.parse_args()
+
+    if args.install_plugin:
+        project_root = Path(args.project_root).resolve()
+        copied_files = _copy_plugin_dir(project_root=project_root)
+        if not copied_files:
+            print("No plugin files were found to install.")
+            return
+
+        print(f"Installed {len(copied_files)} plugin file(s) to {project_root / '.opencode' / 'plugins'}:")
+        for file_path in copied_files:
+            print(f"- {file_path}")
+        return
+
+    # setup_logging()
+    verify_config()
+    uvicorn.run(
+        "mhub_proxy.app:app",
+        host=host(),
+        port=port(),
+        log_level=log_level(),
+        access_log=True,
+    )

mhub_proxy-1.0.0/mhub_proxy/config.py

@@ -0,0 +1,35 @@
+import os
+
+def required_env(name: str) -> str:
+    value = os.getenv(name, "").strip()
+    if not value:
+        raise ValueError(f"{name} is not set")
+    return value
+
+def mhub_base_url() -> str:
+    return required_env("MHUB_API_URL").rstrip("/")
+
+def mhub_client_id() -> str:
+    return required_env("MHUB_CLIENT_ID")
+
+def mhub_client_secret() -> str:
+    return required_env("MHUB_CLIENT_SECRET")
+
+def oneaccount_login_url() -> str:
+    return required_env("ONEACCOUNT_LOGIN_URL").rstrip("/")
+
+def log_level() -> str:
+    return os.getenv("MHUB_PROXY_LOG_LEVEL") or os.getenv("LLM_PROXY_LOG_LEVEL", "info")
+
+def host() -> str:
+    return os.getenv("MHUB_PROXY_HOST") or os.getenv("LLM_PROXY_HOST", "127.0.0.1")
+
+def port() -> int:
+    return int(os.getenv("MHUB_PROXY_PORT") or os.getenv("LLM_PROXY_PORT", "8123"))
+
+def verify_config() -> None:
+    mhub_base_url()
+    mhub_client_id()
+    mhub_client_secret()
+    oneaccount_login_url()
+    

mhub_proxy-1.0.0/mhub_proxy/proxy.py

@@ -0,0 +1,85 @@
+import logging
+import uuid
+from typing import AsyncIterator
+import json
+
+import httpx
+from fastapi import APIRouter, Request
+from fastapi.responses import StreamingResponse
+
+from .config import (
+    mhub_base_url,  
+)
+
+from .auth import _authenticate
+
+router = APIRouter()
+request_logger = logging.getLogger("mhub_proxy.requests")
+
+
+def openai_upstream_url(deployment_id: str) -> str:
+    upstream_base = mhub_base_url()
+    base = upstream_base.rstrip("/")
+    model_id = deployment_id.split('@')[0]
+    api_version = deployment_id.split('@')[1]
+    return f"{base}/providers/openai/deployments/{model_id}/chat/completions?api-version={api_version}"
+
+
+@router.get("/health")
+async def health() -> dict[str, str]:
+    return {"status": "ok"}
+
+
+@router.post("/openai/chat/completions")
+async def chat_completions(request: Request) -> StreamingResponse:
+    request_id = uuid.uuid4().hex
+    body = await request.body()
+    body = json.loads(body)
+
+    upstream_url = openai_upstream_url(
+        deployment_id=body.get("model")
+    )
+    request_logger.info(
+        "body=%s", json.dumps(body),
+    )
+
+    request_logger.info(
+        "request_id=%s method=%s path=%s upstream_url=%s query=%s",
+        request_id,
+        request.method,
+        request.url.path,
+        upstream_url,
+        str(request.query_params),
+    )
+
+    auth_token = await _authenticate(request)
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {auth_token}",
+    }
+    payload = {
+        "messages": body.get("messages"),
+        "tools": body.get("tools"),
+        "reasoning_effort": body.get("reasoning_effort", "medium"),
+        "tool_choice": "auto",
+        "stream_options": {"include_usage": True},
+        "stream": True,
+    }
+
+    async def stream_response() -> AsyncIterator[bytes]:
+        async with httpx.AsyncClient(verify=False, timeout=300) as client:
+            async with client.stream(
+                "POST",
+                upstream_url,
+                headers=headers,
+                json=payload,
+            ) as response:
+                response.raise_for_status()
+                async for chunk in response.aiter_bytes():
+                    yield chunk
+
+    return StreamingResponse(
+        content=stream_response(),
+        status_code=200,
+        headers={"Content-Type": "application/json"},
+    )

mhub_proxy-1.0.0/mhub_proxy.egg-info/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: mhub_proxy
+Version: 1.0.0
+Summary: OpenAI-compatible local proxy for enterprise LLM endpoints
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.133.1
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: uvicorn>=0.41.0
+
+# mhub_proxy
+
+`mhub_proxy` is a local OpenAI-compatible proxy that lets CLI tools (for example, Opencode) send OpenAI-style requests to SecureGPT.
+
+## Requirements:
+
+`uv` is required to install and run the proxy.
+
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+Or, using `pip`:
+
+```bash
+pip install uv
+```
+## Install `mhub_proxy`
+
+Install as a `uv` tool:
+
+```bash
+uv tool install mhub_proxy
+```
+
+## Required environment variables
+
+Before starting the proxy, define the variables used by `mhub_proxy/config.py`:
+
+- `MHUB_API_URL` : URL of the Model Hub API
+- `MHUB_CLIENT_ID` : Client ID for the Model Hub API
+- `MHUB_CLIENT_SECRET` : Client Secret for the Model Hub API
+- `ONEACCOUNT_LOGIN_URL` : URL of the OneAccount login API
+
+Optional:
+
+- `MHUB_PROXY_HOST` (default: `127.0.0.1`)
+- `MHUB_PROXY_PORT` (default: `8123`)
+- `MHUB_PROXY_LOG_LEVEL` (default: `info`)
+
+## Run the proxy
+
+Start the proxy with:
+
+```bash
+uvx mhub_proxy
+```
+
+By default, the proxy runs on `http://127.0.0.1:8123`.
+
+## Use with Opencode
+
+1. Add an `opencode.json` file to the root of your project.
+2. Use the configuration in this repository as your example (`/opencode.json`).
+
+**IMPORTANT: Notice how the API version is included in the model ID, e.g. `gpt-5.1-2025-11-13@2025-01-01-preview`.**
+This is required for the proxy to correctly route requests to the Model Hub API.
+
+3. Optionally: Install the OpenCode plugin (see below) in your project (`uvx mhub_proxy --install-plugin`).
+4. Start Opencode from a terminal **inside your project directory**.
+
+The included `opencode.json` points Opencode to the local proxy URL:
+
+```json
+"baseURL": "http://127.0.0.1:8123/openai"
+```
+
+When Opencode asks for an API key, you can enter any value.
+
+Reference: [OpenCode plugin docs](https://opencode.ai/docs/plugins/#create-a-plugin)
+
+## Install the OpenCode plugin
+
+A plugin is included to automatically start the proxy when Opencode starts (if not started already).
+Optionally, you may install the bundled plugin into your project:
+
+```bash
+uvx mhub_proxy --install-plugin
+```
+
+This copies plugin files into:
+
+```text
+<project_root>/.opencode/plugins
+```
+
+You can also install into a specific project root:
+
+```bash
+uvx mhub_proxy --install-plugin --project-root /path/to/project
+```
+
+## Notes
+
+- The proxy expects OpenAI chat-completions style traffic from your CLI tool.
+- If startup fails, first verify that all required environment variables are set.
+- The installed OpenCode plugin checks proxy health at session start and will launch `uvx mhub_proxy` in the background when needed.

mhub_proxy-1.0.0/mhub_proxy.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+mhub_proxy/__init__.py
+mhub_proxy/app.py
+mhub_proxy/auth.py
+mhub_proxy/cli.py
+mhub_proxy/config.py
+mhub_proxy/proxy.py
+mhub_proxy.egg-info/PKG-INFO
+mhub_proxy.egg-info/SOURCES.txt
+mhub_proxy.egg-info/dependency_links.txt
+mhub_proxy.egg-info/entry_points.txt
+mhub_proxy.egg-info/requires.txt
+mhub_proxy.egg-info/top_level.txt

mhub_proxy-1.0.0/mhub_proxy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mhub_proxy-1.0.0/mhub_proxy.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mhub_proxy = mhub_proxy.cli:main

mhub_proxy-1.0.0/mhub_proxy.egg-info/requires.txt

@@ -0,0 +1,3 @@
+fastapi>=0.133.1
+httpx>=0.28.1
+uvicorn>=0.41.0

mhub_proxy-1.0.0/mhub_proxy.egg-info/top_level.txt

@@ -0,0 +1 @@
+mhub_proxy

mhub_proxy-1.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "mhub_proxy"
+version = "1.0.0"
+description = "OpenAI-compatible local proxy for enterprise LLM endpoints"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "fastapi>=0.133.1",
+    "httpx>=0.28.1",
+    "uvicorn>=0.41.0",
+]
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.uv]
+package = true
+
+[[tool.uv.index]]
+url = "https://pypi.org/simple/"
+
+[tool.setuptools.packages.find]
+include = ["mhub_proxy*"]
+
+[project.scripts]
+mhub_proxy = "mhub_proxy.cli:main"

mhub_proxy-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+