Upload app.py with huggingface_hub

app.py

@@ -522,8 +522,8 @@ async def lifespan(app: FastAPI):
 
 app = FastAPI(
     title="Free Coding API",
-    description="OpenAI & Anthropic compatible API with Prefill, Thinking & Computer Use Agent (CUA) support",
-    version="1.2.0",
+    description="OpenAI & Anthropic compatible API with Files, Skills, Batches, CUA, Prefill & Thinking support",
+    version="1.3.0",
     lifespan=lifespan
 )
 
@@ -912,6 +912,411 @@ async def anthropic_messages(
         )
     )
 
+# ============================================================================
+# Files API (Beta)
+# ============================================================================
+
+# In-memory file storage (for demo - in production use persistent storage)
+files_storage: Dict[str, Dict] = {}
+
+class FileUploadResponse(BaseModel):
+    id: str
+    object: str = "file"
+    bytes: int
+    created_at: int
+    filename: str
+    purpose: str
+
+@app.post("/v1/files")
+async def upload_file(
+    request: Request,
+    authorization: Optional[str] = Header(None),
+):
+    """Upload a file for use across multiple API calls"""
+    if not verify_api_key(authorization):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    form = await request.form()
+    file = form.get("file")
+    purpose = form.get("purpose", "assistants")
+
+    if not file:
+        raise HTTPException(status_code=400, detail="No file provided")
+
+    file_id = f"file-{uuid.uuid4().hex[:24]}"
+    content = await file.read()
+
+    file_data = {
+        "id": file_id,
+        "object": "file",
+        "bytes": len(content),
+        "created_at": int(time.time()),
+        "filename": file.filename,
+        "purpose": purpose,
+        "content": content  # Store content in memory
+    }
+    files_storage[file_id] = file_data
+
+    return FileUploadResponse(
+        id=file_id,
+        bytes=len(content),
+        created_at=file_data["created_at"],
+        filename=file.filename,
+        purpose=purpose
+    )
+
+@app.get("/v1/files")
+async def list_files(
+    authorization: Optional[str] = Header(None),
+    purpose: Optional[str] = None,
+):
+    """List all uploaded files"""
+    if not verify_api_key(authorization):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    files_list = []
+    for file_id, file_data in files_storage.items():
+        if purpose and file_data.get("purpose") != purpose:
+            continue
+        files_list.append({
+            "id": file_data["id"],
+            "object": "file",
+            "bytes": file_data["bytes"],
+            "created_at": file_data["created_at"],
+            "filename": file_data["filename"],
+            "purpose": file_data["purpose"]
+        })
+
+    return {"object": "list", "data": files_list}
+
+@app.get("/v1/files/{file_id}")
+async def get_file(
+    file_id: str,
+    authorization: Optional[str] = Header(None),
+):
+    """Get file metadata"""
+    if not verify_api_key(authorization):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    if file_id not in files_storage:
+        raise HTTPException(status_code=404, detail="File not found")
+
+    file_data = files_storage[file_id]
+    return {
+        "id": file_data["id"],
+        "object": "file",
+        "bytes": file_data["bytes"],
+        "created_at": file_data["created_at"],
+        "filename": file_data["filename"],
+        "purpose": file_data["purpose"]
+    }
+
+@app.delete("/v1/files/{file_id}")
+async def delete_file(
+    file_id: str,
+    authorization: Optional[str] = Header(None),
+):
+    """Delete a file"""
+    if not verify_api_key(authorization):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    if file_id not in files_storage:
+        raise HTTPException(status_code=404, detail="File not found")
+
+    del files_storage[file_id]
+    return {"id": file_id, "object": "file", "deleted": True}
+
+
+# ============================================================================
+# Skills API (Beta)
+# ============================================================================
+
+skills_storage: Dict[str, Dict] = {}
+
+class SkillCreate(BaseModel):
+    name: str
+    description: Optional[str] = None
+    instructions: str
+    tools: Optional[List[Dict]] = None
+
+class SkillResponse(BaseModel):
+    id: str
+    object: str = "skill"
+    name: str
+    description: Optional[str] = None
+    instructions: str
+    tools: Optional[List[Dict]] = None
+    created_at: int
+
+@app.post("/v1/skills")
+async def create_skill(
+    request: SkillCreate,
+    authorization: Optional[str] = Header(None),
+):
+    """Create a custom agent skill"""
+    if not verify_api_key(authorization):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    skill_id = f"skill-{uuid.uuid4().hex[:24]}"
+    skill_data = {
+        "id": skill_id,
+        "object": "skill",
+        "name": request.name,
+        "description": request.description,
+        "instructions": request.instructions,
+        "tools": request.tools or [],
+        "created_at": int(time.time())
+    }
+    skills_storage[skill_id] = skill_data
+
+    return SkillResponse(**skill_data)
+
+@app.get("/v1/skills")
+async def list_skills(
+    authorization: Optional[str] = Header(None),
+):
+    """List all custom skills"""
+    if not verify_api_key(authorization):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    return {
+        "object": "list",
+        "data": [
+            {k: v for k, v in skill.items()}
+            for skill in skills_storage.values()
+        ]
+    }
+
+@app.get("/v1/skills/{skill_id}")
+async def get_skill(
+    skill_id: str,
+    authorization: Optional[str] = Header(None),
+):
+    """Get skill details"""
+    if not verify_api_key(authorization):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    if skill_id not in skills_storage:
+        raise HTTPException(status_code=404, detail="Skill not found")
+
+    return skills_storage[skill_id]
+
+@app.delete("/v1/skills/{skill_id}")
+async def delete_skill(
+    skill_id: str,
+    authorization: Optional[str] = Header(None),
+):
+    """Delete a skill"""
+    if not verify_api_key(authorization):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    if skill_id not in skills_storage:
+        raise HTTPException(status_code=404, detail="Skill not found")
+
+    del skills_storage[skill_id]
+    return {"id": skill_id, "object": "skill", "deleted": True}
+
+
+# ============================================================================
+# Message Batches API (50% cost reduction for async processing)
+# ============================================================================
+
+batches_storage: Dict[str, Dict] = {}
+
+class BatchRequest(BaseModel):
+    custom_id: str
+    params: Dict  # Contains the message request parameters
+
+class CreateBatchRequest(BaseModel):
+    requests: List[BatchRequest]
+
+class BatchResponse(BaseModel):
+    id: str
+    type: str = "message_batch"
+    processing_status: str  # "in_progress", "ended"
+    request_counts: Dict
+    ended_at: Optional[int] = None
+    created_at: int
+    expires_at: int
+    results_url: Optional[str] = None
+
+@app.post("/v1/messages/batches")
+async def create_message_batch(
+    request: CreateBatchRequest,
+    authorization: Optional[str] = Header(None),
+    x_api_key: Optional[str] = Header(None, alias="x-api-key"),
+):
+    """
+    Create a Message Batch for async processing with 50% cost reduction.
+    Process large volumes of Messages requests asynchronously.
+    """
+    auth_key = x_api_key or authorization
+    if not verify_api_key(auth_key):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    batch_id = f"batch_{uuid.uuid4().hex[:24]}"
+    created_at = int(time.time())
+
+    # Process batch requests asynchronously (simulated)
+    results = []
+    succeeded = 0
+    failed = 0
+
+    for req in request.requests:
+        try:
+            # Extract message parameters
+            params = req.params
+            messages = params.get("messages", [])
+            max_tokens = params.get("max_tokens", 1024)
+
+            # Format and generate
+            formatted_msgs = []
+            for m in messages:
+                content = m.get("content", "")
+                if isinstance(content, list):
+                    content = " ".join([b.get("text", "") for b in content if b.get("type") == "text"])
+                formatted_msgs.append({"role": m.get("role"), "content": content})
+
+            prompt = format_messages_for_model(formatted_msgs)
+            response_text, _, input_tokens, output_tokens, _ = generate_response(
+                prompt, max_tokens=max_tokens
+            )
+
+            results.append({
+                "custom_id": req.custom_id,
+                "result": {
+                    "type": "succeeded",
+                    "message": {
+                        "id": f"msg_{uuid.uuid4().hex[:24]}",
+                        "type": "message",
+                        "role": "assistant",
+                        "content": [{"type": "text", "text": response_text}],
+                        "model": params.get("model", "claude-3-sonnet"),
+                        "stop_reason": "end_turn",
+                        "usage": {"input_tokens": input_tokens, "output_tokens": output_tokens}
+                    }
+                }
+            })
+            succeeded += 1
+        except Exception as e:
+            results.append({
+                "custom_id": req.custom_id,
+                "result": {
+                    "type": "errored",
+                    "error": {"type": "server_error", "message": str(e)}
+                }
+            })
+            failed += 1
+
+    batch_data = {
+        "id": batch_id,
+        "type": "message_batch",
+        "processing_status": "ended",
+        "request_counts": {
+            "processing": 0,
+            "succeeded": succeeded,
+            "errored": failed,
+            "canceled": 0,
+            "expired": 0
+        },
+        "ended_at": int(time.time()),
+        "created_at": created_at,
+        "expires_at": created_at + 86400,  # 24 hours
+        "results": results
+    }
+    batches_storage[batch_id] = batch_data
+
+    return BatchResponse(
+        id=batch_id,
+        processing_status="ended",
+        request_counts=batch_data["request_counts"],
+        ended_at=batch_data["ended_at"],
+        created_at=created_at,
+        expires_at=batch_data["expires_at"],
+        results_url=f"/v1/messages/batches/{batch_id}/results"
+    )
+
+@app.get("/v1/messages/batches")
+async def list_batches(
+    authorization: Optional[str] = Header(None),
+    x_api_key: Optional[str] = Header(None, alias="x-api-key"),
+):
+    """List all message batches"""
+    auth_key = x_api_key or authorization
+    if not verify_api_key(auth_key):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    return {
+        "object": "list",
+        "data": [
+            {k: v for k, v in batch.items() if k != "results"}
+            for batch in batches_storage.values()
+        ]
+    }
+
+@app.get("/v1/messages/batches/{batch_id}")
+async def get_batch(
+    batch_id: str,
+    authorization: Optional[str] = Header(None),
+    x_api_key: Optional[str] = Header(None, alias="x-api-key"),
+):
+    """Get batch status and details"""
+    auth_key = x_api_key or authorization
+    if not verify_api_key(auth_key):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    if batch_id not in batches_storage:
+        raise HTTPException(status_code=404, detail="Batch not found")
+
+    batch = batches_storage[batch_id]
+    return {k: v for k, v in batch.items() if k != "results"}
+
+@app.get("/v1/messages/batches/{batch_id}/results")
+async def get_batch_results(
+    batch_id: str,
+    authorization: Optional[str] = Header(None),
+    x_api_key: Optional[str] = Header(None, alias="x-api-key"),
+):
+    """Get batch results (JSONL format)"""
+    auth_key = x_api_key or authorization
+    if not verify_api_key(auth_key):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    if batch_id not in batches_storage:
+        raise HTTPException(status_code=404, detail="Batch not found")
+
+    batch = batches_storage[batch_id]
+    if batch["processing_status"] != "ended":
+        raise HTTPException(status_code=400, detail="Batch still processing")
+
+    # Return results as JSON (in real API this would be JSONL)
+    return {"results": batch.get("results", [])}
+
+@app.post("/v1/messages/batches/{batch_id}/cancel")
+async def cancel_batch(
+    batch_id: str,
+    authorization: Optional[str] = Header(None),
+    x_api_key: Optional[str] = Header(None, alias="x-api-key"),
+):
+    """Cancel a batch"""
+    auth_key = x_api_key or authorization
+    if not verify_api_key(auth_key):
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+    if batch_id not in batches_storage:
+        raise HTTPException(status_code=404, detail="Batch not found")
+
+    batch = batches_storage[batch_id]
+    if batch["processing_status"] == "ended":
+        raise HTTPException(status_code=400, detail="Batch already ended")
+
+    batch["processing_status"] = "ended"
+    batch["request_counts"]["canceled"] = batch["request_counts"].get("processing", 0)
+    batch["request_counts"]["processing"] = 0
+
+    return {k: v for k, v in batch.items() if k != "results"}
+
+
 # ============================================================================
 # Anthropic Separate Base Path: /anthropic/v1/
 # ============================================================================
