Upload 12 files

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Make run script executable
+RUN chmod +x run.sh
+
+# Expose port
+EXPOSE 7860
+
+# Environment variables
+ENV PORT=7860
+ENV API_BASE_URL=https://fragments.e2b.dev
+ENV API_KEY=sk-123456
+
+# Command to run the application
+CMD ["./run.sh"]

README.md

@@ -1,10 +1,97 @@
 ---
-title: Eb2
-emoji: 😻
-colorFrom: green
-colorTo: green
+title: eb2
+emoji: 🚀
+colorFrom: blue
+colorTo: indigo
 sdk: docker
 pinned: false
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# E2B API Proxy with FastAPI
+
+This project is a FastAPI implementation of an API proxy for E2B (fragments.e2b.dev). It provides a compatible interface for various AI model providers including OpenAI, Google, and Anthropic.
+
+## Description
+
+The E2B API Proxy acts as a middleware between your application and the E2B service, providing:
+
+- Proxy API requests to E2B service
+- Support for multiple AI models (OpenAI, Google Vertex AI, Anthropic)
+- Streaming and non-streaming response handling
+- CORS support for cross-origin requests
+
+## Deployment on Hugging Face Spaces
+
+This application is ready to be deployed on Hugging Face Spaces:
+
+1. Create a new Space on Hugging Face with Docker SDK
+2. Upload these files to your Space
+3. Set the environment variables in the Space settings:
+   - `API_KEY`: Your API key for authentication (default: sk-123456)
+   - `API_BASE_URL`: The base URL for the E2B service (default: https://fragments.e2b.dev)
+
+## API Endpoints
+
+- `GET /hf/v1/models`: List available models
+- `POST /hf/v1/chat/completions`: Send chat completion requests
+- `GET /`: Root endpoint (health check)
+
+## Configuration
+
+The main configuration is in the `app.py` file. You can customize:
+
+- API key for authentication
+- Base URL for the E2B service
+- Model configurations
+- Default headers for requests
+
+## Local Development
+
+### Prerequisites
+
+- Docker and Docker Compose
+
+### Running the Application Locally
+
+1. Clone this repository
+2. Update the API key in docker-compose.yml (replace `sk-123456` with your actual key)
+3. Build and start the container:
+
+```bash
+docker-compose up -d
+```
+
+4. The API will be available at http://localhost:7860
+
+### Testing the API
+
+You can test the API using curl:
+
+```bash
+# Get available models
+curl http://localhost:7860/hf/v1/models
+
+# Send a chat completion request
+curl -X POST http://localhost:7860/hf/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer sk-123456" \
+  -d '{
+    "model": "gpt-4o",
+    "messages": [
+      {"role": "user", "content": "Hello, how are you?"}
+    ]
+  }'
+```
+
+## Supported Models
+
+The API supports various models from different providers:
+
+- **OpenAI**: o1-preview, o3-mini, gpt-4o, gpt-4.5-preview, gpt-4-turbo
+- **Google**: gemini-1.5-pro, gemini-2.5-pro-exp-03-25, gemini-exp-1121, gemini-2.0-flash-exp
+- **Anthropic**: claude-3-5-sonnet-latest, claude-3-7-sonnet-latest, claude-3-5-haiku-latest
+
+## License
+
+This project is open source and available under the MIT License.

app.py

@@ -0,0 +1,643 @@
+import json
+import uuid
+import time
+import asyncio
+import logging
+from datetime import datetime
+from typing import Dict, List, Optional, Union, Any
+
+import httpx
+from fastapi import FastAPI, Request, Response, Depends, HTTPException, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse, JSONResponse, HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel, Field
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='[%(asctime)s] %(levelname)s: %(message)s',
+    datefmt='%Y-%m-%dT%H:%M:%S'
+)
+logger = logging.getLogger(__name__)
+
+# Import os for environment variables
+import os
+
+# Configuration constants
+CONFIG = {
+    "API": {
+        "BASE_URL": os.environ.get("API_BASE_URL", "https://fragments.e2b.dev"),
+        "API_KEY": os.environ.get("API_KEY", "sk-123456")  # Customize your own authentication key
+    },
+    "RETRY": {
+        "MAX_ATTEMPTS": 1,
+        "DELAY_BASE": 1000
+    },
+    "MODEL_CONFIG": {
+        "o1-preview": {
+            "id": "o1",
+            "provider": "OpenAI",
+            "providerId": "openai",
+            "name": "o1",
+            "multiModal": True,
+            "Systemprompt": "",
+            "opt_max": {
+                "temperatureMax": 2,
+                "max_tokensMax": 0,
+                "presence_penaltyMax": 2,
+                "frequency_penaltyMax": 2,
+                "top_pMax": 1,
+                "top_kMax": 500
+            }
+        },
+        "o3-mini": {
+            "id": "o3-mini",
+            "provider": "OpenAI",
+            "providerId": "openai",
+            "name": "o3 Mini",
+            "multiModal": True,
+            "Systemprompt": "",
+            "opt_max": {
+                "temperatureMax": 2,
+                "max_tokensMax": 4096,
+                "presence_penaltyMax": 2,
+                "frequency_penaltyMax": 2,
+                "top_pMax": 1,
+                "top_kMax": 500
+            }
+        },
+        "gpt-4o": {
+            "id": "gpt-4o",
+            "provider": "OpenAI",
+            "providerId": "openai",
+            "name": "GPT-4o",
+            "multiModal": True,
+            "Systemprompt": "",
+            "opt_max": {
+                "temperatureMax": 2,
+                "max_tokensMax": 16380,
+                "presence_penaltyMax": 2,
+                "frequency_penaltyMax": 2,
+                "top_pMax": 1,
+                "top_kMax": 500
+            }
+        },
+        "gpt-4.5-preview": {
+            "id": "gpt-4.5-preview",
+            "provider": "OpenAI",
+            "providerId": "openai",
+            "name": "GPT-4.5",
+            "multiModal": True,
+            "Systemprompt": "",
+            "opt_max": {
+                "temperatureMax": 2,
+                "max_tokensMax": 16380,
+                "presence_penaltyMax": 2,
+                "frequency_penaltyMax": 2,
+                "top_pMax": 1,
+                "top_kMax": 500
+            }
+        },
+        "gpt-4-turbo": {
+            "id": "gpt-4-turbo",
+            "provider": "OpenAI",
+            "providerId": "openai",
+            "name": "GPT-4 Turbo",
+            "multiModal": True,
+            "Systemprompt": "",
+            "opt_max": {
+                "temperatureMax": 2,
+                "max_tokensMax": 16380,
+                "presence_penaltyMax": 2,
+                "frequency_penaltyMax": 2,
+                "top_pMax": 1,
+                "top_kMax": 500
+            }
+        },
+        "gemini-1.5-pro": {
+            "id": "gemini-1.5-pro-002",
+            "provider": "Google Vertex AI",
+            "providerId": "vertex",
+            "name": "Gemini 1.5 Pro",
+            "multiModal": True,
+            "Systemprompt": "",
+            "opt_max": {
+                "temperatureMax": 2,
+                "max_tokensMax": 8192,
+                "presence_penaltyMax": 2,
+                "frequency_penaltyMax": 2,
+                "top_pMax": 1,
+                "top_kMax": 500
+            }
+        },
+        "gemini-2.5-pro-exp-03-25": {
+            "id": "gemini-2.5-pro-exp-03-25",
+            "provider": "Google Generative AI",
+            "providerId": "google",
+            "name": "Gemini 2.5 Pro Experimental 03-25",
+            "multiModal": True,
+            "Systemprompt": "",
+            "opt_max": {
+                "temperatureMax": 2,
+                "max_tokensMax": 8192,
+                "presence_penaltyMax": 2,
+                "frequency_penaltyMax": 2,
+                "top_pMax": 1,
+                "top_kMax": 40
+            }
+        },
+        "gemini-exp-1121": {
+            "id": "gemini-exp-1121",
+            "provider": "Google Generative AI",
+            "providerId": "google",
+            "name": "Gemini Experimental 1121",
+            "multiModal": True,
+            "Systemprompt": "",
+            "opt_max": {
+                "temperatureMax": 2,
+                "max_tokensMax": 8192,
+                "presence_penaltyMax": 2,
+                "frequency_penaltyMax": 2,
+                "top_pMax": 1,
+                "top_kMax": 40
+            }
+        },
+        "gemini-2.0-flash-exp": {
+            "id": "models/gemini-2.0-flash-exp",
+            "provider": "Google Generative AI",
+            "providerId": "google",
+            "name": "Gemini 2.0 Flash",
+            "multiModal": True,
+            "Systemprompt": "",
+            "opt_max": {
+                "temperatureMax": 2,
+                "max_tokensMax": 8192,
+                "presence_penaltyMax": 2,
+                "frequency_penaltyMax": 2,
+                "top_pMax": 1,
+                "top_kMax": 40
+            }
+        },
+        "claude-3-5-sonnet-latest": {
+            "id": "claude-3-5-sonnet-latest",
+            "provider": "Anthropic",
+            "providerId": "anthropic",
+            "name": "Claude 3.5 Sonnet",
+            "multiModal": True,
+            "Systemprompt": "",
+            "opt_max": {
+                "temperatureMax": 1,
+                "max_tokensMax": 8192,
+                "presence_penaltyMax": 2,
+                "frequency_penaltyMax": 2,
+                "top_pMax": 1,
+                "top_kMax": 500
+            }
+        },
+        "claude-3-7-sonnet-latest": {
+            "id": "claude-3-7-sonnet-latest",
+            "provider": "Anthropic",
+            "providerId": "anthropic",
+            "name": "Claude 3.7 Sonnet",
+            "multiModal": True,
+            "Systemprompt": "",
+            "opt_max": {
+                "temperatureMax": 1,
+                "max_tokensMax": 8192,
+                "presence_penaltyMax": 2,
+                "frequency_penaltyMax": 2,
+                "top_pMax": 1,
+                "top_kMax": 500
+            }
+        },
+        "claude-3-5-haiku-latest": {
+            "id": "claude-3-5-haiku-latest",
+            "provider": "Anthropic",
+            "providerId": "anthropic",
+            "name": "Claude 3.5 Haiku",
+            "multiModal": False,
+            "Systemprompt": "",
+            "opt_max": {
+                "temperatureMax": 1,
+                "max_tokensMax": 8192,
+                "presence_penaltyMax": 2,
+                "frequency_penaltyMax": 2,
+                "top_pMax": 1,
+                "top_kMax": 500
+            }
+        }
+    },
+    "DEFAULT_HEADERS": {
+        "accept": "*/*",
+        "accept-language": "zh-CN,zh;q=0.9",
+        "content-type": "application/json",
+        "priority": "u=1, i",
+        "sec-ch-ua": "\"Microsoft Edge\";v=\"131\", \"Chromium\";v=\"131\", \"Not_A Brand\";v=\"24\"",
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": "\"Windows\"",
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-origin",
+        "Referer": "https://fragments.e2b.dev/",
+        "Referrer-Policy": "strict-origin-when-cross-origin"
+    },
+    "MODEL_PROMPT": "Chatting with users and starting role-playing, the most important thing is to pay attention to their latest messages, use only 'text' to output the chat text reply content generated for user messages, and finally output it in code"
+}
+
+
+# Utility functions
+def generate_uuid():
+    """Generate a UUID v4 string."""
+    return str(uuid.uuid4())
+
+
+async def config_opt(params: Dict[str, Any], model_config: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Constrain parameters based on model configuration."""
+    if not model_config.get("opt_max"):
+        return None
+
+    options_map = {
+        "temperature": "temperatureMax",
+        "max_tokens": "max_tokensMax",
+        "presence_penalty": "presence_penaltyMax",
+        "frequency_penalty": "frequency_penaltyMax",
+        "top_p": "top_pMax",
+        "top_k": "top_kMax"
+    }
+
+    constrained_params = {}
+    for key, value in params.items():
+        max_key = options_map.get(key)
+        if (max_key and 
+            max_key in model_config["opt_max"] and 
+            value is not None):
+            constrained_params[key] = min(value, model_config["opt_max"][max_key])
+
+    return constrained_params
+
+
+# API client class
+class ApiClient:
+    def __init__(self, model_id: str, request_id: str = ""):
+        if model_id not in CONFIG["MODEL_CONFIG"]:
+            raise ValueError(f"Unsupported model: {model_id}")
+        self.model_config = CONFIG["MODEL_CONFIG"][model_id]
+        self.request_id = request_id
+
+    def process_message_content(self, content: Any) -> Optional[str]:
+        """Process message content to extract text."""
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            return "\n".join([item.get("text", "") for item in content if item.get("type") == "text"])
+        if isinstance(content, dict):
+            return content.get("text")
+        return None
+
+    async def prepare_chat_request(self, request: Dict[str, Any], config: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+        """Prepare chat request for E2B API."""
+        logger.info(f"[{self.request_id}] Preparing chat request, model: {self.model_config['name']}, messages count: {len(request.get('messages', []))}")
+        
+        opt_config = config or {"model": self.model_config["id"]}
+        transformed_messages = await self.transform_messages(request)
+        
+        logger.info(f"[{self.request_id}] Transformed messages count: {len(transformed_messages)}")
+        
+        return {
+            "userID": generate_uuid(),
+            "messages": transformed_messages,
+            "template": {
+                "text": {
+                    "name": CONFIG["MODEL_PROMPT"],
+                    "lib": [""],
+                    "file": "pages/ChatWithUsers.txt",
+                    "instructions": self.model_config["Systemprompt"],
+                    "port": None
+                }
+            },
+            "model": {
+                "id": self.model_config["id"],
+                "provider": self.model_config["provider"],
+                "providerId": self.model_config["providerId"],
+                "name": self.model_config["name"],
+                "multiModal": self.model_config["multiModal"]
+            },
+            "config": opt_config
+        }
+
+    async def transform_messages(self, request: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Transform and merge messages for E2B API."""
+        messages = request.get("messages", [])
+        merged_messages = []
+        
+        for current in messages:
+            current_content = self.process_message_content(current.get("content"))
+            if current_content is None:
+                continue
+                
+            if (merged_messages and 
+                current.get("role") == merged_messages[-1].get("role")):
+                last_content = self.process_message_content(merged_messages[-1].get("content"))
+                if last_content is not None:
+                    merged_messages[-1]["content"] = f"{last_content}\n{current_content}"
+                    continue
+                    
+            merged_messages.append(current)
+        
+        result = []
+        for msg in merged_messages:
+            role = msg.get("role", "")
+            content = msg.get("content", "")
+            
+            if role in ["system", "user"]:
+                result.append({
+                    "role": "user",
+                    "content": [{"type": "text", "text": content}]
+                })
+            elif role == "assistant":
+                result.append({
+                    "role": "assistant",
+                    "content": [{"type": "text", "text": content}]
+                })
+            else:
+                result.append(msg)
+                
+        return result
+
+
+# Response handler class
+class ResponseHandler:
+    @staticmethod
+    async def handle_stream_response(chat_message: str, model: str, request_id: str):
+        """Handle streaming response."""
+        logger.info(f"[{request_id}] Handling streaming response, content length: {len(chat_message)} characters")
+        
+        async def generate():
+            index = 0
+            while index < len(chat_message):
+                # Simulate chunking similar to the Deno implementation
+                chunk_size = min(15 + int(15 * (0.5 - (0.5 * (index / len(chat_message))))), 30)
+                chunk = chat_message[index:index + chunk_size]
+                
+                event_data = {
+                    "id": generate_uuid(),
+                    "object": "chat.completion.chunk",
+                    "created": int(time.time()),
+                    "model": model,
+                    "choices": [{
+                        "index": 0,
+                        "delta": {"content": chunk},
+                        "finish_reason": "stop" if index + chunk_size >= len(chat_message) else None
+                    }]
+                }
+                
+                yield f"data: {json.dumps(event_data)}\n\n"
+                
+                index += chunk_size
+                await asyncio.sleep(0.05)  # 50ms delay between chunks
+            
+            yield "data: [DONE]\n\n"
+            logger.info(f"[{request_id}] Streaming response completed")
+        
+        return StreamingResponse(
+            generate(),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+            }
+        )
+
+    @staticmethod
+    async def handle_normal_response(chat_message: str, model: str, request_id: str):
+        """Handle normal (non-streaming) response."""
+        logger.info(f"[{request_id}] Handling normal response, content length: {len(chat_message)} characters")
+        
+        response_data = {
+            "id": generate_uuid(),
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": model,
+            "choices": [{
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": chat_message
+                },
+                "finish_reason": "stop"
+            }],
+            "usage": None
+        }
+        
+        return JSONResponse(content=response_data)
+
+
+# Pydantic models for request validation
+class Message(BaseModel):
+    role: str
+    content: Union[str, List[Dict[str, Any]], Dict[str, Any]]
+
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[Message]
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = None
+    frequency_penalty: Optional[float] = None
+    top_p: Optional[float] = None
+    top_k: Optional[int] = None
+    stream: Optional[bool] = False
+
+
+# Create FastAPI app
+app = FastAPI(title="E2B API Proxy")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Mount static files directory
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+
+# Dependency for API key validation
+async def verify_api_key(request: Request):
+    auth_header = request.headers.get("authorization")
+    if not auth_header:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Missing API key"
+        )
+    
+    token = auth_header.replace("Bearer ", "")
+    if token != CONFIG["API"]["API_KEY"]:
+        logger.error(f"Authentication failed, provided token: {token[:8]}...")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid API key"
+        )
+    
+    return token
+
+
+# API endpoints
+@app.get("/hf/v1/models")
+async def get_models():
+    """Get available models."""
+    logger.info("Getting model list")
+    
+    models = [
+        {
+            "id": model_id,
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "e2b"
+        }
+        for model_id in CONFIG["MODEL_CONFIG"].keys()
+    ]
+    
+    logger.info(f"Model list returned successfully, model count: {len(models)}")
+    return {"object": "list", "data": models}
+
+
+@app.post("/hf/v1/chat/completions")
+async def chat_completions(
+    request: ChatCompletionRequest,
+    api_key: str = Depends(verify_api_key)
+):
+    """Handle chat completions."""
+    request_id = generate_uuid()
+    logger.info(f"[{request_id}] Processing chat completion request")
+    
+    try:
+        logger.info(f"[{request_id}] User request body:", {
+            "model": request.model,
+            "messages_count": len(request.messages),
+            "stream": request.stream,
+            "temperature": request.temperature,
+            "max_tokens": request.max_tokens
+        })
+        
+        # Configure options based on model limits
+        config_options = await config_opt(
+            {
+                "temperature": request.temperature,
+                "max_tokens": request.max_tokens,
+                "presence_penalty": request.presence_penalty,
+                "frequency_penalty": request.frequency_penalty,
+                "top_p": request.top_p,
+                "top_k": request.top_k
+            },
+            CONFIG["MODEL_CONFIG"][request.model]
+        )
+        
+        # Prepare request for E2B API
+        api_client = ApiClient(request.model, request_id)
+        request_payload = await api_client.prepare_chat_request(
+            request.dict(),
+            config_options
+        )
+        
+        logger.info(f"[{request_id}] Sending request to E2B:", {
+            "model": request_payload["model"]["name"],
+            "messages_count": len(request_payload["messages"]),
+            "config": request_payload["config"]
+        })
+        
+        # Send request to E2B API
+        fetch_start_time = time.time()
+        async with httpx.AsyncClient() as client:
+            fetch_response = await client.post(
+                f"{CONFIG['API']['BASE_URL']}/api/chat",
+                headers=CONFIG["DEFAULT_HEADERS"],
+                json=request_payload,
+                timeout=60.0
+            )
+        fetch_end_time = time.time()
+
+        print(fetch_response.text)
+        
+        # Process response
+        # response_data = fetch_response.json()
+        # logger.info(
+        #     f"[{request_id}] Received E2B response: {fetch_response.status_code}, "
+        #     f"time: {(fetch_end_time - fetch_start_time) * 1000:.0f}ms",
+        #     {
+        #         "status": fetch_response.status_code,
+        #         "has_code": bool(response_data.get("code")),
+        #         "has_text": bool(response_data.get("text")),
+        #         "response_preview": (response_data.get("code", "") or 
+        #                             response_data.get("text", "") or 
+        #                             "")[:100] + "..."
+        #     }
+        # )
+        
+        # # Extract message content
+        # chat_message = (
+        #     response_data.get("code", "").strip() or
+        #     response_data.get("text", "").strip() or
+        #     (response_data.strip() if isinstance(response_data, str) else None)
+        # )
+
+        chat_message = fetch_response.text
+        
+        if not chat_message:
+            logger.error(f"[{request_id}] E2B did not return a valid response")
+            raise ValueError("No response from upstream service")
+        
+        # Return response based on streaming preference
+        if request.stream:
+            return await ResponseHandler.handle_stream_response(
+                chat_message,
+                request.model,
+                request_id
+            )
+        else:
+            return await ResponseHandler.handle_normal_response(
+                chat_message,
+                request.model,
+                request_id
+            )
+            
+    except Exception as e:
+        logger.error(f"[{request_id}] Error processing request:", exc_info=e)
+        
+        return JSONResponse(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            content={
+                "error": {
+                    "message": f"{str(e)} Request failed, possibly due to context limit exceeded or other error. Please try again later.",
+                    "type": "server_error",
+                    "param": None,
+                    "code": None
+                }
+            }
+        )
+
+
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    """Root endpoint that serves the HTML UI."""
+    with open("static/index.html", "r") as f:
+        html_content = f.read()
+    return HTMLResponse(content=html_content)
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint for Hugging Face."""
+    return {"status": "ok", "message": "E2B API Proxy is running"}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    import os
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run("app:app", host="0.0.0.0", port=port, reload=True)

app.py.dockerignore

@@ -0,0 +1,23 @@
+# Ignore git and version control
+.git
+.gitignore
+
+# Ignore Docker files
+Dockerfile
+docker-compose.yml
+
+# Ignore Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Ignore environment files
+.env
+.env.example
+
+# Ignore development files
+.vscode/
+.idea/
+
+# Ignore logs
+*.log

docker-compose.yml

@@ -0,0 +1,14 @@
+version: '3.8'
+
+services:
+  e2b-api-proxy:
+    build: .
+    container_name: e2b-api-proxy
+    ports:
+      - "7860:7860"
+    environment:
+      - API_BASE_URL=https://fragments.e2b.dev
+      - API_KEY=sk-123456  # Replace with your actual API key
+    restart: unless-stopped
+    volumes:
+      - ./app.py:/app/app.py  # For development - allows code changes without rebuilding

dockerignore

@@ -0,0 +1,22 @@
+# Ignore git and version control
+.git
+.gitignore
+
+# Ignore Docker files
+docker-compose.yml
+
+# Ignore Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Ignore environment files
+.env
+.env.example
+
+# Ignore development files
+.vscode/
+.idea/
+
+# Ignore logs
+*.log

env.example

@@ -0,0 +1,7 @@
+# E2B API Configuration
+API_BASE_URL=https://fragments.e2b.dev
+API_KEY=your-api-key-here
+
+# Server Configuration
+PORT=8000
+LOG_LEVEL=INFO

gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

gitignore

@@ -0,0 +1,43 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+.env
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Logs
+logs/
+*.log
+
+# Docker
+.docker/
+
+# OS specific
+.DS_Store
+Thumbs.db

requirements.txt

@@ -0,0 +1,5 @@
+fastapi==0.110.0
+uvicorn==0.27.1
+python-dotenv==1.0.1
+httpx==0.27.0
+pydantic==2.6.1

run.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+# Set default port for Hugging Face
+export PORT=${PORT:-7860}
+
+# Start the FastAPI application
+exec uvicorn app:app --host 0.0.0.0 --port $PORT

static/index.html

@@ -0,0 +1,104 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>E2B API Proxy</title>
+    <style>
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            line-height: 1.6;
+            color: #333;
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+        h1 {
+            color: #2c3e50;
+            border-bottom: 2px solid #3498db;
+            padding-bottom: 10px;
+        }
+        h2 {
+            color: #2980b9;
+            margin-top: 30px;
+        }
+        pre {
+            background-color: #f8f9fa;
+            border: 1px solid #e9ecef;
+            border-radius: 4px;
+            padding: 15px;
+            overflow-x: auto;
+        }
+        code {
+            font-family: 'Courier New', Courier, monospace;
+        }
+        .endpoint {
+            background-color: #e9f7fe;
+            border-left: 4px solid #3498db;
+            padding: 10px 15px;
+            margin: 20px 0;
+        }
+        .method {
+            font-weight: bold;
+            color: #2980b9;
+        }
+        .url {
+            color: #27ae60;
+        }
+        .button {
+            display: inline-block;
+            background-color: #3498db;
+            color: white;
+            padding: 10px 15px;
+            text-decoration: none;
+            border-radius: 4px;
+            margin-top: 20px;
+        }
+        .button:hover {
+            background-color: #2980b9;
+        }
+    </style>
+</head>
+<body>
+    <h1>E2B API Proxy</h1>
+    <p>This is a FastAPI implementation of an API proxy for E2B (fragments.e2b.dev). It provides a compatible interface for various AI model providers including OpenAI, Google, and Anthropic.</p>
+    
+    <h2>API Endpoints</h2>
+    
+    <div class="endpoint">
+        <p><span class="method">GET</span> <span class="url">/hf/v1/models</span></p>
+        <p>List available models</p>
+        <pre><code>curl http://localhost:7860/hf/v1/models</code></pre>
+    </div>
+    
+    <div class="endpoint">
+        <p><span class="method">POST</span> <span class="url">/hf/v1/chat/completions</span></p>
+        <p>Send chat completion requests</p>
+        <pre><code>curl -X POST http://localhost:7860/hf/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer sk-123456" \
+  -d '{
+    "model": "gpt-4o",
+    "messages": [
+      {"role": "user", "content": "Hello, how are you?"}
+    ]
+  }'</code></pre>
+    </div>
+    
+    <div class="endpoint">
+        <p><span class="method">GET</span> <span class="url">/health</span></p>
+        <p>Health check endpoint</p>
+        <pre><code>curl http://localhost:7860/health</code></pre>
+    </div>
+    
+    <h2>Supported Models</h2>
+    <p>The API supports various models from different providers:</p>
+    <ul>
+        <li><strong>OpenAI</strong>: o1-preview, o3-mini, gpt-4o, gpt-4.5-preview, gpt-4-turbo</li>
+        <li><strong>Google</strong>: gemini-1.5-pro, gemini-2.5-pro-exp-03-25, gemini-exp-1121, gemini-2.0-flash-exp</li>
+        <li><strong>Anthropic</strong>: claude-3-5-sonnet-latest, claude-3-7-sonnet-latest, claude-3-5-haiku-latest</li>
+    </ul>
+    
+    <a href="https://github.com/yourusername/e2b-api-proxy" class="button">View on GitHub</a>
+</body>
+</html>