Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.
Go agentagenticaichatbotdsh-pluginembeddingsevaluationgenerative-aigolangknowledge-basellmmulti-tenantollamaopenaiquestion-answeringragrerankingsemantic-searchvector-searchwiki
fix(agent): 将空闲超时覆盖到模型流建立阶段
yeliheng-0100466c294ef1a
diff --git a/internal/agent/compaction/compactor.go b/internal/agent/compaction/compactor.goindex 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.BuilderstreamErr := ""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, nildiff --git a/internal/agent/compaction/stream_start_timeout_test.go b/internal/agent/compaction/stream_start_timeout_test.gonew file mode 100644index 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.gonew file mode 100644index 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.goindex 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++