mirror of
https://github.com/BaaRai/ARTEX.git
synced 2026-11-16 13:10:53 +08:00
Compare commits
15
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
0374f32aeb | ||
|
|
be317a1337 | ||
|
|
feaaf9e416 | ||
|
|
5463ea4375 | ||
|
|
73aa56c16f | ||
|
|
5a8498bb4f | ||
|
|
2ad8ba16c3 | ||
|
|
09c9e6cfc2 | ||
|
|
59c3002bcc | ||
|
|
68f2db1d0b | ||
|
|
f0be3ae51f | ||
|
|
3b755228d6 | ||
|
|
d147dce344 | ||
|
|
60728092e1 | ||
|
|
ff599c65d3 |
@@ -48,6 +48,19 @@ jobs:
|
||||
# as rotating failures in the agent package). Serial package execution
|
||||
# keeps the database state deterministic.
|
||||
run: go test -p 1 ./...
|
||||
- name: online index scripts
|
||||
# Apply and roll back scripts/sql on a database built here from
|
||||
# db/schema.sql and db/migrations. The job-level artextest database
|
||||
# never gets the schema (packages use suffixed databases), and cached
|
||||
# test results mean no test database is guaranteed to exist.
|
||||
env:
|
||||
SQL_DSN: postgres://artex:testpass@localhost:5432/artextest_sqlscripts?sslmode=disable
|
||||
run: |
|
||||
psql "$ARTEX_PG_DSN" -X -v ON_ERROR_STOP=1 -c 'CREATE DATABASE artextest_sqlscripts'
|
||||
psql "$SQL_DSN" -X -q -v ON_ERROR_STOP=1 -f db/schema.sql
|
||||
for f in db/migrations/*.sql; do psql "$SQL_DSN" -X -q -v ON_ERROR_STOP=1 -f "$f"; done
|
||||
psql "$SQL_DSN" -X -v ON_ERROR_STOP=1 -f scripts/sql/20261115-task-query-indexes.sql
|
||||
psql "$SQL_DSN" -X -v ON_ERROR_STOP=1 -f scripts/sql/20261115-task-query-indexes.rollback.sql
|
||||
- name: go test -race
|
||||
# Race detector on the packages that pass under -race today. ./server
|
||||
# joined once its suite was checked with -race against postgres and its
|
||||
@@ -86,4 +99,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
@@ -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
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
@@ -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
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
package db
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
"errors"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// Migration 0004 leaves a valid, ready btree index on llm_usage(ts) for the
|
||||
// time-window queries (UsageDaily, JudgeUsageStats).
|
||||
func TestLLMUsageTsIndex(t *testing.T) {
|
||||
d, err := Open(testDSN(t))
|
||||
if err != nil {
|
||||
t.Skipf("postgres unavailable (%v) — skipping", err)
|
||||
}
|
||||
t.Cleanup(func() { d.Close() })
|
||||
|
||||
var valid, ready bool
|
||||
var def string
|
||||
err = d.QueryRow(`
|
||||
SELECT i.indisvalid, i.indisready, pg_get_indexdef(i.indexrelid)
|
||||
FROM pg_index i JOIN pg_class c ON c.oid = i.indexrelid
|
||||
JOIN pg_namespace n ON n.oid = c.relnamespace
|
||||
WHERE n.nspname='public' AND c.relname='idx_llm_usage_ts'`).Scan(&valid, &ready, &def)
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
t.Fatal("index public.idx_llm_usage_ts does not exist after Open")
|
||||
}
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if !valid || !ready {
|
||||
t.Fatalf("idx_llm_usage_ts indisvalid=%v indisready=%v, want both true (%s)", valid, ready, def)
|
||||
}
|
||||
if !strings.Contains(def, "USING btree (ts)") {
|
||||
t.Fatalf("idx_llm_usage_ts definition %q does not index ts with a btree", def)
|
||||
}
|
||||
}
|
||||
+2
-2
@@ -136,9 +136,9 @@ func assertEmbeddedApplied(t *testing.T, d *DB) []appliedMigration {
|
||||
want := []struct {
|
||||
version int
|
||||
name string
|
||||
}{{1, llmRecordsMigration}, {2, llmUsageMigration}, {3, "0003_task_scope_icp_index.sql"}}
|
||||
}{{1, llmRecordsMigration}, {2, llmUsageMigration}, {3, "0003_task_scope_icp_index.sql"}, {4, "0004_llm_usage_ts_index.sql"}}
|
||||
if len(applied) != len(want) {
|
||||
t.Fatalf("schema_migrations = %+v, want versions 1 to 3", applied)
|
||||
t.Fatalf("schema_migrations = %+v, want versions 1 to 4", applied)
|
||||
}
|
||||
for i, w := range want {
|
||||
content, err := fs.ReadFile(migrationsFS(), w.name)
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
-- UsageDaily and JudgeUsageStats (db/llm_usage.go) filter llm_usage on
|
||||
-- ts >= now() - interval; the dashboard polls UsageDaily every 15 seconds.
|
||||
-- llm_usage is an append-only ledger that gains a row per LLM call and is never
|
||||
-- purged, so without an index on ts those queries scan the whole table.
|
||||
--
|
||||
-- This is a plain (non-concurrent) CREATE INDEX: migrations run in a
|
||||
-- transaction, where CONCURRENTLY is not allowed. It is safe here because
|
||||
-- db.Open applies migrations at startup, before the HTTP server listens, so the
|
||||
-- SHARE lock it takes blocks no agent call or request in flight.
|
||||
--
|
||||
-- For an exceptionally large ledger, build the same index online before the
|
||||
-- upgrade, outside a transaction:
|
||||
-- CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_llm_usage_ts ON llm_usage(ts);
|
||||
-- This migration then finds it and does nothing.
|
||||
CREATE INDEX IF NOT EXISTS idx_llm_usage_ts ON llm_usage(ts);
|
||||
@@ -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
|
||||
|
||||
@@ -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=
|
||||
|
||||
@@ -0,0 +1,6 @@
|
||||
\set ON_ERROR_STOP on
|
||||
-- Removes only the two indexes introduced by this change; retains table data.
|
||||
SET lock_timeout = '5s';
|
||||
SET statement_timeout = '10min';
|
||||
DROP INDEX CONCURRENTLY IF EXISTS public.idx_activity_tool_result_lookup;
|
||||
DROP INDEX CONCURRENTLY IF EXISTS public.idx_llm_usage_task_model_tokens;
|
||||
Executable
+22
@@ -0,0 +1,22 @@
|
||||
\set ON_ERROR_STOP on
|
||||
-- Run with psql outside a transaction. Adds indexes without blocking normal DML.
|
||||
SET lock_timeout = '5s';
|
||||
SET statement_timeout = '10min';
|
||||
SET maintenance_work_mem = '128MB';
|
||||
SET max_parallel_maintenance_workers = 1;
|
||||
|
||||
-- db/commands.go joins by tool_use_id without an exploration_id constraint.
|
||||
-- The existing (exploration_id, tool_use_id, id) index has the wrong leading key.
|
||||
CREATE INDEX CONCURRENTLY idx_activity_tool_result_lookup
|
||||
ON public.activity (tool_use_id) INCLUDE (is_error)
|
||||
WHERE kind = 'tool_result';
|
||||
|
||||
-- Match TokenByModel's actual COALESCE(task_id, '') predicate and cover its sums.
|
||||
CREATE INDEX CONCURRENTLY idx_llm_usage_task_model_tokens
|
||||
ON public.llm_usage ((COALESCE(task_id, '')), model)
|
||||
INCLUDE (task_id, input_tokens, output_tokens, cache_read, cache_write);
|
||||
|
||||
-- Mark committed append-only pages visible so the covering index can avoid heap reads.
|
||||
SET vacuum_cost_delay = '2ms';
|
||||
SET vacuum_cost_limit = 1000;
|
||||
VACUUM (ANALYZE) public.llm_usage;
|
||||
Executable
+38
@@ -0,0 +1,38 @@
|
||||
# Online task-query indexes
|
||||
|
||||
`20261115-task-query-indexes.sql` adds two PostgreSQL indexes for existing queries:
|
||||
|
||||
- `activity(tool_use_id) INCLUDE (is_error) WHERE kind = 'tool_result'` supports the tool-result join in `db/commands.go` (`LEFT JOIN activity r ON r.tool_use_id = u.tool_use_id AND r.kind = 'tool_result'`). That join does not constrain the result row's exploration ID, so the existing `idx_act_tool_call (exploration_id, tool_use_id, id)` has the wrong leading key for it.
|
||||
- `llm_usage((COALESCE(task_id, '')), model) INCLUDE (task_id, input_tokens, output_tokens, cache_read, cache_write)` covers the per-task model aggregation in `db/llm_usage.go` (`TokenByModel`). That query filters on `COALESCE(task_id,'') = $1` and groups by `model`. The expression matches that predicate; the existing `idx_llm_usage_model (task_id, model)` cannot serve it.
|
||||
|
||||
## Apply
|
||||
|
||||
```sh
|
||||
psql -X -v ON_ERROR_STOP=1 -d <database> -f scripts/sql/20261115-task-query-indexes.sql
|
||||
```
|
||||
|
||||
Run it outside a transaction: `CREATE INDEX CONCURRENTLY` cannot run inside one, so do not wrap the file in `BEGIN`/`COMMIT` or use `psql -1`. Use the deployment's normal PostgreSQL authentication.
|
||||
|
||||
Both indexes are created concurrently, so normal reads and writes continue. The script sets a 5-second lock timeout, a 10-minute statement timeout and bounded maintenance resources. Its final `VACUUM (ANALYZE)` is an ordinary vacuum, not `VACUUM FULL`; it updates visibility and statistics so the covering index can serve index-only scans.
|
||||
|
||||
This is an explicit, one-time maintenance step, not a numbered migration. `db/migrate.go` runs each migration file inside a transaction, where `CONCURRENTLY` is not allowed. A plain `CREATE INDEX` at startup would lock `activity` against writes for the whole build. No application or database restart is required.
|
||||
|
||||
## After an interruption
|
||||
|
||||
The script intentionally fails if an index with the same name already exists. A partial run may have created the first index before the second failed. An interrupted concurrent build can also leave an invalid index behind. Before retrying, check the state of both indexes:
|
||||
|
||||
```sql
|
||||
SELECT c.relname, i.indisvalid, i.indisready
|
||||
FROM pg_index i JOIN pg_class c ON c.oid = i.indexrelid
|
||||
WHERE c.relname IN ('idx_activity_tool_result_lookup', 'idx_llm_usage_task_model_tokens');
|
||||
```
|
||||
|
||||
Both must show `indisvalid = true` and `indisready = true`. Drop an index that is invalid or not ready with `DROP INDEX CONCURRENTLY`, or run the rollback below, then rerun the script.
|
||||
|
||||
## Rollback
|
||||
|
||||
```sh
|
||||
psql -X -v ON_ERROR_STOP=1 -d <database> -f scripts/sql/20261115-task-query-indexes.rollback.sql
|
||||
```
|
||||
|
||||
The rollback drops only these two indexes, concurrently and only if they exist. Table data is kept. Review the current index definitions before applying it. No application restart is required.
|
||||
+3
-1
@@ -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
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
+2
-1
@@ -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}": [
|
||||
|
||||
Executable
+120
@@ -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 (
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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]);
|
||||
|
||||
|
||||
@@ -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 }) {
|
||||
|
||||
@@ -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]);
|
||||
|
||||
|
||||
@@ -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.
|
||||
|
||||
Executable
+41
@@ -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);
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user