agentgear-ai 0.1.16__py3-none-any.whl

agentgear/server/app/api/auth.py

@@ -0,0 +1,156 @@
+import secrets
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from agentgear.server.app import schemas
+from agentgear.server.app.auth import generate_token, hash_password
+from agentgear.server.app.config import get_settings
+from agentgear.server.app.db import get_db
+from agentgear.server.app.models import AdminUser, APIKey, Project
+
+router = APIRouter(prefix="/api/auth", tags=["auth"])
+
+
+def _ensure_default_project(db: Session) -> Project:
+    project = db.query(Project).filter(Project.name == "Default Project").first()
+    if project:
+        return project
+    project = Project(name="Default Project", description="Default project for AgentGear UI")
+    db.add(project)
+    db.commit()
+    db.refresh(project)
+    return project
+
+
+def _issue_token(db: Session, project: Project, role: str = "user") -> str:
+    raw, hashed = generate_token()
+    scopes = ["runs.write", "prompts.read", "prompts.write", "tokens.manage", "datasets.read", "datasets.write", "evaluations.read", "evaluations.write"]
+    record = APIKey(project_id=project.id, key_hash=hashed, scopes=scopes, role=role)
+    db.add(record)
+    db.commit()
+    return raw
+
+
+def _login_success(db: Session, username: str, role: str = "user", project_id: str | None = None) -> schemas.AuthResponse:
+    if project_id:
+        project = db.query(Project).filter(Project.id == project_id).first()
+        if not project:
+            # Fallback if specific project ID not found (shouldn't happen for valid users, but safety)
+            project = _ensure_default_project(db)
+    else:
+        project = _ensure_default_project(db)
+            
+    token = _issue_token(db, project, role)
+    return schemas.AuthResponse(token=token, project_id=project.id, username=username, role=role)
+
+
+@router.get("/status", response_model=schemas.AuthStatus)
+def auth_status(db: Session = Depends(get_db)):
+    settings = get_settings()
+    env_mode = bool(settings.admin_username and settings.admin_password)
+    stored: Optional[AdminUser] = db.query(AdminUser).first()
+    project = db.query(Project).filter(Project.name == "Default Project").first()
+    return schemas.AuthStatus(
+        configured=env_mode or stored is not None,
+        mode="env" if env_mode else ("db" if stored else "none"),
+        username=settings.admin_username or (stored.username if stored else None),
+        project_id=project.id if project else None,
+    )
+
+
+@router.post("/setup", response_model=schemas.AuthResponse, status_code=status.HTTP_201_CREATED)
+def setup_admin(payload: schemas.AuthSetup, db: Session = Depends(get_db)):
+    settings = get_settings()
+    if settings.admin_username and settings.admin_password:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Setup is disabled when admin credentials are provided via environment.",
+        )
+    existing = db.query(AdminUser).first()
+    if existing:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Admin already configured")
+    salt = secrets.token_hex(8)
+    password_hash = hash_password(payload.password, salt)
+    admin = AdminUser(username=payload.username, password_hash=password_hash, salt=salt)
+    db.add(admin)
+    db.commit()
+    return _login_success(db, payload.username, role="admin")
+
+
+@router.post("/login", response_model=schemas.AuthResponse)
+def login(payload: schemas.AuthLogin, db: Session = Depends(get_db)):
+    settings = get_settings()
+    env_mode = settings.admin_username and settings.admin_password
+    if env_mode:
+        if payload.username != settings.admin_username or payload.password != settings.admin_password:
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
+        return _login_success(db, settings.admin_username, role="admin")
+
+    admin: Optional[AdminUser] = db.query(AdminUser).filter(AdminUser.username == payload.username).first()
+    if admin:
+        if hash_password(payload.password, admin.salt) == admin.password_hash:
+             return _login_success(db, admin.username, role="admin")
+    
+    # Check standard users
+    from agentgear.server.app.models import User
+    user: Optional[User] = db.query(User).filter(User.username == payload.username).first()
+    if user:
+        if hash_password(payload.password, user.salt) == user.password_hash:
+            return _login_success(db, user.username, role=user.role, project_id=user.project_id)
+
+    raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
+
+
+class ForgotPasswordRequest(schemas.BaseModel):
+    email: str
+
+@router.post("/forgot-password", status_code=status.HTTP_200_OK)
+def forgot_password(payload: ForgotPasswordRequest, db: Session = Depends(get_db)):
+    from agentgear.server.app.models import User, SMTPSettings
+    from agentgear.server.app.utils.email import send_email
+
+    # Find user
+    user = db.query(User).filter(User.email == payload.email).first()
+    if not user:
+        # Prevent enumeration? For internal tool maybe not critical.
+        # But let's be nice.
+        return {"message": "If an account with that email exists, a reset code has been sent."}
+
+    # Find SMTP config
+    # Try user's project first
+    smtp = None
+    if user.project_id:
+        smtp = db.query(SMTPSettings).filter(SMTPSettings.project_id == user.project_id).first()
+    
+    if not smtp or not smtp.enabled:
+        # Fallback to any enabled SMTP (e.g. global/admin)
+        smtp = db.query(SMTPSettings).filter(SMTPSettings.enabled == True).first()
+    
+    if not smtp:
+        raise HTTPException(status_code=500, detail="SMTP not configured. Contact admin.")
+
+    # Generate temp password
+    temp_pass = secrets.token_hex(4) # 8 chars
+    user.salt = secrets.token_hex(8)
+    user.password_hash = hash_password(temp_pass, user.salt)
+    db.add(user)
+    db.commit()
+
+    # Send Email
+    try:
+        subject = "AgentGear Password Reset"
+        html = f"""
+        <p>Hello {user.username},</p>
+        <p>Your password has been reset.</p>
+        <p><strong>New Password:</strong> {temp_pass}</p>
+        <p>Please login and change your password immediately.</p>
+        """
+        send_email(smtp, [user.email], subject, html)
+    except Exception as e:
+        import logging
+        logging.error(f"Failed to send reset email: {e}")
+        raise HTTPException(status_code=500, detail="Failed to send email.")
+
+    return {"message": "Password reset email sent."}

