@rulemetric/proxy 0.2.2

package/addon/session_linker.py

@@ -0,0 +1,206 @@
+"""Read active RuleMetric session info from $TMPDIR/rulemetric/."""
+
+from __future__ import annotations
+
+import logging
+import re
+import tempfile
+import time
+from pathlib import Path
+
+logger = logging.getLogger("rulemetric.session_linker")
+
+# UUID v4 pattern — used to validate FILE CONTENTS (a real RuleMetric DB
+# session id) where strict UUID format is guaranteed.
+_UUID_RE = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.IGNORECASE)
+
+# Loose pattern for harness-supplied EXTERNAL session ids (filenames). Some
+# harnesses append a suffix to the UUID — VS Code's `vscode-sessionid` is
+# `<uuid><epoch-ms>` (no separator) — so we accept anything that's a
+# reasonable, filesystem-safe identifier without requiring strict UUID form.
+# Bounded length to avoid pathologically long filenames.
+_EXTERNAL_ID_RE = re.compile(r"^[A-Za-z0-9_.\-]{8,128}$")
+
+# Consider session files stale after 4 hours
+MAX_SESSION_AGE_SECONDS = 4 * 60 * 60
+
+
+def _get_session_dir() -> Path:
+    return Path(tempfile.gettempdir()) / "rulemetric"
+
+
+# Map provider names to the tool types that generate that traffic.
+# Used to prefer session files whose tool type matches the request provider.
+_PROVIDER_TO_TOOLS: dict[str, list[str]] = {
+    "anthropic": ["claude_code"],
+    "openai": ["cursor", "vscode_copilot"],
+    "github_copilot_chat": ["vscode_copilot"],
+    "github_copilot_fim": ["vscode_copilot"],
+    "azure_openai": ["cursor", "vscode_copilot"],
+}
+
+
+def _parse_session_file(f: Path, now: float) -> dict[str, str] | None:
+    """Parse a single session file, returning its info or None if invalid/stale.
+
+    Returned dict has keys: session_id, rw_session_id, tool_type.
+    """
+    SKIP_SUFFIXES = (".log", ".seq", ".ctxhash", ".pid", ".lock")
+
+    if not f.is_file():
+        return None
+    if any(f.name.endswith(s) for s in SKIP_SUFFIXES):
+        return None
+
+    # Check file age — use the newer of session file or its .seq companion
+    try:
+        file_mtime = f.stat().st_mtime
+        seq_file = f.with_suffix(".seq")
+        if seq_file.is_file():
+            seq_mtime = seq_file.stat().st_mtime
+            file_mtime = max(file_mtime, seq_mtime)
+        file_age = now - file_mtime
+    except OSError:
+        return None
+    if file_age > MAX_SESSION_AGE_SECONDS:
+        logger.debug("Skipping stale session file %s (age: %.0fs)", f.name, file_age)
+        return None
+
+    try:
+        content = f.read_text().strip()
+        if not content:
+            logger.debug("Empty session file: %s", f.name)
+            return None
+
+        # File format: line 1 = RuleMetric session ID (UUID),
+        #              line 2 = tool type (e.g. claude_code, cursor) — optional
+        lines = content.splitlines()
+        session_id = lines[0].strip()
+        tool_type = lines[1].strip() if len(lines) > 1 else ""
+
+        # Validate UUID format
+        if not _UUID_RE.match(session_id):
+            logger.warning("Invalid session ID format in %s: '%s' — skipping", f.name, session_id[:50])
+            return None
+
+        logger.debug(
+            "Found session: %s (tool=%s, file=%s, age=%.0fs)",
+            session_id[:8], tool_type or "unknown", f.name, file_age,
+        )
+        return {
+            "session_id": session_id,
+            "rw_session_id": "",  # Not used in current format; session_id IS the RW ID
+            "tool_type": tool_type,
+        }
+    except PermissionError as exc:
+        logger.error("Permission denied reading session file %s: %s", f, exc)
+        return None
+    except OSError as exc:
+        logger.warning("Cannot read session file %s: %s", f, exc)
+        return None
+
+
+def _effective_mtime(f: Path) -> float:
+    """Return the most recent mtime between a session file and its .seq companion.
+
+    The session file is written once at session-start and never touched again.
+    The .seq file is bumped per event, so it's the canonical liveness signal.
+    Sorting by this value (not the raw file mtime) ensures the actively-active
+    session is preferred over a more-recently-started but idle one — without
+    this, multiple concurrent claude_code sessions cause snapshots to pile onto
+    whichever session started last, regardless of which is currently producing
+    events.
+    """
+    try:
+        m = f.stat().st_mtime
+    except OSError:
+        return 0.0
+    seq = f.with_suffix(".seq")
+    if seq.is_file():
+        try:
+            m = max(m, seq.stat().st_mtime)
+        except OSError:
+            pass
+    return m
+
+
+def find_session_by_external_id(external_session_id: str) -> dict[str, str] | None:
+    """Look up a single session file by its harness session id (= filename).
+
+    The harness (Claude Code, Cursor, etc.) writes one file per session at
+    `$TMPDIR/rulemetric/<harness-session-id>`, content = the RuleMetric DB
+    session id. When the wire request carries the harness session id (e.g.
+    Claude Code embeds it in Anthropic's `metadata.user_id`), this is the
+    canonical attribution path — race-free across concurrent same-tool
+    sessions because every request has its OWN session id.
+
+    Returns the same dict shape as ``find_active_session`` or None.
+    """
+    if not external_session_id or not _EXTERNAL_ID_RE.match(external_session_id):
+        return None
+    session_dir = _get_session_dir()
+    if not session_dir.is_dir():
+        return None
+    f = session_dir / external_session_id
+    if not f.is_file():
+        return None
+    return _parse_session_file(f, time.time())
+
+
+def find_active_session(provider: str | None = None) -> dict[str, str] | None:
+    """Find the most recently active session file in $TMPDIR/rulemetric/.
+
+    When *provider* is given (e.g. ``"anthropic"``, ``"openai"``), prefer
+    sessions whose tool type matches the expected source of that traffic.
+    Falls back to the most recent session if no tool-type match is found.
+
+    Liveness is measured against the session's `.seq` companion (which is
+    bumped per event), not the session file itself (which is write-once).
+
+    Returns a dict with session_id, rw_session_id, and tool_type keys, or None.
+    """
+    session_dir = _get_session_dir()
+
+    if not session_dir.is_dir():
+        logger.warning("Session dir does not exist: %s — session tracking may not be installed", session_dir)
+        return None
+
+    try:
+        files = sorted(session_dir.iterdir(), key=_effective_mtime, reverse=True)
+    except PermissionError as exc:
+        logger.error("Permission denied reading session dir %s: %s", session_dir, exc)
+        return None
+    except OSError as exc:
+        logger.warning("Cannot read session dir %s: %s", session_dir, exc)
+        return None
+
+    now = time.time()
+    candidates: list[dict[str, str]] = []
+
+    for f in files:
+        info = _parse_session_file(f, now)
+        if info:
+            candidates.append(info)
+
+    if not candidates:
+        logger.warning("No valid session files found in %s (%d files checked)", session_dir, len(files))
+        return None
+
+    # If a provider is given, try to find a session whose tool type matches
+    if provider:
+        preferred_tools = _PROVIDER_TO_TOOLS.get(provider, [])
+        if preferred_tools:
+            for candidate in candidates:
+                if candidate.get("tool_type") in preferred_tools:
+                    logger.debug(
+                        "Matched session %s (tool=%s) for provider %s",
+                        candidate["session_id"][:8], candidate["tool_type"], provider,
+                    )
+                    return candidate
+
+    # Fall back to most recent session (candidates are already sorted by mtime desc)
+    logger.debug(
+        "Using most recent session %s (tool=%s) — no provider-specific match",
+        candidates[0]["session_id"][:8], candidates[0].get("tool_type", "unknown"),
+    )
+    return candidates[0]

