fix(history,loop,gateway): 上下文续接的最新性/一致性三条(裁决 13.4.5 的面内部分)
CI / Backend (build / vet / test / cross-compile) (push) Has been cancelled
CI / Frontend (tsc + vite build) (push) Has been cancelled

本组只落地「在允许文件面内、且能用 design/15 既有规格推出」的部分;13.4.5 的「真并行 + 动态旧上下文」
与 design/15 §2.1/§2.2 的既有串行续接规格存在读法冲突,按规程**停下上报**(未自创语义)。

- history.Recent(续接窗口)并列打破:created_at DESC, rowid DESC —— Windows time.Now() 步长 ~0.44ms,
  用户连发必然同毫秒并列;修复前并列时取**更早**的 ⇒ 丢掉刚发出的最新 n 条且同毫秒内反插入序
- 上行 chat 不再经**可丢弃**的 bus:直达会话编排器的非阻塞 Submit(design/15 §2.1「会话消息不能被 drop」
  + §4「不阻塞是硬约束」);orchestrator 为 nil 时回退 bus,旧断言仍绿
- 被**取消**(中断)的回合把该会话 checkpoint 落定为不可恢复(用 context.WithoutCancel 写,快照保留可查询,
  仅在回合未落定时触发)⇒ 不再顶掉下一条消息的上下文
- 复核:build/vet 绿 + loop/gateway/history 三包测试与 -race 全绿;新增 5 条用例(含一条真 WS+真编排器+
  真 loop+真 persist 的集成用例);**3 条变异反证**精确复现「新消息被丢弃只见旧窗口」「窗口取早不取新」
  「bus 饱和时会话消息静默消失」,均已还原
- 待裁决(已上报主人):① 「同一会话多回合真并行」需改 checkpoint 键(sessionID:step 并发互相覆盖)、
  flow 图按轮键控、前端单槽 busy —— 均在本组文件面外;② 「动态吸收新到消息」在 design/15 **无规格**,
  属新语义,须先写设计;③ 非取消的错误退出同样留可恢复快照(同机制,未扩范围,因 resume_test 正钉住旧行为)
This commit is contained in:
AskaEth committed 2026-10-04 13:56:35 +08:00
1 parent a1083a322f
commit 74b12d87ca
6 files changed
+633 -3

No files matched your search