agentgear/server/app/api/datasets.py

@@ -0,0 +1,185 @@
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request, status, UploadFile, File
+from sqlalchemy.orm import Session
+
+from agentgear.server.app import schemas
+from agentgear.server.app.config import get_settings
+from agentgear.server.app.db import get_db
+from agentgear.server.app.models import Dataset, DatasetExample, Project
+from agentgear.server.app.deps import require_scopes
+
+router = APIRouter(prefix="/api/datasets", tags=["datasets"])
+
+@router.post("", response_model=schemas.DatasetRead, status_code=status.HTTP_201_CREATED)
+def create_dataset(
+    payload: schemas.DatasetCreate,
+    request: Request,
+    db: Session = Depends(get_db),
+    _: None = Depends(require_scopes(["datasets.write"])),
+):
+    settings = get_settings()
+    # RBAC check
+    pid = payload.project_id or request.state.project_id
+    if not pid:
+         # Fallback to default project if local mode or loose auth? 
+         # Ideally request.state.project_id is always set by auth middleware.
+         raise HTTPException(status_code=400, detail="Project ID required")
+
+    if not settings.local_mode and request.state.project_id and request.state.project_id != pid:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Project mismatch")
+
+    dataset = Dataset(
+        project_id=pid,
+        name=payload.name,
+        description=payload.description,
+        tags=payload.tags,
+        metadata_=payload.metadata
+    )
+    db.add(dataset)
+    db.commit()
+    db.refresh(dataset)
+    return dataset
+
+@router.get("", response_model=List[schemas.DatasetRead])
+def list_datasets(
+    project_id: str | None = Query(default=None),
+    request: Request = None,
+    db: Session = Depends(get_db),
+    _: None = Depends(require_scopes(["datasets.read"])),
+):
+    settings = get_settings()
+    query = db.query(Dataset)
+    
+    # Filter by user's project if strict mode
+    if not settings.local_mode and request.state.project_id:
+        query = query.filter(Dataset.project_id == request.state.project_id)
+    elif project_id:
+        query = query.filter(Dataset.project_id == project_id)
+        
+    return query.order_by(Dataset.created_at.desc()).all()
+
+@router.get("/{dataset_id}", response_model=schemas.DatasetRead)
+def get_dataset(
+    dataset_id: str,
+    db: Session = Depends(get_db),
+    _: None = Depends(require_scopes(["datasets.read"])),
+):
+    dataset = db.query(Dataset).filter(Dataset.id == dataset_id).first()
+    if not dataset:
+        raise HTTPException(status_code=404, detail="Dataset not found")
+    return dataset
+
+@router.post("/{dataset_id}/examples", response_model=schemas.DatasetExampleRead)
+def create_example(
+    dataset_id: str,
+    payload: schemas.DatasetExampleCreate,
+    db: Session = Depends(get_db),
+    _: None = Depends(require_scopes(["datasets.write"])),
+):
+    dataset = db.query(Dataset).filter(Dataset.id == dataset_id).first()
+    if not dataset:
+        raise HTTPException(status_code=404, detail="Dataset not found")
+        
+    example = DatasetExample(
+        dataset_id=dataset_id,
+        input_text=payload.input_text,
+        expected_output=payload.expected_output,
+        metadata_=payload.metadata
+    )
+    db.add(example)
+    db.commit()
+    db.refresh(example)
+    return example
+
+@router.get("/{dataset_id}/examples", response_model=List[schemas.DatasetExampleRead])
+def list_examples(
+    dataset_id: str,
+    db: Session = Depends(get_db),
+    _: None = Depends(require_scopes(["datasets.read"])),
+):
+    return db.query(DatasetExample).filter(DatasetExample.dataset_id == dataset_id).all()
+
+@router.delete("/{dataset_id}/examples/{example_id}", status_code=204)
+def delete_example(
+    dataset_id: str,
+    example_id: str,
+    db: Session = Depends(get_db),
+    _: None = Depends(require_scopes(["datasets.write"])),
+):
+    example = db.query(DatasetExample).filter(DatasetExample.id == example_id, DatasetExample.dataset_id == dataset_id).first()
+    if not example:
+        raise HTTPException(status_code=404, detail="Example not found")
+    
+    db.delete(example)
+    db.commit()
+
+@router.post("/{dataset_id}/upload", status_code=201)
+async def upload_dataset_file(
+    dataset_id: str,
+    file: UploadFile = File(...),
+    db: Session = Depends(get_db),
+    _: None = Depends(require_scopes(["datasets.write"])),
+):
+    dataset = db.query(Dataset).filter(Dataset.id == dataset_id).first()
+    if not dataset:
+        raise HTTPException(status_code=404, detail="Dataset not found")
+
+    content = await file.read()
+    filename = file.filename.lower()
+    
+    examples_to_add = []
+    
+    import csv
+    import json
+    import io
+
+    try:
+        if filename.endswith(".csv"):
+            # Expect header: input, output (optional)
+            text = content.decode("utf-8")
+            reader = csv.DictReader(io.StringIO(text))
+            for row in reader:
+                # Flexible column matching
+                input_text = row.get("input") or row.get("input_text") or row.get("prompt")
+                expected_output = row.get("output") or row.get("expected_output") or row.get("completion")
+                
+                if input_text:
+                    examples_to_add.append({
+                        "input_text": input_text,
+                        "expected_output": expected_output
+                    })
+                    
+        elif filename.endswith(".json"):
+            data = json.loads(content)
+            if isinstance(data, list):
+                for item in data:
+                    input_text = item.get("input") or item.get("input_text") or item.get("prompt")
+                    expected_output = item.get("output") or item.get("expected_output") or item.get("completion")
+                    if input_text:
+                        examples_to_add.append({
+                            "input_text": input_text,
+                            "expected_output": expected_output
+                        })
+        else:
+             raise HTTPException(status_code=400, detail="Unsupported file type. Use .csv or .json")
+             
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Failed to parse file: {str(e)}")
+
+    if not examples_to_add:
+        return {"message": "No valid examples found", "count": 0}
+
+    # Bulk insert
+    objects = [
+        DatasetExample(
+            dataset_id=dataset_id, 
+            input_text=ex["input_text"], 
+            expected_output=ex.get("expected_output")
+        ) 
+        for ex in examples_to_add
+    ]
+    db.add_all(objects)
+    db.commit()
+    
+    return {"message": "Successfully uploaded examples", "count": len(objects)}

