Compare commits

..
Author SHA1 Message Date
BaaRai 73aa56c16f perf(web): pause snapshot polling in hidden tabs
Adds setVisibleInterval (web/src/lib/polling.ts): no ticks while the tab is hidden, an immediate refresh on return, no overlapping polls, errors swallowed, cleanup removes the listener. API pollers use it; local clock ticks keep setInterval. CI runs the helper tests. Backported from #209 (contributed by @renaesop).
2026-11-15 23:08:24 +01:00
BaaRai 2ad8ba16c3 Merge pull request #247 from BaaRai/fix/noa-budget-no-retry
fix(server): do not rerun intents refused by the NOA budget
2026-11-15 22:54:09 +01:00
BaaRai 09c9e6cfc2 fix(server): do not rerun intents refused by the NOA budget
The NOA budget refusal now wraps an exported ErrNoaBudget sentinel, which survives the Norma harness unchanged; retryableWorkerModelError excludes it, so a deterministic refusal is no longer replayed twice by the engine.
2026-11-15 22:26:21 +01:00
BaaRai 59c3002bcc Merge pull request #246 from BaaRai/chore/norma-v0.4.10
chore(deps): bump Norma to v0.4.10
2026-11-15 22:15:15 +01:00
BaaRai 68f2db1d0b chore(deps): bump Norma to v0.4.10
Brings the English shell tool, task notice and NOA archive strings and the corrected dispatch session note (BaaRai/Norma v0.4.10). No other module moves.
2026-11-15 20:39:53 +01:00
BaaRai f0be3ae51f Merge pull request #245 from BaaRai/feat/noa-budget-wiring
feat(agent): size NOA to the configured window and refuse irreducible requests
2026-11-15 20:06:59 +01:00
BaaRai 3b755228d6 feat(agent): size NOA to the configured window and refuse irreducible requests
Bump Norma to v0.4.9 (BaaRai/Norma v0.4.9). enableNoa passes the configured context window to noaadapter as ModelContextLimit and, once NOA is enabled, wraps the provider in a budget check that refuses a request whose estimate exceeds that window before any transport.
2026-11-15 19:08:49 +01:00
BaaRai d147dce344 Merge pull request #244 from BaaRai/fix/cache-write-cost
fix(db): stop billing cache writes twice in profile cost
2026-11-15 18:37:12 +01:00
BaaRai 60728092e1 fix(db): stop billing cache writes twice in profile cost
Norma normalizes InputTokens to input + cache read + cache write, so both cache buckets are subsets of it. The fresh share billed at the input price is now input minus reads minus writes, still clamped at zero for gateways that report disjoint buckets.
2026-11-15 18:17:33 +01:00
BaaRai ff599c65d3 Merge pull request #243 from BaaRai/fix/stream-usage-echo
fix(llmrec,sidequestion): fold echoed stream usage with MergeEcho
2026-11-15 18:14:20 +01:00
BaaRai ce096cdba1 fix(llmrec,sidequestion): fold echoed stream usage with MergeEcho
Since Norma v0.4.7 message_delta echoes the input side reported by message_start. The recorder and side answers added both events, counting input and cache twice in llm_usage and side-answer usage. message_start is still added; message_delta is now folded with llm.Usage.MergeEcho, as llm.Accumulator does.
2026-11-15 17:51:53 +01:00
BaaRai 50f6d07640 Merge pull request #241 from BaaRai/fix/task-llm-usage
fix(server): sum task LLM usage across retries and failover
2026-11-15 17:48:11 +01:00
33 changed files with 804 additions and 74 deletions
+1
View File
@@ -86,4 +86,5 @@ jobs:
cache-dependency-path: web/package-lock.json
- run: npm ci
- run: npx tsc --noEmit
- run: npm run test:polling
- run: npm run build:static
+17 -4
View File
@@ -39,10 +39,17 @@ func enableNoa(opts *agentcore.Options, enabled func() bool, archiveRoot, sessio
if opts.OnWarn == nil {
opts.OnWarn = onWarn
}
if err := noaadapter.Enable(opts, noaadapter.Options{
ArchiveBaseDir: filepath.Join(archiveRoot, "noa"),
SessionID: sessionID,
OnWarn: onWarn,
// noa sizes its thresholds to the window this agent is configured for, read
// before Compaction is cleared below; without it noa assumes its own default.
window := defaultWindowK * 1000
if opts.Compaction != nil && opts.Compaction.ContextWindow > 0 {
window = opts.Compaction.ContextWindow
}
if err := noaEnable(opts, noaadapter.Options{
ArchiveBaseDir: filepath.Join(archiveRoot, "noa"),
SessionID: sessionID,
OnWarn: onWarn,
ModelContextLimit: window,
}); err != nil {
if onWarn != nil {
onWarn("failed to enable noa compression, falling back to built-in compaction: " + err.Error())
@@ -52,4 +59,10 @@ func enableNoa(opts *agentcore.Options, enabled func() bool, archiveRoot, sessio
// Compactor overrides Compaction, but agentcore warns on every run when both are
// set; clear it explicitly.
opts.Compaction = nil
// noa can only trim what it may drop; a request whose protected part alone
// exceeds the window is refused here instead of by the provider.
opts.Provider = &noaBudgetProvider{Provider: opts.Provider, window: window}
}
// noaEnable is noaadapter.Enable; tests replace it to observe the options.
var noaEnable = noaadapter.Enable
+50
View File
@@ -0,0 +1,50 @@
package agent
import (
"context"
"errors"
"fmt"
"iter"
"github.com/Autumn-27/artex/sidequestion"
"github.com/Autumn-27/norma/llm"
)
// noaRequestOverhead covers request framing the input estimate does not count.
const noaRequestOverhead = 512
// ErrNoaBudget marks a request refused by the NOA budget check. The refusal is
// deterministic (the same history fails the same way), so callers must not
// retry it.
var ErrNoaBudget = errors.New("noa request budget exceeded")
// noaBudgetProvider refuses, before any transport, a request that cannot fit the
// window noa was configured with. noa trims what it is allowed to drop; when
// the protected part (system prompt, recent turns, the output reservation)
// alone is over the window, sending it only buys a provider rejection.
type noaBudgetProvider struct {
llm.Provider
window int
}
func (p *noaBudgetProvider) check(req llm.CompletionRequest) error {
estimate := sidequestion.EstimateInputTokens(req) + max(req.MaxTokens, 0) + noaRequestOverhead
if estimate > p.window {
return fmt.Errorf("%w: estimate %d exceeds configured budget %d; protected context cannot fit, increase the configured window or start a new session", ErrNoaBudget, estimate, p.window)
}
return nil
}
func (p *noaBudgetProvider) Complete(ctx context.Context, req llm.CompletionRequest) (llm.Message, string, llm.Usage, error) {
if err := p.check(req); err != nil {
return llm.Message{}, "", llm.Usage{}, err
}
return p.Provider.Complete(ctx, req)
}
func (p *noaBudgetProvider) Stream(ctx context.Context, req llm.CompletionRequest) iter.Seq2[llm.StreamEvent, error] {
if err := p.check(req); err != nil {
return func(yield func(llm.StreamEvent, error) bool) { yield(llm.StreamEvent{}, err) }
}
return p.Provider.Stream(ctx, req)
}
+155
View File
@@ -0,0 +1,155 @@
package agent
import (
"context"
"errors"
"iter"
"strings"
"testing"
"github.com/Autumn-27/norma/agentcore"
"github.com/Autumn-27/norma/harness"
"github.com/Autumn-27/norma/llm"
"github.com/Autumn-27/norma/noaadapter"
)
// A worker whose protected context exceeds a tiny NOA window ends with
// model_error and an error that still wraps ErrNoaBudget after the Norma harness
// and the capture layer: the engine's retry check relies on that.
func TestWorkerNoaBudgetRefusalKeepsSentinelThroughHarness(t *testing.T) {
f := newSessionFixture(t)
inner := &countingProvider{}
w := NewWorker(inner, "test-model", t.TempDir(), nil, 2000, 3)
w.SetNoaEnabled(func() bool { return true })
reason, _, err := w.Execute(t.Context(), "work#1", f.expID, nil, f.ts, f.intent, passHooks{}, nil, nil, nil)
if reason != harness.ReasonModelError || !errors.Is(err, ErrNoaBudget) || inner.calls != 0 {
t.Fatalf("reason=%q err=%v provider calls=%d; want model_error wrapping ErrNoaBudget and no call", reason, err, inner.calls)
}
}
// countingProvider answers with one text turn and counts the calls it receives.
type countingProvider struct{ calls int }
func (p *countingProvider) Stream(context.Context, llm.CompletionRequest) iter.Seq2[llm.StreamEvent, error] {
p.calls++
return func(yield func(llm.StreamEvent, error) bool) {
if yield(llm.StreamEvent{Type: llm.SETextDelta, Text: "ok"}, nil) {
yield(llm.StreamEvent{Type: llm.SEMessageStop}, nil)
}
}
}
func (p *countingProvider) Complete(context.Context, llm.CompletionRequest) (llm.Message, string, llm.Usage, error) {
p.calls++
return llm.Message{Role: llm.RoleAssistant, Content: []llm.ContentBlock{llm.TextBlock("ok")}}, "end_turn", llm.Usage{}, nil
}
// withNoaEnable swaps the noaadapter.Enable seam for the duration of a test.
func withNoaEnable(t *testing.T, fn func(*agentcore.Options, noaadapter.Options) error) {
t.Helper()
prev := noaEnable
noaEnable = fn
t.Cleanup(func() { noaEnable = prev })
}
func TestEnableNoaUsesConfiguredWindow(t *testing.T) {
for _, tc := range []struct {
name string
compaction func() *agentcore.Options
want int
}{
{"configured", func() *agentcore.Options { return &agentcore.Options{Compaction: compactionConfig(32000)} }, 32000},
{"default", func() *agentcore.Options { return &agentcore.Options{} }, defaultWindowK * 1000},
} {
t.Run(tc.name, func(t *testing.T) {
var got noaadapter.Options
withNoaEnable(t, func(opts *agentcore.Options, o noaadapter.Options) error {
got = o
return noaadapter.Enable(opts, o)
})
inner := &countingProvider{}
opts := tc.compaction()
opts.Provider = inner
enableNoa(opts, func() bool { return true }, t.TempDir(), "noa-window", nil)
if got.ModelContextLimit != tc.want {
t.Fatalf("noaadapter.Options.ModelContextLimit=%d, want %d", got.ModelContextLimit, tc.want)
}
bp, ok := opts.Provider.(*noaBudgetProvider)
if !ok || bp.window != tc.want || bp.Provider != inner {
t.Fatalf("provider %T %+v, want *noaBudgetProvider{window %d} around the original", opts.Provider, opts.Provider, tc.want)
}
if opts.Compaction != nil || opts.Compactor == nil {
t.Fatalf("Compaction=%v Compactor=%v; noa must replace the built-in compaction", opts.Compaction, opts.Compactor)
}
})
}
}
func irreducibleRequest() llm.CompletionRequest {
return llm.CompletionRequest{System: []string{strings.Repeat("protected system prompt ", 8000)}, MaxTokens: 8000}
}
func TestNoaBudgetRefusesIrreducibleRequestBeforeTransport(t *testing.T) {
t.Run("atomic", func(t *testing.T) {
inner := &countingProvider{}
p := &noaBudgetProvider{Provider: inner, window: 32000}
_, _, _, err := p.Complete(t.Context(), irreducibleRequest())
if err == nil || !strings.Contains(err.Error(), "exceeds configured budget 32000") || inner.calls != 0 {
t.Fatalf("err=%v provider calls=%d", err, inner.calls)
}
if !errors.Is(err, ErrNoaBudget) {
t.Fatalf("atomic refusal does not wrap ErrNoaBudget: %v", err)
}
if _, _, _, err := p.Complete(t.Context(), llm.CompletionRequest{System: []string{"short"}, MaxTokens: 1000}); err != nil || inner.calls != 1 {
t.Fatalf("a request that fits was refused or not sent: err=%v calls=%d", err, inner.calls)
}
})
t.Run("stream", func(t *testing.T) {
inner := &countingProvider{}
p := &noaBudgetProvider{Provider: inner, window: 32000}
var events int
var err error
for ev, e := range p.Stream(t.Context(), irreducibleRequest()) {
if e != nil {
err = e
break
}
_ = ev
events++
}
if err == nil || !strings.Contains(err.Error(), "exceeds configured budget 32000") || events != 0 || inner.calls != 0 {
t.Fatalf("err=%v events=%d provider calls=%d", err, events, inner.calls)
}
if !errors.Is(err, ErrNoaBudget) {
t.Fatalf("stream refusal does not wrap ErrNoaBudget: %v", err)
}
for _, e := range p.Stream(t.Context(), llm.CompletionRequest{System: []string{"short"}, MaxTokens: 1000}) {
if e != nil {
t.Fatal(e)
}
}
if inner.calls != 1 {
t.Fatalf("a request that fits was not streamed: calls=%d", inner.calls)
}
})
}
func TestEnableNoaFailureKeepsBuiltInCompaction(t *testing.T) {
withNoaEnable(t, func(*agentcore.Options, noaadapter.Options) error { return errors.New("archive dir unusable") })
inner := &countingProvider{}
compaction := compactionConfig(32000)
opts := &agentcore.Options{Compaction: compaction, Provider: inner}
var warns []string
enableNoa(opts, func() bool { return true }, t.TempDir(), "noa-fail", func(m string) { warns = append(warns, m) })
if len(warns) != 1 || !strings.Contains(warns[0], "falling back to built-in compaction") || !strings.Contains(warns[0], "archive dir unusable") {
t.Fatalf("warnings %q", warns)
}
if opts.Compaction != compaction || opts.Compactor != nil {
t.Fatalf("Compaction=%v Compactor=%v; the built-in compaction must stay", opts.Compaction, opts.Compactor)
}
if opts.Provider != llm.Provider(inner) {
t.Fatalf("provider %T was wrapped although noa is off", opts.Provider)
}
}
+6 -5
View File
@@ -341,11 +341,12 @@ func applyCostEur(d *DB, out []ProfileUsage) error {
if !ok || (pr.in == 0 && pr.outp == 0 && pr.cr == 0 && pr.cw == 0) {
continue
}
// InputTokens includes the cached subset (Anthropic and OpenAI usage
// semantics), so the fresh share is input minus cache reads; charging
// both buckets at full input price double-counts the cache. Clamped at
// zero for gateways that report the buckets disjointly.
fresh := out[i].InputTokens - out[i].CacheReadTokens
// InputTokens already includes both cached subsets: Norma normalizes it to
// input + cache read + cache write (OpenAI prompt_tokens semantics). The
// fresh share is therefore input minus cache reads minus cache writes;
// charging either subset at full input price as well bills it twice.
// Clamped at zero for gateways that report the buckets disjointly.
fresh := out[i].InputTokens - out[i].CacheReadTokens - out[i].CacheWriteTokens
if fresh < 0 {
fresh = 0
}
+125
View File
@@ -0,0 +1,125 @@
package db
import (
"fmt"
"math"
"testing"
"time"
)
// costProfiles saves a priced profile (EUR per million tokens: input 2.00,
// output 4.00, cache read 0.20, cache write 2.50) and an unpriced one.
func costProfiles(t *testing.T, d *DB) (priced, unpriced string) {
t.Helper()
suffix := time.Now().UnixNano()
priced, unpriced = fmt.Sprintf("t-cost-priced-%d", suffix), fmt.Sprintf("t-cost-unpriced-%d", suffix)
for _, p := range []*LLMProfile{
{Name: priced, Format: "anthropic", Model: "m", APIKey: "k",
PriceInputPerM: 2, PriceOutputPerM: 4, PriceCacheReadPerM: 0.2, PriceCacheWritePerM: 2.5},
{Name: unpriced, Format: "anthropic", Model: "m", APIKey: "k"},
} {
id, err := d.SaveProfile(p)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { d.Exec(`DELETE FROM llm_profiles WHERE id=$1`, id) })
}
return priced, unpriced
}
func assertCost(t *testing.T, got *float64, want float64) {
t.Helper()
if got == nil {
t.Fatalf("cost=nil, want %.2f", want)
}
if math.Abs(*got-want) > 1e-9 {
t.Fatalf("cost=%.4f, want %.2f", *got, want)
}
}
// InputTokens already includes the cache read and cache write subsets, so only
// the remainder is billed at the input price.
func TestCostSeparatesFreshReadAndWriteBuckets(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Fatal(err)
}
defer d.Close()
priced, unpriced := costProfiles(t, d)
// Every case adds 100k output tokens: 0.1 × 4.00 = 0.40.
for _, tc := range []struct {
name string
in, read, write int
want float64
}{
{"fresh", 1_000_000, 0, 0, 2.40}, // 1M×2.00 + 0.40
{"read_only", 1_000_000, 1_000_000, 0, 0.60}, // 0 fresh + 1M×0.20 + 0.40
{"write_only", 1_000_000, 0, 1_000_000, 2.90}, // 0 fresh + 1M×2.50 + 0.40
{"mixed", 1_000_000, 200_000, 300_000, 2.19}, // 500k×2.00 + 200k×0.20 + 300k×2.50 + 0.40
{"inconsistent_gateway", 100_000, 200_000, 300_000, 1.19}, // fresh clamped to 0 + 0.04 + 0.75 + 0.40
} {
t.Run(tc.name, func(t *testing.T) {
out := []ProfileUsage{
{ProfileName: priced, InputTokens: tc.in, CacheReadTokens: tc.read, CacheWriteTokens: tc.write, OutputTokens: 100_000},
{ProfileName: unpriced, InputTokens: tc.in, CacheReadTokens: tc.read, CacheWriteTokens: tc.write, OutputTokens: 100_000},
{ProfileName: "t-cost-unknown-profile", InputTokens: tc.in, OutputTokens: 100_000},
}
if err := applyCostEur(d, out); err != nil {
t.Fatal(err)
}
assertCost(t, out[0].CostEur, tc.want)
if out[1].CostEur != nil || out[2].CostEur != nil {
t.Fatalf("unpriced usage got a cost: %v %v", out[1].CostEur, out[2].CostEur)
}
})
}
}
// Several ledger rows of one profile are summed before pricing; with no clamp
// involved the profile cost equals the sum of the per-row costs.
func TestUsageByProfileCostAggregatesRows(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Fatal(err)
}
defer d.Close()
priced, unpriced := costProfiles(t, d)
t.Cleanup(func() { d.Exec(`DELETE FROM llm_usage WHERE profile_name IN ($1,$2)`, priced, unpriced) })
rows := []LLMUsage{
// fresh 400k×2.00 + 200k×0.20 + 40k×4.00 = 0.80 + 0.04 + 0.16 = 1.00
{InputTokens: 600_000, CacheRead: 200_000, OutputTokens: 40_000},
// fresh 100k×2.00 + 300k×2.50 + 60k×4.00 = 0.20 + 0.75 + 0.24 = 1.19
{InputTokens: 400_000, CacheWrite: 300_000, OutputTokens: 60_000},
}
for _, profile := range []string{priced, unpriced} {
for _, r := range rows {
r.ProfileName, r.Model, r.Status = profile, "m", "ok"
if err := d.InsertLLMUsage(&r); err != nil {
t.Fatal(err)
}
}
}
usage, err := d.UsageByProfile()
if err != nil {
t.Fatal(err)
}
found := 0
for _, p := range usage {
switch p.ProfileName {
case priced:
found++
if p.Calls != 2 || p.InputTokens != 1_000_000 || p.CacheReadTokens != 200_000 || p.CacheWriteTokens != 300_000 || p.OutputTokens != 100_000 {
t.Fatalf("aggregate %+v", p)
}
assertCost(t, p.CostEur, 2.19) // = 1.00 + 1.19, the mixed case
case unpriced:
found++
if p.Calls != 2 || p.CostEur != nil {
t.Fatalf("unpriced aggregate %+v", p)
}
}
}
if found != 2 {
t.Fatalf("profiles missing from UsageByProfile: found %d of 2", found)
}
}
+2 -2
View File
@@ -3,7 +3,7 @@ module github.com/Autumn-27/artex
go 1.26.10
require (
github.com/Autumn-27/norma v0.4.3
github.com/Autumn-27/norma v0.4.10
github.com/golang-jwt/jwt/v5 v5.3.1
github.com/google/uuid v1.6.0
github.com/jackc/pgx/v5 v5.10.0
@@ -61,4 +61,4 @@ require (
modernc.org/memory v1.11.0 // indirect
)
replace github.com/Autumn-27/norma => github.com/BaaRai/Norma v0.4.8
replace github.com/Autumn-27/norma => github.com/BaaRai/Norma v0.4.10
+2 -2
View File
@@ -1,5 +1,5 @@
github.com/BaaRai/Norma v0.4.8 h1:k3at2aYSJ6aIDjEo7tC4VDSLBHXw2HobYjpKChVe6hI=
github.com/BaaRai/Norma v0.4.8/go.mod h1:BudWrf7iHl96FgHqFr/HwN3mKYmGjJDt+xL2ZHXfFZw=
github.com/BaaRai/Norma v0.4.10 h1:+Sj6m8gZQIcVoOr5x9b3y7T1jI+95u43M07MLuvdaZk=
github.com/BaaRai/Norma v0.4.10/go.mod h1:BudWrf7iHl96FgHqFr/HwN3mKYmGjJDt+xL2ZHXfFZw=
github.com/andybalholm/brotli v1.2.1 h1:R+f5xP285VArJDRgowrfb9DqL18yVK0gKAW/F+eTWro=
github.com/andybalholm/brotli v1.2.1/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so=
+6 -6
View File
@@ -195,11 +195,11 @@ func (r *Recorder) Stream(ctx context.Context, req llm.CompletionRequest) iter.S
return
}
// Always track usage (cheap); accumulate text/thinking only for bodies.
// Anthropic (and the other providers) split token usage across events:
// message_start carries ONLY the input side (input + cache), message_delta
// ONLY the output. They must be FOLDED with Add — overwriting on delta
// would zero out the input already counted at start (mirrors the SDK's own
// llm.Accumulator; see norma/llm/accumulate.go).
// message_start carries the input side (input + cache) and is added.
// Since Norma v0.4.7 message_delta also echoes that input side next to the
// output, so it is folded with llm.Usage.MergeEcho (max on echoed fields,
// sum on output), as llm.Accumulator does; Add would count the input and
// cache twice. An output-only delta folds the same either way.
switch ev.Type {
case llm.SETextDelta:
if recordBodies {
@@ -215,7 +215,7 @@ func (r *Recorder) Stream(ctx context.Context, req llm.CompletionRequest) iter.S
if ev.StopReason != "" {
stopReason = ev.StopReason
}
usage.Add(ev.Usage)
usage.MergeEcho(ev.Usage)
}
if !yield(ev, err) {
return
+118
View File
@@ -0,0 +1,118 @@
package llmrec
import (
"context"
"iter"
"testing"
"github.com/Autumn-27/artex/db"
"github.com/Autumn-27/norma/llm"
"github.com/google/uuid"
)
// echoStreamProvider streams one message_start and one message_delta with the
// given (already normalized) usage, as Norma's providers emit them.
type echoStreamProvider struct {
completeProvider
start, delta llm.Usage
}
func (p echoStreamProvider) Stream(context.Context, llm.CompletionRequest) iter.Seq2[llm.StreamEvent, error] {
return func(yield func(llm.StreamEvent, error) bool) {
for _, ev := range []llm.StreamEvent{
{Type: llm.SEMessageStart, Usage: p.start},
{Type: llm.SETextDelta, Text: "answer"},
{Type: llm.SEMessageDelta, StopReason: "end_turn", Usage: p.delta},
{Type: llm.SEMessageStop},
} {
if !yield(ev, nil) {
return
}
}
}
}
// Norma normalizes Anthropic usage so InputTokens includes the cache read and
// write subsets, and since v0.4.7 message_delta echoes that input side.
var usageEchoCases = []struct {
name string
start, delta llm.Usage
want llm.Usage
}{
{
name: "full_echo",
start: llm.Usage{InputTokens: 23, CacheReadTokens: 5, CacheWriteTokens: 3},
delta: llm.Usage{InputTokens: 23, CacheReadTokens: 5, CacheWriteTokens: 3, OutputTokens: 5},
want: llm.Usage{InputTokens: 23, OutputTokens: 5, CacheReadTokens: 5, CacheWriteTokens: 3},
},
{
// Raw start: input 500, cache read 200, cache creation 40 → normalized 740.
// Raw delta: input 500, output 77, no cache fields → normalized 500.
name: "partial_echo",
start: llm.Usage{InputTokens: 740, CacheReadTokens: 200, CacheWriteTokens: 40},
delta: llm.Usage{InputTokens: 500, OutputTokens: 77},
want: llm.Usage{InputTokens: 740, OutputTokens: 77, CacheReadTokens: 200, CacheWriteTokens: 40},
},
{
name: "no_echo",
start: llm.Usage{InputTokens: 23, CacheReadTokens: 5, CacheWriteTokens: 3},
delta: llm.Usage{OutputTokens: 5},
want: llm.Usage{InputTokens: 23, OutputTokens: 5, CacheReadTokens: 5, CacheWriteTokens: 3},
},
}
func drainRecorderStream(t *testing.T, ctx context.Context, r *Recorder) {
t.Helper()
for _, err := range r.Stream(ctx, llm.CompletionRequest{}) {
if err != nil {
t.Fatal(err)
}
}
}
// The metered usage of a streamed call counts an echoed input side once.
func TestStreamUsageEchoCountedOnce(t *testing.T) {
for _, tc := range usageEchoCases {
t.Run(tc.name, func(t *testing.T) {
var got []llm.Usage
ctx := WithUsageSink(t.Context(), func(u llm.Usage) { got = append(got, u) })
drainRecorderStream(t, ctx, Wrap(echoStreamProvider{start: tc.start, delta: tc.delta}, nil, "fixture", "profile", "", "", func() bool { return false }))
if len(got) != 1 || got[0] != tc.want {
t.Fatalf("metered %+v, want one call with %+v", got, tc.want)
}
})
}
}
// The llm_usage ledger gets one row per streamed call, with the echo counted once.
func TestStreamUsageEchoLedgerRow(t *testing.T) {
dsn, _, err := db.DSN()
if err != nil {
t.Skipf("no database config (%v)", err)
}
pg, err := db.Open(dsn)
if err != nil {
t.Skipf("postgres unavailable (%v)", err)
}
defer pg.Close()
if err := pg.EnsureLLMUsageTable(); err != nil {
t.Fatal(err)
}
for _, tc := range usageEchoCases {
t.Run(tc.name, func(t *testing.T) {
profile := "usage-echo-" + uuid.NewString()
t.Cleanup(func() { _, _ = pg.Exec(`DELETE FROM llm_usage WHERE profile_name=$1`, profile) })
drainRecorderStream(t, t.Context(), Wrap(echoStreamProvider{start: tc.start, delta: tc.delta}, pg, "fixture", profile, "", "", func() bool { return false }))
var rows int
var got llm.Usage
err := pg.QueryRow(`SELECT count(*), COALESCE(sum(input_tokens),0), COALESCE(sum(output_tokens),0), COALESCE(sum(cache_read),0), COALESCE(sum(cache_write),0)
FROM llm_usage WHERE profile_name=$1`, profile).Scan(&rows, &got.InputTokens, &got.OutputTokens, &got.CacheReadTokens, &got.CacheWriteTokens)
if err != nil {
t.Fatal(err)
}
if rows != 1 || got != tc.want {
t.Fatalf("ledger rows=%d usage=%+v, want 1 row with %+v", rows, got, tc.want)
}
})
}
}
+3 -1
View File
@@ -79,8 +79,10 @@ var errWorkControlConflict = errors.New("work control conflict")
// retryableWorkerModelError excludes errors already handled by the task router.
// In particular, a quota error after partial streaming advances the task cursor
// for the next LLM call but must not replay this whole intent on the backup.
// A NOA budget refusal is deterministic and never reached the provider, so a
// rerun would only fail the same way.
func retryableWorkerModelError(reason harness.TerminalReason, err error) bool {
return reason == harness.ReasonModelError && !isTaskLLMRuntimeError(err)
return reason == harness.ReasonModelError && !isTaskLLMRuntimeError(err) && !errors.Is(err, agent.ErrNoaBudget)
}
// Engine drives the event-driven exploration loop with real LLM agents
+32
View File
@@ -0,0 +1,32 @@
package server
import (
"errors"
"fmt"
"testing"
"github.com/Autumn-27/artex/agent"
"github.com/Autumn-27/norma/harness"
)
// A NOA budget refusal is deterministic: the engine must not rerun the intent,
// whether the sentinel arrives bare or wrapped.
func TestWorkerModelErrorRetrySkipsNoaBudget(t *testing.T) {
for _, tc := range []struct {
name string
err error
want bool
}{
{"noa budget", agent.ErrNoaBudget, false},
{"noa budget wrapped", fmt.Errorf("%w: estimate 64000 exceeds configured budget 32000", agent.ErrNoaBudget), false},
{"noa budget wrapped twice", fmt.Errorf("worker: %w", fmt.Errorf("%w: estimate", agent.ErrNoaBudget)), false},
{"generic model error", errors.New("connection reset by peer"), true},
{"task router error", &taskLLMError{taskID: "7", cause: errors.New("insufficient_quota")}, false},
} {
t.Run(tc.name, func(t *testing.T) {
if got := retryableWorkerModelError(harness.ReasonModelError, tc.err); got != tc.want {
t.Fatalf("retryableWorkerModelError(model_error, %v) = %v, want %v", tc.err, got, tc.want)
}
})
}
}
+4 -1
View File
@@ -32,8 +32,11 @@ func (s SideQuestionService) Answer(ctx context.Context, req llm.CompletionReque
out.Text += ev.Text
case llm.SEToolUseStart:
out.ToolUse = true
case llm.SEMessageStart, llm.SEMessageDelta:
case llm.SEMessageStart:
out.Usage.Add(ev.Usage)
case llm.SEMessageDelta:
// message_delta may echo message_start's input side: MergeEcho, not Add.
out.Usage.MergeEcho(ev.Usage)
case llm.SEMessageStop:
complete = true
}
+52
View File
@@ -0,0 +1,52 @@
package sidequestion
import (
"context"
"iter"
"testing"
"github.com/Autumn-27/norma/llm"
)
// A streamed side answer counts message_delta's echo of the input side once.
func TestAnswerStreamUsageEchoCountedOnce(t *testing.T) {
for _, tc := range []struct {
name string
start, delta llm.Usage
want llm.Usage
}{
{"full_echo",
llm.Usage{InputTokens: 23, CacheReadTokens: 5, CacheWriteTokens: 3},
llm.Usage{InputTokens: 23, CacheReadTokens: 5, CacheWriteTokens: 3, OutputTokens: 5},
llm.Usage{InputTokens: 23, OutputTokens: 5, CacheReadTokens: 5, CacheWriteTokens: 3}},
{"partial_echo",
llm.Usage{InputTokens: 740, CacheReadTokens: 200, CacheWriteTokens: 40},
llm.Usage{InputTokens: 500, OutputTokens: 77},
llm.Usage{InputTokens: 740, OutputTokens: 77, CacheReadTokens: 200, CacheWriteTokens: 40}},
{"no_echo",
llm.Usage{InputTokens: 23, CacheReadTokens: 5, CacheWriteTokens: 3},
llm.Usage{OutputTokens: 5},
llm.Usage{InputTokens: 23, OutputTokens: 5, CacheReadTokens: 5, CacheWriteTokens: 3}},
} {
t.Run(tc.name, func(t *testing.T) {
p := fakeProvider{stream: func(context.Context, llm.CompletionRequest) iter.Seq2[llm.StreamEvent, error] {
return func(yield func(llm.StreamEvent, error) bool) {
for _, ev := range []llm.StreamEvent{
{Type: llm.SEMessageStart, Usage: tc.start},
{Type: llm.SETextDelta, Text: "answer"},
{Type: llm.SEMessageDelta, StopReason: "end_turn", Usage: tc.delta},
{Type: llm.SEMessageStop},
} {
if !yield(ev, nil) {
return
}
}
}
}}
out, err := (SideQuestionService{Provider: p}).Answer(t.Context(), llm.CompletionRequest{}, true, nil)
if err != nil || out.Text != "answer" || out.Usage != tc.want {
t.Fatalf("answer=%+v err=%v, want usage %+v", out, err, tc.want)
}
})
}
}
+2 -1
View File
@@ -12,7 +12,8 @@
"check": "biome check",
"check:fix": "biome check --write",
"prepare": "husky",
"generate:presets": "ts-node -P tsconfig.scripts.json src/scripts/generate-theme-presets.ts"
"generate:presets": "ts-node -P tsconfig.scripts.json src/scripts/generate-theme-presets.ts",
"test:polling": "node --test scripts/polling.test.mjs"
},
"lint-staged": {
"*.{js,ts,jsx,tsx}": [
+120
View File
@@ -0,0 +1,120 @@
import { test } from "node:test";
import assert from "node:assert/strict";
import fs from "node:fs";
import vm from "node:vm";
import path from "node:path";
import { fileURLToPath } from "node:url";
import ts from "typescript";
const web = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
function moduleFor(name, globals = {}) {
const output = ts.transpileModule(fs.readFileSync(path.join(web, "src/lib", name + ".ts"), "utf8"), {
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 },
}).outputText;
const exports = {};
vm.runInNewContext(output, { exports, ...globals });
return exports;
}
function setup(hidden = false) {
let sequence = 0;
const timers = new Map();
const listeners = new Set();
const document = {
visibilityState: hidden ? "hidden" : "visible",
addEventListener: (_, callback) => listeners.add(callback),
removeEventListener: (_, callback) => listeners.delete(callback),
};
const { setVisibleInterval } = moduleFor("polling", {
document,
setTimeout: (callback) => {
const id = ++sequence;
timers.set(id, callback);
return id;
},
clearTimeout: (id) => timers.delete(id),
});
return {
setVisibleInterval,
timers,
listeners,
visibility(hidden) {
document.visibilityState = hidden ? "hidden" : "visible";
for (const callback of listeners) callback();
},
tick() {
const entries = [...timers];
timers.clear();
for (const [, callback] of entries) callback();
},
};
}
async function settle() {
for (let i = 0; i < 8; i++) await Promise.resolve();
}
test("hidden tabs make no scheduled requests; returning refreshes immediately and cleanup stops work", async () => {
const s = setup(true);
let calls = 0;
const stop = s.setVisibleInterval(() => {
calls++;
}, 5000);
s.tick();
await settle();
assert.equal(calls, 0);
assert.equal(s.timers.size, 0);
s.visibility(false);
await settle();
assert.equal(calls, 1);
assert.equal(s.timers.size, 1);
s.visibility(true);
assert.equal(s.timers.size, 0);
s.visibility(false);
await settle();
assert.equal(calls, 2);
stop();
s.tick();
s.visibility(false);
await settle();
assert.equal(calls, 2);
assert.equal(s.listeners.size, 0);
assert.equal(s.timers.size, 0);
});
test("a slow poll cannot overlap on timer or visibility changes; dispose while running cannot revive it", async () => {
const s = setup();
let calls = 0;
let release;
const stop = s.setVisibleInterval(() => {
calls++;
return new Promise((resolve) => {
release = resolve;
});
}, 2000);
s.tick();
assert.equal(calls, 1);
s.visibility(true);
s.visibility(false);
s.tick();
assert.equal(calls, 1);
release();
await settle();
assert.equal(s.timers.size, 1);
s.tick();
assert.equal(calls, 2);
stop();
release();
await settle();
assert.equal(s.timers.size, 0);
});
test("a failed background refresh retries on the next interval", async () => {
const s = setup();
let calls = 0;
const stop = s.setVisibleInterval(async () => {
if (++calls === 1) throw Error("temporary");
}, 1000);
s.tick();
await settle();
assert.equal(s.timers.size, 1);
s.tick();
await settle();
assert.equal(calls, 2);
stop();
});
@@ -37,6 +37,7 @@ import type {
NavMainLinkItem,
NavMainParentItem,
} from "@/navigation/sidebar/sidebar-items";
import { setVisibleInterval } from "@/lib/polling";
interface NavMainProps {
readonly items: readonly NavGroup[];
@@ -174,8 +175,8 @@ function InterceptPendingBadge() {
} catch { /* ignore */ }
}
poll();
const t = setInterval(poll, 5000);
return () => { live = false; clearInterval(t); };
const stopPolling = setVisibleInterval(poll, 5000);
return () => { live = false; stopPolling(); };
}, []);
if (count === 0) return null;
return (
+7 -6
View File
@@ -40,6 +40,7 @@ import type {
UsageStats,
} from "@/lib/types";
import { cn } from "@/lib/utils";
import { setVisibleInterval } from "@/lib/polling";
// ── chart constants ───────────────────────────────────────────────────────────
@@ -172,10 +173,10 @@ export default function DashboardPage() {
}
};
void load();
const t = setInterval(load, 5000);
const stopPolling = setVisibleInterval(load, 5000);
return () => {
alive = false;
clearInterval(t);
stopPolling();
};
}, []);
@@ -211,10 +212,10 @@ export default function DashboardPage() {
}
};
void load();
const timer = setInterval(load, 5000);
const stopPolling = setVisibleInterval(load, 5000);
return () => {
alive = false;
clearInterval(timer);
stopPolling();
};
}, []);
@@ -247,10 +248,10 @@ export default function DashboardPage() {
}
};
void load();
const t = setInterval(load, 15000);
const stopPolling = setVisibleInterval(load, 15000);
return () => {
alive = false;
clearInterval(t);
stopPolling();
};
}, []);
@@ -67,6 +67,7 @@ import {
VERIFICATION_META,
VERIFICATION_STATUSES,
} from "./_components/findings-table";
import { setVisibleInterval } from "@/lib/polling";
const FINDING_LIST_PREFERENCE_KEY = "artex_finding_list_preferences";
@@ -573,8 +574,8 @@ export default function FindingsPage() {
};
refresh();
if (view === "asset") return;
const timer = setInterval(refresh, 5000);
return () => clearInterval(timer);
const stopPolling = setVisibleInterval(refresh, 5000);
return stopPolling;
}, [activeRetestFingerprint, loadFlat, loadGroup, preferencesHydrated, refreshGroups, view]);
React.useEffect(() => {
@@ -606,10 +607,10 @@ export default function FindingsPage() {
});
};
load();
const t = setInterval(load, 5000);
const stopPolling = setVisibleInterval(load, 5000);
return () => {
alive = false;
clearInterval(t);
stopPolling();
};
}, []);
@@ -43,6 +43,7 @@ import { parseCompanyScopeText } from "@/lib/company-scope";
import { taskAssetSourceLabel } from "@/lib/task-assets";
import type { Asset, NewAssetType } from "@/lib/types";
import { cn } from "@/lib/utils";
import { setVisibleInterval } from "@/lib/polling";
const PAGE_SIZES = [25, 50, 100, 200];
@@ -415,11 +416,11 @@ export function AssetsTab({ taskId }: { taskId: string }) {
};
// Debounce DSL keystrokes; plain (re)loads and polling run immediately.
const debounce = setTimeout(() => void load(), dsl ? 400 : 0);
const timer = setInterval(() => void load(), 10_000);
const stopPolling = setVisibleInterval(() => void load(), 10_000);
return () => {
active = false;
clearTimeout(debounce);
clearInterval(timer);
stopPolling();
};
}, [page, query, refreshKey, size, tab, taskId]);
@@ -33,6 +33,7 @@ import { type Tone, toneClasses, toneDot } from "@/lib/status";
import { taskAssetTypeLabel } from "@/lib/task-assets";
import type { Edge, ExploreKind, FindingAsset, NewAssetType, TaskNode } from "@/lib/types";
import { cn } from "@/lib/utils";
import { setVisibleInterval } from "@/lib/polling";
const PAGE_SIZES = [20, 50, 100];
const POLL_MS = 8000;
@@ -519,10 +520,10 @@ export function BroadcastTab({ taskId }: { taskId: string }) {
alive = false;
};
}
const timer = setInterval(load, POLL_MS);
const stopPolling = setVisibleInterval(load, POLL_MS);
return () => {
alive = false;
clearInterval(timer);
stopPolling();
};
}, [taskId, page, size, kinds, query, order, live, atLive]);
@@ -12,6 +12,7 @@ import { Input } from "@/components/ui/input";
import { Skeleton } from "@/components/ui/skeleton";
import { api } from "@/lib/api";
import type { TaskCredential } from "@/lib/types";
import { setVisibleInterval } from "@/lib/polling";
// Credentials tab (#3): the task's test accounts — user-declared (program alias
// accounts) and agent-recorded (accounts the workers registered themselves).
@@ -38,8 +39,8 @@ export function CredentialsTab({ taskId }: { taskId: string }) {
React.useEffect(() => {
load();
// Agent runs can record credentials mid-task; a light poll keeps the tab current.
const timer = setInterval(load, 15000);
return () => clearInterval(timer);
const stopPolling = setVisibleInterval(load, 15000);
return stopPolling;
}, [load]);
async function add() {
@@ -16,6 +16,7 @@ import { useStoredSortPreference } from "@/lib/sort-preference";
import { statusMeta } from "@/lib/status";
import type { Finding, FindingStatus } from "@/lib/types";
import { cn } from "@/lib/utils";
import { setVisibleInterval } from "@/lib/polling";
type FindingSortField = "time";
@@ -159,10 +160,10 @@ export function FindingsTab({ taskId }: { taskId: string }) {
});
};
load();
const t = setInterval(load, 3000);
const stopPolling = setVisibleInterval(load, 3000);
return () => {
active = false;
clearInterval(t);
stopPolling();
};
}, [taskId]);
@@ -6,6 +6,7 @@ import { Card, CardContent } from "@/components/ui/card";
import { ExplorationGraph } from "@/components/exploration-graph";
import { api } from "@/lib/api";
import type { Edge, TaskNode } from "@/lib/types";
import { setVisibleInterval } from "@/lib/polling";
export function GraphTab({ taskId }: { taskId: string }) {
const [nodes, setNodes] = React.useState<TaskNode[]>([]);
@@ -38,10 +39,10 @@ export function GraphTab({ taskId }: { taskId: string }) {
});
};
load();
const timer = setInterval(load, 20000);
const stopPolling = setVisibleInterval(load, 20000);
return () => {
cancelled = true;
clearInterval(timer);
stopPolling();
};
}, [taskId]);
@@ -40,6 +40,7 @@ import type {
TaskNode,
TaskScopeRow,
} from "@/lib/types";
import { setVisibleInterval } from "@/lib/polling";
// Compact token count formatting (12345 → 12.3k, 2000000 → 2M).
function fmtTokens(n: number): string {
@@ -402,7 +403,7 @@ export function OverviewTab({ taskId }: { taskId: string }) {
void loadTokens();
void loadGoals();
void loadConstraints();
const timer = setInterval(() => {
const stopPolling = setVisibleInterval(() => {
void load();
void loadTokens();
void loadGoals();
@@ -410,7 +411,7 @@ export function OverviewTab({ taskId }: { taskId: string }) {
}, 3000);
return () => {
cancelled = true;
clearInterval(timer);
stopPolling();
};
}, [taskId, loadScope, loadTokens, loadGoals, loadConstraints]);
@@ -69,6 +69,7 @@ import type {
TokenTotal,
} from "@/lib/types";
import { cn } from "@/lib/utils";
import { setVisibleInterval } from "@/lib/polling";
// resolutionLabel names the LLM a session runs on. The badge shows this alone and
// keeps the model id in its tooltip. Env-backed configs can arrive without a name,
@@ -794,10 +795,10 @@ export function SessionsTab({ taskId, taskPaused = false }: { taskId: string; ta
// Polling is best-effort; the next interval retries automatically.
});
void load();
const t = setInterval(load, 5000);
const stopPolling = setVisibleInterval(load, 5000);
return () => {
alive = false;
clearInterval(t);
stopPolling();
};
}, [taskId]);
@@ -817,10 +818,10 @@ export function SessionsTab({ taskId, taskPaused = false }: { taskId: string; ta
});
};
void load();
const timer = setInterval(load, 2000);
const stopPolling = setVisibleInterval(load, 2000);
return () => {
alive = false;
clearInterval(timer);
stopPolling();
};
}, [taskId]);
@@ -836,10 +837,10 @@ export function SessionsTab({ taskId, taskPaused = false }: { taskId: string; ta
// Polling is best-effort; the next interval retries automatically.
});
void load();
const timer = setInterval(load, 10_000);
const stopPolling = setVisibleInterval(load, 10_000);
return () => {
alive = false;
clearInterval(timer);
stopPolling();
};
}, [taskId]);
@@ -855,10 +856,10 @@ export function SessionsTab({ taskId, taskPaused = false }: { taskId: string; ta
// Polling is best-effort; the next interval retries automatically.
});
void load();
const t = setInterval(load, 5000);
const stopPolling = setVisibleInterval(load, 5000);
return () => {
alive = false;
clearInterval(t);
stopPolling();
};
}, [taskId]);
@@ -1059,10 +1060,10 @@ export function SessionsTab({ taskId, taskPaused = false }: { taskId: string; ta
// The next poll retries; Worker controls and transcripts remain available.
});
void load();
const timer = setInterval(load, 5000);
const stopPolling = setVisibleInterval(load, 5000);
return () => {
active = false;
clearInterval(timer);
stopPolling();
};
}, [taskId]);
@@ -1099,10 +1100,10 @@ export function SessionsTab({ taskId, taskPaused = false }: { taskId: string; ta
// Polling is best-effort; the next interval retries automatically.
});
void load();
const t = setInterval(load, 5000);
const stopPolling = setVisibleInterval(load, 5000);
return () => {
active = false;
clearInterval(t);
stopPolling();
};
}, [taskId]);
@@ -50,6 +50,7 @@ import { OverviewTab } from "./_tabs/overview-tab";
import { ReportTab } from "./_tabs/report-tab";
import { RetestsTab } from "./_tabs/retests-tab";
import { SessionsTab } from "./_tabs/sessions-tab";
import { setVisibleInterval } from "@/lib/polling";
const TABS = [
{ value: "sessions", label: "Sessions" },
@@ -235,10 +236,10 @@ function TaskDetailInner() {
// Polling is best-effort; the next interval retries automatically.
});
void load();
const t = setInterval(load, 5000);
const stopPolling = setVisibleInterval(load, 5000);
return () => {
alive = false;
clearInterval(t);
stopPolling();
};
}, [id]);
@@ -273,8 +274,8 @@ function TaskDetailInner() {
}, [id]);
React.useEffect(() => {
load();
const timer = setInterval(load, 5000);
return () => clearInterval(timer);
const stopPolling = setVisibleInterval(load, 5000);
return stopPolling;
}, [load]);
async function togglePause() {
+5 -4
View File
@@ -119,6 +119,7 @@ import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@
import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
import { Textarea } from "@/components/ui/textarea";
import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
import { setVisibleInterval } from "@/lib/polling";
import { api } from "@/lib/api";
import { getLocalStorageValue, setLocalStorageValue } from "@/lib/local-storage.client";
import { type SortDirection, useStoredSortPreference } from "@/lib/sort-preference";
@@ -485,8 +486,8 @@ export default function TasksPage() {
React.useEffect(() => {
load();
loadCategories();
const i = setInterval(load, POLL_MS);
return () => clearInterval(i);
const stopPolling = setVisibleInterval(load, POLL_MS);
return stopPolling;
}, [load, loadCategories]);
const refreshCategoriesAndTasks = React.useCallback(() => {
@@ -1694,8 +1695,8 @@ function TaskArchivesPanel({ onChanged }: { onChanged: () => void }) {
React.useEffect(() => {
void load();
const timer = setInterval(() => void load(), 2_000);
return () => clearInterval(timer);
const stopPolling = setVisibleInterval(() => void load(), 2_000);
return stopPolling;
}, [load]);
const selectable = React.useMemo(
+3 -2
View File
@@ -45,6 +45,7 @@ import { api } from "@/lib/api";
import { useStoredSortPreference } from "@/lib/sort-preference";
import type { TrafficDetail, TrafficExchange, TrafficHost, TrafficResp } from "@/lib/types";
import { cn } from "@/lib/utils";
import { setVisibleInterval } from "@/lib/polling";
function fmtTime(ts: string) {
return new Date(ts).toLocaleString("zh-CN", {
@@ -227,13 +228,13 @@ export default function TrafficPage() {
});
};
load();
const t = setInterval(() => {
const stopPolling = setVisibleInterval(() => {
if (page !== 0) return; // only auto-refresh the newest page
load();
}, 5000);
return () => {
alive = false;
clearInterval(t);
stopPolling();
};
}, [page, size, hostQ, method, queryQ, bodyQ, pathQ, statusFilter, respMinQ, respMaxQ, sort, reloadTick]);
+3 -2
View File
@@ -31,6 +31,7 @@ import type { LLMPoolMember, LLMPoolStatus, LLMProfile, LLMRetryOverride } from
import { cn } from "@/lib/utils";
import { ProfileRetryFields, RetryPolicyPanel, ZERO_OVERRIDE } from "./_components/retry";
import { setVisibleInterval } from "@/lib/polling";
// The thinking switch (thinking.type) and the thinking effort (reasoning_effort) are two [independent] fields,
// each set on its own — some APIs have no thinking field and activate thinking via the effort parameter alone, hence the decoupling.
@@ -125,8 +126,8 @@ function PoolSheet({
// The cooldown countdown is the remaining seconds computed by the backend — fetched on a timer only while the drawer is open and some profile is unhealthy, to keep it ticking.
React.useEffect(() => {
if (!open || !pool?.enabled || !pool.chain.some((m) => m.state !== "ok")) return;
const t = setInterval(() => void onReload(), 10_000);
return () => clearInterval(t);
const stopPolling = setVisibleInterval(() => void onReload(), 10_000);
return stopPolling;
}, [open, pool, onReload]);
async function toggle(patch: { llm_pool_enabled?: boolean; llm_pool_bind_fallback?: boolean }) {
+3 -2
View File
@@ -47,6 +47,7 @@ import type {
InterceptRisk,
} from "@/lib/types";
import { cn } from "@/lib/utils";
import { setVisibleInterval } from "@/lib/polling";
function fmtTime(value?: string) {
if (!value) return "—";
@@ -863,10 +864,10 @@ export function ApprovalRecords({ taskId }: { taskId?: string }) {
React.useEffect(() => {
void load();
const timer = setInterval(() => void load(), 5000);
const stopPolling = setVisibleInterval(() => void load(), 5000);
return () => {
request.current++;
clearInterval(timer);
stopPolling();
};
}, [load]);
+3 -2
View File
@@ -6,6 +6,7 @@ import { toast } from "sonner";
import { sseUrl } from "@/lib/api";
import { isBtwCommand, type SideExchange, type SideHistory, sideAPI } from "@/lib/side-questions";
import { setVisibleInterval } from "@/lib/polling";
// crypto.randomUUID is only available in secure contexts (https/localhost); it degrades when accessed via IP+http.
function newSideRequestID(): string {
@@ -120,8 +121,8 @@ export function useSideQuestions(parent: string | null) {
useEffect(() => {
if (!open || !parent) return;
void load();
const timer = setInterval(() => void load(), 2000);
return () => clearInterval(timer);
const stopPolling = setVisibleInterval(() => void load(), 2000);
return stopPolling;
}, [open, parent, load]);
// biome-ignore lint/correctness/useExhaustiveDependencies: Reconnect after a clear attempt invalidates older callbacks.
+41
View File
@@ -0,0 +1,41 @@
// Background browser tabs must not keep downloading snapshots. A poll that
// returns a promise completes before the next interval starts; focus refreshes
// immediately, without creating a second request while one is still running.
export function setVisibleInterval(callback: () => unknown | Promise<unknown>, delay: number): () => void {
let stopped = false;
let running = false;
let timer: ReturnType<typeof setTimeout> | undefined;
const visible = () => typeof document === "undefined" || document.visibilityState !== "hidden";
const clear = () => {
if (timer !== undefined) clearTimeout(timer);
timer = undefined;
};
const schedule = () => {
clear();
if (!stopped && visible()) timer = setTimeout(() => void run(), delay);
};
const run = async () => {
clear();
if (stopped || running || !visible()) return;
running = true;
try {
await callback();
} catch {
// Existing loaders own their error UI; transient polling failures retry.
} finally {
running = false;
schedule();
}
};
const onVisibility = () => {
clear();
if (visible()) void run();
};
if (typeof document !== "undefined") document.addEventListener("visibilitychange", onVisibility);
schedule();
return () => {
stopped = true;
clear();
if (typeof document !== "undefined") document.removeEventListener("visibilitychange", onVisibility);
};
}