Ultrafast troubleshooting: what to do when it won't connect, clicks don't work, or it goes off track
When running Jev Ultrafast hits a problem, it's most likely stuck at one of four layers: the local service isn't up, Chrome isn't connected, the model call was rejected, or decision execution hit a wall. This lesson goes through common jev-ultrafast errors one by one by their original error text, giving the cause and fix for each—first do the 60-second quick check, then match your error to the list.
All original error texts come from the repository source code (jev_ultrafast/model.py, agent.py, browser.py, demo.py, and the inspector UI), searchable word for word and copyable for asking questions. It's fine if a prerequisite lesson has you stuck—whenever installation and running blows up at any step, you can come back here to look it up.
What you'll be able to do after this lesson
- Use 4 commands to locate within 60 seconds which link is broken: the directory, the Key, Chrome, or the browser execution layer
- Match jev-ultrafast errors to their fixes: original error text → cause → fix steps
- Distinguish how three classes of errors are handled: stale ones (auto mode heals itself), retry ones (the code backs off automatically), and hands-on ones (you need to change the config or the target)
- Understand the 6 displays of the inspector status bar, and know what to do next for done and blocked respectively
- Remember the unsupported list: shadow DOM, frames, canvas, uploads, opening new tabs, nested scrolling, arbitrary keyboard components
- Use Export trace to export decision evidence and ask questions with minimal information
Your current predicament
- Start demo doesn't respond when clicked, and you don't know whether the service isn't up, Chrome isn't connected, or the Key isn't configured
- The English error in the red box flashes by, and you don't know which phrase to search for—or even if you find it, you can't tell which layer is at fault
- The agent status becomes done / blocked, but the page isn't the result you wanted—did you write the target wrong, or can this page simply not be run?
When to use this technique
When you need to:
- Fix errors you're stuck on from Ultrafast installation and running, getting Google Flights working, and writing your own browser tasks
- Judge before starting whether a website is suitable for Ultrafast—run it against the unsupported list first, don't force your way through
And you don't want to:
- Delete the repo and reinstall from scratch at the first error, walking through the whole installation process again
- Fail to tell apart "the page changed, retry" from "the config is broken, fix it," and waste half a day making the wrong changes
🎒 Preparation before starting
- completed Ultrafast installation and running (it's fine if you're stuck—this lesson is exactly for getting you unstuck)
- the repository is cloned locally, and your terminal can run commands in the
jev-ultrafast/root directory - (optional) you've gone through writing your own browser tasks—errors you hit when using the Agent library can be matched here just the same
Core idea
Identify the layer first, then look at the error. An Ultrafast task has to pass through four layers, and each layer's errors look different:
| Layer | What to check | Typical error / symptom |
|---|---|---|
| 1. Local service | uv run jev whether it's running, whether the directory is right, whether the address is 127.0.0.1 | Cannot reach local demo server / Forbidden |
| 2. Chrome connection | Browser Harness, remote debugging authorization | the panel stays motionless |
| 3. Model calls | the two Keys, network, quota | TYPE_TEXT needs TEXT_MODEL_API_KEY / Model provider returned HTTP 401 |
| 4. Decision and execution | page changes, action budget, page widget boundaries | Target changed or is covered / status becomes blocked |
Three classes of errors, three ways of handling them. Classify the error first when you see it—don't rush to act:
| Class | Example | What you need to do |
|---|---|---|
| Self-healing (stale, the page changed) | Page changed since the decision / Target changed or is covered | Do nothing: automatic runs will re-observe and decide again; in manual mode, click Choose next once |
| Retry class (server temporarily rejects) | 429 / 529 / 503 → the code attempts 3 times in total (2 retries), and if it still fails, reports Model provider returned HTTP 429/529/503 | Wait a bit and run again; check your quota |
| Hands-on class (configuration / budget / boundaries) | Missing key, HTTP 401, 60 action budget, shadow DOM not supported | Follow the items below to change the configuration, change the target, or switch pages |
💡 inspector status bar reference table (original text from app.js)
| Status bar shows | Meaning | What you should do |
|---|---|---|
| Ready to explore | Start demo has not been clicked yet | Fill in the target and click Start demo |
| Page observed · ready for a decision | Page observed, waiting for a decision | Click Choose next or Run automatically |
| Choice ready · inspect or execute | Decision made, pending execution | Check the probabilities, then click Execute choice |
| Jev reports complete · inspect the page | The model chose DONE | Verify the page yourself—DONE is not proof of success |
| Stopped · no supported next action | blocked: consecutive invalid actions or the model chose BLOCKED | Look at the last few steps in the Decision trail and compare against the unsupported list |
| Paused · needs attention | Paused due to an error | Look at the original error text in the red box and match it to the cases below |
First troubleshooting pass: 60-second quick check
Run the four commands in order, verifying the directory, key, Chrome connection, and browser execution layer in turn. Prerequisites: the terminal running uv run jev is still printing Jev Ultrafast: http://127.0.0.1:8766, and the browser was opened with 127.0.0.1:8766 (not localhost; see the Forbidden troubleshooting entry below for the reason).
# 1. 当前目录对吗?——.env 从「当前目录」读取,必须在仓库根目录跑
pwd
# 应以 jev-ultrafast 结尾;不在就先 cd jev-ultrafast
# 2. 两个 Key 都配了吗?——应看到两行(值非空才算数)
grep -E "^(TYPESAFE_API_KEY|TEXT_MODEL_API_KEY)=." .env
# 顺手 echo $TYPESAFE_API_KEY 确认 shell 里没有旧值抢先——.env 不会覆盖已 export 的变量
# 3. Chrome 连得上吗?——官方诊断命令
uv run browser-harness --doctor
# 按提示在 Chrome 里允许远程调试
# 4. 浏览器执行层正常吗?——官方开发命令,不调用模型、不花 API 费
uv run python scripts/check_guards.py
# 在本地浏览器里跑执行守卫回归;脚本自己的说明:No model calls or external websitesYou should see: item 1 ends with jev-ultrafast; item 2 outputs two lines; item 3 completes the connection diagnostics; item 4 ends by printing PASS: N browser guard checks; no model calls. Fix whichever item breaks; if all four pass and there is still an error, the problem is almost certainly in the model call or decision layer—match it to the cases below.
Troubleshooting common problems
Startup and Chrome connection (cannot connect)
"Cannot reach local demo server"
Cause: the inspector page cannot connect to the local service—uv run jev is not running, the port was changed, or the page is an old tab. This message appears in the status bar (the fetch-failure branch of app.js).
Solution:
- Restart from the repository root; the terminal should print:
uv run jev
# Jev Ultrafast: http://127.0.0.1:8766- Open
http://127.0.0.1:8766in the browser. If you changed the port:TYPESAFE_DEMO_PORTmust be set before startup (demo.py reads the fixed port at module import time); see the advanced tips in the installation and running lesson.
Opening the page only shows "Forbidden"
Cause: you used localhost:8766 instead of 127.0.0.1:8766. The demo service validates the Host header and only accepts 127.0.0.1:8766—this service listens only on the loopback address (demo.py calls itself a Loopback-only inspector), and POST requests also get {"error": "Local demo requests only"}.
Solution: change the address bar to http://127.0.0.1:8766 and refresh.
Chrome cannot connect and the panel never moves
Cause: Browser Harness requires Chrome to allow remote debugging; Chrome shows a prompt on the first connection, and if you miss it or decline, the connection fails. From the README: Allow remote debugging in Chrome when prompted.
Solution:
- Run the official diagnostic command from the repository root:
uv run browser-harness --doctor- When Chrome shows the "allow remote debugging" prompt again, click Allow.
- If the diagnostics pass but it still does not move: first run the
uv run python scripts/check_guards.pyabove—it does not call the model, so it can verify the browser execution layer in isolation.
"A browser step is already running"
Cause: the previous step is still executing. The demo service uses a global lock to ensure only one browser step runs at a time; requests that hit the lock return 409 along with this message.
Solution: wait for the current step to finish; if you want to stop Run automatically while it is running, click Pause.
"Local demo failed; no automatic retry. Reset to recover."
Cause: the demo service wraps any exception not specially caught into this generic 500 fallback message. The most common trigger: TYPESAFE_API_KEY is not set at all—model.py reads os.environ["TYPESAFE_API_KEY"] directly, and a missing key raises a KeyError; the original message is not shown and it falls through to this fallback.
Solution:
- Check the two keys in
.env(with a 60-second quick check on item 2). - Reset as prompted: click Start demo to start over.
- If you use the Agent library, you will see the raw traceback directly (e.g.
KeyError: 'TYPESAFE_API_KEY'); handle it by filling in whichever key is missing.
"Start a demo first"
Cause: you clicked Choose next / Execute choice / Run automatically in the inspector before Start demo—the demo service rejects these commands when no agent has been created yet.
Solution: first fill in the target and click Start demo, then use the control buttons.
"Enter 1–2,000 characters"
Cause: the target is empty or exceeds 2000 characters (the reset validation in demo.py).
Solution: keep the target within 1–2000 characters. Passing an empty target with the Agent library raises Supply a task (agent.py)—same meaning.
Keys and model calls (the high-error zone for TEXT_MODEL errors)
"TYPE_TEXT needs TEXT_MODEL_API_KEY; no text is hardcoded or guessed by the executor."
Cause: .env is missing TEXT_MODEL_API_KEY. This check only triggers when the action is TYPE_TEXT (model.py's field_text()), so the demo can start and the page can be observed, but it stops as soon as you "type into an input box"—the Flights demo has to generate city names, so there is no way around it.
Solution:
- Fill in your text model key in
.env(for where to get it, see method A/B/C in step 3 of the installation and setup lesson). - Note the loading rules:
.envis read from the current directory, and it does not override same-named variables already exported in your shell—if you clearly filled it in but still get the error, runcd jev-ultrafastagain and checkecho $TEXT_MODEL_API_KEY.
"Model provider returned HTTP 401; no action executed."
Reason: The model endpoint returned an error status code, which is wrapped into this message template (the source is f"Model provider returned HTTP {response.status_code}; no action executed."). 401 = invalid Key. This message is shared by TypeSafe and the text model, so first determine which side it comes from:
| When it's reported | Which side | What to check |
|---|---|---|
| Reported at the very first decision step | TypeSafe (decision is called every cycle) | TYPESAFE_API_KEY |
| Only reported at the typing step | The text model (only used by TYPE_TEXT) | Whether TEXT_MODEL_API_KEY and TEXT_MODEL_BASE_URL match |
Solution:
- On the TypeSafe side: go back to the console Keys page and re-copy the key; you can verify it with curl (the getting-started troubleshooting has the full command).
- On the text model side: confirm the key belongs to the endpoint you configured (an OpenRouter key with a DeepSeek endpoint configured is 401).
- For the meaning of other status codes (400/413/415/422 etc.), see the status code table in the API quick reference—429/529/503 are not reported immediately; see "Model provider returned HTTP 429/529/503" below.
"Model connection failed; no action executed."
Cause: The HTTP client threw an exception at the network layer—things like failing to connect to the endpoint or DNS resolution failure; the request was never sent out (model.py raises this message after catching httpx.HTTPError).
Solution:
- Check whether your network can reach
api.typesafe.aiand yourTEXT_MODEL_BASE_URL. - Check the endpoint spelling: with
TEXT_MODEL_BASE_URLa common mistake is a missing or extra/v1(example valuehttps://openrouter.ai/api/v1, DeepSeek defaulthttps://api.deepseek.com/v1).
"Model provider returned HTTP 429/529/503; no action executed." (rate limiting and overload)
Cause: The model endpoint returned 429 (rate limited) / 529 (overloaded) / 503. These status codes are not reported immediately: the code makes 3 attempts in total (2 retries, with 0.5s and 1s intervals); only if the 3rd attempt still fails is the status code template above used, reporting Model provider returned HTTP 429; no action executed. (529, 503 use the same wording).
There is also a fallback message in the source code, "Model unavailable" (model.py L27), but under the current control flow it is unreachable—after 429/529/503 retries are exhausted, the status code template is used, so this message never appears in the UI; if you find it in the source code, map it to this entry.
Fix: Wait a bit and run again; if it happens frequently, check your quota—on the TypeSafe side, view it on the console rate-limits page; on the text model side, check your provider's billing page.
"Invalid TypeSafe response; no action executed."
Cause: The decision response failed local validation (the validate_choice() of model.py: the chosen option must be among the candidates, every option must have a probability, all values must be within 0–1, and the probabilities must sum to about 1). This is a "response violates the contract" guard, not a problem with your configuration.
Fix: First just rerun as-is (it can be sporadic); if it persists, export a trace (see "Still not working?") and take it to feedback.
"Text helper returned no valid field value; nothing typed."
Cause: The text model's output does not conform to the contract—it must be JSON containing only the single key text, with a value that is a non-empty string no longer than 2000 characters (the parsing rules of model.py). Two common triggers:
| Trigger | Mechanism |
|---|---|
| The target is missing a required value | The model instructions explicitly state: return {"text": null} when a value is missing and never invent personal information (the TEXT_VALUE in questions.py)—null fails to parse, nothing gets typed |
| The model misbehaves | It outputs a passage of commentary text instead of JSON—the official performance report mentions rejecting such models during probing |
Solution:
- Write the values the task needs into the target (dates, city names, and the like—don't make the model guess).
- If it still fails, switch text models and keep
TEXT_MODEL_REASONING=none(models with reasoning disabled improvise less). - Typing the wrong value (rather than not typing) is handled the same way—the official probing also rejected models that swapped origin and destination, so test with a small task before switching models.
Execution interruption and budget (nothing responds to clicks)
"Target changed or is covered. Observe again."
Cause: The pre-execution safety recheck found that the target changed: it was overlaid, hidden, disabled, moved out of the viewport, or is no longer the node it was at observation time. This is the guard doing its job, not a bug—model output only ever references real elements that were observed, and the geometry is re-verified once more before execution.
Fix: Observe again and make a new decision. In automatic runs (without Slow motion), each step goes through a tick, and these stale errors are automatically swallowed and followed by a re-observation, so you never see them; in manual stepping or slow mode, it pauses and shows the original message—just click Choose next once to make a new decision.
"Page changed since the decision. Choose again."
Cause: The stale family—the page changed after the decision was made, invalidating the old decision. Variants in the same family: Page changed before text generation. Choose again. (the page changed before typing), Page changed since this decision. Observe again. (pre-execution recheck), Document changed during evaluation / Document is navigating (the page was changing during observation).
Fix: As above—observe again. Two details:
- The typed value is not generated for nothing: only when the text helper's input is completely unchanged will the retry reuse the previously generated value (see "Reuse an interrupted text request" in the README).
- Frequent occurrences mean the page has lots of animations/loading; wait a bit before running, or switch to a more stable page.
"Page did not settle"
Cause: The page never settled across 10 consecutive observations (20ms apart each)—animations keep running or it keeps loading.
Fix: Wait until the page quiets down before running; some heavyweight pages (constant scroll animations, persistent skeleton screens) may simply be unsuitable.
"Dropdown execution was not confirmed; inspect before retrying."
Cause: The execution result of the native <select> was not confirmed, or execution was interrupted (variant wording: Dropdown execution was interrupted; inspect before retrying.). The code chooses to stop conservatively here rather than blindly retry—retrying could cause duplicate selections.
Solution: Observe again (Choose next / rerun), letting the agent make a fresh decision based on the new page.
"Observe and choose before acting"
Cause: In manual mode, Execute choice was clicked without a decision, or the page fingerprint changed after the decision was made and the decision had already been consumed.
Solution: Click Choose next once to get a new decision, then Execute choice.
"Stopped at the 60-action demo budget"
Cause: The hard budget for a single run is used up: at most 60 executed actions (MAX_STEPS = 60). Decision calls have a separate limit of 120 (MAX_STEPS × 2); when reached, Reached the demo's model-call budget is reported.
Solution: If the task is too big, split it into smaller ones — the official example parameter in examples/run.py is literally named 'A narrow goal', so writing a narrow goal is the official recommendation. If it doesn't finish within the budget, it usually means the goal is too broad or the page is unsuitable (see the group below).
"This run has stopped. Start a fresh demo."
Cause: The state is already done or blocked, yet a new decision is still being requested — one run has ended.
Solution: Click Start demo to start a fresh run.
Status bar shows "Stopped · no supported next action" (blocked)
Cause: Two sources: the model actively chose BLOCKED (instruction definition: no supported action can advance the task), or for 3 consecutive executed actions (none of them WAIT) the page showed no change at all — the code determines it's stuck and automatically switches to blocked.
Solution:
- Look at the last 3 steps of the Decision trail: what was clicked and why the page didn't change.
- Check against the "unsupported list" group below — the most common root cause of blocked is a control on the page that can't be operated.
- Make the goal narrower and more specific, then restart the demo.
Wrong results and page boundaries (going off track)
Status bar shows "Jev reports complete · inspect the page", but the page isn't what you wanted
Cause: The model chose DONE, but DONE is never proof of success — the official Evidence and limits section puts it bluntly: even after DONE is chosen, the result still needs independent verification. The second half of the status bar message (inspect the page) is exactly a reminder for you to look yourself.
Solution:
- Add independent verification for important tasks. The official template is
examples/flights.py'sverify(): check the results page item by item for one-way trip, origin, destination, date, and visible results — don't trust the model's DONE; if verification fails, exit and reportFinal page did not satisfy the route/date checks. - Write the stop condition clearly in the goal. The official Flights example goal ends with
Stop when …; follow that phrasing. - Goals of the "open a certain result" kind deserve extra attention: the model instructions explicitly state that "finding a matching link alone doesn't count as complete".
Controls don't respond when clicked / not in the element list at all (shadow DOM, canvas, upload…)
Cause: You've hit an MVP boundary. The DOM reader only recognizes common HTML and ARIA controls and doesn't implement the full accessible-name algorithm. Per the official Limits list, the following are all unsupported:
| Unsupported | Examples |
|---|---|
| shadow roots / frames | internal controls rendered by component frameworks |
| canvas | map- and canvas-style interactions |
| file upload | <input type="file"> |
| pop-up new tabs | links that open a new tab when clicked |
| nested scrolling | inner scrollable containers |
| arbitrary keyboard components | keyboard shortcuts, rich-text editors |
Solution: Before starting a task, screen it against the list first; for now, don't force your way through pages involving these controls (step 4 of the principles lesson has the same boundary list); switch to a page or task that only involves regular controls. Also note: the agent's tab shares your existing Chrome profile — your login state affects page content, so keep that in mind when troubleshooting "the page isn't what I expected".
Typed text is wrong, or text that should be typed wasn't
Cause: The string is inferred from the goal by the text helper, not written by Jev. Wrong text = the helper model misunderstood; no typing = it returned {"text": null} per the rules (refusing to invent values when the goal lacks required ones; see the nothing typed entry above).
Solution: Write required values verbatim into the goal ("September 20, 2026" instead of "next month"); if that still doesn't work, switch text models, probing first with a small task — the official process used six probe calls to eliminate models that swapped cities or output comments (see the performance analysis).
Fills the form but doesn't submit, types text but doesn't pick a suggestion
Cause: These rules are actually hard-coded in the model instructions: submit after filling required fields ("filled fields don't equal an applied search"), and after typing a query, select the matching autocomplete suggestion. Failures are usually a timing issue — after typing, the code waits at most 200ms for suggestions to appear, so sites with slow-loading suggestions may miss the next observation.
Solution: Rerunning as-is usually passes; if it keeps getting stuck at the same spot, make the goal more explicit (what to submit, where to stop), or switch to a page whose suggestions load faster.
Still not working?
Isolate first, then gather evidence, then ask with the evidence in hand.
The isolation tools are the two scripts bundled with the repo (both in scripts/, from the Development section of the README):
# 只测浏览器执行层:本地页面、不调用模型、不花钱
uv run python scripts/check_guards.py
# 测完整链路:浏览器只开本地 fixture 页面,但会发起真实模型调用(产生付费 API 费用)
uv run python scripts/smoke.pycheck_guards.py passed and smoke.py passed too, but the real website still fails — the problem is most likely with that site itself (control boundaries, load timing); check against the unsupported list.
Gather evidence — three things are enough:
| Evidence | How to get it | What's inside |
|---|---|---|
| Decision trace | the Export trace ↓ button at the bottom of the inspector | downloads typesafe-browser-trace.json: full decision history, probabilities, goal, page URL and visible text (no screenshots) |
| What the model saw | the page's collapsible section What the model sees | the full request body sent to the model, inspectable field by field |
| The exact error text | the sentence in the red box | every H4 on this page matches |
⚠️ Review before sending
The trace contains the page URL and visible text, which may include your account information; also note: the live example and the recording script both make paid API calls (README's exact words), so be aware before reproducing repeatedly.
Where to ask:
| Channel | When to go |
|---|---|
| This lesson + Install and run | Check yourself twice first; most problems never make it this far |
| Getting Started Troubleshooting / API Quick Reference | TypeSafe API-side status code issues |
| GitHub Issues | Defects in Ultrafast itself: include the trace + the original error text + the goal and URL |
| TypeSafe Discord | Issues on the decision API (Jev) side; if the officials say it's broken, report it directly |
| Browser Use Cloud | Issues when using the hosted BU Ultrafast (model: "bu-ultrafast") |
Checkpoint ✅
- 60-second quick check: all four commands have been run, so you know which layer is stuck
- I can distinguish three classes of errors: stale self-heals, 429/529/503 auto-retries, and config/budget/limits need hands-on work
- When the status is done I don't just call it a day—I add independent verification for important tasks (flights.py's verify() is the model)
- I've reviewed the unsupported list: shadow DOM, frames, canvas, uploads, new tabs, nested scrolling, keyboard components
- When asking questions I include typesafe-browser-trace.json, the original error text, and the goal and URL
Lesson summary
✅ Troubleshooting starts by identifying the layer: local service → Chrome connection → model calls → decision execution; each layer's errors look different.
✅ Every jev-ultrafast error message comes verbatim from the repo source and is searchable word for word; the H4 heading is the original error text—copy it to search or to ask.
✅ Three classes of treatment: stale errors go to automatic re-observation, 429/529/503 go to code retries, and only config/budget/limit errors require hands-on work from you.
✅ DONE is not proof of success, blocked means check the unsupported list first, and the 60-action limit is a hard budget—remember these three and half of the "gone off track" cases can be avoided in advance.
Quick reference of key signals:
| Signal | Which layer | First step |
|---|---|---|
| Cannot reach local demo server / Forbidden | Local service | Re-run uv run jev; open 127.0.0.1:8766 |
| Panel stays frozen | Chrome connection | uv run browser-harness --doctor, allow remote debugging |
| TYPE_TEXT needs TEXT_MODEL_API_KEY | Model calls (text side) | Add the Key in .env, mind cwd and setdefault |
| Model provider returned HTTP 401 | Model calls (invalid Key) | First figure out whether it's TypeSafe or the text model, then re-copy the Key |
| Model provider returned HTTP 429/529/503 | Model calls (rate limit/overload) | Wait a bit and re-run, check your quota |
| Target changed or is covered | Decision execution (stale) | Re-observe; auto mode self-heals |
| Stopped at the 60-action demo budget | Decision execution (budget) | Write narrower goals, split tasks smaller |
| Status done but the result is wrong | Result verification | Verify in person; add flights.py-style independent verification |
| Status blocked | Page boundaries | Check against the unsupported list, switch pages or change the goal |
Next lesson preview
That wraps up the browser chapters. The next lesson Jev 1.13 Pitfall handbook: 9 failure modes and alternative approaches returns to the Jev model itself—beyond Ultrafast, it applies to all Jev applications. You will learn:
- The 9 failure modes in the official jaggedness docs: literal interpretation, arithmetic counting, date comparison, indirect reference…
- Alternative approaches for each failure mode: put arithmetic in code, extract date components, filter large state first
- How these questioning habits feed back into your Ultrafast goals and other Jev applications
Related tutorials
- Ultrafast install and run: uv sync plus two API keys
- Getting Google Flights working: a real search in 7 seconds
- What if it won't install or run: getting-started troubleshooting
Appendix: source code reference
Click to expand and view the source code location
Updated: 2026-11-04 (repo github.com/browser-use/jev-ultrafast, local information source sources/jev/repo-ultrafast/)
| Feature | File path | Key location |
|---|---|---|
| Original error text: connection/HTTP/retry | jev_ultrafast/model.py | L15–27 post_json(L20 connection failed, L21–23 automatic retry on 429/529/503·3 total attempts, L25 HTTP status code template, L27 Model unavailable fallback text·unreachable in the current control flow); L12 client timeout=25 |
| Original error text: decision response validation | jev_ultrafast/model.py | L30–45 validate_choice(L44 Invalid TypeSafe response) |
| Original error text: text helper | jev_ultrafast/model.py | L160–198 field_text(L163 missing-key original text, L187–193 JSON contract validation, L193 nothing typed) |
| TypeSafe request and key reading | jev_ultrafast/model.py | L119(api.typesafe.ai/v1/systemone + os.environ["TYPESAFE_API_KEY"], raises KeyError if missing) |
| Original error text: budget and state machine | jev_ultrafast/agent.py | L74 stopped, L75–76 model call budget(MAX_STEPS×2=120), L88–89 observe before executing, L96/L107–108 stale original text, L102–104 60 action budget, L153–158 3 consecutive times with no change→blocked |
| Original error text: stale and execution guards | jev_ultrafast/browser.py | L86 Page did not settle, L102 page changed before execution, L130–131/L162–163 dropdown unconfirmed/interrupted, L164 target covered; L16 StalePage(ValueError) |
| Original error text: demo service | jev_ultrafast/demo.py | L16 port(set TYPESAFE_DEMO_PORT before startup), L23–29 .env reading(cwd + setdefault), L48–52 scenarios and 1–2000 characters, L64–65 Start a demo first, L111–112 409 single-step lock, L122–123 500 fallback |
| inspector status bar and error display | jev_ultrafast/static/app.js | L63 Paused · needs attention, L82–88 five status texts, L173–183 automatic loop(tick self-healing vs slow stepping), L217–235 export trace(screenshots removed), L243 Cannot reach local demo server |
| UI buttons and collapsible sections | jev_ultrafast/static/index.html | L56–59 Choose next / Execute choice / Run automatically / Pause, L126 Export trace ↓, L133 What the model sees |
| Model instructions(DONE/BLOCKED/submit/suggestion rules) | jev_ultrafast/questions.py | L3–14 NEXT_ACTION, L21–24 TEXT_VALUE(returns null for missing values, does not invent personal information), L26 MAX_STEPS = 60 |
| Installation, --doctor, remote debugging, unsupported-features list | README.md | L53–68 Try it(includes uv run browser-harness --doctor), L118–126 Evidence and limits(DONE requires independent verification; shadow roots/frames/canvas/upload/new tab/nested scrolling/keyboard components unsupported; tabs share the existing Chrome profile), L128–138 Development(check_guards, paid API notice) |
| Unsupported-features list(Limits original text) | docs/performance.md | L53–55; L49 probing rejected models(swapping origin and destination/outputting annotations) |
| Independent verification template | examples/flights.py | L18–38 verify() item-by-item checks, L63–64 Final page did not satisfy the route/date checks |
| Local guard regression script | scripts/check_guards.py | L1 docstring(No model calls or external websites), L133 final print PASS: N browser guard checks; no model calls |
| Local fixture smoke script | scripts/smoke.py | L1 docstring(paid API), L19 --max-actions(default 15), L25 prints the trace directory |