Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

gateway: a turn on Codex's own sign-in says where its time went

yetone5dc908f764f6
diff --git a/internal/gateway/codex_backend.go b/internal/gateway/codex_backend.go
index 123036d94..f4780e3c1 100644
--- a/internal/gateway/codex_backend.go
+++ b/internal/gateway/codex_backend.go
@@ -10,10 +10,12 @@ import (
"io"
"log"
"net/http"
+ "net/http/httptrace"
"regexp"
"slices"
"strings"
"sync"
+ "sync/atomic"
"time"
"github.com/tidwall/gjson"
@@ -977,6 +979,10 @@ func (s *Server) codexUpstreamOn(w http.ResponseWriter, r *http.Request, rest st
// a turn goes in the Routing view's live trace as the others do, to
// the one it can go to: Codex's own sign-in, or its key
var tr *Route
+ // where the try now going spent its time (TryNet): the request goes
+ // out through magpie's own client, as a routed try's does, so the
+ // Routing page says whose time a slow turn was here too
+ nt := &netTrace{}
first := firstToken{start: start} // the reply's first tokens (#196), counted as ms are
served := "" // the model the reply says answered
var uu Usage
@@ -1037,7 +1043,18 @@ func (s *Server) codexUpstreamOn(w http.ResponseWriter, r *http.Request, rest st
// the last try: the turn asked again for an overload has one each
try := &t.Tries[len(t.Tries)-1]
try.Done, try.Status, try.Millis, try.Error = true, status, time.Since(try.Start).Milliseconds(), msg
- try.TTFT, try.FirstText = ttft, text
+ // the try's first token from its own Start, as its timing's
+ // first byte is: a turn asked again for an overload began
+ // after the request did
+ before := try.Start.Sub(start).Milliseconds()
+ fromTry := func(ms int64) int64 {
+ if ms <= 0 {
+ return 0 // none came
+ }
+ return max(ms-before, 1)
+ }
+ try.TTFT, try.FirstText = fromTry(ttft), fromTry(text)
+ try.Net = nt.timing(try.Start, 0)
t.ReasoningHidden = first.hidesReasoning(provider.Responses)
try.ReasoningHidden = t.ReasoningHidden
t.Done, t.Status, t.Error, t.Millis, t.Tokens = true, status, msg, ms, tokens
@@ -1082,6 +1099,7 @@ func (s *Server) codexUpstreamOn(w http.ResponseWriter, r *http.Request, rest st
try := &t.Tries[len(t.Tries)-1]
try.Done, try.Status, try.Error, try.Fail = true, status, msg, failOther
try.Millis, try.Again = time.Since(try.Start).Milliseconds(), wait.Milliseconds()
+ try.Net = nt.timing(try.Start, 0)
})
servedProvider, servedAccount := codexServed(base, r.Header, on)
rec := usage.Record{RouteID: tr.ID, Time: began, Agent: callerOf(r).agent, Provider: servedProvider, Host: provider.HostOf(base),
@@ -1102,7 +1120,7 @@ func (s *Server) codexUpstreamOn(w http.ResponseWriter, r *http.Request, rest st
end(status, msg, 0, 0)
return false
}
- began = time.Now()
+ began, nt = time.Now(), &netTrace{}
s.trace.update(tr, func(t *Route) {
again := t.Tries[0]
t.Tries = append(t.Tries, Try{ID: again.ID, Model: again.Model, Effort: again.Effort, Start: began})
@@ -1129,9 +1147,13 @@ func (s *Server) codexUpstreamOn(w http.ResponseWriter, r *http.Request, rest st
attempt, cancel := context.WithCancel(r.Context())
defer cancel()
for tries := 0; ; tries++ {
- ctx := provider.ViaSignedIn(attempt, "codex")
+ // a request asked again within the try (a reset spent, a
+ // dropped one, an item taken out) is its Before
+ var asking, asked, wrote atomic.Int64
+ traced := httptrace.WithClientTrace(attempt, nt.hooks(&asking, &asked, &wrote))
+ ctx := provider.ViaSignedIn(traced, "codex")
if on != nil {
- ctx = on.Via(attempt)
+ ctx = on.Via(traced)
}
req, err := http.NewRequestWithContext(ctx, r.Method, u, bytes.NewReader(body))
if err != nil {
diff --git a/internal/gateway/codex_backend_test.go b/internal/gateway/codex_backend_test.go
index 61066f2c1..5ccd00c4d 100644
--- a/internal/gateway/codex_backend_test.go
+++ b/internal/gateway/codex_backend_test.go
@@ -1250,3 +1250,37 @@ func TestRenamedProviderAnsweredItsLead(t *testing.T) {
t.Fatalf("answers %+v", a)
}
}
+
+// A turn on Codex's own sign-in goes out through magpie's client as a
+// routed try does, so its try says where its time went as one does
+// (TryNet): the Routing page showed nothing for it (Discord, lute: some
+// requests showed magpie's and the vendor's time and some didn't). The
+// backend's wait before its headers is the vendor's.
+func TestCodexOwnSignInTellsWhereItsTimeWent(t *testing.T) {
+ setup(t, provider.Chat, &fake{t: t})
+ const hold = 200 * time.Millisecond
+ chatgpt(t, func(w http.ResponseWriter, r *http.Request) {
+ io.ReadAll(r.Body)
+ time.Sleep(hold)
+ w.Header().Set("Content-Type", "text/event-stream")
+ io.WriteString(w, sse(`data: {"type":"response.completed","response":{"id":"r1","usage":{"input_tokens":9,"output_tokens":2}}}`))
+ })
+ s := New()
+ rec := httptest.NewRecorder()
+ req := httptest.NewRequest("POST", CodexPath+"/responses", strings.NewReader(`{"model":"gpt-5.5","stream":true,"input":"hi"}`))
+ req.Header.Set("Authorization", "Bearer chatgpt-token")
+ s.Handler().ServeHTTP(rec, req)
+ st := s.Trace(t.Context(), 0, 0)
+ if rec.Code != 200 || len(st.Routes) != 1 || len(st.Routes[0].Tries) != 1 {
+ t.Fatalf("%d %+v", rec.Code, st.Routes)
+ }
+ n := st.Routes[0].Tries[0].Net
+ if n == nil {
+ t.Fatal("no timing for a turn on Codex's own sign-in")
+ }
+ holdMs := float64(hold.Milliseconds())
+ if n.Asks != 1 || n.Wait < holdMs-1 || n.Head < n.Wait {
+ t.Fatalf("timing %+v for a %v hold", *n, hold)
+ }
+}
+