@cachly-dev/mcp-server 0.10.64 → 0.10.66

package/apps/travel-chaos-organizer/backend/app/routers/inbox.py

@@ -1,122 +0,0 @@
-import json
-from datetime import datetime
-from typing import Annotated
-from uuid import UUID
-from fastapi import APIRouter, Depends, HTTPException, status
-from sqlalchemy import text
-from sqlalchemy.ext.asyncio import AsyncSession
-from app.auth.keycloak import user_id
-from app.db.database import get_db
-from app.models.schemas import InboxItemOut, InboxAssign
-
-
-def _safe_dt(val: str | None) -> datetime | None:
-    """Convert an ISO 8601 string to datetime, returning None on failure."""
-    if not val or not isinstance(val, str):
-        return None
-    try:
-        return datetime.fromisoformat(val.replace("Z", "+00:00"))
-    except ValueError:
-        return None
-
-router = APIRouter(prefix="/inbox", tags=["inbox"])
-
-
-def _parse_inbox_row(row: dict) -> dict:
-    if isinstance(row.get("parsed_data"), str):
-        try:
-            row["parsed_data"] = json.loads(row["parsed_data"])
-        except (json.JSONDecodeError, TypeError):
-            row["parsed_data"] = None
-    return row
-
-
-@router.get("", response_model=list[InboxItemOut])
-async def list_inbox(
-    uid: Annotated[str, Depends(user_id)],
-    db: Annotated[AsyncSession, Depends(get_db)],
-    status_filter: str = "pending",
-):
-    result = await db.execute(
-        text("SELECT * FROM chaos_inbox WHERE user_id = :uid AND status = :status ORDER BY created_at DESC"),
-        {"uid": uid, "status": status_filter},
-    )
-    return [_parse_inbox_row(dict(r._mapping)) for r in result.fetchall()]
-
-
-@router.post("/{inbox_id}/assign", response_model=dict)
-async def assign_to_trip(
-    inbox_id: UUID,
-    body: InboxAssign,
-    uid: Annotated[str, Depends(user_id)],
-    db: Annotated[AsyncSession, Depends(get_db)],
-):
-    iid = str(inbox_id)
-    row = await db.execute(
-        text("SELECT * FROM chaos_inbox WHERE id = :id AND user_id = :uid"),
-        {"id": iid, "uid": uid},
-    )
-    inbox_item = row.fetchone()
-    if not inbox_item:
-        raise HTTPException(status_code=404, detail="Inbox item not found")
-
-    # Verify the target trip belongs to this user (prevents assigning to other users' trips)
-    trip_check = await db.execute(
-        text("SELECT id FROM trips WHERE id = :tid AND user_id = :uid"),
-        {"tid": str(body.trip_id), "uid": uid},
-    )
-    if not trip_check.fetchone():
-        raise HTTPException(status_code=403, detail="Trip not found or access denied")
-
-    item = dict(inbox_item._mapping)
-    raw_pd = item.get("parsed_data") or {}
-    parsed = json.loads(raw_pd) if isinstance(raw_pd, str) else raw_pd
-    title = parsed.get("title", "Imported item") if isinstance(parsed, dict) else "Imported item"
-
-    result = await db.execute(
-        text("""
-            INSERT INTO trip_items (trip_id, user_id, type, title, raw_text, parsed_data,
-                                    event_at, event_end_at, booking_ref, provider)
-            VALUES (:trip_id, :uid, :type, :title, :raw, :pd,
-                    :event_at, :event_end_at, :booking_ref, :provider)
-            RETURNING id, title, event_at
-        """),
-        {
-            "trip_id": str(body.trip_id), "uid": uid, "type": body.type, "title": title,
-            "raw": item.get("raw_content"), "pd": json.dumps(parsed),
-            "event_at": _safe_dt(parsed.get("event_at") if isinstance(parsed, dict) else None),
-            "event_end_at": _safe_dt(parsed.get("event_end_at") if isinstance(parsed, dict) else None),
-            "booking_ref": parsed.get("booking_ref") if isinstance(parsed, dict) else None,
-            "provider": parsed.get("provider") if isinstance(parsed, dict) else None,
-        },
-    )
-    row = result.fetchone()
-    trip_item_id = row[0]
-    item_title = row[1]
-    event_at = row[2].isoformat() if row[2] else None
-
-    await db.execute(
-        text("UPDATE chaos_inbox SET status = 'assigned', updated_at = CURRENT_TIMESTAMP WHERE id = :id"),
-        {"id": iid},
-    )
-    await db.execute(
-        text("UPDATE attachments SET trip_item_id = :tid, inbox_id = NULL WHERE inbox_id = :iid"),
-        {"tid": trip_item_id, "iid": iid},
-    )
-    await db.commit()
-    return {"trip_item_id": str(trip_item_id), "title": item_title, "event_at": event_at}
-
-
-@router.delete("/{inbox_id}", status_code=status.HTTP_204_NO_CONTENT)
-async def reject_inbox_item(
-    inbox_id: UUID,
-    uid: Annotated[str, Depends(user_id)],
-    db: Annotated[AsyncSession, Depends(get_db)],
-):
-    result = await db.execute(
-        text("UPDATE chaos_inbox SET status = 'rejected', updated_at = CURRENT_TIMESTAMP WHERE id = :id AND user_id = :uid"),
-        {"id": str(inbox_id), "uid": uid},
-    )
-    await db.commit()
-    if result.rowcount == 0:
-        raise HTTPException(status_code=404, detail="Inbox item not found")

