spatialagents 0.1.0__py3-none-any.whl

spatialagents/chat/http.py

@@ -0,0 +1,308 @@
+"""The chat's HTTP + SSE contract, framework-free: `ChatApi`.
+
+The page (`chat/static/`) and Plexora's chat panel speak one wire. Paths are
+relative to wherever a host mounts the API (Plexora's `/ai/v1`, the stdlib
+server's `/api`):
+
+    POST /conversations                  start one          {title, viewer}
+    GET  /conversations                  list them          ?limit=
+    GET  /conversations/<id>             one, with events   ?after=
+    POST /conversations/<id>/messages    the user's message {text, images}
+    GET  /conversations/<id>/events      SSE, or a held poll (?after=&wait=)
+    POST /conversations/<id>/control     pause|resume|stop  {action}
+    POST /conversations/<id>/approve     approve|deny       {approval_id, decision}
+    POST /conversations/<id>/undo        an Undo chip       {operation_id}   (when the host can undo)
+
+and, when the host gives a `plans.PlanService`:
+
+    POST /plans                          start one: compose a plan for {goal, dataset}
+    GET  /plans                          list them
+    GET  /plans/<run_id>                 the run's status and its plan
+    GET  /plans/<run_id>/events          SSE, or a held poll
+    POST /plans/<run_id>/answer          the person's answer {decision_id, answer}
+    POST /plans/<run_id>/resolve         which option free text meant {decision_id, text}
+    POST /plans/<run_id>/confirm         confirm and run
+    POST /plans/<run_id>/continue        go on after a checkpoint {from_step?, until_step?}
+    POST /plans/<run_id>/summarise       the report
+    POST /plans/<run_id>/retry           send a paused packet again
+    POST /plans/<run_id>/stop            stop between steps
+
+A JSON answer is `{"success": true, "ok": true, ...result}`, or `{"success":
+false, "ok": false, "error": {code, message, detail, retryable}}` with 409 for a
+conflict, 403 for a licence or a permission, 404 for an unknown id and 400
+otherwise. `/events` streams server-sent events when the client asks for them
+(`Accept: text/event-stream`, what `EventSource` sends, or `?stream=1`) --
+`id: <seq>`, `event: <name>`, `data: <json>`, a `retry:` hint first and
+keep-alive comments while idle, picking up after `Last-Event-ID` on a
+reconnect -- and otherwise answers a held poll, the fallback when a proxy
+buffers the stream. `?until_idle=1` ends a stream with an `idle` event once
+nothing is running.
+
+The operations behind the routes are `ChatOperations` over a
+`conversations.ChatService`; a product that drives its conversations through
+its own capability layer (Plexora's `ai.chat_*`, for its licence check and
+audit) gives its own, and keeps its own guards in front. Approving is the
+person's hand: a host must only mount `/approve` where the caller is the
+person at the page (the stdlib server's cookie, Plexora's viewer), never on a
+surface a model's tools can reach.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import time
+from dataclasses import dataclass, field
+from typing import Any, Iterator
+from urllib.parse import unquote
+
+from spatialagents.errors import AgentError
+
+#: How long one SSE response stays open before the client reconnects.
+STREAM_S = 300.0
+#: The longest a held poll waits.
+HELD_POLL_S = 20.0
+#: How long a stream waits for an event before a keep-alive comment.
+KEEPALIVE_S = 10.0
+STATUS = {"conflict": 409, "license_required": 403, "permission_required": 403}
+
+
+@dataclass
+class Response:
+    """What a host sends back: JSON (`body`), or a stream of SSE chunks."""
+
+    status: int = 200
+    body: Any = None
+    headers: dict = field(default_factory=dict)
+    stream: Iterator[str] | None = None
+
+    @property
+    def content_type(self) -> str:
+        return "text/event-stream" if self.stream is not None else "application/json"
+
+    def json_bytes(self) -> bytes:
+        return json.dumps(self.body, default=str, ensure_ascii=False).encode("utf-8")
+
+
+def ok(result: dict | None = None, status: int = 200) -> Response:
+    return Response(status, {"success": True, "ok": True, **(result or {})})
+
+
+def refused(error: dict, status: int | None = None) -> Response:
+    code = error.get("code") if isinstance(error, dict) else None
+    return Response(status or STATUS.get(code, 400), {"success": False, "ok": False, "error": error})
+
+
+def missing(message: str) -> Response:
+    return Response(404, {"success": False, "error": message})
+
+
+class ChatOperations:
+    """The routes' operations over a `ChatService`, as the person at the page
+    asks for them. Each returns a result dict or raises `AgentError`."""
+
+    def __init__(self, service, *, policy=None):
+        from spatialagents.policy import Policy
+
+        self.service = service
+        self.policy = policy or Policy(principal="page")
+
+    def start(self, *, title: str | None = None, viewer: bool = False) -> dict:
+        return self.service.start(self.policy, title=title, viewer=viewer)
+
+    def history(self, conversation_id: str | None = None, **options) -> dict:
+        """The conversations (`limit`), or one with its events (`after`,
+        `wait_s`): only what the route was given is passed."""
+        return self.service.history(conversation_id, after=int(options.get("after", 0)),
+                                    limit=int(options.get("limit", 500)), wait_s=float(options.get("wait_s", 0)))
+
+    def send(self, conversation_id: str, text: str, images: list) -> dict:
+        if not str(text or "").strip() and not images:
+            raise AgentError("invalid_input", "send some text or an image")
+        sent = self.service.send(conversation_id, text, images, policy=self.policy)
+        return {**sent, **self.service.events(conversation_id, sent["after"])}
+
+    def control(self, conversation_id: str, action: str) -> dict:
+        return {"control": self.service.control(conversation_id, action)}
+
+    def approve(self, conversation_id: str, approval_id: str, decision: str) -> dict:
+        if decision not in ("approve", "deny"):
+            raise AgentError("invalid_input", f"decision is approve or deny, not {decision!r}")
+        approval = self.service.approve(conversation_id, approval_id, decision == "approve", by="page")
+        return {"approval": approval}
+
+
+_CONVERSATION = re.compile(r"^/conversations/([^/]+)(?:/([a-z_]+))?$")
+_PLAN = re.compile(r"^/plans/([^/]+)(?:/([a-z_]+))?$")
+
+
+class ChatApi:
+    """The contract above, over a `ChatService` (and a `PlanService`).
+
+    `undo(operation_id) -> result` is the host's reversal of a write a
+    conversation made (Plexora's `undo_operation`); without it `/undo` is 404."""
+
+    def __init__(self, service, *, operations: ChatOperations | None = None, plans=None, undo=None,
+                 stream_s: float = STREAM_S, held_poll_s: float = HELD_POLL_S, keepalive_s: float = KEEPALIVE_S):
+        self.service = service
+        self.operations = operations or ChatOperations(service)
+        self.plans = plans
+        self.undo = undo
+        self.stream_s = stream_s
+        self.held_poll_s = held_poll_s
+        self.keepalive_s = keepalive_s
+
+    # -- dispatch -------------------------------------------------------------------
+
+    def handle(self, method: str, path: str, *, query: dict | None = None, body: dict | None = None,
+               headers: dict | None = None) -> Response:
+        method = method.upper()
+        path = "/" + path.strip("/")
+        query = {k: (v[0] if isinstance(v, list) else v) for k, v in (query or {}).items()}
+        headers = {str(k).lower(): v for k, v in (headers or {}).items()}
+        body = body if isinstance(body, dict) else {}
+        try:
+            if path == "/conversations":
+                if method == "POST":
+                    return ok(self.operations.start(title=body.get("title"), viewer=bool(body.get("viewer"))))
+                if method == "GET":
+                    return ok(self.operations.history(limit=int(_number(query, "limit", 50))))
+            found = _CONVERSATION.match(path)
+            if found:
+                return self._conversation(method, unquote(found.group(1)), found.group(2), query, body, headers)
+            if self.plans is not None:
+                if path == "/plans":
+                    if method == "POST":
+                        return ok(self.plans.start(str(body.get("goal") or ""), str(body.get("dataset") or "")),
+                                  201)
+                    if method == "GET":
+                        return ok({"plans": self.plans.list(int(_number(query, "limit", 50)))})
+                found = _PLAN.match(path)
+                if found:
+                    return self._plan(method, unquote(found.group(1)), found.group(2), query, body, headers)
+        except AgentError as exc:
+            return refused(exc.to_problem())
+        except (TypeError, ValueError) as exc:
+            return refused({"code": "invalid_input", "message": str(exc), "detail": None, "retryable": False})
+        return missing(f"no route {method} {path}")
+
+    def _conversation(self, method, cid, action, query, body, headers) -> Response:
+        if action is None and method == "GET":
+            return ok(self.operations.history(cid, after=int(_number(query, "after", 0))))
+        if action == "messages" and method == "POST":
+            return ok(self.operations.send(cid, body.get("text") or "", body.get("images") or []))
+        if action == "events" and method == "GET":
+            return self._events(cid, query, headers)
+        if action == "control" and method == "POST":
+            return ok(self.operations.control(cid, body.get("action")))
+        if action == "approve" and method == "POST":
+            return ok(self.operations.approve(cid, body.get("approval_id"), body.get("decision")))
+        if action == "undo" and method == "POST" and self.undo is not None:
+            return self._undo(cid, str(body.get("operation_id") or ""))
+        return missing(f"no route {method} /conversations/{cid}/{action or ''}".rstrip("/"))
+
+    def _undo(self, cid: str, operation_id: str) -> Response:
+        store = self.service.store
+        if not store.exists(cid):
+            return missing(f"no conversation {cid!r}")
+        made = {e.get("operation_id") for e in store.decisions(cid) if e.get("event") == "tool_result"}
+        if not operation_id or operation_id not in made:
+            return Response(400, {"success": False, "error": "that operation was not made by this conversation"})
+        try:
+            result = self.undo(operation_id)
+        except AgentError as exc:
+            return refused(exc.to_problem())
+        self.service.note(cid, f"[The user undid operation {operation_id} from the chat panel.]")
+        store.append_event(cid, {"event": "undone", "operation_id": operation_id})
+        return ok(result if isinstance(result, dict) else {})
+
+    # -- events -------------------------------------------------------------------------
+
+    @staticmethod
+    def _wants_stream(query, headers) -> bool:
+        return "text/event-stream" in str(headers.get("accept") or "") or query.get("stream") == "1"
+
+    @staticmethod
+    def _cursor(query, headers) -> int:
+        after = int(_number(query, "after", 0))
+        last = str(headers.get("last-event-id") or "")
+        return int(last) if last.isdigit() else after
+
+    def _events(self, cid, query, headers) -> Response:
+        if not self._wants_stream(query, headers):
+            wait = max(0.0, min(_number(query, "wait", 0), self.held_poll_s))
+            return ok(self.operations.history(cid, after=int(_number(query, "after", 0)), wait_s=wait))
+        after = self._cursor(query, headers)
+        if not self.service.store.exists(cid):
+            return missing(f"no conversation {cid!r}")
+
+        def poll(cursor, wait_s):
+            polled = self.service.events(cid, cursor, wait_s=wait_s)
+            return polled["events"], polled["running"]
+
+        return self._stream(poll, after, until_idle=query.get("until_idle") == "1")
+
+    def _stream(self, poll, after: int, *, until_idle: bool) -> Response:
+        def chunks():
+            cursor = after
+            deadline = time.monotonic() + self.stream_s
+            yield "retry: 2000\n\n"
+            while time.monotonic() < deadline:
+                events, running = poll(cursor, self.keepalive_s)
+                for event in events:
+                    cursor = event["seq"]
+                    yield (f"id: {cursor}\nevent: {event.get('event', 'message')}\n"
+                           f"data: {json.dumps(event, default=str)}\n\n")
+                if not events:
+                    if not running and until_idle:
+                        yield f"event: idle\ndata: {json.dumps({'after': cursor})}\n\n"
+                        return
+                    yield ": keep-alive\n\n"
+
+        return Response(200, None, {"Cache-Control": "no-cache", "X-Accel-Buffering": "no"}, chunks())
+
+    # -- plans ----------------------------------------------------------------------------
+
+    def _plan(self, method, run_id, action, query, body, headers) -> Response:
+        plans = self.plans
+        if action is None and method == "GET":
+            return ok(plans.status(run_id))
+        if action == "events" and method == "GET":
+            if not self._wants_stream(query, headers):
+                wait = max(0.0, min(_number(query, "wait", 0), self.held_poll_s))
+                return ok(plans.events(run_id, int(_number(query, "after", 0)), wait))
+            after = self._cursor(query, headers)
+            plans.run(run_id)                 # 400 now for an unknown run, not mid-stream
+
+            def poll(cursor, wait_s):
+                polled = plans.events(run_id, cursor, wait_s)
+                return polled["events"], polled["running"]
+
+            return self._stream(poll, after, until_idle=query.get("until_idle") == "1")
+        if method != "POST":
+            return missing(f"no route {method} /plans/{run_id}/{action or ''}".rstrip("/"))
+        if action == "answer":
+            if "decision_id" not in body or "answer" not in body:
+                raise AgentError("invalid_input", "answer needs decision_id and answer")
+            return ok(plans.answer(run_id, str(body["decision_id"]), body["answer"]))
+        if action == "resolve":
+            return ok(plans.resolve(run_id, str(body.get("decision_id") or ""), str(body.get("text") or "")))
+        if action == "confirm":
+            return ok(plans.confirm(run_id), 202)
+        if action == "continue":
+            return ok(plans.proceed(run_id, from_step=body.get("from_step"), until_step=body.get("until_step")),
+                      202)
+        if action == "summarise":
+            return ok(plans.summarise(run_id), 202)
+        if action == "retry":
+            return ok(plans.retry(run_id), 202)
+        if action == "stop":
+            return ok(plans.stop(run_id))
+        return missing(f"no route POST /plans/{run_id}/{action}")
+
+
+def _number(query: dict, name: str, default: float) -> float:
+    try:
+        return float(query.get(name, default))
+    except (TypeError, ValueError):
+        return default

spatialagents/chat/server.py

@@ -0,0 +1,269 @@
+"""The chat page and its API on a loopback port, with nothing but the standard library.
+
+    server = ChatServer(ChatApi(service, plans=plans), title="SCIMAP Pro AI")
+    server.start()                    # a thread; or serve_forever()
+    print(server.launch_url)          # http://127.0.0.1:<port>/?token=<one-time token>
+
+This is the host a product with no web app of its own gives a person (SCIMAP
+Pro's `scimappro ai chat`), and the one a notebook kernel runs in a thread. It
+serves the page (`chat/static/`) at `/`, its assets at `/static/`, and the
+`ChatApi` at `/api/`.
+
+**Who may talk to it.** It binds a loopback address only. The launch URL
+carries a one-time token; the first request with it trades the token for an
+`HttpOnly`, `SameSite=Strict` session cookie (Plexora's idiom: only the entry
+URL ever carries a secret) and is redirected to the same page without it, so
+the token is in no history, log or `Referer`. The token is used once: a second
+request with it is refused. Every other request needs the cookie; a POST also
+needs `Content-Type: application/json` and, when the browser sends one, an
+`Origin` that is this server's. The token comes from the caller or the
+environment (`SPATIALAGENTS_CHAT_TOKEN`, how a parent process hands it to a
+sidecar), never from argv, where other users of the machine could read it.
+
+`/approve` is the person's hand: only the page holding the cookie can reach
+it, and no tool a model can call talks to this server.
+"""
+
+from __future__ import annotations
+
+import hmac
+import json
+import os
+import secrets
+import threading
+from http.cookies import SimpleCookie
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from importlib import resources
+from pathlib import Path
+from urllib.parse import parse_qs, urlencode, urlsplit
+
+TOKEN_ENV = "SPATIALAGENTS_CHAT_TOKEN"
+COOKIE = "spatialagents_chat"
+LOOPBACK = ("127.0.0.1", "::1", "localhost")
+#: The most a request body may be (images ride in it, base64).
+MAX_BODY = 40 * 1024 * 1024
+STATIC_TYPES = {".js": "text/javascript; charset=utf-8", ".css": "text/css; charset=utf-8",
+                ".html": "text/html; charset=utf-8", ".svg": "image/svg+xml", ".png": "image/png"}
+
+
+def static_dir() -> Path:
+    """The page's files, as installed."""
+    return Path(str(resources.files("spatialagents.chat") / "static"))
+
+
+class ChatServer:
+    """`api` behind a one-time token and a session cookie, on a loopback port.
+
+    `page` (the page's settings: `title`, `assistant`, `dataset`, `plans`,
+    `undo`) is handed to the page as JSON; nothing the server holds -- the
+    token, the session -- is ever in it."""
+
+    def __init__(self, api, *, host: str = "127.0.0.1", port: int = 0, token: str | None = None,
+                 title: str = "AI assistant", page: dict | None = None):
+        if host not in LOOPBACK:
+            raise ValueError(f"the chat server binds a loopback address only, not {host!r}")
+        self.api = api
+        self.title = title
+        self.page = {"title": title, "base": "api", "plans": api.plans is not None, "undo": api.undo is not None,
+                     **(page or {})}
+        self._token = token or os.environ.get(TOKEN_ENV) or secrets.token_urlsafe(24)
+        self._token_used = False
+        self._sessions: set[str] = set()
+        self._lock = threading.Lock()
+        self.httpd = ThreadingHTTPServer((host, port), self._handler())
+        self.httpd.daemon_threads = True
+        self.thread: threading.Thread | None = None
+
+    # -- addresses -------------------------------------------------------------------
+
+    @property
+    def address(self) -> tuple:
+        return self.httpd.server_address[:2]
+
+    @property
+    def url(self) -> str:
+        host, port = self.address
+        host = f"[{host}]" if ":" in host else host
+        return f"http://{host}:{port}/"
+
+    @property
+    def launch_url(self) -> str:
+        """Where the person starts: the page, with the one-time token."""
+        return self.url + "?" + urlencode({"token": self._token})
+
+    # -- running ------------------------------------------------------------------------
+
+    def start(self) -> "ChatServer":
+        self.thread = threading.Thread(target=self.httpd.serve_forever, name="spatialagents-chat-server",
+                                       daemon=True)
+        self.thread.start()
+        return self
+
+    def serve_forever(self) -> None:
+        self.httpd.serve_forever()
+
+    def stop(self) -> None:
+        self.httpd.shutdown()
+        self.httpd.server_close()
+
+    def __enter__(self):
+        return self.start()
+
+    def __exit__(self, *exc):
+        self.stop()
+
+    # -- who is asking ---------------------------------------------------------------------
+
+    def _redeem(self, supplied: str) -> str | None:
+        """A session for the one-time token, or None once it has been used."""
+        with self._lock:
+            if self._token_used or not hmac.compare_digest(str(supplied), self._token):
+                return None
+            self._token_used = True
+            session = secrets.token_urlsafe(32)
+            self._sessions.add(session)
+            return session
+
+    def _session_ok(self, cookie_header: str | None) -> bool:
+        cookie = SimpleCookie()
+        try:
+            cookie.load(cookie_header or "")
+        except Exception:                     # noqa: BLE001 -- a bad cookie is no cookie
+            return False
+        morsel = cookie.get(COOKIE)
+        if morsel is None:
+            return False
+        with self._lock:
+            return any(hmac.compare_digest(morsel.value, known) for known in self._sessions)
+
+    # -- the handler -------------------------------------------------------------------------
+
+    def _handler(self):
+        server = self
+
+        class Handler(BaseHTTPRequestHandler):
+            protocol_version = "HTTP/1.1"
+
+            def log_message(self, *args):
+                pass
+
+            def _send(self, status: int, body: bytes, content_type: str, headers: dict | None = None):
+                self.send_response(status)
+                self.send_header("Content-Type", content_type)
+                self.send_header("Content-Length", str(len(body)))
+                self.send_header("Cache-Control", "no-store")
+                self.send_header("X-Content-Type-Options", "nosniff")
+                self.send_header("Referrer-Policy", "no-referrer")
+                for key, value in (headers or {}).items():
+                    self.send_header(key, value)
+                self.end_headers()
+                if self.command != "HEAD":
+                    self.wfile.write(body)
+
+            def _json(self, status: int, body: dict, headers: dict | None = None):
+                self._send(status, json.dumps(body, default=str).encode("utf-8"), "application/json", headers)
+
+            def _refuse(self, status: int, message: str):
+                if self.path.startswith("/api/"):
+                    self._json(status, {"success": False, "ok": False,
+                                        "error": {"code": "permission_required", "message": message,
+                                                  "detail": None, "retryable": False}})
+                else:
+                    self._send(status, (message + "\n").encode("utf-8"), "text/plain; charset=utf-8")
+
+            def _authorised(self) -> bool:
+                if server._session_ok(self.headers.get("Cookie")):
+                    return True
+                self._refuse(403, "This page needs the link it was started with (it carries a one-time "
+                                  "token). Start it again for a new one.")
+                return False
+
+            def do_GET(self):  # noqa: N802
+                parts = urlsplit(self.path)
+                query = parse_qs(parts.query)
+                if "token" in query:
+                    session = server._redeem(query["token"][0])
+                    if session is None:
+                        return self._refuse(403, "That link has been used already; start the chat again "
+                                                 "for a new one.")
+                    rest = {k: v for k, v in query.items() if k != "token"}
+                    target = parts.path + ("?" + urlencode(rest, doseq=True) if rest else "")
+                    return self._send(303, b"", "text/plain", {
+                        "Location": target or "/",
+                        "Set-Cookie": f"{COOKIE}={session}; HttpOnly; SameSite=Strict; Path=/"})
+                if not self._authorised():
+                    return None
+                if parts.path in ("/", "/index.html"):
+                    return self._page()
+                if parts.path.startswith("/static/"):
+                    return self._static(parts.path[len("/static/"):])
+                if parts.path.startswith("/api/"):
+                    return self._api("GET", parts.path[len("/api"):], query, None)
+                return self._refuse(404, "not found")
+
+            def do_POST(self):  # noqa: N802
+                parts = urlsplit(self.path)
+                if not self._authorised():
+                    return None
+                origin = self.headers.get("Origin")
+                if origin and origin.rstrip("/") != server.url.rstrip("/"):
+                    return self._refuse(403, "a request from another page")
+                if not str(self.headers.get("Content-Type") or "").startswith("application/json"):
+                    return self._refuse(415, "send JSON")
+                length = int(self.headers.get("Content-Length") or 0)
+                if length > MAX_BODY:
+                    return self._refuse(413, "that request is too large")
+                try:
+                    body = json.loads(self.rfile.read(length) or b"{}")
+                except ValueError:
+                    return self._json(400, {"success": False, "ok": False,
+                                            "error": {"code": "invalid_input", "message": "the body is not JSON",
+                                                      "detail": None, "retryable": False}})
+                if not parts.path.startswith("/api/"):
+                    return self._refuse(404, "not found")
+                return self._api("POST", parts.path[len("/api"):], parse_qs(parts.query), body)
+
+            def _api(self, method, path, query, body):
+                answer = server.api.handle(method, path, query=query, body=body, headers=dict(self.headers))
+                if answer.stream is None:
+                    return self._send(answer.status, answer.json_bytes(), "application/json", answer.headers)
+                self.send_response(answer.status)
+                self.send_header("Content-Type", "text/event-stream")
+                self.send_header("Connection", "close")
+                for key, value in answer.headers.items():
+                    self.send_header(key, value)
+                self.end_headers()
+                self.close_connection = True
+                try:
+                    for chunk in answer.stream:
+                        self.wfile.write(chunk.encode("utf-8"))
+                        self.wfile.flush()
+                except (BrokenPipeError, ConnectionResetError, OSError):
+                    pass              # the page went away; its next connection picks up the cursor
+                finally:
+                    close = getattr(answer.stream, "close", None)
+                    if close:
+                        close()
+
+            def _page(self):
+                html = (static_dir() / "index.html").read_text(encoding="utf-8")
+                settings = json.dumps(server.page, default=str).replace("<", "\\u003c")
+                html = html.replace("{{TITLE}}", _escape(server.title)).replace("{{SETTINGS}}", settings)
+                self._send(200, html.encode("utf-8"), "text/html; charset=utf-8",
+                           {"Content-Security-Policy": "default-src 'self'; img-src 'self' data:; "
+                                                       "style-src 'self'; script-src 'self'; "
+                                                       "connect-src 'self'; frame-ancestors 'self'"})
+
+            def _static(self, name: str):
+                root = static_dir().resolve()
+                path = (root / name).resolve()
+                if root not in path.parents or not path.is_file() or path.suffix not in STATIC_TYPES:
+                    return self._refuse(404, "not found")
+                self._send(200, path.read_bytes(), STATIC_TYPES[path.suffix])
+
+        return Handler
+
+
+def _escape(text: str) -> str:
+    return (str(text).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+            .replace('"', "&quot;"))