From d82d5c1ae05046f8d839f563643505add84471f0 Mon Sep 17 00:00:00 2001 From: chinbor Date: Mon, 16 Nov 2026 14:29:45 +0800 Subject: [PATCH 1/2] fix(gemini): prevent double release of requestSlot in awaitTurn (#22) --- internal/adapter/hedge.go | 21 ++++++++-- internal/gemini/client.go | 10 +++++ internal/gemini/research.go | 22 ++++++---- internal/gemini/research_slot_test.go | 60 +++++++++++++++++++++++++++ 4 files changed, 103 insertions(+), 10 deletions(-) create mode 100644 internal/gemini/research_slot_test.go diff --git a/internal/adapter/hedge.go b/internal/adapter/hedge.go index 787d95c..50c3a0a 100644 --- a/internal/adapter/hedge.go +++ b/internal/adapter/hedge.go @@ -229,7 +229,7 @@ func (g *outputGate) emitter(attempt *generationAttempt, onEvent func(gemini.Eve } // yieldingRelease 返回请求结束时的释放函数与首个内容事件到达时的通知函数:等待首事件超过 slotYieldAfter 时提前让出请求槽,让其他请求可以使用该账号 -func yieldingRelease(client *gemini.Client, release func()) (func(), func()) { +func yieldingRelease(client *gemini.Client, release func()) (func(), func(), gemini.SlotYieldController) { var mu sync.Mutex var endYield func() released := false @@ -258,7 +258,21 @@ func yieldingRelease(client *gemini.Client, release func()) (func(), func()) { release() } } - return finish, func() { timer.Stop() } + suspend := func() (func(), bool) { + timer.Stop() + mu.Lock() + defer mu.Unlock() + if released { + return func() {}, true + } + released = true + return func() { + mu.Lock() + defer mu.Unlock() + released = false + }, false + } + return finish, func() { timer.Stop() }, suspend } // startAttempt 在后台以 client 执行一次生成,结束时释放请求槽并按结果报告账号状态,被另一方取代或 panic 的尝试不报告 @@ -269,7 +283,8 @@ func startAttempt(ctx context.Context, pool *balancer.AccountPool, gate *outputG claimed: make(chan struct{}), done: make(chan struct{}), } emit := gate.emitter(attempt, onEvent) - finish, firstContent := yieldingRelease(client, release) + finish, firstContent, suspend := yieldingRelease(client, release) + attemptCtx = gemini.WithSlotYieldController(attemptCtx, suspend) go func() { defer close(attempt.done) defer cancel() diff --git a/internal/gemini/client.go b/internal/gemini/client.go index ab64a2e..099d7ba 100644 --- a/internal/gemini/client.go +++ b/internal/gemini/client.go @@ -96,6 +96,16 @@ func (c *Client) CachedUsage() *UsageInfo { return c.usage.Load() } +type slotYieldContextKey struct{} + +// SlotYieldController 协调外层超时让出与内部后台轮询让出,防止同一请求重复释放请求槽 +type SlotYieldController func() (restore func(), alreadyReleased bool) + +// WithSlotYieldController 将槽位让出协调器绑定到 context +func WithSlotYieldController(ctx context.Context, ctrl SlotYieldController) context.Context { + return context.WithValue(ctx, slotYieldContextKey{}, ctrl) +} + // AcquireRequest 占用账号的一个请求槽直到完整上游请求链结束,后台生成的轮询阶段让出 func (c *Client) AcquireRequest(ctx context.Context) (func(), error) { c.busy.Add(1) diff --git a/internal/gemini/research.go b/internal/gemini/research.go index 162b7ec..4e93c23 100644 --- a/internal/gemini/research.go +++ b/internal/gemini/research.go @@ -114,13 +114,21 @@ func (r *researchThoughts) progress(candidate []any) error { func (c *Client) awaitTurn(ctx context.Context, state *ConversationState, decoder *FrameDecoder, model Model, level ThinkingLevel, progress func([]any) error, researchConfirm *string, emit func(Event) error) error { trace := logging.FromContext(ctx) trace.Background(model.ID) - c.requestSlot.Release(1) - c.busy.Add(-1) - c.notifyRelease() - defer func() { - c.busy.Add(1) - c.requestSlot.Acquire(context.Background(), 1) - }() + alreadyReleased := false + restore := func() {} + if ctrl, ok := ctx.Value(slotYieldContextKey{}).(SlotYieldController); ok && ctrl != nil { + restore, alreadyReleased = ctrl() + } + if !alreadyReleased { + c.requestSlot.Release(1) + c.busy.Add(-1) + c.notifyRelease() + defer func() { + c.busy.Add(1) + _ = c.requestSlot.Acquire(context.Background(), 1) + restore() + }() + } session := state.Snapshot() request, err := json.Marshal([]any{session.CID, 10, nil, 1, []any{0}, []any{4}, nil, 1}) if err != nil { diff --git a/internal/gemini/research_slot_test.go b/internal/gemini/research_slot_test.go new file mode 100644 index 0000000..18ff7d1 --- /dev/null +++ b/internal/gemini/research_slot_test.go @@ -0,0 +1,60 @@ +package gemini + +import ( + "context" + "testing" +) + +func TestAwaitTurnRespectsAlreadyReleasedSlotYieldController(t *testing.T) { + client, err := NewClient(AccountSource{Concurrency: 1}, "", false) + if err != nil { + t.Fatalf("NewClient failed: %v", err) + } + release, err := client.AcquireRequest(context.Background()) + if err != nil { + t.Fatalf("AcquireRequest failed: %v", err) + } + // 模拟外层 yieldingRelease 已经提前释放了唯一 1 个请求槽 + release() + + ctx, cancel := context.WithCancel(context.Background()) + cancel() + ctx = WithSlotYieldController(ctx, func() (func(), bool) { + return func() {}, true + }) + + // 若 awaitTurn 未检查 alreadyReleased,此处会触发 panic: semaphore: released more than held + err = client.awaitTurn(ctx, NewConversationState(), nil, Model{ID: "gemini-video"}, 0, nil, nil, func(Event) error { + return nil + }) + if err == nil { + t.Fatalf("expected context canceled error, got nil") + } +} + +func TestAwaitTurnReleasesAndRestoresWhenSlotStillHeld(t *testing.T) { + client, err := NewClient(AccountSource{Concurrency: 1}, "", false) + if err != nil { + t.Fatalf("NewClient failed: %v", err) + } + release, err := client.AcquireRequest(context.Background()) + if err != nil { + t.Fatalf("AcquireRequest failed: %v", err) + } + + restored := false + ctx, cancel := context.WithCancel(context.Background()) + cancel() + ctx = WithSlotYieldController(ctx, func() (func(), bool) { + return func() { restored = true }, false + }) + + _ = client.awaitTurn(ctx, NewConversationState(), nil, Model{ID: "gemini-video"}, 0, nil, nil, func(Event) error { + return nil + }) + if !restored { + t.Fatalf("expected restore callback to be invoked") + } + // 结束后仍持有 1 个槽位,由外层统一释放,不应 panic + release() +} From 852e516249fa0765ecf628a822c8e1da0269fa9b Mon Sep 17 00:00:00 2001 From: Mag1cFall Date: Tue, 17 Nov 2026 18:28:23 +0800 Subject: [PATCH 2/2] =?UTF-8?q?fix:=20=E6=95=B4=E7=90=86=E8=AF=B7=E6=B1=82?= =?UTF-8?q?=E6=A7=BD=E8=AE=A9=E5=87=BA=E5=8D=8F=E8=B0=83=E7=9A=84=E6=B3=A8?= =?UTF-8?q?=E9=87=8A=EF=BC=8C=E6=B5=8B=E8=AF=95=E6=94=B9=E4=B8=BA=E6=96=AD?= =?UTF-8?q?=E8=A8=80=E8=AF=B7=E6=B1=82=E6=A7=BD=E5=8D=A0=E7=94=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- internal/adapter/hedge.go | 6 ++++- internal/gemini/client.go | 1 + internal/gemini/research.go | 8 +++--- internal/gemini/research_slot_test.go | 38 +++++++++++++++------------ 4 files changed, 30 insertions(+), 23 deletions(-) diff --git a/internal/adapter/hedge.go b/internal/adapter/hedge.go index 50c3a0a..2e4554c 100644 --- a/internal/adapter/hedge.go +++ b/internal/adapter/hedge.go @@ -228,7 +228,7 @@ func (g *outputGate) emitter(attempt *generationAttempt, onEvent func(gemini.Eve } } -// yieldingRelease 返回请求结束时的释放函数与首个内容事件到达时的通知函数:等待首事件超过 slotYieldAfter 时提前让出请求槽,让其他请求可以使用该账号 +// yieldingRelease 返回请求结束时的释放函数、首个内容事件到达时的通知函数与后台轮询的让出协调器:等待首事件超过 slotYieldAfter 时提前让出请求槽,让其他请求可以使用该账号 func yieldingRelease(client *gemini.Client, release func()) (func(), func(), gemini.SlotYieldController) { var mu sync.Mutex var endYield func() @@ -263,6 +263,10 @@ func yieldingRelease(client *gemini.Client, release func()) (func(), func(), gem mu.Lock() defer mu.Unlock() if released { + if endYield != nil { + endYield() + endYield = nil + } return func() {}, true } released = true diff --git a/internal/gemini/client.go b/internal/gemini/client.go index 099d7ba..e6f74c9 100644 --- a/internal/gemini/client.go +++ b/internal/gemini/client.go @@ -96,6 +96,7 @@ func (c *Client) CachedUsage() *UsageInfo { return c.usage.Load() } +// slotYieldContextKey 是 context 中请求槽让出协调器的键 type slotYieldContextKey struct{} // SlotYieldController 协调外层超时让出与内部后台轮询让出,防止同一请求重复释放请求槽 diff --git a/internal/gemini/research.go b/internal/gemini/research.go index 4e93c23..b9ea3b9 100644 --- a/internal/gemini/research.go +++ b/internal/gemini/research.go @@ -110,19 +110,17 @@ func (r *researchThoughts) progress(candidate []any) error { return nil } -// awaitTurn 在调用方持有账号请求槽时调用,轮询期间让出请求槽,以 hNvQHb 轮询会话中本轮回答,完成后重新占用请求槽并按生成流解析该回答,连续 turnMissingPolls 次读不到本轮回答时返回可重试错误;decoder 为已输出部分回答的生成流解码器,为 nil 时从头输出;progress 接收进行中的候选,researchConfirm 非空时写入该回答计划卡片的确认按钮文字 +// awaitTurn 以 hNvQHb 轮询会话中本轮回答,读到后按生成流解析该回答:调用方仍持有账号请求槽时轮询期间让出、返回前重新占用并调用让出协调器的恢复函数,请求槽已被首事件等待让出时保持让出;连续 turnMissingPolls 次读不到本轮回答时返回可重试错误;decoder 为已输出部分回答的生成流解码器,为 nil 时从头输出;progress 接收进行中的候选,researchConfirm 非空时写入该回答计划卡片的确认按钮文字 func (c *Client) awaitTurn(ctx context.Context, state *ConversationState, decoder *FrameDecoder, model Model, level ThinkingLevel, progress func([]any) error, researchConfirm *string, emit func(Event) error) error { trace := logging.FromContext(ctx) trace.Background(model.ID) alreadyReleased := false restore := func() {} - if ctrl, ok := ctx.Value(slotYieldContextKey{}).(SlotYieldController); ok && ctrl != nil { + if ctrl, ok := ctx.Value(slotYieldContextKey{}).(SlotYieldController); ok { restore, alreadyReleased = ctrl() } if !alreadyReleased { - c.requestSlot.Release(1) - c.busy.Add(-1) - c.notifyRelease() + c.releaseRequest() defer func() { c.busy.Add(1) _ = c.requestSlot.Acquire(context.Background(), 1) diff --git a/internal/gemini/research_slot_test.go b/internal/gemini/research_slot_test.go index 18ff7d1..13ee03c 100644 --- a/internal/gemini/research_slot_test.go +++ b/internal/gemini/research_slot_test.go @@ -5,7 +5,8 @@ import ( "testing" ) -func TestAwaitTurnRespectsAlreadyReleasedSlotYieldController(t *testing.T) { +// TestAwaitTurnAfterSlotYield 验证请求槽已被首事件等待让出时轮询不再释放,账号仍只有一个请求槽 +func TestAwaitTurnAfterSlotYield(t *testing.T) { client, err := NewClient(AccountSource{Concurrency: 1}, "", false) if err != nil { t.Fatalf("NewClient failed: %v", err) @@ -14,7 +15,6 @@ func TestAwaitTurnRespectsAlreadyReleasedSlotYieldController(t *testing.T) { if err != nil { t.Fatalf("AcquireRequest failed: %v", err) } - // 模拟外层 yieldingRelease 已经提前释放了唯一 1 个请求槽 release() ctx, cancel := context.WithCancel(context.Background()) @@ -22,17 +22,19 @@ func TestAwaitTurnRespectsAlreadyReleasedSlotYieldController(t *testing.T) { ctx = WithSlotYieldController(ctx, func() (func(), bool) { return func() {}, true }) - - // 若 awaitTurn 未检查 alreadyReleased,此处会触发 panic: semaphore: released more than held - err = client.awaitTurn(ctx, NewConversationState(), nil, Model{ID: "gemini-video"}, 0, nil, nil, func(Event) error { - return nil - }) - if err == nil { - t.Fatalf("expected context canceled error, got nil") + if err := client.awaitTurn(ctx, NewConversationState(), nil, Model{ID: "gemini-video"}, 0, nil, nil, func(Event) error { return nil }); err == nil { + t.Fatal("expected context canceled error") + } + if _, ok := client.TryAcquireRequest(); !ok { + t.Fatal("the yielded request slot should be free for other requests") + } + if _, ok := client.TryAcquireRequest(); ok { + t.Fatal("the account should still have exactly one request slot") } } -func TestAwaitTurnReleasesAndRestoresWhenSlotStillHeld(t *testing.T) { +// TestAwaitTurnKeepsHeldSlot 验证调用方持有请求槽时轮询返回前重新占用并调用恢复函数,请求结束后请求槽空闲 +func TestAwaitTurnKeepsHeldSlot(t *testing.T) { client, err := NewClient(AccountSource{Concurrency: 1}, "", false) if err != nil { t.Fatalf("NewClient failed: %v", err) @@ -42,19 +44,21 @@ func TestAwaitTurnReleasesAndRestoresWhenSlotStillHeld(t *testing.T) { t.Fatalf("AcquireRequest failed: %v", err) } - restored := false ctx, cancel := context.WithCancel(context.Background()) cancel() + restored := false ctx = WithSlotYieldController(ctx, func() (func(), bool) { return func() { restored = true }, false }) - - _ = client.awaitTurn(ctx, NewConversationState(), nil, Model{ID: "gemini-video"}, 0, nil, nil, func(Event) error { - return nil - }) + _ = client.awaitTurn(ctx, NewConversationState(), nil, Model{ID: "gemini-video"}, 0, nil, nil, func(Event) error { return nil }) if !restored { - t.Fatalf("expected restore callback to be invoked") + t.Fatal("the yield controller should be restored so the request releases its slot when it ends") + } + if _, ok := client.TryAcquireRequest(); ok { + t.Fatal("the request should hold its slot again after polling") } - // 结束后仍持有 1 个槽位,由外层统一释放,不应 panic release() + if _, ok := client.TryAcquireRequest(); !ok { + t.Fatal("the slot should be free after the request ends") + } }