provekit 0.1.0__py3-none-any.whl

provekit/routers/flows.py

@@ -0,0 +1,188 @@
+"""Flows — CRUD for visual agent workflows + streamed run/step-debug."""
+import json
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import PlainTextResponse, StreamingResponse
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+
+from ..database import SessionLocal, get_db
+from ..models import Connection, Flow, Workspace, iso_utc
+from ..services import flow as engine
+from ..services import templates, testfile
+from ..services.workspace import current_workspace
+from .run import _active_vars
+
+
+def _get(db, ws, fid) -> Flow:
+    f = db.get(Flow, fid)
+    if not f or f.workspace_id != ws.id:
+        raise HTTPException(404, "Flow not found")
+    return f
+
+router = APIRouter(prefix="/api/flows", tags=["flows"])
+
+
+def _f(f: Flow) -> dict:
+    return {"id": f.id, "name": f.name, "description": f.description,
+            "nodes": f.nodes, "edges": f.edges,
+            "updated_at": iso_utc(f.updated_at)}
+
+
+@router.get("/node-types")
+def node_types():
+    return engine.NODE_TYPES
+
+
+@router.get("/templates")
+def list_templates(q: str = "", limit: int = 60):
+    """Searchable gallery of bundled flow templates (name/description/category), plus a
+    small curated `featured` showcase for the picker's default (no-search) view."""
+    return {"total": templates.total(), "categories": templates.categories(),
+            "items": templates.search(q, limit), "featured": templates.featured()}
+
+
+class FromTemplateIn(BaseModel):
+    slug: str
+
+
+@router.post("/from-template")
+def create_from_template(payload: FromTemplateIn, db: Session = Depends(get_db),
+                         ws: Workspace = Depends(current_workspace)):
+    """Instantiate a bundled template as a new flow in this workspace, resolving the
+    template's connection names against the workspace."""
+    doc = templates.load(payload.slug)
+    if not doc or doc.get("kind") != "flow":
+        raise HTTPException(404, "Template not found")
+    nodes = []
+    for n in doc["nodes"]:
+        cfg = dict(n.get("config") or {})
+        cname = cfg.pop("connection", None)
+        if cname:
+            c = db.query(Connection).filter(Connection.workspace_id == ws.id, Connection.name == cname).first()
+            cfg["connection_id"] = c.id if c else None
+        nodes.append({**n, "config": cfg})
+    f = Flow(workspace_id=ws.id, name=doc.get("name") or "New flow",
+             description=doc.get("description") or "", nodes=nodes, edges=doc["edges"])
+    db.add(f); db.commit(); db.refresh(f)
+    return _f(f)
+
+
+class FlowIn(BaseModel):
+    name: str
+    description: str = ""
+    nodes: list = []
+    edges: list = []
+
+
+@router.get("")
+def list_flows(db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    return [{"id": f.id, "name": f.name, "description": f.description,
+             "updated_at": iso_utc(f.updated_at)}
+            for f in db.query(Flow).filter(Flow.workspace_id == ws.id).order_by(Flow.id).all()]
+
+
+def _check_nodes(nodes: list) -> None:
+    from ..config import get_settings
+    cap = get_settings().max_flow_nodes
+    if cap and len(nodes or []) > cap:
+        raise HTTPException(400, f"Flow too large: {len(nodes)} nodes (max {cap}).")
+
+
+@router.post("")
+def create_flow(payload: FlowIn, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    _check_nodes(payload.nodes)
+    f = Flow(workspace_id=ws.id, name=payload.name, description=payload.description, nodes=payload.nodes, edges=payload.edges)
+    db.add(f); db.commit(); db.refresh(f)
+    return _f(f)
+
+
+@router.get("/{fid}")
+def get_flow(fid: int, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    return _f(_get(db, ws, fid))
+
+
+@router.get("/{fid}/export", response_class=PlainTextResponse)
+def export_flow(fid: int, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    f = _get(db, ws, fid)
+    ids = {(n.get("config") or {}).get("connection_id") for n in (f.nodes or [])}
+    ids.discard(None)
+    names = {c.id: c.name for c in db.query(Connection).filter(Connection.workspace_id == ws.id, Connection.id.in_(ids)).all()} if ids else {}
+    return testfile.dump_flow(f.name, f.description, f.nodes, f.edges, names)
+
+
+@router.put("/{fid}")
+def update_flow(fid: int, payload: FlowIn, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    _check_nodes(payload.nodes)
+    f = _get(db, ws, fid)
+    f.name, f.description, f.nodes, f.edges = payload.name, payload.description, payload.nodes, payload.edges
+    db.commit(); db.refresh(f)
+    return _f(f)
+
+
+@router.delete("/{fid}")
+def delete_flow(fid: int, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    f = db.get(Flow, fid)
+    if f and f.workspace_id == ws.id:
+        db.delete(f); db.commit()
+    return {"deleted": True}
+
+
+class RunPayload(BaseModel):
+    input: dict = {}
+    breakpoints: list[str] = []
+    step: bool = False
+
+
+@router.post("/{fid}/run/stream")
+def run_stream(fid: int, payload: RunPayload, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    f = _get(db, ws, fid)
+    flow = {"nodes": f.nodes, "edges": f.edges}
+    variables = _active_vars(db, ws.id)
+    ws_id = ws.id
+
+    async def events():
+        session = SessionLocal()  # request-scoped db is torn down before this generator runs
+        try:
+            async for ev in engine.run_stream(session, flow, payload.input, breakpoints=set(payload.breakpoints),
+                                              single_step=payload.step, variables=variables, workspace_id=ws_id):
+                yield f"data: {json.dumps(ev)}\n\n"
+            yield "data: [DONE]\n\n"
+        finally:
+            session.close()
+
+    return StreamingResponse(events(), media_type="text/event-stream",
+                             headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"})
+
+
+class ContinuePayload(BaseModel):
+    run_id: str
+    node_id: str
+    breakpoints: list[str] = []
+    step: bool = False
+
+
+@router.post("/{fid}/continue/stream")
+def continue_stream(fid: int, payload: ContinuePayload, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    f = _get(db, ws, fid)
+    # pop (not peek) so two concurrent /continue calls can't resume the same run and corrupt
+    # its ctx; scoped to the workspace so another tenant's run_id can't be resumed or deleted.
+    ctx = engine.pop_run(payload.run_id, ws.id)
+    if ctx is None:
+        raise HTTPException(409, "Run context expired or already resumed — start a fresh run.")
+    flow = {"nodes": f.nodes, "edges": f.edges}
+    variables = _active_vars(db, ws.id)
+    ws_id = ws.id
+
+    async def events():
+        session = SessionLocal()
+        try:
+            async for ev in engine.run_stream(session, flow, {}, breakpoints=set(payload.breakpoints), single_step=payload.step,
+                                              start_at=payload.node_id, ctx=ctx, run_id=payload.run_id, variables=variables, workspace_id=ws_id):
+                yield f"data: {json.dumps(ev)}\n\n"
+            yield "data: [DONE]\n\n"
+        finally:
+            session.close()
+
+    return StreamingResponse(events(), media_type="text/event-stream",
+                             headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"})

provekit/routers/library.py

@@ -0,0 +1,265 @@
+"""Collections, saved requests, environments (variables), and .provekit import/export.
+Everything here is scoped to the caller's workspace."""
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import PlainTextResponse
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+
+from ..database import get_db
+from ..models import Collection, Connection, Dataset, Environment, Flow, Request, Workspace
+from ..services import testfile
+from ..services.workspace import current_workspace
+
+router = APIRouter(prefix="/api", tags=["library"])
+
+
+def _scoped(db, model, oid, ws):
+    """Fetch a row by id only if it belongs to the workspace (else None)."""
+    row = db.get(model, oid)
+    return row if row and row.workspace_id == ws.id else None
+
+
+def _valid_collection(db, cid, ws) -> int | None:
+    """Return cid only if it names a collection in this workspace; a foreign/unknown id
+    becomes None (unfiled) rather than a dangling cross-workspace reference."""
+    if cid is None:
+        return None
+    return cid if _scoped(db, Collection, cid, ws) else None
+
+
+# ---- collections ----
+class CollectionIn(BaseModel):
+    name: str
+
+
+@router.get("/collections")
+def list_collections(db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    cols = db.query(Collection).filter(Collection.workspace_id == ws.id).order_by(Collection.id).all()
+    reqs = db.query(Request).filter(Request.workspace_id == ws.id).order_by(Request.updated_at.desc()).all()
+    by_col: dict[int | None, list] = {}
+    for r in reqs:
+        by_col.setdefault(r.collection_id, []).append(
+            {"id": r.id, "name": r.name, "type": r.type, "collection_id": r.collection_id})
+    return {
+        "collections": [{"id": c.id, "name": c.name, "requests": by_col.get(c.id, [])} for c in cols],
+        "loose": by_col.get(None, []),
+    }
+
+
+@router.post("/collections")
+def create_collection(payload: CollectionIn, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    c = Collection(workspace_id=ws.id, name=payload.name)
+    db.add(c); db.commit(); db.refresh(c)
+    return {"id": c.id, "name": c.name, "requests": []}
+
+
+@router.delete("/collections/{cid}")
+def delete_collection(cid: int, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    c = _scoped(db, Collection, cid, ws)
+    if c:
+        for r in db.query(Request).filter(Request.collection_id == cid).all():
+            r.collection_id = None
+        db.delete(c); db.commit()
+    return {"deleted": True}
+
+
+# ---- requests ----
+class RequestIn(BaseModel):
+    name: str
+    type: str
+    payload: dict = {}
+    collection_id: int | None = None
+
+
+def _req(r: Request) -> dict:
+    return {"id": r.id, "name": r.name, "type": r.type, "payload": r.payload,
+            "collection_id": r.collection_id}
+
+
+@router.post("/requests")
+def save_request(payload: RequestIn, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    r = Request(workspace_id=ws.id, name=payload.name, type=payload.type, payload=payload.payload,
+                collection_id=_valid_collection(db, payload.collection_id, ws))
+    db.add(r); db.commit(); db.refresh(r)
+    return _req(r)
+
+
+@router.get("/requests/{rid}")
+def get_request(rid: int, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    r = _scoped(db, Request, rid, ws)
+    if not r:
+        raise HTTPException(404, "Request not found")
+    return _req(r)
+
+
+@router.put("/requests/{rid}")
+def update_request(rid: int, payload: RequestIn, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    r = _scoped(db, Request, rid, ws)
+    if not r:
+        raise HTTPException(404, "Request not found")
+    r.name, r.type, r.payload = payload.name, payload.type, payload.payload
+    r.collection_id = _valid_collection(db, payload.collection_id, ws)
+    db.commit(); db.refresh(r)
+    return _req(r)
+
+
+@router.delete("/requests/{rid}")
+def delete_request(rid: int, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    r = _scoped(db, Request, rid, ws)
+    if r:
+        db.delete(r); db.commit()
+    return {"deleted": True}
+
+
+# ---- .provekit file import/export (the git-diffable test format) ----
+@router.get("/requests/{rid}/export", response_class=PlainTextResponse)
+def export_request(rid: int, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    r = _scoped(db, Request, rid, ws)
+    if not r:
+        raise HTTPException(404, "Request not found")
+    payload = dict(r.payload or {})
+    conn = _scoped(db, Connection, payload.get("connection_id"), ws) if payload.get("connection_id") else None
+    return testfile.dump_test(r.name, payload, conn.name if conn else None)
+
+
+class ImportIn(BaseModel):
+    content: str
+    collection_id: int | None = None
+
+
+@router.post("/import")
+def import_file(payload: ImportIn, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    """Import an .provekit document (test or flow). Connection names resolve within this
+    workspace; an unresolved name imports fine but needs a connection re-pick."""
+    try:
+        doc = testfile.load(payload.content)
+    except ValueError as exc:
+        raise HTTPException(400, str(exc))
+
+    def _resolve(name: str | None) -> int | None:
+        if not name:
+            return None
+        c = db.query(Connection).filter(Connection.workspace_id == ws.id, Connection.name == name).first()
+        return c.id if c else None
+
+    collection_id = _valid_collection(db, payload.collection_id, ws)
+    if doc["kind"] == "test":
+        req = dict(doc["request"])
+        cid = _resolve(doc.get("connection"))
+        if cid:
+            req["connection_id"] = cid
+        if doc.get("assertions"):
+            req["assertions"] = doc["assertions"]
+        r = Request(workspace_id=ws.id, name=doc.get("name") or "imported", type=req.get("type"),
+                    payload=req, collection_id=collection_id)
+        db.add(r)
+        d = None
+        if doc.get("dataset"):
+            d = Dataset(workspace_id=ws.id, name=doc.get("name") or "imported", rows=doc["dataset"])
+            db.add(d)
+        db.commit(); db.refresh(r)
+        return {"kind": "test", "request": _req(r), "dataset_id": d.id if d else None,
+                "connection_resolved": bool(cid) or not doc.get("connection")}
+
+    raw_nodes = doc["nodes"]
+    # Enforce the same node cap as create/update so import can't persist an oversized graph.
+    from ..config import get_settings
+    cap = get_settings().max_flow_nodes
+    if cap and len(raw_nodes or []) > cap:
+        raise HTTPException(400, f"Flow too large: {len(raw_nodes)} nodes (max {cap}).")
+    nodes = []
+    unresolved = 0
+    for n in raw_nodes:
+        if not isinstance(n, dict):
+            raise HTTPException(400, "Invalid flow: each node must be an object")
+        cfg = dict(n.get("config") or {})
+        cname = cfg.pop("connection", None)
+        if cname:
+            cfg["connection_id"] = _resolve(cname)
+            unresolved += cfg["connection_id"] is None
+        nodes.append({**n, "config": cfg})
+    f = Flow(workspace_id=ws.id, name=doc.get("name") or "imported", description=doc.get("description") or "",
+             nodes=nodes, edges=doc["edges"])
+    db.add(f); db.commit(); db.refresh(f)
+    return {"kind": "flow", "flow_id": f.id, "connection_resolved": unresolved == 0}
+
+
+# ---- environments ----
+class EnvironmentIn(BaseModel):
+    name: str
+    variables: dict = {}
+    is_active: bool = False
+
+
+@router.get("/environments")
+def list_environments(db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    return [{"id": e.id, "name": e.name, "variables": e.variables, "is_active": e.is_active}
+            for e in db.query(Environment).filter(Environment.workspace_id == ws.id).order_by(Environment.id).all()]
+
+
+@router.post("/environments")
+def create_environment(payload: EnvironmentIn, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    e = Environment(workspace_id=ws.id, name=payload.name, variables=payload.variables, is_active=payload.is_active)
+    db.add(e); db.commit(); db.refresh(e)
+    return {"id": e.id, "name": e.name, "variables": e.variables, "is_active": e.is_active}
+
+
+@router.put("/environments/{eid}")
+def update_environment(eid: int, payload: EnvironmentIn, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    e = _scoped(db, Environment, eid, ws)
+    if not e:
+        raise HTTPException(404, "Environment not found")
+    if payload.is_active:  # only one active at a time, within the workspace
+        for other in db.query(Environment).filter(Environment.workspace_id == ws.id, Environment.id != eid).all():
+            other.is_active = False
+    e.name, e.variables, e.is_active = payload.name, payload.variables, payload.is_active
+    db.commit()
+    return {"id": e.id, "name": e.name, "variables": e.variables, "is_active": e.is_active}
+
+
+@router.delete("/environments/{eid}")
+def delete_environment(eid: int, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    e = _scoped(db, Environment, eid, ws)
+    if e:
+        db.delete(e); db.commit()
+    return {"deleted": True}
+
+
+# ---- datasets (reusable input-row sets) ----
+class DatasetIn(BaseModel):
+    name: str
+    rows: list = []
+
+
+def _ds(d: Dataset) -> dict:
+    return {"id": d.id, "name": d.name, "rows": d.rows}
+
+
+@router.get("/datasets")
+def list_datasets(db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    return [_ds(d) for d in db.query(Dataset).filter(Dataset.workspace_id == ws.id).order_by(Dataset.id.desc()).all()]
+
+
+@router.post("/datasets")
+def create_dataset(payload: DatasetIn, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    d = Dataset(workspace_id=ws.id, name=payload.name, rows=payload.rows)
+    db.add(d); db.commit(); db.refresh(d)
+    return _ds(d)
+
+
+@router.put("/datasets/{did}")
+def update_dataset(did: int, payload: DatasetIn, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    d = _scoped(db, Dataset, did, ws)
+    if not d:
+        raise HTTPException(404, "Dataset not found")
+    d.name, d.rows = payload.name, payload.rows
+    db.commit()
+    return _ds(d)
+
+
+@router.delete("/datasets/{did}")
+def delete_dataset(did: int, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    d = _scoped(db, Dataset, did, ws)
+    if d:
+        db.delete(d); db.commit()
+    return {"deleted": True}

provekit/routers/prompts.py

@@ -0,0 +1,72 @@
+"""Prompt Registry — manage reusable prompts, scoped per workspace."""
+import re
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+
+from ..database import get_db
+from ..models import Prompt, Workspace, iso_utc
+from ..services.workspace import current_workspace
+
+router = APIRouter(prefix="/api/prompts", tags=["prompts"])
+
+
+def _slug(s: str) -> str:
+    return re.sub(r"[^a-z0-9.]+", "-", s.lower()).strip("-") or "prompt"
+
+
+def _p(p: Prompt) -> dict:
+    return {"id": p.id, "key": p.key, "name": p.name, "description": p.description,
+            "content": p.content, "updated_at": iso_utc(p.updated_at)}
+
+
+class PromptIn(BaseModel):
+    key: str | None = None
+    name: str
+    description: str = ""
+    content: str = ""
+
+
+@router.get("")
+def list_prompts(db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    return [_p(p) for p in db.query(Prompt).filter(Prompt.workspace_id == ws.id).order_by(Prompt.key).all()]
+
+
+@router.post("")
+def create_prompt(payload: PromptIn, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    def taken(k: str) -> bool:
+        return db.query(Prompt).filter(Prompt.workspace_id == ws.id, Prompt.key == k).first() is not None
+    key = payload.key or _slug(payload.name)
+    if taken(key):
+        base, n = key, 2
+        while taken(key):
+            key = f"{base}-{n}"; n += 1
+    p = Prompt(workspace_id=ws.id, key=key, name=payload.name, description=payload.description, content=payload.content)
+    db.add(p); db.commit(); db.refresh(p)
+    return _p(p)
+
+
+@router.put("/{pid}")
+def update_prompt(pid: int, payload: PromptIn, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    p = db.get(Prompt, pid)
+    if not p or p.workspace_id != ws.id:
+        raise HTTPException(404, "Prompt not found")
+    if payload.key and payload.key != p.key:
+        # Reject a rename onto an existing key with a clean 409 (the DB unique constraint
+        # would otherwise surface as an unhandled 500).
+        clash = db.query(Prompt).filter(Prompt.workspace_id == ws.id, Prompt.key == payload.key).first()
+        if clash:
+            raise HTTPException(409, f"A prompt with key '{payload.key}' already exists")
+        p.key = payload.key
+    p.name, p.description, p.content = payload.name, payload.description, payload.content
+    db.commit(); db.refresh(p)
+    return _p(p)
+
+
+@router.delete("/{pid}")
+def delete_prompt(pid: int, db: Session = Depends(get_db), ws: Workspace = Depends(current_workspace)):
+    p = db.get(Prompt, pid)
+    if p and p.workspace_id == ws.id:
+        db.delete(p); db.commit()
+    return {"deleted": True}