first commit

.env.example

@@ -0,0 +1,2 @@
+FLOWITH_AUTH_TOKEN=YOUR_TOKEN_HERE
+API_KEY=123456

.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+.env
+venv/
+*.log
+.idea/
+.vscode/

Dockerfile

@@ -0,0 +1,26 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container at /app
+COPY requirements.txt .
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code into the container at /app
+COPY . .
+
+# Ensure models.json is copied
+COPY models.json .
+
+# Make port 8000 available to the world outside this container
+EXPOSE 7860
+
+# Define environment variable
+ENV NAME World
+
+# Run main.py when the container launches
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,58 @@
+---
+title: OpenAI to Flowith Converter
+emoji: 🔄
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 7860
+env:
+  - FLOWITH_AUTH_TOKEN
+  - API_KEY # Add this line
+secrets:
+  - FLOWITH_AUTH_TOKEN
+  - API_KEY # Add this line
+---
+
+# OpenAI to Flowith Converter
+
+This project provides a simple API endpoint that accepts OpenAI-compatible chat completion requests and forwards them to the Flowith API, translating the request and response formats as needed. It's designed to be run easily using Docker, both locally and on Hugging Face Spaces.
+
+## Setup
+
+1.  **Environment Variables:** Create a `.env` file in the project root by copying the example: `cp .env.example .env` (or manually create it).
+2.  **Flowith Token:** Open the `.env` file and replace the placeholder with your actual Flowith authorization token:
+    ```
+    FLOWITH_AUTH_TOKEN=your_actual_token_here
+    ```
+3.  **Model Mappings (Optional):** If you need to use different Flowith models or map OpenAI model names differently, you can update the [`models.json`](models.json) file.
+4.  **API Key (Optional):** By default, the API uses the key `123456`. If you want to use a different key, set the `API_KEY` environment variable in your `.env` file (for local runs) or as a secret named `API_KEY` in Hugging Face Spaces.
+
+## Running Locally (Docker)
+
+To build and run the service locally using Docker Compose:
+
+```bash
+docker-compose up --build
+```
+
+The API will then be accessible at [`http://localhost:8099/v1/chat/completions`](http://localhost:8099/v1/chat/completions).
+
+## Running on Hugging Face Spaces
+
+This repository is configured for deployment on Hugging Face Spaces using Docker.
+
+1.  Create a new Space on Hugging Face, selecting "Docker" as the SDK.
+2.  Link this repository to your Space.
+3.  Navigate to your Space's "Settings" page.
+4.  Go to the "Secrets" section.
+5.  Add a new secret with the name `FLOWITH_AUTH_TOKEN` and paste your actual Flowith authorization token as the value. The application will automatically read this secret.
+
+The Space will build the Docker image and start the service. The API endpoint will be available at your Space's URL (e.g., `https://your-username-your-space-name.hf.space/v1/chat/completions`).
+
+## API Endpoint
+
+*   **URL:** `/v1/chat/completions`
+*   **Method:** `POST`
+*   **Request Body:** Send a JSON payload conforming to the OpenAI Chat Completions API schema (e.g., specifying `model`, `messages`, `stream`, etc.). The `model` field should correspond to a key in [`models.json`](models.json).
+*   **Authentication:** Requests must include an `Authorization` header with your API key. Use the format `Bearer your_api_key`. For example, if using the default key, the header would be `Authorization: Bearer 123456`.
+*   **Response:** The API will return either a standard JSON response or a server-sent event stream, mimicking the OpenAI API behavior based on the `stream` parameter in the request.

docker-compose.yml

@@ -0,0 +1,9 @@
+version: '3.8'
+
+services:
+  api:
+    build: .
+    ports:
+      - "8099:7860"
+    env_file:
+      - .env

main.py

@@ -0,0 +1,256 @@
+import os
+import json
+import uuid
+from typing import List, Optional, Literal, Dict, Any, AsyncGenerator
+
+import httpx
+import dotenv
+from fastapi import FastAPI, HTTPException, Request, Depends, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel, Field
+
+# Load environment variables from .env file
+dotenv.load_dotenv()
+
+# --- Configuration ---
+FLOWITH_AUTH_TOKEN = os.getenv("FLOWITH_AUTH_TOKEN")
+FLOWITH_API_URL = "https://edge.flo.ing/completion?mode=general"
+MODELS_FILE_PATH = "models.json"
+API_KEY = os.getenv("API_KEY", "123456") # Read API Key
+
+# --- Security Scheme ---
+security = HTTPBearer()
+
+if not FLOWITH_AUTH_TOKEN:
+    # In a real app, you might want to log this and exit,
+    # but for simplicity, we'll raise an error if accessed.
+    print("Warning: FLOWITH_AUTH_TOKEN environment variable not set.")
+    # raise ValueError("FLOWITH_AUTH_TOKEN environment variable is required.") # Or handle differently
+
+# --- Load Model Mappings ---
+try:
+    with open(MODELS_FILE_PATH, 'r') as f:
+        model_mappings = json.load(f)
+except FileNotFoundError:
+    print(f"Error: Models file not found at {MODELS_FILE_PATH}")
+    model_mappings = {} # Or raise an error / exit
+except json.JSONDecodeError:
+    print(f"Error: Invalid JSON in models file: {MODELS_FILE_PATH}")
+    model_mappings = {} # Or raise an error / exit
+
+# --- Pydantic Models ---
+class OpenAIMessage(BaseModel):
+    role: Literal["system", "user", "assistant"]
+    content: str
+
+class OpenAIRequest(BaseModel):
+    model: str
+    messages: List[OpenAIMessage]
+    stream: Optional[bool] = False
+    # Add other potential OpenAI fields if needed, e.g., temperature, max_tokens
+    # temperature: Optional[float] = None
+    # max_tokens: Optional[int] = None
+
+class FlowithMessage(BaseModel):
+    role: Literal["user", "assistant"] # Flowith uses 'user' and 'assistant'
+    content: str
+
+class FlowithRequest(BaseModel):
+    model: str
+    messages: List[FlowithMessage]
+    stream: bool
+    nodeId: str # UUID for Flowith
+
+# --- FastAPI App ---
+app = FastAPI(
+    title="OpenAI to Flowith Proxy",
+    description="Translates OpenAI-compatible chat completion requests to Flowith's format.",
+)
+
+# --- Helper for Streaming ---
+async def stream_flowith_response(flowith_stream: httpx.Response) -> AsyncGenerator[str, None]:
+    """Asynchronously streams the response from Flowith."""
+    async for chunk in flowith_stream.aiter_bytes():
+        # Assuming Flowith streams data in a format compatible with OpenAI's SSE
+        # If Flowith uses a different streaming format, this needs adjustment.
+        yield chunk.decode('utf-8') # Decode bytes to string
+
+# --- Security Dependency ---
+async def verify_api_key(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    """Verify the provided API key against the environment variable."""
+    # Use constant time comparison to prevent timing attacks
+    # This requires Python 3.3+
+    import hmac
+    is_valid = hmac.compare_digest(credentials.credentials, API_KEY)
+
+    if not credentials or credentials.scheme != "Bearer" or not is_valid:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or missing API Key",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return credentials.credentials # Return the key or True if successful
+
+# --- API Endpoint ---
+@app.post("/v1/chat/completions")
+async def chat_completions(
+    request: OpenAIRequest,
+    http_request: Request,
+    api_key: str = Depends(verify_api_key) # Add API Key dependency
+):
+    """
+    Accepts OpenAI-like chat completion requests and forwards them to Flowith.
+    """
+    if not FLOWITH_AUTH_TOKEN:
+         raise HTTPException(status_code=500, detail="Server configuration error: Flowith auth token not set.")
+
+    # 1. Map the model
+    flowith_model_name = model_mappings.get(request.model)
+    if not flowith_model_name:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Model '{request.model}' not found in mappings. Available: {list(model_mappings.keys())}"
+        )
+
+    # 2. Generate nodeId
+    node_id = str(uuid.uuid4())
+
+    # 3. Process messages (Handle system prompt for specific models)
+    processed_messages: List[FlowithMessage] = []
+    # Check if the *target* Flowith model indicates Claude or Gemini
+    # Adjust this logic if the check should be based on the *source* OpenAI model name
+    is_claude_or_gemini = "claude" in flowith_model_name.lower() or "gemini" in flowith_model_name.lower()
+
+    for msg in request.messages:
+        role = msg.role
+        if is_claude_or_gemini and role == "system":
+            # Convert system message to user message for Claude/Gemini via Flowith
+            role = "user"
+        elif role == "system":
+             # If it's a system message but not for Claude/Gemini, Flowith might not support it directly.
+             # Option 1: Skip it (might lose context)
+             # continue
+             # Option 2: Convert to user (might change semantics)
+             role = "user"
+             # Option 3: Prepend to the next user message (complex)
+             # For now, converting to 'user' is a simple approach.
+             print(f"Warning: Converting system message to 'user' for model {flowith_model_name}")
+
+        # Ensure only 'user' or 'assistant' roles are sent to Flowith
+        if role in ["user", "assistant"]:
+             processed_messages.append(FlowithMessage(role=role, content=msg.content))
+        # else: # Handle unexpected roles if necessary
+
+
+    # 4. Construct Flowith Request Payload
+    flowith_payload = FlowithRequest(
+        model=flowith_model_name,
+        messages=processed_messages,
+        stream=True, # Always stream from Flowith
+        nodeId=node_id,
+    )
+
+    # 5. Prepare Headers for Flowith Request
+    # Headers exactly matching the curl -H flags provided
+    headers = {
+        'accept': '*/*',
+        'accept-language': 'en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7,zh-TW;q=0.6,ja;q=0.5',
+        'authorization': f'Bearer {FLOWITH_AUTH_TOKEN}', # Keep this dynamic
+        'content-type': 'application/json', 
+        'origin': 'https://flowith.net',
+        'priority': 'u=1, i',
+        'referer': 'https://flowith.net/',
+        'responsetype': 'stream', # Added - Was present in -H flags
+        'sec-ch-ua': '"Google Chrome";v="135", "Not-A.Brand";v="8", "Chromium";v="135"',
+        'sec-ch-ua-mobile': '?0',
+        'sec-ch-ua-platform': '"Windows"',
+        'sec-fetch-dest': 'empty',
+        'sec-fetch-mode': 'cors',
+        'sec-fetch-site': 'cross-site',
+        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36'
+    }
+
+    # 6. Make Asynchronous Request to Flowith
+    async with httpx.AsyncClient(timeout=300.0) as client: # Increased timeout for potentially long requests
+        try:
+            # Always use stream for the request to Flowith
+            # Serialize payload manually for content=
+            payload_bytes = json.dumps(flowith_payload.dict()).encode('utf-8')
+            response_stream = client.stream( # Changed from post to stream
+                "POST", # Explicitly set method for stream
+                FLOWITH_API_URL,
+                content=payload_bytes, # Send serialized bytes
+                headers=headers,
+            )
+            # Need to acquire the stream context
+            async with response_stream as response:
+                # Check status code *before* attempting to read the stream body
+                if response.status_code != 200:
+                    # Attempt to read error details from the response body if possible
+                    try:
+                        error_detail = await response.aread()
+                        detail_msg = f"Flowith API Error ({response.status_code}): {error_detail.decode()}"
+                    except Exception:
+                        detail_msg = f"Flowith API Error ({response.status_code})"
+                    # No need to manually close here, 'async with' handles it
+                    raise HTTPException(status_code=response.status_code, detail=detail_msg)
+
+                # 7. Handle Flowith Response based on *client's* request.stream preference
+                if request.stream:
+                    # Client wants streaming: Use StreamingResponse with the helper
+                    return StreamingResponse(
+                        stream_flowith_response(response), # Pass the response object itself
+                        media_type="text/event-stream"
+                    )
+                else:
+                    # Client wants non-streaming: Accumulate the response
+                    full_response_bytes = bytearray()
+                    try:
+                        async for chunk in response.aiter_bytes():
+                            full_response_bytes.extend(chunk)
+                    except Exception as e:
+                         # Handle potential errors during stream reading
+                         print(f"Error reading stream from Flowith: {e}")
+                         raise HTTPException(status_code=502, detail=f"Error reading stream from Flowith: {e}")
+                    finally:
+                         # 'async with' ensures the stream is closed
+                         pass
+
+                    # Decode the accumulated bytes
+                    full_response_text = full_response_bytes.decode('utf-8')
+
+                    # Try to parse as JSON
+                    try:
+                        response_data = json.loads(full_response_text)
+                        from fastapi.responses import JSONResponse # Import locally if not already global
+                        return JSONResponse(content=response_data)
+                    except json.JSONDecodeError:
+                        # If not valid JSON, return as plain text
+                        print(f"Warning: Flowith response was not valid JSON. Returning as plain text. Content: {full_response_text[:200]}...") # Log snippet
+                        from fastapi.responses import PlainTextResponse # Import locally
+                        return PlainTextResponse(content=full_response_text)
+
+        except httpx.RequestError as exc:
+            print(f"Error requesting Flowith: {exc}")
+            raise HTTPException(status_code=503, detail=f"Error connecting to Flowith service: {exc}")
+        except HTTPException as http_exc:
+             # Re-raise HTTPExceptions raised during stream processing
+             raise http_exc
+        except Exception as exc:
+             print(f"Unexpected error during Flowith request/processing: {exc}")
+             # Log the traceback for debugging
+             import traceback
+             traceback.print_exc()
+             raise HTTPException(status_code=500, detail=f"Internal server error: {exc}")
+
+
+# --- Optional: Add a root endpoint for health check ---
+@app.get("/")
+async def root():
+    return {"message": "OpenAI to Flowith Proxy is running"}
+
+# --- To run locally (for development) ---
+# if __name__ == "__main__":
+#     import uvicorn
+#     uvicorn.run(app, host="0.0.0.0", port=8000)

models.json

@@ -0,0 +1,19 @@
+{
+  "deepseek-chat": "deepseek-chat",
+  "deepseek-reasoner": "deepseek-reasoner",
+  "claude-4-opus": "claude-4-opus",
+  "claude-4-sonnet": "claude-4-sonnet",
+  "gemini-2.5-flash": "gemini-2.5-flash",
+  "gemini-2.5-pro-exp": "gemini-2.5-pro-exp",
+  "claude-3.5-haiku": "claude-3.5-haiku",
+  "claude-3.5-sonnet": "claude-3.5-sonnet",
+  "claude-3.7-sonnet": "claude-3.7-sonnet",
+  "gpt-4.1": "gpt-4.1",
+  "gpt-4.1-mini": "gpt-4.1-mini",
+  "o3": "o3",
+  "o4-mini": "o4-mini",
+  "grok-3-mini": "grok-3-mini",
+  "grok-3": "grok-3",
+  "glm-4-plus": "glm-4-plus",
+  "gemini-2.0-flash": "gemini-2.0-flash"
+}

requirements.txt

@@ -0,0 +1,7 @@
+fastapi
+uvicorn[standard]
+pydantic
+requests
+python-dotenv
+aiohttp
+httpx