package/apps/travel-chaos-organizer/backend/app/routers/items.py

@@ -1,130 +0,0 @@
-import json
-from typing import Annotated
-from uuid import UUID
-from fastapi import APIRouter, Depends, HTTPException, Request, status
-from sqlalchemy import text
-from sqlalchemy.ext.asyncio import AsyncSession
-from app.auth.keycloak import user_id
-from app.db.database import get_db
-from app.limiter import limiter
-from app.models.schemas import TripItemCreate, TripItemOut, TripItemUpdate
-
-router = APIRouter(prefix="/trips/{trip_id}/items", tags=["items"])
-
-
-async def _assert_trip_owner(trip_id: str, uid: str, db: AsyncSession) -> None:
-    result = await db.execute(
-        text("SELECT id FROM trips WHERE id = :id AND user_id = :uid"),
-        {"id": trip_id, "uid": uid},
-    )
-    if not result.fetchone():
-        raise HTTPException(status_code=404, detail="Trip not found")
-
-
-def _parse_item_row(row: dict) -> dict:
-    """Deserialize parsed_data from JSON string (SQLite) or dict (PostgreSQL)."""
-    if isinstance(row.get("parsed_data"), str):
-        try:
-            row["parsed_data"] = json.loads(row["parsed_data"])
-        except (json.JSONDecodeError, TypeError):
-            row["parsed_data"] = None
-    return row
-
-
-@router.get("", response_model=list[TripItemOut])
-async def list_items(
-    trip_id: UUID,
-    uid: Annotated[str, Depends(user_id)],
-    db: Annotated[AsyncSession, Depends(get_db)],
-):
-    tid = str(trip_id)
-    await _assert_trip_owner(tid, uid, db)
-    result = await db.execute(
-        text("SELECT * FROM trip_items WHERE trip_id = :tid ORDER BY event_at ASC"),
-        {"tid": tid},
-    )
-    return [_parse_item_row(dict(r._mapping)) for r in result.fetchall()]
-
-
-@limiter.limit("30/minute")
-@router.post("", response_model=TripItemOut, status_code=status.HTTP_201_CREATED)
-async def create_item(
-    request: Request,
-    trip_id: UUID,
-    body: TripItemCreate,
-    uid: Annotated[str, Depends(user_id)],
-    db: Annotated[AsyncSession, Depends(get_db)],
-):
-    tid = str(trip_id)
-    await _assert_trip_owner(tid, uid, db)
-    pd_json = json.dumps(body.parsed_data) if body.parsed_data else None
-    result = await db.execute(
-        text("""
-            INSERT INTO trip_items
-              (trip_id, user_id, type, title, raw_text, parsed_data,
-               event_at, event_end_at, booking_ref, provider)
-            VALUES
-              (:trip_id, :uid, :type, :title, :raw_text, :parsed_data,
-               :event_at, :event_end_at, :booking_ref, :provider)
-            RETURNING *
-        """),
-        {
-            "trip_id": tid, "uid": uid, "type": body.type, "title": body.title,
-            "raw_text": body.raw_text, "parsed_data": pd_json,
-            "event_at": body.event_at, "event_end_at": body.event_end_at,
-            "booking_ref": body.booking_ref, "provider": body.provider,
-        },
-    )
-    await db.commit()
-    return _parse_item_row(dict(result.fetchone()._mapping))
-
-
-@limiter.limit("30/minute")
-@router.patch("/{item_id}", response_model=TripItemOut)
-async def update_item(
-    request: Request,
-    trip_id: UUID,
-    item_id: UUID,
-    body: TripItemUpdate,
-    uid: Annotated[str, Depends(user_id)],
-    db: Annotated[AsyncSession, Depends(get_db)],
-):
-    tid, iid = str(trip_id), str(item_id)
-    await _assert_trip_owner(tid, uid, db)
-    updates = body.model_dump(exclude_none=True)
-    if not updates:
-        raise HTTPException(status_code=400, detail="Nothing to update")
-    if "parsed_data" in updates:
-        updates["parsed_data"] = json.dumps(updates["parsed_data"])
-
-    set_clauses = ", ".join(f"{k} = :{k}" for k in updates)
-    updates.update({"item_id": iid, "trip_id": tid})
-    result = await db.execute(
-        text(f"UPDATE trip_items SET {set_clauses}, updated_at = CURRENT_TIMESTAMP WHERE id = :item_id AND trip_id = :trip_id RETURNING *"),
-        updates,
-    )
-    row = result.fetchone()
-    if not row:
-        raise HTTPException(status_code=404, detail="Item not found")
-    await db.commit()
-    return _parse_item_row(dict(row._mapping))
-
-
-@limiter.limit("30/minute")
-@router.delete("/{item_id}", status_code=status.HTTP_204_NO_CONTENT)
-async def delete_item(
-    request: Request,
-    trip_id: UUID,
-    item_id: UUID,
-    uid: Annotated[str, Depends(user_id)],
-    db: Annotated[AsyncSession, Depends(get_db)],
-):
-    tid, iid = str(trip_id), str(item_id)
-    await _assert_trip_owner(tid, uid, db)
-    result = await db.execute(
-        text("DELETE FROM trip_items WHERE id = :item_id AND trip_id = :trip_id"),
-        {"item_id": iid, "trip_id": tid},
-    )
-    await db.commit()
-    if result.rowcount == 0:
-        raise HTTPException(status_code=404, detail="Item not found")

