Add runnable 75K+ text-context example

README.md

@@ -96,6 +96,17 @@ Captured response for this exact image and request:
 
 The full response is saved as [`output.json`](examples/real-photo/output.json). This is one qualitative example, not an image benchmark or evidence of general image accuracy. The displayed latency came from a CPU smoke run and is not a performance claim.
 
+## 75K+ text-context example
+
+This request builds a long text state and asks JEVision to read a fact from its final record. The runner uses the pinned Qwen3.5 tokenizer and targets a 76,000-token state; the server's `usage.input_tokens` field reports the input-token count for the request it accepts.
+
+```bash
+python run_jevvision.py --text-adapter jevbench-m3 --port 8009
+python examples/long-context/run_demo.py --endpoint http://127.0.0.1:8009
+```
+
+[`input.json`](examples/long-context/input.json) defines the target, generated log format, and typed question. Running [`run_demo.py`](examples/long-context/run_demo.py) creates `state-75k.txt`, submits the text-only request to `/v1/systemone`, and saves the server's returned JSON as `output.json`. This uses the selected text adapter; image-bearing requests use the separate visual route described above.
+
 ## What is bundled
 
 | Component | Route | Notes |

examples/long-context/.gitignore

@@ -0,0 +1,2 @@
+/state-75k.txt
+/output.json

examples/long-context/input.json

@@ -0,0 +1,24 @@
+{
+  "model": "kev-latest",
+  "state_target_tokens": 76000,
+  "minimum_request_tokens": 75000,
+  "state_file": "state-75k.txt",
+  "tokenizer": {
+    "repo_id": "Qwen/Qwen3.5-0.8B-Base",
+    "revision": "dc7cdfe2ee4154fa7e30f5b51ca41bfa40174e68"
+  },
+  "state_prefix": "Archived operations log for the Northstar help desk. The following records summarize historical tickets. Use the final audit record to answer the question.\n",
+  "record_template": "Record {index:06d} | date=2025-{month:02d}-{day:02d} | team={team} | ticket=TK-{ticket:06d} | status={status} | priority={priority} | note=The customer confirmed the resolution and the support owner recorded the next review in the normal queue.\n",
+  "final_record": "FINAL AUDIT RECORD | date=2025-12-31 | verification_code=K7M4 | This is the final record in the archive.\n",
+  "questions": {
+    "verification_code": {
+      "type": "choice",
+      "instructions": "Which verification code is recorded in the FINAL AUDIT RECORD at the end of the state?",
+      "criteria": {
+        "K7M4": "The final audit record contains verification code K7M4.",
+        "N2R8": "The final audit record contains verification code N2R8.",
+        "not_present": "The final audit record contains no verification code."
+      }
+    }
+  }
+}

examples/long-context/run_demo.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""Generate and submit the bundled 75K+ text-context request to a running JEVision server."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+EXAMPLE_DIR = Path(__file__).resolve().parent
+CONFIG_PATH = EXAMPLE_DIR / "input.json"
+MINIMUM_REQUEST_TOKENS = 75_000
+BATCH_RECORDS = 32
+TEAMS = ("billing", "accounts", "delivery", "returns", "technical")
+STATUSES = ("closed", "resolved", "reviewed", "archived")
+PRIORITIES = ("normal", "standard", "follow-up")
+
+
+def token_length(tokenizer, text: str) -> int:
+    return len(tokenizer.encode(text, add_special_tokens=False))
+
+
+def make_record(template: str, index: int) -> str:
+    return template.format(
+        index=index,
+        month=(index % 12) + 1,
+        day=(index % 28) + 1,
+        team=TEAMS[index % len(TEAMS)],
+        ticket=index,
+        status=STATUSES[index % len(STATUSES)],
+        priority=PRIORITIES[index % len(PRIORITIES)],
+    )
+
+
+def make_state(tokenizer, config: dict) -> tuple[str, int]:
+    target = int(config["state_target_tokens"])
+    minimum = int(config["minimum_request_tokens"])
+    prefix = str(config["state_prefix"])
+    final_record = str(config["final_record"])
+    template = str(config["record_template"])
+    records: list[str] = []
+    next_index = 1
+
+    while True:
+        for _ in range(BATCH_RECORDS):
+            records.append(make_record(template, next_index))
+            next_index += 1
+
+        state = prefix + "".join(records) + final_record
+        count = token_length(tokenizer, state)
+        if count >= target:
+            while count > target and records:
+                records.pop()
+                state = prefix + "".join(records) + final_record
+                count = token_length(tokenizer, state)
+            if count < minimum:
+                raise RuntimeError(
+                    f"Could not build the requested long state: {count} tokens; minimum is {minimum}."
+                )
+            return state, count
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--endpoint", default="http://127.0.0.1:8009")
+    parser.add_argument("--output", type=Path, default=EXAMPLE_DIR / "output.json")
+    args = parser.parse_args()
+
+    config = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+    try:
+        from transformers import AutoTokenizer
+    except ImportError as exc:
+        raise SystemExit("Install the JEVision requirements first (including transformers).") from exc
+
+    tokenizer_config = config["tokenizer"]
+    tokenizer = AutoTokenizer.from_pretrained(
+        tokenizer_config["repo_id"],
+        revision=tokenizer_config["revision"],
+    )
+    state, state_tokens = make_state(tokenizer, config)
+
+    state_path = (EXAMPLE_DIR / config["state_file"]).resolve()
+    state_path.relative_to(EXAMPLE_DIR.resolve())
+    state_path.write_text(state, encoding="utf-8")
+
+    payload = {
+        "model": config["model"],
+        "state": state,
+        "questions": config["questions"],
+    }
+    request = Request(
+        args.endpoint.rstrip("/") + "/v1/systemone",
+        data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
+        headers={"content-type": "application/json"},
+        method="POST",
+    )
+    try:
+        with urlopen(request, timeout=1800) as response:
+            result = json.loads(response.read().decode("utf-8"))
+    except HTTPError as exc:
+        raise SystemExit(f"JEVision returned HTTP {exc.code}; no response file was written.") from None
+    except URLError as exc:
+        raise SystemExit(f"Could not reach the JEVision endpoint ({exc.reason}); no response file was written.") from None
+
+    usage = result.get("usage") or {}
+    accepted_tokens = usage.get("input_tokens")
+    if not isinstance(accepted_tokens, int) or accepted_tokens < int(config["minimum_request_tokens"]):
+        raise SystemExit(
+            "The server response did not report an accepted input of at least "
+            f"{config['minimum_request_tokens']} tokens; no response file was written."
+        )
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(result, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    print(
+        f"Generated state: {state_tokens:,} tokenizer tokens. "
+        f"Server-reported request: {accepted_tokens:,} input tokens."
+    )
+    print(f"Response saved to: {args.output}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())