@@ -1475,35 +1880,34 @@ async def cua_info():
 async def root():
     return {
         "name": "Free Coding API",
-        "version": "1.2.0",
+        "version": "1.3.0",
         "model": MODEL_ID,
         "features": {
-            "prefill_response": "Supported - Include assistant message at end for output control",
-            "thinking": "Supported - Enable with thinking: {type: 'enabled'}",
-            "streaming": "Supported - Both OpenAI and Anthropic formats",
-            "computer_use": "Supported - CUA with sheikh-computer-use-preview model"
-        },
-        "compatibility": {
-            "openai": "v1 Chat Completions API",
-            "anthropic": "Messages API (2023-06-01)",
-            "computer_use": "Anthropic Computer Use API compatible"
+            "prefill_response": "Supported",
+            "thinking": "Supported",
+            "streaming": "Supported",
+            "computer_use": "Supported",
+            "files_api": "Beta",
+            "skills_api": "Beta",
+            "message_batches": "Supported (50% cost reduction)"
         },
         "openai": {
             "base_url": "/v1",
             "chat": "/v1/chat/completions",
-            "models": "/v1/models"
+            "models": "/v1/models",
+            "files": "/v1/files",
+            "skills": "/v1/skills"
         },
         "anthropic": {
             "base_url": "/anthropic/v1",
             "messages": "/anthropic/v1/messages",
-            "models": "/anthropic/v1/models",
-            "info": "/anthropic"
+            "batches": "/v1/messages/batches",
+            "models": "/anthropic/v1/models"
         },
         "cua": {
             "base_url": "/cua/v1",
             "messages": "/cua/v1/messages",
             "models": "/cua/v1/models",
-            "info": "/cua",
             "model": "sheikh-computer-use-preview"
         },
         "docs": "/docs"