Skip to content

Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.

fix(agent): 将空闲超时覆盖到模型流建立阶段

yeliheng-0100466c294ef1a
diff --git a/internal/agent/compaction/compactor.go b/internal/agent/compaction/compactor.go
index 330a7cfc4..bbfe48a2d 100644
--- a/internal/agent/compaction/compactor.go
+++ b/internal/agent/compaction/compactor.go
@@ -232,10 +232,26 @@ func (c *Compactor) summarize(
func (c *Compactor) streamSummary(
ctx context.Context, messages []chat.Message, opts *chat.ChatOptions,
) (content, finishReason string, err error) {
- callCtx, cancel := context.WithCancel(types.WithLLMCallMetadata(ctx, llmCallLabel, ""))
- defer cancel()
+ callCtx, cancel := context.WithCancelCause(types.WithLLMCallMetadata(ctx, llmCallLabel, ""))
+ defer cancel(nil)
+ // Arm before ChatStream: opening the connection and waiting for headers
+ // must not bypass the time-to-first-output budget.
+ timeout := c.settings.stallTimeout()
+ stall := time.AfterFunc(timeout, func() {
+ cancel(fmt.Errorf("summarization stalled: no output for %s", timeout))
+ })
+ defer stall.Stop()
+ callError := func() error {
+ if err := ctx.Err(); err != nil {
+ return err
+ }
+ return context.Cause(callCtx)
+ }
stream, err := c.chatModel.ChatStream(callCtx, messages, opts)
if err != nil {
+ if callCtx.Err() != nil {
+ return "", "", callError()
+ }
return "", "", err
}
if stream == nil {
@@ -253,26 +269,21 @@ func (c *Compactor) streamSummary(
}()
}()
- timeout := c.settings.stallTimeout()
- stall := time.NewTimer(timeout)
- defer stall.Stop()
var sb strings.Builder
streamErr := ""
for {
// select picks at random among ready cases, and a provider closes its
// stream once the turn's context is cancelled, so a stopped turn could
// otherwise read as a completed (partial) summary.
- if err := ctx.Err(); err != nil {
+ if err := callError(); err != nil {
return "", "", err
}
select {
- case <-ctx.Done():
- return "", "", ctx.Err()
- case <-stall.C:
- return "", "", fmt.Errorf("summarization stalled: no output for %s", timeout)
+ case <-callCtx.Done():
+ return "", "", callError()
case chunk, ok := <-stream:
if !ok {
- if err := ctx.Err(); err != nil {
+ if err := callError(); err != nil {
return "", "", err
}
if streamErr != "" {
@@ -283,7 +294,7 @@ func (c *Compactor) streamSummary(
// context here, and not only in the ctx.Done() arm above, also
// settles the race where a cancellation closes the stream while
// both arms are ready and select picks between them at random.
- if err := ctx.Err(); err != nil {
+ if err := callError(); err != nil {
return "", finishReason, err
}
return sb.String(), finishReason, nil
diff --git a/internal/agent/compaction/stream_start_timeout_test.go b/internal/agent/compaction/stream_start_timeout_test.go
new file mode 100644
index 000000000..dac9c36e3
--- /dev/null
+++ b/internal/agent/compaction/stream_start_timeout_test.go
@@ -0,0 +1,120 @@
+package compaction
+
+import (
+ "context"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "sync/atomic"
+ "testing"
+ "time"
+
+ "github.com/Tencent/WeKnora/internal/models/api"
+ "github.com/Tencent/WeKnora/internal/models/api/openaicompletions"
+ "github.com/Tencent/WeKnora/internal/models/chat"
+ "github.com/stretchr/testify/require"
+)
+
+func startupTestCompactor(t *testing.T, handler http.HandlerFunc) *Compactor {
+ t.Helper()
+ t.Setenv("SSRF_WHITELIST", "127.0.0.1")
+ server := httptest.NewServer(handler)
+ t.Cleanup(server.Close)
+ model := openaicompletions.New(openaicompletions.Config{Endpoint: api.Endpoint{
+ BaseURL: server.URL, Model: "timeout-test", Client: server.Client(),
+ }})
+ s := testSettings()
+ s.StallTimeout = 200 * time.Millisecond
+ return New(model, newEstimator(t), s)
+}
+
+func TestCompactionStartupRetriesAndDegrades(t *testing.T) {
+ for _, persistent := range []bool{false, true} {
+ t.Run(map[bool]string{false: "retry recovers", true: "retry degrades"}[persistent], func(t *testing.T) {
+ var calls atomic.Int32
+ c := startupTestCompactor(t, func(w http.ResponseWriter, r *http.Request) {
+ _, _ = io.Copy(io.Discard, r.Body)
+ if calls.Add(1) == 1 || persistent {
+ <-r.Context().Done()
+ return
+ }
+ writeSummarySSE(w, false)
+ })
+ ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+ defer cancel()
+ result, err := c.Compact(ctx, reactTurn(12), ReasonThreshold)
+ require.NoError(t, err)
+ require.NoError(t, ctx.Err())
+ require.EqualValues(t, maxSummarizationAttempts, calls.Load())
+ require.Equal(t, persistent, result.Degraded)
+ if persistent {
+ require.Contains(t, result.Summary, "Raw conversation archive")
+ } else {
+ require.Contains(t, result.Summary, "COMPLETE_SUMMARY")
+ }
+ })
+ }
+}
+
+func TestCompactionStartupCancellationIsNotRetried(t *testing.T) {
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+ var calls atomic.Int32
+ c := startupTestCompactor(t, func(_ http.ResponseWriter, r *http.Request) {
+ _, _ = io.Copy(io.Discard, r.Body)
+ calls.Add(1)
+ cancel()
+ <-r.Context().Done()
+ })
+ _, err := c.summarize(ctx, reactTurn(2), 0, "", initialSummarizationInstructions, 1024)
+ require.ErrorIs(t, err, context.Canceled)
+ require.EqualValues(t, 1, calls.Load())
+ require.NotContains(t, err.Error(), "stalled")
+}
+
+func TestCompactionStartupPreservesProviderError(t *testing.T) {
+ c := startupTestCompactor(t, func(w http.ResponseWriter, _ *http.Request) {
+ http.Error(w, "invalid API key", http.StatusUnauthorized)
+ })
+ _, _, err := c.streamSummary(context.Background(), nil, &chat.ChatOptions{})
+ var httpErr *api.HTTPError
+ require.ErrorAs(t, err, &httpErr)
+ require.Equal(t, http.StatusUnauthorized, httpErr.StatusCode)
+}
+
+func TestCompactionHeadersDoNotResetFirstOutputBudget(t *testing.T) {
+ const headerDelay = 700 * time.Millisecond
+ c := startupTestCompactor(t, func(w http.ResponseWriter, r *http.Request) {
+ _, _ = io.Copy(io.Discard, r.Body)
+ select {
+ case <-time.After(headerDelay):
+ case <-r.Context().Done():
+ return
+ }
+ w.Header().Set("Content-Type", "text/event-stream")
+ w.(http.Flusher).Flush()
+ <-r.Context().Done()
+ })
+ c.settings.StallTimeout = time.Second
+ ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+ defer cancel()
+ start := time.Now()
+ _, _, err := c.streamSummary(ctx, nil, &chat.ChatOptions{})
+ require.ErrorContains(t, err, "stalled")
+ require.Less(t, time.Since(start), 1500*time.Millisecond)
+ require.NoError(t, ctx.Err())
+}
+
+func TestCompactionStallIncludesHTTPHeaders(t *testing.T) {
+ c := startupTestCompactor(t, func(_ http.ResponseWriter, r *http.Request) {
+ _, _ = io.Copy(io.Discard, r.Body)
+ <-r.Context().Done()
+ })
+ ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+ defer cancel()
+ start := time.Now()
+ _, _, err := c.streamSummary(ctx, []chat.Message{{Role: "user", Content: "summarize"}}, &chat.ChatOptions{})
+ t.Logf("stall_timeout=%s; elapsed=%s; error=%v", c.settings.StallTimeout, time.Since(start), err)
+ require.ErrorContains(t, err, "stalled", "the configured idle timeout must cover response headers")
+ require.NoError(t, ctx.Err(), "the parent must remain usable for retry")
+}
diff --git a/internal/agent/stream_start_timeout_test.go b/internal/agent/stream_start_timeout_test.go
new file mode 100644
index 000000000..3f2e2086d
--- /dev/null
+++ b/internal/agent/stream_start_timeout_test.go
@@ -0,0 +1,121 @@
+package agent
+
+import (
+ "context"
+ "fmt"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+ "time"
+
+ "github.com/Tencent/WeKnora/internal/modelcontext"
+ "github.com/Tencent/WeKnora/internal/models/api"
+ "github.com/Tencent/WeKnora/internal/models/api/openaicompletions"
+ "github.com/Tencent/WeKnora/internal/models/chat"
+ "github.com/Tencent/WeKnora/internal/types"
+ "github.com/stretchr/testify/require"
+)
+
+func startupTestEngine(t *testing.T, handler http.HandlerFunc) *AgentEngine {
+ t.Helper()
+ t.Setenv("SSRF_WHITELIST", "127.0.0.1")
+ server := httptest.NewServer(handler)
+ t.Cleanup(server.Close)
+ return &AgentEngine{
+ config: &types.AgentConfig{LLMCallTimeout: 1},
+ chatModel: openaicompletions.New(openaicompletions.Config{Endpoint: api.Endpoint{
+ BaseURL: server.URL, Model: "timeout-test", Client: server.Client(),
+ }}),
+ modelContext: modelcontext.NewRegistry(false),
+ }
+}
+
+func TestAgentStartupCancellationIsNotRetried(t *testing.T) {
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+ engine := startupTestEngine(t, func(_ http.ResponseWriter, r *http.Request) {
+ _, _ = io.Copy(io.Discard, r.Body)
+ cancel()
+ <-r.Context().Done()
+ })
+ _, err := engine.streamLLMToEventBus(ctx, nil, &chat.ChatOptions{}, nil)
+ require.ErrorIs(t, err, context.Canceled)
+ require.False(t, isTransientError(err))
+ require.NotContains(t, err.Error(), "stalled")
+}
+
+func TestAgentStartupPreservesProviderError(t *testing.T) {
+ engine := startupTestEngine(t, func(w http.ResponseWriter, _ *http.Request) {
+ http.Error(w, "invalid API key", http.StatusUnauthorized)
+ })
+ _, err := engine.streamLLMToEventBus(context.Background(), nil, &chat.ChatOptions{}, nil)
+ var httpErr *api.HTTPError
+ require.ErrorAs(t, err, &httpErr)
+ require.Equal(t, http.StatusUnauthorized, httpErr.StatusCode)
+ require.False(t, isTransientError(err))
+}
+
+func TestAgentHeadersDoNotResetFirstOutputBudget(t *testing.T) {
+ const headerDelay = 700 * time.Millisecond
+ engine := startupTestEngine(t, func(w http.ResponseWriter, r *http.Request) {
+ _, _ = io.Copy(io.Discard, r.Body)
+ select {
+ case <-time.After(headerDelay):
+ case <-r.Context().Done():
+ return
+ }
+ w.Header().Set("Content-Type", "text/event-stream")
+ w.(http.Flusher).Flush()
+ <-r.Context().Done()
+ })
+ ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+ defer cancel()
+ start := time.Now()
+ _, err := engine.streamLLMToEventBus(ctx, nil, &chat.ChatOptions{}, nil)
+ require.ErrorContains(t, err, "stalled")
+ require.Less(t, time.Since(start), 1500*time.Millisecond)
+ require.NoError(t, ctx.Err())
+}
+
+func TestAgentStartupAllowsLongActiveHTTPStream(t *testing.T) {
+ const chunks = 8
+ const gap = 200 * time.Millisecond
+ engine := startupTestEngine(t, func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "text/event-stream")
+ for range chunks {
+ select {
+ case <-time.After(gap):
+ case <-r.Context().Done():
+ return
+ }
+ _, _ = fmt.Fprint(w, `data: {"choices":[{"index":0,"delta":{"content":"hello "}}]}`+"\n\n")
+ w.(http.Flusher).Flush()
+ }
+ _, _ = fmt.Fprint(w, `data: {"choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}`+"\n\n")
+ })
+ ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+ defer cancel()
+ start := time.Now()
+ result, err := engine.streamLLMToEventBus(ctx, nil, &chat.ChatOptions{}, nil)
+ require.NoError(t, err)
+ require.Greater(t, time.Since(start), engine.getLLMStallTimeout())
+ require.Equal(t, "stop", result.FinishReason)
+ require.Len(t, result.Content, chunks*len("hello "))
+}
+
+func TestAgentStallIncludesHTTPHeaders(t *testing.T) {
+ engine := startupTestEngine(t, func(_ http.ResponseWriter, r *http.Request) {
+ _, _ = io.Copy(io.Discard, r.Body)
+ <-r.Context().Done()
+ })
+ ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+ defer cancel()
+ start := time.Now()
+ messages := []chat.Message{{Role: "user", Content: "hello"}}
+ _, err := engine.streamLLMToEventBus(ctx, messages, &chat.ChatOptions{}, nil)
+ t.Logf("stall_timeout=1s; elapsed=%s; error=%v", time.Since(start), err)
+ require.ErrorContains(t, err, "stalled", "the idle watchdog must cover waiting for HTTP response headers")
+ require.NoError(t, ctx.Err(), "the per-call stall must not cancel the parent")
+ require.True(t, isTransientError(err), "startup stalls must use the existing retry path")
+}
diff --git a/internal/agent/think.go b/internal/agent/think.go
index 1e71edd98..81a3eafe2 100644
--- a/internal/agent/think.go
+++ b/internal/agent/think.go
@@ -61,8 +61,16 @@ func (e *AgentEngine) streamLLMToEventBus(
reportModelContextLeaks(ctx, "Agent", e.modelContext, messages)
prefixFingerprint := chat.PromptPrefixFingerprint(messages, opts)
llmCtx = types.WithLLMCallMetadata(llmCtx, "agent_round", prefixFingerprint)
+ // ChatStream may wait for connection setup and response headers before
+ // returning a channel. Count that silence toward the same idle budget.
+ stallTimeout := e.getLLMStallTimeout()
+ stalled, stopWatchdog := watchStreamStall(ctx, llmCancel, stallTimeout, &lastChunkAt)
+ defer stopWatchdog()
stream, err := e.chatModel.ChatStream(llmCtx, messages, opts)
if err != nil {
+ if ctx.Err() == nil && stalled.Load() {
+ return nil, fmt.Errorf("LLM stream stalled: no output for %s", stallTimeout)
+ }
logger.Errorf(ctx, "[Agent][Stream] Failed to start LLM stream: %v", err)
return nil, err
}
@@ -74,10 +82,6 @@ func (e *AgentEngine) streamLLMToEventBus(
answerDecoder := e.modelContext.StreamDecoder()
thinkingDecoder := e.modelContext.StreamDecoder()
- stallTimeout := e.getLLMStallTimeout()
- stalled, stopWatchdog := watchStreamStall(ctx, llmCancel, stallTimeout, &lastChunkAt)
- defer stopWatchdog()
-
for chunk := range stream {
lastChunkAt.Store(time.Now().UnixNano())
chunkCount++