agentgear/server/app/api/evaluations.py

@@ -0,0 +1,69 @@
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request, status
+from sqlalchemy.orm import Session
+
+from agentgear.server.app import schemas
+from agentgear.server.app.config import get_settings
+from agentgear.server.app.db import get_db
+from agentgear.server.app.models import Evaluation, Project, Trace
+from agentgear.server.app.deps import require_scopes
+
+router = APIRouter(prefix="/api/scores", tags=["evaluations"])
+
+@router.post("", response_model=schemas.EvaluationRead, status_code=status.HTTP_201_CREATED)
+def create_score(
+    payload: schemas.EvaluationCreate,
+    request: Request,
+    db: Session = Depends(get_db),
+    _: None = Depends(require_scopes(["evaluations.write"])),
+):
+    settings = get_settings()
+     # RBAC check
+    if not settings.local_mode and request.state.project_id and request.state.project_id != payload.project_id:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Project mismatch")
+
+    # Validate target exists (logic can be expanded)
+    if payload.trace_id:
+        trace = db.query(Trace).filter(Trace.id == payload.trace_id).first()
+        if not trace:
+             raise HTTPException(status_code=404, detail="Trace not found")
+
+    evaluation = Evaluation(
+        project_id=payload.project_id,
+        trace_id=payload.trace_id,
+        run_id=payload.run_id,
+        span_id=payload.span_id,
+        evaluator_type=payload.evaluator_type,
+        score=payload.score,
+        max_score=payload.max_score,
+        passed=payload.passed,
+        comments=payload.comments,
+        metadata_=payload.metadata
+    )
+    db.add(evaluation)
+    db.commit()
+    db.refresh(evaluation)
+    return evaluation
+
+@router.get("", response_model=List[schemas.EvaluationRead])
+def list_scores(
+    trace_id: str | None = Query(default=None),
+    project_id: str | None = Query(default=None),
+    request: Request = None,
+    db: Session = Depends(get_db),
+    _: None = Depends(require_scopes(["evaluations.read"])),
+):
+    settings = get_settings()
+    query = db.query(Evaluation)
+    
+    # Filter by user's project if strict mode
+    if not settings.local_mode and request.state.project_id:
+        query = query.filter(Evaluation.project_id == request.state.project_id)
+    elif project_id:
+        query = query.filter(Evaluation.project_id == project_id)
+        
+    if trace_id:
+        query = query.filter(Evaluation.trace_id == trace_id)
+        
+    return query.order_by(Evaluation.created_at.desc()).all()

