Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
54 changes: 31 additions & 23 deletions internal/agent/fragment_content_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,7 @@ import (
"encoding/json"
fanoutmcp "github.com/labstack/fanout/internal/mcp"
"github.com/labstack/fanout/internal/panel"
"github.com/labstack/fanout/internal/toolerror"
"reflect"
"strings"
"testing"
Expand Down Expand Up @@ -142,31 +143,38 @@ func TestAppSummariesBoundedOnSuccessAndError(t *testing.T) {
}

func TestAppToolErrorHasNoActivity(t *testing.T) {
messages := []agtypes.Message{{ID: "user", Role: agtypes.RoleUser, Content: "show"}}
provider := &scriptedProvider{steps: [][]StreamEvent{{{Type: EventToolUse, ToolCall: &ToolCall{ID: "call", Name: "query_telemetry", Input: `{}`}}, {Type: EventStop, StopReason: "tool_calls"}}, {{Type: EventStop, StopReason: "end_turn"}}}}
runtime := NewRuntime(provider, &fakeTools{execution: ToolExecution{Content: "Invalid telemetry window", IsError: true, AppResourceURI: "ui://fanout/panels.html"}}, nil)
emitter, _ := newTestEmitter()
if _, err := runtime.execute(t.Context(), "thread", "run", &messages, emitter); err != nil {
t.Fatal(err)
}
found := false
for _, message := range messages {
if message.Role == agtypes.RoleActivity {
t.Fatal("error emitted an app activity")
}
if message.Role == agtypes.RoleTool {
found = true
var payload struct {
Error struct{ Code, Message string }
IsError bool
for _, tc := range []struct{ name, tool, content, code, message string }{
{"plain", "query_telemetry", "Invalid telemetry window", "tool_failed", "Invalid telemetry window"},
{"unknown service", "get_service_performance", toolerror.JSON("unknown_service", "kafka is a messaging system used by checkout, fraud-detection, accounting"), "unknown_service", "kafka is a messaging system used by checkout, fraud-detection, accounting"},
} {
t.Run(tc.name, func(t *testing.T) {
messages := []agtypes.Message{{ID: "user", Role: agtypes.RoleUser, Content: "show"}}
provider := &scriptedProvider{steps: [][]StreamEvent{{{Type: EventToolUse, ToolCall: &ToolCall{ID: "call", Name: tc.tool, Input: `{}`}}, {Type: EventStop, StopReason: "tool_calls"}}, {{Type: EventStop, StopReason: "end_turn"}}}}
runtime := NewRuntime(provider, &fakeTools{execution: ToolExecution{Content: tc.content, IsError: true, AppResourceURI: "ui://fanout/panels.html"}}, nil)
emitter, _ := newTestEmitter()
if _, err := runtime.execute(t.Context(), "thread", "run", &messages, emitter); err != nil {
t.Fatal(err)
}
if json.Unmarshal([]byte(messageText(message.Content)), &payload) != nil || payload.Error.Code != "tool_failed" || payload.Error.Message != "Invalid telemetry window" || !payload.IsError || message.Error == "" {
t.Fatal("tool error lost")
found := false
for _, message := range messages {
if message.Role == agtypes.RoleActivity {
t.Fatal("error emitted an app activity")
}
if message.Role == agtypes.RoleTool {
found = true
var payload struct {
Error struct{ Code, Message string }
IsError bool
}
if json.Unmarshal([]byte(messageText(message.Content)), &payload) != nil || payload.Error.Code != tc.code || payload.Error.Message != tc.message || !payload.IsError || message.Error == "" {
t.Fatal("tool error lost")
}
}
}
}
}
if !found {
t.Fatal("tool error missing")
if !found {
t.Fatal("tool error missing")
}
})
}
}

Expand Down
73 changes: 73 additions & 0 deletions internal/agent/service_input_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,73 @@
package agent

import (
"encoding/json"
"fmt"
"strings"
"testing"
"time"
"unicode/utf8"

"github.com/labstack/fanout/internal/config"
fanoutmcp "github.com/labstack/fanout/internal/mcp"
"github.com/labstack/fanout/internal/observability"
"github.com/labstack/fanout/internal/panel"
"github.com/labstack/fanout/internal/query"
"github.com/labstack/fanout/internal/telemetry"
telemetrystore "github.com/labstack/fanout/internal/telemetry/store"
"github.com/labstack/fanout/internal/toolerror"
)

func TestToolRegistryUnknownServiceBoundsOversizedAliases(t *testing.T) {
cfg := config.Config{DataDir: t.TempDir(), DuckDBMemory: "256MB", DuckDBThreads: 2, DuckDBMaxConns: 4, RollupInterval: time.Hour}
repo, err := telemetrystore.Open(cfg.TelemetryDir())
if err != nil {
t.Fatal(err)
}
defer repo.Close()
duck, err := query.NewDuck(t.Context(), cfg, repo)
if err != nil {
t.Fatal(err)
}
defer duck.Close()
to := time.Now().UTC()
from := to.Add(-time.Hour)
batch := telemetrystore.Batch{ID: "oversized-aliases"}
for i := range 30 {
batch.Spans = append(batch.Spans, telemetry.Span{
Namespace: "shop", ServiceName: fmt.Sprintf("user%02d-", i) + strings.Repeat("<\\\"\n界", 512),
TraceID: fmt.Sprint(i), SpanID: fmt.Sprint(i),
StartUnixNanos: from.Add(time.Minute).UnixNano(), EndUnixNanos: from.Add(2 * time.Minute).UnixNano(),
Attributes: map[string]any{"messaging.system": "kafka"},
})
}
if err := repo.Commit(t.Context(), batch); err != nil {
t.Fatal(err)
}
executor := panel.NewExecutor(duck, 7)
server := fanoutmcp.NewWithIntelligence(observability.New(duck, duck, 7), nil, executor, nil, "test")
registry, err := NewToolRegistry(t.Context(), server.MCP())
if err != nil {
t.Fatal(err)
}
defer registry.Close()
// Keep the service filter executable; the alias list above supplies the
// oversized guidance, and this name also exercises JSON/UTF-8 escaping.
for _, service := range []string{"kafka", strings.Repeat("<\\\"\n界", 64)} {
input, err := json.Marshal(map[string]any{"service": service, "namespace": "shop", "from": from, "to": to})
if err != nil {
t.Fatal(err)
}
result, err := registry.Execute(t.Context(), ToolCall{Name: "get_service_performance", Input: string(input)})
if err != nil || !result.IsError || result.Structured != nil {
t.Fatalf("unknown service result: %+v %v", result, err)
}
var failure toolerror.Result
if len(result.Content) > 16*1024 || !utf8.ValidString(result.Content) || json.Unmarshal([]byte(result.Content), &failure) != nil || failure.Error == nil || failure.Error.Code != "unknown_service" || failure.Error.Message == "" {
t.Fatalf("invalid error contract: bytes=%d valid_json=%v", len(result.Content), json.Valid([]byte(result.Content)))
}
if service == "kafka" && !strings.Contains(failure.Error.Message, "kafka is a messaging system used by user00-") {
t.Fatalf("alias guidance missing: %q", failure.Error.Message)
}
}
}
90 changes: 79 additions & 11 deletions internal/mcp/server.go
Original file line number Diff line number Diff line change
Expand Up @@ -93,6 +93,8 @@ type panelExecutor interface {
Schema(context.Context, panel.SchemaRequest) (*panel.Schema, error)
Exemplars(context.Context, panel.ExemplarRequest) (panel.ExemplarResponse, error)
ResolveVariables(context.Context, panel.ResolveRequest) (map[string][]panel.Option, error)
ResolveWindow(time.Time, time.Time) (time.Time, time.Time, error)
ServiceGuidance(context.Context, time.Time, time.Time, string, string) (string, error)
}

type Server struct {
Expand Down Expand Up @@ -386,6 +388,11 @@ func (s *Server) dependencies(ctx context.Context, _ *mcp.CallToolRequest, input
if err != nil {
return nil, output, safePanelToolError(err)
}
if len(output.Data.Nodes) == 0 {
if err := s.checkService(ctx, scope, strings.TrimSpace(input.Service)); err != nil {
return nil, observability.Result[observability.Dependencies]{}, err
}
}
return summary(output.Summary), output, nil
}

Expand All @@ -404,7 +411,16 @@ func (s *Server) presetFragment(ctx context.Context, input QueryInput, kind, ser
}
d := fragmentPreset(kind, service, input.Namespace, severity, search, input.Limit)
d.Time = panel.Time{From: &scope.Start, To: &scope.End, Refresh: "off"}
return s.runFragment(ctx, panel.RunRequest{Dashboard: d}, "preset")
result, out, err := s.runFragment(ctx, panel.RunRequest{Dashboard: d}, "preset")
if err != nil {
return nil, PanelFragment{}, err
}
if allResultsEmpty(out.Results) {
if err := s.checkService(ctx, scope, service); err != nil {
return nil, PanelFragment{}, err
}
}
return result, out, nil
}
func (s *Server) overview(ctx context.Context, _ *mcp.CallToolRequest, input QueryInput) (*mcp.CallToolResult, PanelFragment, error) {
return s.presetFragment(ctx, input, "overview", "", "", "")
Expand Down Expand Up @@ -440,6 +456,11 @@ func (s *Server) trace(ctx context.Context, _ *mcp.CallToolRequest, input TraceI
if err != nil {
return nil, PanelFragment{}, err
}
if allResultsEmpty(out.Results) && len(detail.Data.Spans) == 0 && len(detail.Data.Logs) == 0 {
if err := s.checkService(ctx, scope, strings.TrimSpace(input.Service)); err != nil {
return nil, PanelFragment{}, err
}
}
if detail.Data.Spans == nil {
detail.Data.Spans = []observability.TraceSpan{}
}
Expand All @@ -458,33 +479,80 @@ func (s *Server) trace(ctx context.Context, _ *mcp.CallToolRequest, input TraceI
return summary(fragmentSummary(out)), out, nil
}

func allResultsEmpty(results []panel.Result) bool {
if len(results) == 0 {
return false
}
for _, result := range results {
if result.Status != panel.StatusEmpty {
return false
}
}
return true
}

// Called only after a service-scoped tool succeeds with entirely empty results.
// Unknown names return a product tool error without a typed success payload.
func (s *Server) checkService(ctx context.Context, scope observability.Scope, service string) error {
if service == "" || s.panels == nil {
return nil
}
message, err := s.panels.ServiceGuidance(ctx, scope.Start, scope.End, scope.Namespace, service)
if err != nil {
return safePanelToolError(err)
}
if message == "" {
return nil
}
// JSON escaping expands a byte by at most six bytes. Reserve the envelope
// and bound before encoding so the agent's 16 KiB app cap cannot cut JSON.
const maxMessageBytes = (16*1024 - 128) / 6
if len(message) > maxMessageBytes {
message = message[:maxMessageBytes-len("…")]
for !utf8.ValidString(message) {
message = message[:len(message)-1]
}
message += "…"
}
return errors.New(toolerror.JSON("unknown_service", message))
}

func (s *Server) scope(input QueryInput) (observability.Scope, error) {
if input.Limit < 0 || input.Limit > 500 {
return observability.Scope{}, errors.New("limit must be from 1 to 500")
}
if (input.From == nil) != (input.To == nil) {
return observability.Scope{}, errors.New("from and to must be supplied together")
}
var start, end time.Time
if input.From != nil {
if strings.TrimSpace(input.Window) != "" {
return observability.Scope{}, errors.New("from/to cannot coexist with window")
}
start, end := input.From.UTC(), input.To.UTC()
start, end = input.From.UTC(), input.To.UTC()
if !end.After(start) {
return observability.Scope{}, errors.New("to must be after from")
}
return observability.Scope{Namespace: input.Namespace, Start: start, End: end}, nil
} else {
window := time.Hour
if strings.TrimSpace(input.Window) != "" {
parsed, err := time.ParseDuration(input.Window)
if err != nil || parsed <= 0 {
return observability.Scope{}, fmt.Errorf("window must be a positive duration such as 15m or 1h")
}
window = parsed
}
end = s.now().UTC()
start = end.Add(-window)
}
window := time.Hour
if strings.TrimSpace(input.Window) != "" {
parsed, err := time.ParseDuration(input.Window)
if err != nil || parsed <= 0 {
return observability.Scope{}, fmt.Errorf("window must be a positive duration such as 15m or 1h")
if s.panels != nil {
var err error
start, end, err = s.panels.ResolveWindow(start, end)
if err != nil {
return observability.Scope{}, safePanelToolError(err)
}
window = parsed
}
end := s.now().UTC()
return observability.Scope{Namespace: input.Namespace, Start: end.Add(-window), End: end}, nil
return observability.Scope{Namespace: input.Namespace, Start: start, End: end}, nil
}

func summary(text string) *mcp.CallToolResult {
Expand Down
Loading
Loading