package/apps/travel-chaos-organizer/backend/app/routers/mail.py

@@ -1,108 +0,0 @@
-"""
-Mail import endpoint — paste raw email text or forward as plain text.
-Gmail / Outlook share-to-app flows send the body as plain text;
-we strip headers and run it through the same Ollama parsing pipeline.
-Results are Cachly-cached by content hash when CACHLY_REDIS_URL is configured.
-"""
-import json
-import re
-from datetime import datetime
-from typing import Annotated
-from uuid import UUID
-
-from fastapi import APIRouter, Body, Depends, Query
-from pydantic import ValidationError
-from sqlalchemy import text
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.auth.keycloak import user_id
-from app.config import get_settings
-from app.db.database import get_db
-from app.models.schemas import ParseResponse, ParsedTravelData
-from app.services import ollama as ollama_svc
-
-router = APIRouter(prefix="/mail", tags=["mail"])
-settings = get_settings()
-
-_HEADER_RE = re.compile(
-    r"^(From|To|Cc|Bcc|Subject|Date|Message-ID|MIME-Version|Content-Type"
-    r"|Content-Transfer-Encoding|Delivered-To|Received|Return-Path|X-[^:]+)"
-    r":\s.*$",
-    re.MULTILINE | re.IGNORECASE,
-)
-_BLANK_LINES_RE = re.compile(r"\n{3,}")
-
-
-def _safe_dt(val: str | None) -> datetime | None:
-    """Parse an Ollama-produced datetime string to a proper datetime object.
-    asyncpg requires a datetime object (not a string) for TIMESTAMPTZ columns.
-    Returns None on missing or unparseable input."""
-    if val is None:
-        return None
-    try:
-        return datetime.fromisoformat(val.replace("Z", "+00:00"))
-    except (ValueError, AttributeError):
-        return None
-
-
-def _build_parsed(parsed_dict: dict) -> ParsedTravelData:
-    """Build a ParsedTravelData, falling back to safe defaults on ValidationError.
-    Matches the same pattern as parse.py to avoid a double-fail scenario."""
-    try:
-        return ParsedTravelData(**{k: parsed_dict.get(k) for k in ParsedTravelData.model_fields})
-    except ValidationError:
-        return ParsedTravelData(
-            type="other",
-            title=str(parsed_dict.get("title") or "E-Mail"),
-            booking_ref=parsed_dict.get("booking_ref"),
-            provider=parsed_dict.get("provider"),
-            event_at=parsed_dict.get("event_at"),
-            raw_summary=parsed_dict.get("raw_summary"),
-        )
-
-
-def strip_email_headers(raw: str) -> str:
-    cleaned = _HEADER_RE.sub("", raw)
-    cleaned = _BLANK_LINES_RE.sub("\n\n", cleaned)
-    return cleaned.strip()
-
-
-@router.post("/import", response_model=ParseResponse)
-async def import_mail(
-    uid: Annotated[str, Depends(user_id)],
-    db: Annotated[AsyncSession, Depends(get_db)],
-    raw_email: str = Body(..., media_type="text/plain", description="Raw email body (paste or share)"),
-    trip_id: UUID | None = Query(None, description="Assign directly to this trip (optional)"),
-):
-    body_text = strip_email_headers(raw_email)
-    parsed_dict, _was_cached = await ollama_svc.parse_text(body_text)
-    parsed = _build_parsed(parsed_dict)
-
-    if trip_id:
-        await db.execute(
-            text("""
-                INSERT INTO trip_items
-                  (trip_id, user_id, type, title, raw_text, parsed_data,
-                   event_at, event_end_at, booking_ref, provider)
-                VALUES (:trip_id, :uid, :type, :title, :raw, :pd,
-                        :event_at, :event_end_at, :booking_ref, :provider)
-            """),
-            {
-                "trip_id": str(trip_id), "uid": uid, "type": parsed.type, "title": parsed.title,
-                "raw": body_text, "pd": json.dumps(parsed.model_dump()),
-                "event_at": _safe_dt(parsed.event_at),
-                "event_end_at": _safe_dt(parsed.event_end_at),
-                "booking_ref": parsed.booking_ref, "provider": parsed.provider,
-            },
-        )
-    else:
-        await db.execute(
-            text("""
-                INSERT INTO chaos_inbox (user_id, raw_content, parsed_data, source)
-                VALUES (:uid, :raw, :pd, 'mail')
-            """),
-            {"uid": uid, "raw": body_text, "pd": json.dumps(parsed.model_dump())},
-        )
-    await db.commit()
-
-    return ParseResponse(parsed=parsed, raw_text=body_text, model_used=settings.ollama_model)