agentgear/server/app/api/evaluators.py

@@ -0,0 +1,157 @@
+from typing import List, Optional
+from fastapi import APIRouter, Depends, HTTPException, status, Request
+from sqlalchemy.orm import Session
+from pydantic import BaseModel
+
+from agentgear.server.app import schemas
+from agentgear.server.app.config import get_settings
+from agentgear.server.app.db import get_db
+from agentgear.server.app.models import Evaluator, Trace, Run, Span, Project
+from agentgear.server.app.deps import require_scopes
+
+router = APIRouter(prefix="/api/evaluators", tags=["evaluators"])
+
+class EvaluateRequest(BaseModel):
+    trace_id: Optional[str] = None
+    run_id: Optional[str] = None # span id if run_id? confusing naming in models. Run=Span container (Trace)?
+    # In my model: Run = Trace (renamed in UI?), Span = Step.
+    # Actually Trace = container, Run = ? 
+    # Let's look at models again. Trace has many Runs? 
+    # Trace has Span. Run has Span.
+    # Trace seems to be the top level.
+    # Let's support trace_id and span_id.
+
+    span_id: Optional[str] = None
+
+@router.post("", response_model=schemas.EvaluatorRead, status_code=status.HTTP_201_CREATED)
+def create_evaluator(
+    payload: schemas.EvaluatorCreate,
+    request: Request,
+    db: Session = Depends(get_db),
+    _: None = Depends(require_scopes(["evaluations.write"])),
+):
+    settings = get_settings()
+    pid = payload.project_id or request.state.project_id
+    if not pid:
+        raise HTTPException(status_code=400, detail="Project ID required")
+
+    obj = Evaluator(
+        project_id=pid,
+        name=payload.name,
+        prompt_template=payload.prompt_template,
+        model=payload.model,
+        config=payload.config
+    )
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.get("", response_model=List[schemas.EvaluatorRead])
+def list_evaluators(
+    request: Request,
+    db: Session = Depends(get_db),
+    _: None = Depends(require_scopes(["evaluations.read"])),
+):
+    settings = get_settings()
+    pid = request.state.project_id
+    query = db.query(Evaluator)
+    if not settings.local_mode and pid:
+        query = query.filter(Evaluator.project_id == pid)
+    return query.all()
+
+@router.post("/{evaluator_id}/run")
+async def run_evaluation(
+    evaluator_id: str,
+    target: EvaluateRequest,
+    db: Session = Depends(get_db),
+    _: None = Depends(require_scopes(["evaluations.write"])),
+):
+    evaluator = db.query(Evaluator).filter(Evaluator.id == evaluator_id).first()
+    if not evaluator:
+        raise HTTPException(status_code=404, detail="Evaluator not found")
+
+    # Fetch context
+    input_text = ""
+    output_text = ""
+    
+    if target.span_id:
+        span = db.query(Span).filter(Span.id == target.span_id).first()
+        if not span:
+             raise HTTPException(status_code=404, detail="Span not found")
+        # Find input/output from span?
+        # Span doesn't strictly have input_text/output_text columns in my memory, let's check models.
+        # It has request_payload / response_payload.
+        # Or I might have added input_text?
+        # Checking models.py... Span has request_payload (JSON), response_payload (JSON).
+        # We need to extract text.
+        input_text = str(span.request_payload)
+        output_text = str(span.response_payload)
+        
+    elif target.trace_id:
+        trace = db.query(Trace).filter(Trace.id == target.trace_id).first()
+        if not trace:
+            raise HTTPException(status_code=404, detail="Trace not found")
+        input_text = trace.input_text
+        output_text = trace.output_text
+    else:
+        raise HTTPException(status_code=400, detail="Target trace_id or span_id required")
+
+    # Simple template substitution
+    prompt = evaluator.prompt_template.replace("{{input}}", str(input_text)).replace("{{output}}", str(output_text))
+    
+    # Call LLM
+    try:
+        from agentgear.server.app.utils.llm import call_llm
+        import os
+        
+        # Simple provider detection
+        provider = "openai" 
+        # In a real app, looking up LLMModel by name to get provider/key would be better
+        # For now, rely on env var
+        api_key = os.getenv("OPENAI_API_KEY", "")
+        
+        messages = [{"role": "user", "content": prompt}]
+        
+        # call_llm is synchronous currently
+        result_text = call_llm(
+            provider=provider,
+            api_key=api_key,
+            model_name=evaluator.model,
+            messages=messages,
+            config=evaluator.config
+        )
+        
+        # Parse result - expecting JSON? or Score? 
+        # For simplicity, let's assume the template asks for a number 0-1 or JSON.
+        # We'll try to extract a number.
+        score = None
+        try:
+            import re
+            match = re.search(r'\b(0(\.\d+)?|1(\.0+)?)\b', result_text)
+            if match:
+                score = float(match.group(0))
+        except:
+            pass
+
+        # Save Evaluation
+        from agentgear.server.app.models import Evaluation
+        evaluation = Evaluation(
+            project_id=evaluator.project_id,
+            trace_id=target.trace_id,
+            span_id=target.span_id,
+            evaluator_type="llm_as_a_judge",
+            score=score,
+            comments=result_text,
+            metadata_={"evaluator_id": evaluator.id, "model": evaluator.model}
+        )
+        db.add(evaluation)
+        db.commit()
+        db.refresh(evaluation)
+        
+        return evaluation
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=str(e))