+34 -1
View File
@@ -82,7 +82,21 @@ func (l *Loop) Run(ctx context.Context, sessionID string, messages []model.Messa
// 已 settle 的 Result;step 或工具批次的错误以 %w 包装返回。
func (l *Loop) driveTurn(ctx context.Context, sessionID string, msgs []model.Message, startStep int, res *Result) (*Result, error) {
toolState := &toolLoopState{prevFP: make(map[string]bool)}
for step := startStep; step <= l.maxRounds; step++ {
step := startStep
// 被用户中断(design/15 §3)的回合不留下「可恢复的在途态」:design/15
// 要求中断后**立即**按最新上下文处理下一条消息,而一个被放弃的回合若把
// 可恢复 checkpoint 留在该会话上,下一条消息会被它顶掉——继承旧窗口、
// 丢掉刚发出的那条,上下文既不最新也不完整(裁决 13.4.5)。因此取消后
// 把该会话的快照落定为不可恢复态(快照本身保留,仍可查询)。
//
// 只在回合**未落定**时标记(落定路径已写入终态快照,其 stop reason 本就
// 不可恢复),因此这里不会改写一个已交付答案的回合。
defer func() {
if ctx.Err() != nil && res.StopReason == "" {
l.abandonCanceledCheckpoint(ctx, sessionID, step, msgs)
}
}()
for ; step <= l.maxRounds; step++ {
if err := ctx.Err(); err != nil {
return nil, fmt.Errorf("loop: run: step %d: %w", step, err)
}
@@ -143,3 +157,22 @@ func (l *Loop) settleAndReturn(ctx context.Context, sessionID string, msgs []mod
l.settleTurn(ctx, sessionID, msgs, res)
return res, nil
}
// StopReasonCanceled 标记一个因用户中断(design/15 §3「停下/算了/换个话题」)
// 而放弃的回合。它不是可恢复的在途态:design/15 要求中断后立即按**最新**
// 上下文处理下一条消息,因此这种快照绝不能被下一条消息续接
// (见 driveTurn 与 abandonCanceledCheckpoint)。
const StopReasonCanceled = "canceled"
// abandonCanceledCheckpoint 把一个被取消回合的 checkpoint 落定为不可恢复态
// (stop reason = StopReasonCanceled),使该会话的下一条消息从它自己的最新
// 上下文开始,而不是被放弃回合的旧窗口顶掉(裁决 13.4.5:上下文一致性 /
// 完整性 / 最新性)。快照本身保留在 store 里,仍可查询。
//
// 写入必须脱离已取消的 ctx(否则 ExecContext 必然立即失败),因此这里用
// WithoutCancel 派生背景上下文,保留原 ctx 的值而丢弃取消信号。失败只记日志,
// 绝不让这个收尾动作把中断路径变成错误。
func (l *Loop) abandonCanceledCheckpoint(ctx context.Context, sessionID string, step int, msgs []model.Message) {
l.log.Info("checkpoint abandoned", "session", sessionID, "step", step, "stop_reason", StopReasonCanceled)
l.saveCheckpoint(context.WithoutCancel(ctx), sessionID, step, msgs, StopReasonCanceled)
}
+145
View File
@@ -0,0 +1,145 @@
package loop
import (
"context"
"strings"
"sync"
"testing"
"time"
"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/model"
)
// 本文件锁定裁决 13.4.5 在「回合被用户中断之后」的上下文口径(design/15 §3):
// 中断后**立即处理下一条消息**,且它必须带着**最新**上下文——被放弃的回合
// 绝不能把它的可恢复 checkpoint 留给下一条消息续接(否则新消息会被旧窗口顶掉,
// 上下文既不最新也不完整)。
// cancelingAdapter 复现「用户中断正在跑的回合」:第一次 Chat 交回一个工具调用,
// 第二次 Chat 阻塞到 ctx 被取消并把 ctx 的错误交回,之后每次都直接收尾。
// 它使一次回合能在**已写入可恢复 checkpoint**(工具步之后)之后才被中断。
type cancelingAdapter struct {
toolCall string
mu sync.Mutex
n int
reqs []model.Request
}
func (a *cancelingAdapter) Name() string { return "canceling" }
func (a *cancelingAdapter) Chat(ctx context.Context, req model.Request, _ model.Options) (model.Response, error) {
a.mu.Lock()
a.n++
n := a.n
a.reqs = append(a.reqs, req)
a.mu.Unlock()
switch n {
case 1:
return model.Response{Content: a.toolCall}, nil
case 2:
<-ctx.Done()
return model.Response{}, ctx.Err()
default:
return model.Response{Content: "final"}, nil
}
}
func (a *cancelingAdapter) ChatStream(ctx context.Context, req model.Request, _ func(model.StreamEvent)) (model.Response, error) {
return a.Chat(ctx, req, model.Options{})
}
// requests 返回被记录模型请求的快照。
func (a *cancelingAdapter) requests() []model.Request {
a.mu.Lock()
defer a.mu.Unlock()
return append([]model.Request(nil), a.reqs...)
}
// TestRun_CanceledTurnDoesNotHijackNextTurn 是 13.4.5 的中断续接用例:
// 回合 A 在工具循环中途被中断(design/15 §3),同一会话的下一条消息 B 必须
// **以 B 自己的最新上下文**开始,不得继承 A 的旧窗口。
//
// A 的窗口里带着工具结果、且**不含 B**,因此「续接 A」就等于把 B 丢掉 ——
// 这正是本用例要挡住的上下文不完整/不最新。用例跑在真实 persist.Store 上,
// 因此 upsert 与 LoadLatest 的取新语义都是真的。
func TestRun_CanceledTurnDoesNotHijackNextTurn(t *testing.T) {
t.Parallel()
ctx := context.Background()
ad := &cancelingAdapter{toolCall: `{"tool_calls":[{"name":"echo","args":{"q":"x"}}]}`}
td := dispatcherWith(t, &mockTool{name: "echo", result: "hi"})
a := newTestAgent(t, ad, td)
cp := newTestCheckpointStore(t)
l := New(Options{Agent: a, Checkpoint: cp, MaxRounds: 8})
const sess = "sess-cancel"
// 回合 A:步 1 请求工具(落下一个 resumable 的 tool_calls checkpoint),
// 步 2 的模型调用期间被中断。
runCtx, cancel := context.WithCancel(ctx)
done := make(chan struct{})
go func() {
defer close(done)
if _, err := l.Run(runCtx, sess, []model.Message{model.TextMessage(model.RoleUser, "A")}); err == nil {
t.Errorf("canceled turn returned no error, want the cancellation error")
}
}()
waitAdapterCall(t, ad, 2)
cancel()
<-done
// 下一条消息 B:必须看到 B 自己,而不是 A 的旧窗口。
res, err := l.Run(ctx, sess, []model.Message{model.TextMessage(model.RoleUser, "B")})
if err != nil {
t.Fatalf("Run(B): %v", err)
}
if res.Text != "final" {
t.Fatalf("Text = %q, want final", res.Text)
}
reqs := ad.requests()
last := reqs[len(reqs)-1]
if !requestHasText(last, "B") {
t.Fatalf("被中断回合之后的请求不含新消息 B:%v(上下文不最新/不完整)", requestTexts(last))
}
for _, m := range last.Messages {
if strings.Contains(messageText(m), "tool echo result") {
t.Fatalf("被中断回合之后的请求仍带着旧窗口的工具结果:%v", requestTexts(last))
}
}
}
// requestHasText 报告请求中是否有一条消息携带该精确文本。
func requestHasText(req model.Request, want string) bool {
for _, m := range req.Messages {
if messageText(m) == want {
return true
}
}
return false
}
// requestTexts 汇总请求里每条消息的文本,供失败信息可读。
func requestTexts(req model.Request) []string {
out := make([]string, 0, len(req.Messages))
for _, m := range req.Messages {
out = append(out, string(m.Role)+":"+messageText(m))
}
return out
}
// waitAdapterCall 阻塞到适配器已被调用 n 次(使中断精确发生在第二次模型调用
// 的阻塞期内),超时即失败而不是静默继续。
func waitAdapterCall(t *testing.T, ad *cancelingAdapter, n int) {
t.Helper()
deadline := time.Now().Add(3 * time.Second)
for time.Now().Before(deadline) {
ad.mu.Lock()
got := ad.n
ad.mu.Unlock()
if got >= n {
return
}
time.Sleep(time.Millisecond)
}
t.Fatalf("adapter calls = %d, want >= %d", n, n)
}