beru 1.0.0a1__py3-none-any.whl

beru/api/__init__.py

@@ -0,0 +1 @@
+# API package initialization

beru/api/v1/__init__.py

@@ -0,0 +1 @@
+# API v1 package initialization

beru/api/v1/agent_sessions.py

@@ -0,0 +1,370 @@
+"""
+Agent chat session CRUD endpoints.
+
+Routes
+------
+GET  /agent-sessions/                   — list all sessions (optionally filtered by agent_id)
+POST /agent-sessions/                   — create a session (optionally on another model)
+GET  /agent-sessions/models?agent_id=   — the models a chat may run on, and the agent's for this person
+PUT  /agent-sessions/{id}/model         — switch the chat to another model, or back to its agent's
+GET  /agent-sessions/{id}               — get session + messages
+PUT  /agent-sessions/{id}               — rename session
+DELETE /agent-sessions/{id}             — delete session (cascades to messages)
+GET  /agent-sessions/{id}/messages      — list messages only
+POST /agent-sessions/{id}/compact       — fold older turns into a summary now
+POST /agent-sessions/{id}/title         — name it from its first prompt (beru/services/titles.py)
+POST /agent-sessions/{id}/uploads       — attach files (multipart `files`); see beru/services/uploads.py
+DELETE /agent-sessions/{id}/uploads/{name} — remove an attachment that was not sent after all
+"""
+
+import logging
+from typing import List, Optional
+
+from fastapi import APIRouter, Depends, File, HTTPException, Query, UploadFile, status
+from fastapi.concurrency import run_in_threadpool
+from sqlalchemy.orm import Session
+
+from beru.core.access import Viewer, get_viewer
+from beru.core.database import get_db
+from beru.schemas.agent_session import (
+    AgentSessionCreate,
+    AgentSessionResponse,
+    AgentSessionUpdate,
+    AgentSessionWithMessages,
+    AgentMessageResponse,
+    Attachment,
+    ChatModelOption,
+    ChatModelProvider,
+    ChatModels,
+    CompactionResult,
+    ModelChoice,
+    TitleRequest,
+    model_choice,
+    session_context,
+)
+from beru.services.agent_session_service import AgentSessionService
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/agent-sessions", tags=["agent-sessions"])
+
+
+@router.get("/", response_model=List[AgentSessionResponse])
+async def list_agent_sessions(
+    agent_id: Optional[str] = Query(None, description="Filter by agent ID"),
+    db: Session = Depends(get_db),
+    viewer: Viewer = Depends(get_viewer),
+):
+    """List all agent chat sessions, optionally filtered by agent_id."""
+    return [AgentSessionResponse.from_row(s) for s in AgentSessionService(db, viewer).list_sessions(agent_id=agent_id)]
+
+
+@router.post("/", response_model=AgentSessionResponse, status_code=status.HTTP_201_CREATED)
+async def create_agent_session(
+    body: AgentSessionCreate,
+    db: Session = Depends(get_db),
+    viewer: Viewer = Depends(get_viewer),
+):
+    """Create a new agent chat session."""
+    choice = _usable_choice(db, viewer, body.model) if body.model and body.model.provider_id else None
+    svc = AgentSessionService(db, viewer)
+    session = svc.create_session(agent_id=body.agent_id, name=body.name)
+    if choice:
+        session = svc.set_model(session.id, choice)
+    return AgentSessionResponse.from_row(session)
+
+
+def _usable_choice(db: Session, viewer: Viewer, body: ModelChoice) -> dict:
+    """{"provider_id", "model"} when this person may run on it (AgentService.usable_providers), else 400."""
+    from beru.services.agent_service import AgentService
+
+    provider = AgentService(db).usable(body.provider_id, body.model, viewer.user_id, viewer.manager)
+    if provider is None:
+        raise HTTPException(status_code=400, detail="That is not a model you can use: pick one from your providers")
+    return {"provider_id": str(provider.id), "model": body.model}
+
+
+@router.get("/models", response_model=ChatModels)
+async def chat_models(
+    agent_id: Optional[str] = Query(None, description="Also say what this agent runs on for the caller"),
+    db: Session = Depends(get_db),
+    viewer: Viewer = Depends(get_viewer),
+):
+    """
+    Every model a chat may be switched to: those of the providers this person may run on (the
+    workspace's and their own; a public instance's members, their own), oldest provider first, with
+    `default`, what `agent_id` runs on for them when the chat is not switched.
+    """
+    from beru.services import beru_models
+    from beru.services.agent_service import AgentService
+
+    service = AgentService(db)
+    providers = []
+    for p in service.usable_providers(viewer.user_id, viewer.manager):
+        labels = beru_models.MODEL_LABELS if p.name == beru_models.NAME else {}
+        providers.append(ChatModelProvider(
+            provider_id=str(p.id), name=p.display_name or p.name, provider_type=str(p.provider_type),
+            personal=p.owner_user_id is not None,
+            models=[ChatModelOption(id=m, label=labels.get(m, (None, None))[0], vendor=labels.get(m, (None, None))[1])
+                    for m in p.supported_models],
+        ))
+    out = ChatModels(providers=providers)
+    agent = await service.get_agent(agent_id) if agent_id else None
+    if agent is not None:
+        out.default_yours = service.person_model(agent.id, viewer.user_id, viewer.manager) is not None
+        try:
+            ran, provider = await service.provider_for(agent, viewer.user_id, viewer.manager)
+            if provider is not None:
+                out.default = ModelChoice(provider_id=str(provider.id), model=ran.model)
+        except ValueError as e:
+            out.default_error = str(e)
+    return out
+
+
+@router.get("/{session_id}", response_model=AgentSessionWithMessages)
+async def get_agent_session(
+    session_id: str,
+    db: Session = Depends(get_db),
+    viewer: Viewer = Depends(get_viewer),
+):
+    """Get a session with its full message history."""
+    svc = AgentSessionService(db, viewer)
+    session = svc.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    msgs = svc.get_messages(session_id)
+    return AgentSessionWithMessages(
+        id=session.id,
+        agent_id=session.agent_id,
+        name=session.name,
+        created_at=session.created_at,
+        updated_at=session.updated_at,
+        context=session_context(session.meta),
+        title_source=(session.meta or {}).get("title_source"),
+        model=model_choice(session.meta),
+        messages=[
+            AgentMessageResponse(
+                id=m.id,
+                session_id=m.session_id,
+                role=m.role,
+                content=m.content,
+                tool_name=m.tool_name,
+                meta=m.meta,
+                created_at=m.created_at,
+                updated_at=m.updated_at,
+            )
+            for m in msgs
+        ],
+    )
+
+
+@router.put("/{session_id}", response_model=AgentSessionResponse)
+async def rename_agent_session(
+    session_id: str,
+    body: AgentSessionUpdate,
+    db: Session = Depends(get_db),
+    viewer: Viewer = Depends(get_viewer),
+):
+    """Rename a session."""
+    session = AgentSessionService(db, viewer).rename_session(session_id, body.name)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return AgentSessionResponse.from_row(session)
+
+
+@router.put("/{session_id}/model", response_model=AgentSessionResponse)
+async def set_agent_session_model(
+    session_id: str,
+    body: ModelChoice,
+    db: Session = Depends(get_db),
+    viewer: Viewer = Depends(get_viewer),
+):
+    """Run the chat's next turns on another model this person may use, or (both fields empty) on its
+    agent's own again. The agent itself is unchanged, for everyone else too."""
+    svc = AgentSessionService(db, viewer)
+    if not svc.get_session(session_id):
+        raise HTTPException(status_code=404, detail="Session not found")
+    choice = _usable_choice(db, viewer, body) if body.provider_id or body.model else None
+    return AgentSessionResponse.from_row(svc.set_model(session_id, choice))
+
+
+@router.post("/{session_id}/title", response_model=AgentSessionResponse)
+async def title_agent_session(
+    session_id: str,
+    body: Optional[TitleRequest] = None,
+    db: Session = Depends(get_db),
+    viewer: Viewer = Depends(get_viewer),
+):
+    """Name the session from its first prompt. A name the user typed stays unless `force`."""
+    from beru.services import titles
+
+    body = body or TitleRequest()
+    svc = AgentSessionService(db, viewer)
+    session = svc.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+    if (session.meta or {}).get("title_source") == "user" and not body.force:
+        return AgentSessionResponse.from_row(session)
+    prompt = body.prompt
+    if not prompt:
+        first = next((m for m in svc.get_messages(session_id) if m.role == "user"), None)
+        inbound = ((first.meta or {}).get("inbound") or {}) if first else {}
+        prompt = inbound.get("body") or (first.content if first else "")
+    if not (prompt or "").strip():
+        raise HTTPException(status_code=409, detail="Nothing to name it from yet: the session has no messages")
+    title = await titles.generate(prompt)
+    session = svc.rename_session(session_id, title.text, source=title.source)
+    return AgentSessionResponse.from_row(session)
+
+
+@router.delete("/{session_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_agent_session(
+    session_id: str,
+    db: Session = Depends(get_db),
+    viewer: Viewer = Depends(get_viewer),
+):
+    """Delete a session, its messages, and the files attached in it."""
+    if not AgentSessionService(db, viewer).delete_session(session_id):
+        raise HTTPException(status_code=404, detail="Session not found")
+
+
+@router.post("/{session_id}/uploads", response_model=List[Attachment], status_code=status.HTTP_201_CREATED)
+async def upload_to_agent_session(
+    session_id: str,
+    files: List[UploadFile] = File(...),
+    db: Session = Depends(get_db),
+    viewer: Viewer = Depends(get_viewer),
+):
+    """
+    Save files into the session's uploads folder in the workspace. They are attached to a message by
+    sending their names with it (`input_data.attachments`), and deleted with the session.
+    """
+    from beru.core import public
+    from beru.core.config import settings
+    from beru.services import uploads
+
+    if not AgentSessionService(db, viewer).get_session(session_id):
+        raise HTTPException(status_code=404, detail="Session not found")
+    # Agents read attachments with their workspace tools, which a public instance's members do not have.
+    public.not_for_members(viewer, "attaching files")
+    if len(files) > settings.CHAT_UPLOAD_MAX_FILES:
+        raise HTTPException(status_code=400, detail=f"At most {settings.CHAT_UPLOAD_MAX_FILES} files at a time")
+    saved: List[dict] = []
+    try:
+        for f in files:
+            saved.append(await run_in_threadpool(uploads.save, db, session_id, f.filename, f.file, f.content_type))
+    except uploads.UploadError as e:
+        # All or nothing: the files saved before the refused one would never be sent.
+        for a in saved:
+            uploads.delete_file(session_id, a["name"])
+        raise HTTPException(status_code=413 if "limit" in str(e) else 400, detail=str(e))
+    return saved
+
+
+@router.get("/{session_id}/files/{file_path:path}")
+async def get_agent_session_file(
+    session_id: str,
+    file_path: str,
+    download: bool = False,
+    db: Session = Depends(get_db),
+    viewer: Viewer = Depends(get_viewer),
+):
+    """
+    A file of this chat: one the person attached, or one an agent shared (`shared/<name>`). Only to
+    whoever may see the chat. Pages and SVGs are served sandboxed (their own opaque origin, no
+    access to this app or its cookies); `?download=1` asks the browser to save it.
+    """
+    import mimetypes
+
+    from fastapi.responses import FileResponse
+
+    from beru.services import uploads
+
+    if not AgentSessionService(db, viewer).get_session(session_id):
+        raise HTTPException(status_code=404, detail="Session not found")
+    try:
+        target = uploads.session_file(session_id, file_path)
+    except uploads.UploadError:
+        target = None
+    if target is None:
+        raise HTTPException(status_code=404, detail="File not found")
+    media = mimetypes.guess_type(target.name)[0] or "application/octet-stream"
+    if target.suffix.lower() in (".md", ".markdown", ".csv", ".txt", ".log", ".json", ".yaml", ".yml", ".py", ".ts", ".tsx", ".js"):
+        media = "text/plain; charset=utf-8" if not media.startswith("text/") or "charset" not in media else media
+    headers = {"X-Content-Type-Options": "nosniff", "Cache-Control": "private, max-age=3600"}
+    if media.split(";")[0] in ("text/html", "application/xhtml+xml", "image/svg+xml", "application/xml", "text/xml"):
+        headers["Content-Security-Policy"] = "sandbox allow-scripts allow-popups allow-downloads"
+    return FileResponse(target, media_type=media, headers=headers,
+                        filename=target.name if download else None,
+                        content_disposition_type="attachment" if download else "inline")
+
+
+@router.delete("/{session_id}/uploads/{name}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_agent_session_upload(
+    session_id: str,
+    name: str,
+    db: Session = Depends(get_db),
+    viewer: Viewer = Depends(get_viewer),
+):
+    """Remove one attachment (the chip taken off the message before it was sent)."""
+    from beru.services import uploads
+
+    if not AgentSessionService(db, viewer).get_session(session_id):
+        raise HTTPException(status_code=404, detail="Session not found")
+    if not uploads.delete_file(session_id, name):
+        raise HTTPException(status_code=404, detail="Attachment not found")
+
+
+@router.get("/{session_id}/messages", response_model=List[AgentMessageResponse])
+async def get_agent_session_messages(
+    session_id: str,
+    db: Session = Depends(get_db),
+    viewer: Viewer = Depends(get_viewer),
+):
+    """List all messages in a session."""
+    svc = AgentSessionService(db, viewer)
+    if not svc.get_session(session_id):
+        raise HTTPException(status_code=404, detail="Session not found")
+    return svc.get_messages(session_id)
+
+
+@router.post("/{session_id}/compact", response_model=CompactionResult)
+async def compact_agent_session(
+    session_id: str,
+    db: Session = Depends(get_db),
+    viewer: Viewer = Depends(get_viewer),
+):
+    """
+    Compact the session now: everything but the latest turn is folded into a summary by the
+    session's own model (see services.compaction). Automatic compaction does the same when a
+    session grows past its context budget; this is for doing it early, or after a long detour.
+    """
+    from beru.services.agent_service import AgentService
+    from beru.services.compaction import compact_session
+
+    svc = AgentSessionService(db, viewer)
+    session = svc.get_session(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+    service = AgentService(db)
+    agent = await service.get_agent(str(session.agent_id))
+    try:
+        agent, provider = await service.provider_for(agent, viewer.user_id, viewer.manager, session_id) if agent else (None, None)
+    except ValueError as e:
+        raise HTTPException(status_code=409, detail=str(e))
+    if agent is None or provider is None:
+        raise HTTPException(status_code=409, detail="The session's agent or provider no longer exists")
+    from beru.core.access import connection_visible
+
+    if not connection_visible(provider.owner_user_id, viewer):
+        raise HTTPException(status_code=409, detail="This agent runs on someone's personal provider")
+    budget = AgentService.context_budget(agent, provider)
+    try:
+        result = await compact_session(db, session_id, agent, provider, budget, keep_recent_turns=1, force=True)
+    except Exception as e:  # noqa: BLE001
+        raise HTTPException(status_code=502, detail=f"Compaction failed: {e}")
+    if result is None:
+        raise HTTPException(status_code=409, detail="Nothing to compact yet: the session needs more than one turn")
+    db.refresh(session)
+    return CompactionResult(**result, context=session_context(session.meta))
+