package/addon/sse_parser.py

@@ -0,0 +1,364 @@
+"""Parse SSE (Server-Sent Events) streaming responses from LLM APIs.
+
+Extracts usage stats, stop_reason, and model info from streaming responses
+that would otherwise be lost because the response body isn't a single JSON object.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+logger = logging.getLogger("rulemetric.sse_parser")
+
+
+# ---------------------------------------------------------------------------
+# Generic SSE parser
+# ---------------------------------------------------------------------------
+
+def parse_sse_events(text: str) -> list[dict[str, Any]]:
+    """Parse an SSE body into a list of event dicts.
+
+    Each event has:
+      - "event": the event type (str or None)
+      - "data": parsed JSON object, or raw string if JSON fails
+    """
+    events: list[dict[str, Any]] = []
+    # Normalize line endings: \r\n → \n, stray \r → \n
+    text = text.replace("\r\n", "\n").replace("\r", "\n")
+    # SSE events are separated by double (or more) newlines
+    chunks = text.split("\n\n")
+
+    for chunk in chunks:
+        chunk = chunk.strip()
+        if not chunk:
+            continue
+
+        event_type: str | None = None
+        data_lines: list[str] = []
+
+        for line in chunk.split("\n"):
+            line = line.strip()
+            if not line:
+                continue
+            if line.startswith("event:"):
+                event_type = line[len("event:"):].strip()
+            elif line.startswith("data:"):
+                data_lines.append(line[len("data:"):].strip())
+            # Skip comments (lines starting with :) and other fields
+
+        if not data_lines:
+            continue
+
+        raw_data = "\n".join(data_lines)
+
+        # Skip [DONE] sentinel (OpenAI and most compatible providers)
+        if raw_data in ("[DONE]", ""):
+            continue
+
+        # Try to parse as JSON
+        try:
+            parsed = json.loads(raw_data)
+        except (json.JSONDecodeError, ValueError):
+            parsed = raw_data
+
+        events.append({"event": event_type, "data": parsed})
+
+    return events
+
+
+# ---------------------------------------------------------------------------
+# Anthropic streaming aggregator
+# ---------------------------------------------------------------------------
+
+def aggregate_anthropic_sse(events: list[dict[str, Any]]) -> dict[str, Any]:
+    """Extract usage, stop_reason, model, and text content from Anthropic SSE events."""
+    result: dict[str, Any] = {"streaming": True}
+    usage: dict[str, Any] = {}
+    content_block_types: dict[str, int] = {}
+    text_parts: list[str] = []
+
+    for ev in events:
+        data = ev.get("data")
+        if not isinstance(data, dict):
+            continue
+
+        msg_type = data.get("type")
+
+        if msg_type == "message_start":
+            message = data.get("message", {})
+            # Input tokens + cache tokens from message_start
+            msg_usage = message.get("usage", {})
+            if msg_usage:
+                usage["input_tokens"] = msg_usage.get("input_tokens")
+                usage["cache_creation_input_tokens"] = msg_usage.get("cache_creation_input_tokens")
+                usage["cache_read_input_tokens"] = msg_usage.get("cache_read_input_tokens")
+                # Granular cache TTL breakdown (Anthropic ephemeral 5m vs 1h pricing tiers).
+                # Prefer the nested `cache_creation` object when present; fall back to
+                # treating the flat sum as 5m (older response shape).
+                cache_creation_obj = msg_usage.get("cache_creation")
+                if isinstance(cache_creation_obj, dict):
+                    usage["cache_creation_5m"] = cache_creation_obj.get("ephemeral_5m_input_tokens", 0) or 0
+                    usage["cache_creation_1h"] = cache_creation_obj.get("ephemeral_1h_input_tokens", 0) or 0
+                elif msg_usage.get("cache_creation_input_tokens") is not None:
+                    usage["cache_creation_5m"] = msg_usage.get("cache_creation_input_tokens") or 0
+                    usage["cache_creation_1h"] = 0
+            result["model_used"] = message.get("model")
+            result["request_id"] = message.get("id")
+
+        elif msg_type == "message_delta":
+            # Output tokens + stop_reason from message_delta
+            delta_usage = data.get("usage", {})
+            if delta_usage:
+                usage["output_tokens"] = delta_usage.get("output_tokens")
+            delta = data.get("delta", {})
+            result["stop_reason"] = delta.get("stop_reason")
+
+        elif msg_type == "content_block_start":
+            block = data.get("content_block", {})
+            block_type = block.get("type", "unknown")
+            content_block_types[block_type] = content_block_types.get(block_type, 0) + 1
+
+        elif msg_type == "content_block_delta":
+            delta = data.get("delta", {})
+            if delta.get("type") == "text_delta":
+                text_parts.append(delta.get("text", ""))
+
+    if usage:
+        result["usage"] = usage
+    if content_block_types:
+        result["content_block_types"] = content_block_types
+    if text_parts:
+        result["text_content"] = "".join(text_parts)
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# OpenAI streaming aggregator
+# ---------------------------------------------------------------------------
+
+def aggregate_openai_sse(events: list[dict[str, Any]]) -> dict[str, Any]:
+    """Extract usage, finish_reason, model from OpenAI-compatible SSE events.
+
+    Handles known provider variations:
+    - OpenAI: ``prompt_tokens`` / ``completion_tokens`` in usage
+    - Some providers: ``input_tokens`` / ``output_tokens`` (Anthropic naming)
+    - DeepSeek: ``reasoning_content`` in delta (chain-of-thought)
+    - Perplexity: ``citations`` array in final chunk
+    - Some providers: usage in a standalone final chunk with no ``choices``
+    - Some providers: ``x_groq`` or similar provider-specific metadata
+    """
+    result: dict[str, Any] = {"streaming": True}
+    usage: dict[str, Any] = {}
+    has_reasoning = False
+    text_parts: list[str] = []
+    reasoning_parts: list[str] = []
+
+    for ev in events:
+        data = ev.get("data")
+        if not isinstance(data, dict):
+            continue
+
+        # Model and ID from first chunk
+        if "model" in data and "model_used" not in result:
+            result["model_used"] = data["model"]
+        if "id" in data and "request_id" not in result:
+            result["request_id"] = data["id"]
+
+        # Finish reason + delta content from choices
+        choices = data.get("choices", [])
+        if choices:
+            finish_reason = choices[0].get("finish_reason")
+            if finish_reason:
+                result["stop_reason"] = finish_reason
+
+            # Accumulate streamed assistant text. OpenAI/Copilot/Azure stream
+            # one token (or fragment) per chunk in `choices[0].delta.content`;
+            # without joining them the assistant_response event ends up with
+            # empty content and the timeline shows nothing for the response.
+            delta = choices[0].get("delta", {})
+            content = delta.get("content")
+            if isinstance(content, str) and content:
+                text_parts.append(content)
+
+            # DeepSeek-style reasoning content (chain-of-thought).
+            reasoning = delta.get("reasoning_content")
+            if isinstance(reasoning, str) and reasoning:
+                reasoning_parts.append(reasoning)
+                has_reasoning = True
+            elif reasoning:
+                # Truthy non-string → flag presence even if we can't capture
+                has_reasoning = True
+
+        # Usage — may appear in final chunk (with or without choices).
+        # Normalize both OpenAI naming (prompt_tokens) and Anthropic naming (input_tokens).
+        chunk_usage = data.get("usage")
+        if chunk_usage and isinstance(chunk_usage, dict):
+            usage["input_tokens"] = (
+                chunk_usage.get("prompt_tokens")
+                or chunk_usage.get("input_tokens")
+            )
+            usage["output_tokens"] = (
+                chunk_usage.get("completion_tokens")
+                or chunk_usage.get("output_tokens")
+            )
+            usage["total_tokens"] = chunk_usage.get("total_tokens")
+
+            # Some providers include cache stats
+            if chunk_usage.get("prompt_tokens_details"):
+                details = chunk_usage["prompt_tokens_details"]
+                if details.get("cached_tokens"):
+                    usage["cache_read_input_tokens"] = details["cached_tokens"]
+
+        # Perplexity citations
+        citations = data.get("citations")
+        if citations and isinstance(citations, list):
+            result["citations"] = citations
+
+    if usage:
+        result["usage"] = usage
+    if has_reasoning:
+        result["has_reasoning"] = True
+    if text_parts:
+        result["text_content"] = "".join(text_parts)
+    if reasoning_parts:
+        result["reasoning_text"] = "".join(reasoning_parts)
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Gemini streaming aggregator
+# ---------------------------------------------------------------------------
+
+def aggregate_gemini_sse(events: list[dict[str, Any]]) -> dict[str, Any]:
+    """Extract usage from Gemini streaming responses."""
+    result: dict[str, Any] = {"streaming": True}
+
+    for ev in events:
+        data = ev.get("data")
+        if not isinstance(data, dict):
+            continue
+
+        # Usage metadata
+        usage_meta = data.get("usageMetadata")
+        if usage_meta and isinstance(usage_meta, dict):
+            result["usage"] = {
+                "input_tokens": usage_meta.get("promptTokenCount"),
+                "output_tokens": usage_meta.get("candidatesTokenCount"),
+                "total_tokens": usage_meta.get("totalTokenCount"),
+            }
+
+        # Finish reason from candidates
+        candidates = data.get("candidates", [])
+        if candidates:
+            finish_reason = candidates[0].get("finishReason")
+            if finish_reason:
+                result["stop_reason"] = finish_reason
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# GitHub Copilot FIM streaming aggregator
+# ---------------------------------------------------------------------------
+
+def aggregate_copilot_fim_sse(events: list[dict[str, Any]]) -> dict[str, Any]:
+    """Extract usage and finish_reason from Copilot FIM SSE events.
+
+    FIM responses use ``choices[].text`` instead of ``choices[].delta.content``.
+    Usage appears in the final event.
+    """
+    result: dict[str, Any] = {"streaming": True}
+    usage: dict[str, Any] = {}
+
+    for ev in events:
+        data = ev.get("data")
+        if not isinstance(data, dict):
+            continue
+
+        # Model and ID from first chunk
+        if "model" in data and "model_used" not in result:
+            result["model_used"] = data["model"]
+        if "id" in data and "request_id" not in result:
+            result["request_id"] = data["id"]
+
+        # Finish reason from choices (same structure as OpenAI but text instead of delta)
+        choices = data.get("choices", [])
+        if choices:
+            finish_reason = choices[0].get("finish_reason")
+            if finish_reason:
+                result["stop_reason"] = finish_reason
+
+        # Usage — appears in the final chunk
+        chunk_usage = data.get("usage")
+        if chunk_usage and isinstance(chunk_usage, dict):
+            usage["input_tokens"] = (
+                chunk_usage.get("prompt_tokens")
+                or chunk_usage.get("input_tokens")
+            )
+            usage["output_tokens"] = (
+                chunk_usage.get("completion_tokens")
+                or chunk_usage.get("output_tokens")
+            )
+            usage["total_tokens"] = chunk_usage.get("total_tokens")
+
+    if usage:
+        result["usage"] = usage
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Dispatcher
+# ---------------------------------------------------------------------------
+
+# Non-OpenAI SSE formats. Any provider not listed here
+# is assumed to use OpenAI-compatible SSE.
+_NON_OPENAI_AGGREGATORS = {
+    "anthropic": aggregate_anthropic_sse,
+    "gemini": aggregate_gemini_sse,
+    "github_copilot_fim": aggregate_copilot_fim_sse,
+}
+
+
+def _get_aggregator(provider: str):
+    """Return the SSE aggregator for a provider, defaulting to OpenAI."""
+    return _NON_OPENAI_AGGREGATORS.get(provider, aggregate_openai_sse)
+
+
+def parse_streaming_response(
+    body_text: str,
+    provider: str,
+    content_type: str | None = None,
+) -> dict[str, Any] | None:
+    """Parse a streaming SSE response body and extract usage/stop_reason.
+
+    Returns None if the body is not SSE (allows fallback to JSON parsing).
+    """
+    # Detect SSE
+    is_sse = False
+    if content_type and "text/event-stream" in content_type:
+        is_sse = True
+    elif body_text.lstrip().startswith(("event:", "data:")):
+        is_sse = True
+
+    if not is_sse:
+        return None
+
+    events = parse_sse_events(body_text)
+    if not events:
+        logger.debug("SSE body parsed but no events found")
+        return None
+
+    aggregator = _get_aggregator(provider)
+    result = aggregator(events)
+    logger.debug(
+        "SSE parsed: %d events, usage=%s, stop_reason=%s",
+        len(events),
+        result.get("usage"),
+        result.get("stop_reason"),
+    )
+    return result

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './types.js';
+export { BaseAdapter } from './providers/base.js';
+export { ProviderRegistry, detectProvider } from './providers/index.js';
+export { AnthropicAdapter } from './providers/anthropic.js';
+export { OpenAIAdapter } from './providers/openai.js';
+export { GeminiAdapter } from './providers/gemini.js';
+export { BedrockAdapter } from './providers/bedrock.js';
+export { findActiveSession } from './session-linker.js';
+export type { ActiveSession } from './session-linker.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from './types.js';
+export { BaseAdapter } from './providers/base.js';
+export { ProviderRegistry, detectProvider } from './providers/index.js';
+export { AnthropicAdapter } from './providers/anthropic.js';
+export { OpenAIAdapter } from './providers/openai.js';
+export { GeminiAdapter } from './providers/gemini.js';
+export { BedrockAdapter } from './providers/bedrock.js';
+export { findActiveSession } from './session-linker.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,8 @@
+import type { ContextSnapshot, Provider } from '../types.js';
+import { BaseAdapter } from './base.js';
+export declare class AnthropicAdapter extends BaseAdapter {
+    provider: Provider;
+    canHandle(host: string, path: string): boolean;
+    parse(body: string): ContextSnapshot | null;
+}
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/providers/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../src/providers/anthropic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAqC,QAAQ,EAAe,MAAM,aAAa,CAAC;AAC7G,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,qBAAa,gBAAiB,SAAQ,WAAW;IAC/C,QAAQ,EAAE,QAAQ,CAAe;IAEjC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO;IAI9C,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI;CAsI5C"}