mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-17 07:08:01 +08:00
- Track the running response identity in the Codex websocket session and reject interrupts that do not target it, so an interrupt after response.completed is never forwarded upstream while turn teardown is pending. - Gate the handler's local interrupt path by explicit turn ownership and close it before terminal payloads are written downstream, preventing fabricated response.incomplete events and silently dropped claimed frames. - Add deterministic regression tests covering late and unknown interrupts across completion, failure, queued rejection, upstream loss, and HTTP fallback turns. Closes: #7065
151 lines
5.1 KiB
Go
151 lines
5.1 KiB
Go
package executor
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/gorilla/websocket"
|
|
cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v8/sdk/cliproxy/executor"
|
|
)
|
|
|
|
// On a duplex socket a rejected queued create can fail while another response
|
|
// is still running. That failure must not end the live response's interrupt
|
|
// window, the running response's own terminal event must, and an unknown id
|
|
// must be rejected even while a different response is active.
|
|
func TestInterruptExecutionSessionTracksActiveResponseIdentity(t *testing.T) {
|
|
received := make(chan string, 8)
|
|
upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
conn, errUpgrade := (&websocket.Upgrader{}).Upgrade(w, r, nil)
|
|
if errUpgrade != nil {
|
|
t.Errorf("upgrade: %v", errUpgrade)
|
|
return
|
|
}
|
|
defer func() {
|
|
if errClose := conn.Close(); errClose != nil {
|
|
t.Errorf("close upstream: %v", errClose)
|
|
}
|
|
}()
|
|
// Hold the completion until the active-r1 interrupt has arrived, so
|
|
// the read loop cannot process it before the checks below run.
|
|
for _, payload := range []string{
|
|
`{"type":"response.created","response":{"id":"r1"}}`,
|
|
// A queued create rejected before its own response.created.
|
|
`{"type":"response.failed","response":{"id":"queued-1"}}`,
|
|
} {
|
|
if errWrite := conn.WriteMessage(websocket.TextMessage, []byte(payload)); errWrite != nil {
|
|
t.Errorf("write: %v", errWrite)
|
|
return
|
|
}
|
|
}
|
|
_, payload, errRead := conn.ReadMessage()
|
|
if errRead != nil {
|
|
return
|
|
}
|
|
received <- string(payload)
|
|
if errWrite := conn.WriteMessage(websocket.TextMessage, []byte(`{"type":"response.completed","response":{"id":"r1","output":[]}}`)); errWrite != nil {
|
|
t.Errorf("write completion: %v", errWrite)
|
|
return
|
|
}
|
|
for {
|
|
_, payload, errRead := conn.ReadMessage()
|
|
if errRead != nil {
|
|
return
|
|
}
|
|
received <- string(payload)
|
|
if string(payload) == "barrier" {
|
|
return
|
|
}
|
|
}
|
|
}))
|
|
defer upstream.Close()
|
|
|
|
client, _, errDial := websocket.DefaultDialer.Dial("ws"+strings.TrimPrefix(upstream.URL, "http"), nil)
|
|
if errDial != nil {
|
|
t.Fatal(errDial)
|
|
}
|
|
exec := NewCodexWebsocketsExecutor(nil)
|
|
exec.store = &codexWebsocketSessionStore{sessions: make(map[string]*codexWebsocketSession)}
|
|
const sessionID = "active-response-identity"
|
|
defer exec.CloseExecutionSession(sessionID)
|
|
sess := exec.getOrCreateSession(sessionID)
|
|
sess.conn = client
|
|
sess.connCloser = newWebsocketConnectionCloser(client)
|
|
sess.configureConn(client)
|
|
readCh := sess.activate(client)
|
|
go exec.readUpstreamLoop(sess, client)
|
|
read := func() codexWebsocketRead {
|
|
t.Helper()
|
|
select {
|
|
case event := <-readCh:
|
|
if event.err != nil {
|
|
t.Fatal(event.err)
|
|
}
|
|
return event
|
|
case <-time.After(3 * time.Second):
|
|
t.Fatal("upstream event timed out")
|
|
return codexWebsocketRead{}
|
|
}
|
|
}
|
|
interrupt := func(payload string) error {
|
|
t.Helper()
|
|
return exec.InterruptExecutionSession(context.Background(), sessionID, []byte(payload))
|
|
}
|
|
|
|
read() // response.created r1
|
|
read() // response.failed queued-1
|
|
|
|
// The queued rejection must not close r1's interrupt window.
|
|
if errInterrupt := interrupt(`{"type":"response.interrupt","response_id":"r1"}`); errInterrupt != nil {
|
|
t.Fatalf("interrupt active r1 after queued failure = %v, want nil (forwarded)", errInterrupt)
|
|
}
|
|
// An unknown id is not the running response: reject outright, without
|
|
// inviting a local HTTP fallback against the live websocket turn.
|
|
if errUnknown := interrupt(`{"type":"response.interrupt","response_id":"unknown"}`); !errors.Is(errUnknown, cliproxyexecutor.ErrUpstreamWebsocketInterruptRejected) {
|
|
t.Fatalf("unknown interrupt during r1 = %v, want ErrUpstreamWebsocketInterruptRejected", errUnknown)
|
|
}
|
|
|
|
read() // response.completed r1
|
|
|
|
// The terminal id itself stays idempotent, but an id that never ran must
|
|
// be rejected while teardown of the active channel is still pending.
|
|
if errTerminal := interrupt(`{"type":"response.interrupt","response_id":"r1"}`); errTerminal != nil {
|
|
t.Fatalf("interrupt completed r1 = %v, want nil (already terminal)", errTerminal)
|
|
}
|
|
if errUnknown := interrupt(`{"type":"response.interrupt","response_id":"unknown-2"}`); !errors.Is(errUnknown, cliproxyexecutor.ErrUpstreamWebsocketInterruptRejected) {
|
|
t.Fatalf("unknown interrupt after completion = %v, want ErrUpstreamWebsocketInterruptRejected", errUnknown)
|
|
}
|
|
|
|
// Only the active-r1 interrupt may have reached the socket.
|
|
if errWrite := client.WriteMessage(websocket.TextMessage, []byte("barrier")); errWrite != nil {
|
|
t.Fatal(errWrite)
|
|
}
|
|
var got []string
|
|
loop:
|
|
for {
|
|
select {
|
|
case payload := <-received:
|
|
got = append(got, payload)
|
|
if payload == "barrier" {
|
|
break loop
|
|
}
|
|
case <-time.After(3 * time.Second):
|
|
t.Fatalf("upstream barrier timed out, received %v", got)
|
|
}
|
|
}
|
|
want := []string{`{"type":"response.interrupt","response_id":"r1"}`, "barrier"}
|
|
if len(got) != len(want) {
|
|
t.Fatalf("upstream received %v, want %v", got, want)
|
|
}
|
|
for i := range want {
|
|
if got[i] != want[i] {
|
|
t.Fatalf("upstream received %v, want %v", got, want)
|
|
}
|
|
}
|
|
sess.clearActive(client, readCh)
|
|
}
|