agentgear/server/app/api/llm_models.py

@@ -0,0 +1,39 @@
+from typing import List
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+
+from agentgear.server.app import schemas
+from agentgear.server.app.db import get_db
+from agentgear.server.app.models import LLMModel
+
+router = APIRouter(prefix="/api/models", tags=["models"])
+
+
+@router.get("", response_model=List[schemas.LLMModelRead])
+def list_models(db: Session = Depends(get_db)):
+    return db.query(LLMModel).all()
+
+
+@router.post("", response_model=schemas.LLMModelRead, status_code=status.HTTP_201_CREATED)
+def create_model(payload: schemas.LLMModelCreate, db: Session = Depends(get_db)):
+    model = LLMModel(
+        name=payload.name,
+        provider=payload.provider,
+        api_key=payload.api_key,
+        base_url=payload.base_url,
+        config=payload.config
+    )
+    db.add(model)
+    db.commit()
+    db.refresh(model)
+    return model
+
+@router.delete("/{model_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_model(model_id: str, db: Session = Depends(get_db)):
+    model = db.query(LLMModel).filter(LLMModel.id == model_id).first()
+    if not model:
+        raise HTTPException(status_code=404, detail="Model not found")
+    
+    db.delete(model)
+    db.commit()

agentgear/server/app/api/metrics.py

@@ -0,0 +1,18 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy import func
+from sqlalchemy.orm import Session
+
+from agentgear.server.app import schemas
+from agentgear.server.app.db import get_db
+from agentgear.server.app.models import Project, Prompt, Run, Span
+
+router = APIRouter(prefix="/api/metrics", tags=["metrics"])
+
+
+@router.get("/summary", response_model=schemas.MetricsSummary)
+def metrics_summary(db: Session = Depends(get_db)):
+    runs = db.query(func.count(Run.id)).scalar() or 0
+    spans = db.query(func.count(Span.id)).scalar() or 0
+    prompts = db.query(func.count(Prompt.id)).scalar() or 0
+    projects = db.query(func.count(Project.id)).scalar() or 0
+    return schemas.MetricsSummary(runs=runs, spans=spans, prompts=prompts, projects=projects)