package/apps/travel-chaos-organizer/backend/app/routers/parse.py

@@ -1,303 +0,0 @@
-"""
-Parse endpoint — accepts file upload, raw text, or a public URL.
-Returns structured travel data via Ollama AI.
-Results are deduplicated via Cachly Redis when CACHLY_REDIS_URL is configured.
-"""
-from datetime import datetime, timezone
-from typing import Annotated
-from uuid import UUID
-import aiofiles
-import os
-from pathlib import Path
-from fastapi import APIRouter, Depends, File, Form, HTTPException, Request, UploadFile, status
-from pydantic import BaseModel, ValidationError
-from sqlalchemy import text
-from sqlalchemy.ext.asyncio import AsyncSession
-from app.auth.keycloak import user_id, user_id_or_bot
-from app.config import get_settings
-from app.db.database import get_db
-from app.models.schemas import ParseResponse, ParsedTravelData
-from app.services import ollama as ollama_svc
-from app.services.parser import extract_text_from_pdf, is_image, is_pdf, is_text
-from app.services.cache import cachly_configured
-from app.services import quota
-from app.limiter import limiter
-
-router = APIRouter(prefix="/parse", tags=["parse"])
-settings = get_settings()
-
-# ── helpers ────────────────────────────────────────────────────────────────────
-
-def _safe_dt(val: str | None) -> datetime | None:
-    """Parse an ISO 8601 datetime string from Ollama to a proper datetime.
-    Returns None if the value is missing, empty, or not parseable.
-    asyncpg requires a proper datetime object or None for TIMESTAMPTZ columns.
-    """
-    if not val or not isinstance(val, str):
-        return None
-    try:
-        # Python 3.11+ fromisoformat handles most ISO 8601 variants.
-        # Replace trailing Z (UTC) so older code paths also work.
-        return datetime.fromisoformat(val.replace("Z", "+00:00"))
-    except ValueError:
-        return None
-
-
-def _build_parsed(parsed_dict: dict) -> ParsedTravelData:
-    """Construct ParsedTravelData from Ollama output.
-    Falls back to safe defaults if Ollama returns an unexpected 'type' value
-    (e.g. 'taxi', 'parking') that is not in the Literal enum — which would
-    otherwise raise an unhandled Pydantic ValidationError and return a 500.
-    """
-    try:
-        return ParsedTravelData(**{k: parsed_dict.get(k) for k in ParsedTravelData.model_fields})
-    except ValidationError:
-        return ParsedTravelData(
-            type="other",
-            title=str(parsed_dict.get("title") or "Dokument"),
-            booking_ref=parsed_dict.get("booking_ref"),
-            provider=parsed_dict.get("provider"),
-            event_at=parsed_dict.get("event_at"),
-            raw_summary=parsed_dict.get("raw_summary"),
-        )
-
-
-async def _save_file(content: bytes, filename: str, uid: str) -> str:
-    dest_dir = Path(settings.upload_dir) / uid
-    dest_dir.mkdir(parents=True, exist_ok=True)
-    dest = dest_dir / filename
-    async with aiofiles.open(dest, "wb") as f:
-        await f.write(content)
-    return str(dest)
-
-
-async def _insert_item_from_parsed(
-    uid: str, trip_id: UUID, parsed: ParsedTravelData,
-    raw_text: str | None, file_path: str | None,
-    mime: str | None, filename: str | None,
-    db: AsyncSession,
-) -> None:
-    import json
-    result = await db.execute(
-        text("""
-            INSERT INTO trip_items
-              (trip_id, user_id, type, title, raw_text, parsed_data,
-               event_at, event_end_at, booking_ref, provider)
-            VALUES (:trip_id, :uid, :type, :title, :raw_text, :pd,
-                    :event_at, :event_end_at, :booking_ref, :provider)
-            RETURNING id
-        """),
-        {
-            "trip_id": str(trip_id), "uid": uid, "type": parsed.type, "title": parsed.title,
-            "raw_text": raw_text, "pd": json.dumps(parsed.model_dump()),
-            # _safe_dt converts Ollama's freeform date strings to proper datetime objects.
-            # asyncpg / PostgreSQL rejects non-ISO strings for TIMESTAMPTZ columns,
-            # which would crash the INSERT and roll back the whole transaction.
-            "event_at": _safe_dt(parsed.event_at), "event_end_at": _safe_dt(parsed.event_end_at),
-            "booking_ref": parsed.booking_ref, "provider": parsed.provider,
-        },
-    )
-    item_id = result.fetchone()[0]
-
-    if file_path:
-        await db.execute(
-            text("""
-                INSERT INTO attachments (trip_item_id, user_id, file_path, file_name, mime_type)
-                VALUES (:item_id, :uid, :fp, :fn, :mime)
-            """),
-            # file_name is NOT NULL in the schema. Use a fallback to avoid a constraint
-            # violation that would roll back the trip_item insert in the same transaction.
-            {"item_id": item_id, "uid": uid, "fp": file_path, "fn": filename or "attachment", "mime": mime or "application/octet-stream"},
-        )
-    await db.commit()
-
-
-async def _insert_inbox(
-    uid: str, raw_text: str | None, parsed_dict: dict,
-    file_path: str | None, mime: str | None, filename: str | None,
-    db: AsyncSession,
-) -> dict:
-    import json
-    result = await db.execute(
-        text("""
-            INSERT INTO chaos_inbox (user_id, raw_content, parsed_data, source)
-            VALUES (:uid, :raw, :pd, :source)
-            RETURNING id
-        """),
-        {"uid": uid, "raw": raw_text, "pd": json.dumps(parsed_dict), "source": filename or "text"},
-    )
-    inbox_id = result.fetchone()[0]
-
-    if file_path:
-        await db.execute(
-            text("""
-                INSERT INTO attachments (inbox_id, user_id, file_path, file_name, mime_type)
-                VALUES (:inbox_id, :uid, :fp, :fn, :mime)
-            """),
-            {"inbox_id": inbox_id, "uid": uid, "fp": file_path, "fn": filename or "attachment", "mime": mime or "application/octet-stream"},
-        )
-    await db.commit()
-    return {"inbox_id": str(inbox_id)}
-
-# ── endpoints ──────────────────────────────────────────────────────────────────
-
-@limiter.limit("10/minute")
-@router.post("/file", response_model=ParseResponse)
-async def parse_file(
-    request: Request,
-    uid: Annotated[str, Depends(user_id_or_bot)],
-    db: Annotated[AsyncSession, Depends(get_db)],
-    file: UploadFile = File(...),
-    trip_id: UUID | None = Form(None),
-):
-    await quota.check_parse(db, uid)
-    _s = get_settings()
-    content = await file.read()
-    if len(content) > _s.max_upload_bytes:
-        raise HTTPException(status_code=413, detail=f"File too large. Max {_s.max_upload_bytes // 1024 // 1024} MB.")
-    mime = file.content_type or "application/octet-stream"
-    raw_text: str | None = None
-    parsed_dict: dict = {}
-
-    was_cached = False
-    if is_pdf(mime):
-        raw_text = extract_text_from_pdf(content)
-        parsed_dict, was_cached = await ollama_svc.parse_text(raw_text)
-    elif is_image(mime):
-        parsed_dict, raw_text, was_cached = await ollama_svc.parse_image(content, mime)
-    elif is_text(mime):
-        raw_text = content.decode("utf-8", errors="replace")
-        parsed_dict, was_cached = await ollama_svc.parse_text(raw_text)
-    else:
-        raise HTTPException(status_code=415, detail=f"Unsupported file type: {mime}")
-
-    file_path = await _save_file(content, file.filename or "upload", uid)
-    parsed = _build_parsed(parsed_dict)
-
-    if trip_id:
-        await _insert_item_from_parsed(uid, trip_id, parsed, raw_text, file_path, mime, file.filename, db)
-    else:
-        await _insert_inbox(uid, raw_text, parsed_dict, file_path, mime, file.filename, db)
-
-    from app.services import telemetry, notifier as notifier_svc
-    await telemetry.track(db, uid, "parse_file", {"mime": mime, "trip_id": str(trip_id) if trip_id else None, "cached": was_cached})
-    if not was_cached:
-        dest = f"Trip zugewiesen" if trip_id else "Chaos Inbox"
-        await notifier_svc.notify_user(db, uid, f"✅ *{parsed.title or 'Dokument'}* geparst\nTyp: {parsed.type} · {dest}")
-    return ParseResponse(parsed=parsed, raw_text=raw_text, model_used=settings.ollama_model)
-
-
-@limiter.limit("20/minute")
-@router.post("/text", response_model=ParseResponse)
-async def parse_text_endpoint(
-    request: Request,
-    uid: Annotated[str, Depends(user_id_or_bot)],
-    db: Annotated[AsyncSession, Depends(get_db)],
-    raw_text: str = Form(...),
-    trip_id: UUID | None = Form(None),
-):
-    await quota.check_parse(db, uid)
-    parsed_dict, was_cached = await ollama_svc.parse_text(raw_text)
-    parsed = _build_parsed(parsed_dict)
-
-    if trip_id:
-        await _insert_item_from_parsed(uid, trip_id, parsed, raw_text, None, None, None, db)
-    else:
-        await _insert_inbox(uid, raw_text, parsed_dict, None, None, None, db)
-
-    from app.services import telemetry
-    await telemetry.track(db, uid, "parse_text", {"mime": None, "trip_id": str(trip_id) if trip_id else None, "cached": was_cached})
-    return ParseResponse(parsed=parsed, raw_text=raw_text, model_used=settings.ollama_model)
-
-
-class ParseUrlRequest(BaseModel):
-    url: str
-    trip_id: UUID | None = None
-
-
-@limiter.limit("5/minute")
-@router.post("/url")
-async def parse_url(
-    request: Request,
-    body: ParseUrlRequest,
-    uid: Annotated[str, Depends(user_id)],
-    db: Annotated[AsyncSession, Depends(get_db)],
-):
-    """
-    Fetch a public URL and parse its content with Ollama.
-    Useful for online booking confirmation pages.
-    Cached in Cachly Redis when CACHLY_REDIS_URL is configured.
-    """
-    import httpx as _httpx
-    from html.parser import HTMLParser
-
-    class _TextExtractor(HTMLParser):
-        def __init__(self):
-            super().__init__()
-            self._parts: list[str] = []
-            self._skip = False
-        def handle_starttag(self, tag, attrs):
-            if tag in ("script", "style", "nav", "footer"):
-                self._skip = True
-        def handle_endtag(self, tag):
-            if tag in ("script", "style", "nav", "footer"):
-                self._skip = False
-        def handle_data(self, data):
-            if not self._skip and data.strip():
-                self._parts.append(data.strip())
-        def text(self) -> str:
-            return " ".join(self._parts)[:8000]
-
-    # SSRF protection: only allow http/https, block private/loopback IP ranges
-    import ipaddress as _ip
-    try:
-        _parsed = _httpx.URL(body.url)
-        if _parsed.scheme not in ("http", "https"):
-            raise HTTPException(status_code=422, detail="Only http/https URLs are allowed")
-        import socket as _socket
-        try:
-            _addr = _socket.gethostbyname(_parsed.host)
-            _net = _ip.ip_address(_addr)
-            if _net.is_private or _net.is_loopback or _net.is_link_local or _net.is_reserved:
-                raise HTTPException(status_code=422, detail="URL resolves to a private/internal address")
-        except HTTPException:
-            raise
-        except Exception:
-            pass  # DNS failure handled below
-    except HTTPException:
-        raise
-    except Exception:
-        raise HTTPException(status_code=422, detail="Invalid URL")
-
-    try:
-        async with _httpx.AsyncClient(timeout=20, follow_redirects=True) as client:
-            resp = await client.get(body.url, headers={"User-Agent": "Mozilla/5.0 TCO/0.1"})
-            resp.raise_for_status()
-    except HTTPException:
-        raise
-    except Exception:
-        raise HTTPException(status_code=422, detail="Could not fetch URL")
-
-    await quota.check_parse(db, uid)
-    ct = resp.headers.get("content-type", "")
-    if "html" in ct:
-        extractor = _TextExtractor()
-        extractor.feed(resp.text)
-        raw_text = extractor.text()
-    elif "pdf" in ct:
-        raw_text = extract_text_from_pdf(resp.content)
-    else:
-        raw_text = resp.text[:8000]
-
-    parsed_dict, was_cached = await ollama_svc.parse_text(raw_text)
-    parsed = _build_parsed(parsed_dict)
-
-    from app.services import telemetry
-    if body.trip_id:
-        await _insert_item_from_parsed(uid, body.trip_id, parsed, raw_text, None, None, body.url, db)
-        await telemetry.track(db, uid, "parse_url", {"mime": None, "trip_id": str(body.trip_id) if body.trip_id else None, "cached": was_cached})
-        return ParseResponse(parsed=parsed, raw_text=raw_text, model_used=settings.ollama_model)
-    else:
-        result = await _insert_inbox(uid, raw_text, parsed_dict, None, None, body.url, db)
-        await telemetry.track(db, uid, "parse_url", {"mime": None, "trip_id": None, "cached": was_cached})
-        return {**ParseResponse(parsed=parsed, raw_text=raw_text, model_used=settings.ollama_model).model_dump(), **result}