Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++
6.3 KB
Raw Blame
"""Read-only, bounded request activity for the source and portable CLI."""

from __future__ import annotations

import json
import sys
import time
from typing import Any

from strata_cli.client import ClientError, Endpoint
from strata_cli.render import activity_label


def _emit(record: dict[str, Any], machine: bool) -> None:
    if machine:
        print(json.dumps({"schema_version": 1, **record}, ensure_ascii=False, allow_nan=False), flush=True)
    elif record["type"] == "activity":
        print(activity_label(record, 120), flush=True)
    elif record["type"] == "gap":
        print(f"Activity #{record['from_seq']}–#{record['to_seq']} is absent from this bounded feed", flush=True)
    elif record["type"] == "instance_change":
        print("Serving instance changed; activity sequence restarted", flush=True)


def activity_delta(snapshot: dict, instance_id: str | None, cursor: int | None) -> tuple[list[dict], str, int]:
    """Return new transitions and explicit sequence gaps from one sanitized snapshot."""
    current_id = (snapshot.get("instance") or {}).get("id")
    activity = snapshot.get("activity") or {}
    if not current_id or not activity.get("available"):
        raise ClientError("request activity is unavailable on this server", 5)
    latest = activity["last_seq"]
    if type(latest) is not int:
        raise ClientError("invalid request activity sequence", 5)
    rows = activity["events"]
    changed = instance_id is not None and current_id != instance_id
    if changed:
        cursor = None
    elif cursor is not None and latest < cursor:
        raise ClientError("request activity sequence moved backwards without an instance change", 5)
    out: list[dict] = []
    if changed:
        out.append({"type": "instance_change", "from_instance_id": instance_id,
                    "instance_id": current_id})
    next_seq = 1 if cursor is None else cursor + 1
    for row in rows:
        seq = row["seq"]
        if seq < next_seq:
            continue
        if seq > next_seq:
            out.append({"type": "gap", "instance_id": current_id,
                        "from_seq": next_seq, "to_seq": seq - 1})
        out.append({"type": "activity", "instance_id": current_id, **row})
        next_seq = seq + 1
    if latest >= next_seq:
        out.append({"type": "gap", "instance_id": current_id,
                    "from_seq": next_seq, "to_seq": latest})
    return out, current_id, latest


class ActivityContinuity:
    """Track gaps seen by one monitor without retaining request history locally."""

    def __init__(self) -> None:
        self.instance_id: str | None = None
        self.cursor: int | None = None
        self.gap: dict[str, int] | None = None
        self.restarted = False
        self.regressed = False

    def add(self, snapshot: dict) -> None:
        instance_id = (snapshot.get("instance") or {}).get("id")
        activity = snapshot.get("activity") or {}
        if not isinstance(instance_id, str) or not instance_id or not activity.get("available"):
            return
        latest = activity.get("last_seq")
        if type(latest) is not int:
            return
        if self.instance_id is None:
            # Retention before attach is expected; only report gaps after observation starts.
            self.instance_id, self.cursor = instance_id, latest
            return
        try:
            events, current_id, cursor = activity_delta(snapshot, self.instance_id, self.cursor)
        except ClientError:
            self.regressed = True
            return
        if current_id != self.instance_id:
            self.gap = None
            self.restarted = True
            self.regressed = False
        gaps = [event for event in events if event["type"] == "gap"]
        if gaps:
            self.gap = {"from_seq": gaps[-1]["from_seq"], "to_seq": gaps[-1]["to_seq"]}
        self.instance_id, self.cursor = current_id, cursor

    def status(self) -> dict:
        return {"gap": dict(self.gap) if self.gap else None,
                "restarted": self.restarted, "regressed": self.regressed}


def run(endpoint: Endpoint, *, follow: bool, output: str, interval: float,
        quiet: bool = False) -> int:
    """Display retained transitions, then poll one snapshot at a time if requested."""
    machine = output != "human"
    snapshot = endpoint.snapshot()
    activity = snapshot.get("activity") or {}
    if not activity.get("available"):
        raise ClientError("request activity is unavailable on this server", 5)
    instance_id = (snapshot.get("instance") or {}).get("id")
    if not follow:
        record = {"schema_version": 1, "ok": True, "source": "runtime_activity",
                  "instance_id": instance_id, "last_seq": activity["last_seq"],
                  "retained": len(activity["events"]), "events": activity["events"]}
        if machine:
            print(json.dumps(record, ensure_ascii=False, allow_nan=False))
        else:
            if not quiet:
                print("Recent request activity (redacted; newest 32 only)")
            if activity["events"]:
                for row in activity["events"]:
                    print(activity_label(row, 120))
            elif not quiet:
                print("No request transitions retained")
        return 0
    if not instance_id:
        raise ClientError("request activity follow needs a serving instance ID", 5)
    if not machine and not quiet:
        print("Following redacted request activity (polling; Ctrl+C to detach)", flush=True)
    events, current_id, cursor = activity_delta(snapshot, None, None)
    for event in events:
        _emit(event, machine)
    failures = 0
    while True:
        try:
            time.sleep(interval)
            snapshot = endpoint.snapshot()
            events, current_id, cursor = activity_delta(snapshot, current_id, cursor)
        except ClientError as e:
            if e.exit_code != 3:
                raise
            failures += 1
            if failures >= 3:
                raise ClientError("request activity connection failed after 3 attempts", 3) from e
            if failures == 1 and not quiet:
                print("strata: activity connection lost; retrying", file=sys.stderr)
            continue
        if failures and not quiet:
            print("strata: activity connection restored", file=sys.stderr)
        failures = 0
        for event in events:
            _emit(event, machine)