fix(agent): honor MCP service advanced_config.timeout for CallTool window

The agent engine derives every tool's execution ctx from a blanket 60s
budget (toolExecutionTimeout), so MCP calls on services configured with a
longer advanced_config.timeout were silently cancelled mid-flight even
though the MCP transport layers honor that value (internal/mcp/client.go,
manager.go). The configuration was partially applied without any signal.

Re-derive the CallTool window from ApprovalCtx (the round-level parent
without the per-tool deadline) using the service timeout when it extends
the engine window. Widening-only by design: services without an explicit
longer timeout keep today's behavior, and shorter values stay enforced
where they already apply (HTTP transport timeout).

Fixes #3135
main
LuckVd 2026-09-11 10:33:48 +08:00 committed by lyingbug
parent 72581cb462
commit 8c2c976127
2 changed files with 141 additions and 5 deletions

View File

@ -109,6 +109,34 @@ func (t *MCPTool) Parameters() json.RawMessage {
}`)
}
// serviceCallTimeout returns the MCP service's configured per-call timeout
// (advanced_config.timeout, in seconds), or 0 when unset or not positive.
func (t *MCPTool) serviceCallTimeout() time.Duration {
if t.service == nil || t.service.AdvancedConfig == nil || t.service.AdvancedConfig.Timeout <= 0 {
return 0
}
return time.Duration(t.service.AdvancedConfig.Timeout) * time.Second
}
// callToolTimeout returns the timeout governing the actual MCP CallTool window.
// The agent engine derives the per-tool budget from a blanket 60s
// (toolExecutionTimeout in internal/agent), while the service-level
// advanced_config.timeout was only honored by the transport layers — a service
// configured with a longer timeout still had every call cancelled at 60s (#3135).
// The service timeout therefore extends the engine window when it is longer; it
// never shortens it, so services without an explicit (longer) timeout keep
// today's behavior and shorter values stay enforced where they already apply
// (the HTTP transport timeout in internal/mcp/client.go).
func (t *MCPTool) callToolTimeout(engineTimeout time.Duration) time.Duration {
if engineTimeout <= 0 {
engineTimeout = 60 * time.Second
}
if st := t.serviceCallTimeout(); st > engineTimeout {
return st
}
return engineTimeout
}
// Execute executes the MCP tool
func (t *MCPTool) Execute(ctx context.Context, args json.RawMessage) (*types.ToolResult, error) {
logger.GetLogger(ctx).Infof("Executing MCP tool: %s from service: %s", t.mcpTool.Name, t.service.Name)
@ -201,12 +229,9 @@ func (t *MCPTool) Execute(ctx context.Context, args json.RawMessage) (*types.Too
// Approval may have consumed most/all of the per-tool exec budget set by the
// agent engine (act.go). Re-derive a fresh tool-exec ctx from ApprovalCtx so
// the actual MCP CallTool gets a full timeout window. (issue #1173 follow-up)
// callToolTimeout honors the service's advanced_config.timeout (#3135).
if meta.ApprovalCtx != nil {
freshTimeout := meta.ExecTimeout
if freshTimeout <= 0 {
freshTimeout = 60 * time.Second
}
freshCtx, freshCancel := context.WithTimeout(meta.ApprovalCtx, freshTimeout)
freshCtx, freshCancel := context.WithTimeout(meta.ApprovalCtx, t.callToolTimeout(meta.ExecTimeout))
defer freshCancel()
ctx = freshCtx
}
@ -222,6 +247,20 @@ func (t *MCPTool) Execute(ctx context.Context, args json.RawMessage) (*types.Too
toolCallID = meta.ToolCallID
}
// The service's advanced_config.timeout must govern the actual CallTool window
// (#3135): the agent engine derives the per-tool ctx from a blanket 60s budget
// (toolExecutionTimeout in internal/agent), so calls on services configured
// with a longer timeout were silently cancelled mid-flight even though the
// transport layers honor the value. Re-derive the window from ApprovalCtx —
// the round-level parent without the per-tool deadline. Skipped on the
// post-approval path, which already re-derived its window above and whose
// swapped ctx no longer carries the exec meta.
if meta != nil && meta.ApprovalCtx != nil {
callCtx, callCancel := context.WithTimeout(meta.ApprovalCtx, t.callToolTimeout(meta.ExecTimeout))
defer callCancel()
ctx = callCtx
}
connectAndCall := func(callCtx context.Context) (*mcp.CallToolResult, error) {
client, err := getOrCreateMCPClientWithOAuthRetry(
callCtx, t.mcpManager, t.service, t.gate, oauthSess, t.mcpTool.Name, toolCallID,

View File

@ -0,0 +1,97 @@
package tools
import (
"testing"
"time"
"github.com/Tencent/WeKnora/internal/types"
"github.com/stretchr/testify/assert"
)
func mcpServiceWithTimeout(seconds int) *types.MCPService {
if seconds <= 0 {
return &types.MCPService{}
}
return &types.MCPService{AdvancedConfig: &types.MCPAdvancedConfig{Timeout: seconds}}
}
func TestServiceCallTimeout(t *testing.T) {
tests := []struct {
name string
serviceTimeout int
expected time.Duration
}{
{"nil advanced config", 0, 0},
{"zero timeout", 0, 0},
{"negative timeout", -5, 0},
{"positive timeout", 300, 300 * time.Second},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tool := &MCPTool{service: mcpServiceWithTimeout(tt.serviceTimeout)}
assert.Equal(t, tt.expected, tool.serviceCallTimeout())
})
}
t.Run("nil service", func(t *testing.T) {
tool := &MCPTool{}
assert.Equal(t, time.Duration(0), tool.serviceCallTimeout())
})
}
// TestCallToolTimeout covers the per-call budget derivation for MCP CallTool
// (#3135): the service's advanced_config.timeout extends the engine-derived
// window when longer, and never shortens it.
func TestCallToolTimeout(t *testing.T) {
const engineWindow = 60 * time.Second
tests := []struct {
name string
serviceTimeout int
engineTimeout time.Duration
expected time.Duration
}{
{
name: "no advanced config keeps engine window",
serviceTimeout: 0,
engineTimeout: engineWindow,
expected: engineWindow,
},
{
name: "longer service timeout wins (#3135)",
serviceTimeout: 300,
engineTimeout: engineWindow,
expected: 300 * time.Second,
},
{
name: "equal service timeout keeps engine window",
serviceTimeout: 60,
engineTimeout: engineWindow,
expected: engineWindow,
},
{
name: "shorter service timeout never shortens",
serviceTimeout: 30,
engineTimeout: engineWindow,
expected: engineWindow,
},
{
name: "missing engine timeout falls back to 60s then extends",
serviceTimeout: 300,
engineTimeout: 0,
expected: 300 * time.Second,
},
{
name: "missing engine timeout with short service keeps 60s",
serviceTimeout: 30,
engineTimeout: 0,
expected: engineWindow,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
tool := &MCPTool{service: mcpServiceWithTimeout(tt.serviceTimeout)}
assert.Equal(t, tt.expected, tool.callToolTimeout(tt.engineTimeout))
})
}
}