Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat(mcp): name masked columns and their reasons in query_database (#21581)
Vincent Huang32ef4e4019e4
diff --git a/backend/api/mcp/tool_query.go b/backend/api/mcp/tool_query.goindex 18b73fe37a..f4cb402ea4 100644--- a/backend/api/mcp/tool_query.go+++ b/backend/api/mcp/tool_query.go@@ -28,18 +28,37 @@ type QueryInput struct {Instance string `json:"instance,omitempty"`// Project narrows database resolution to a specific project.Project string `json:"project,omitempty"`+ // Schema is the default schema for unqualified names.+ Schema string `json:"schema,omitempty"`+ // Container is the CosmosDB container to query.+ Container string `json:"container,omitempty"`// Limit is the maximum number of rows to return (default: 100, max: 1000).Limit int `json:"limit,omitempty"`}// QueryOutput is the output for the query_database tool.type QueryOutput struct {- Columns []string `json:"columns"`- ColumnTypes []string `json:"columnTypes"`- Rows [][]any `json:"rows"`- RowCount int `json:"rowCount"`- Truncated bool `json:"truncated"`- LatencyMs int64 `json:"latencyMs"`+ Columns []string `json:"columns"`+ ColumnTypes []string `json:"columnTypes"`+ Rows [][]any `json:"rows"`+ RowCount int `json:"rowCount"`+ Truncated bool `json:"truncated"`+ LatencyMs int64 `json:"latencyMs"`+ MaskedColumns []MaskedColumn `json:"maskedColumns,omitempty"`+ AppliedAccessGrant string `json:"appliedAccessGrant,omitempty"`+}++// MaskedColumn is a result column whose values masking replaced.+type MaskedColumn struct {+ // Column repeats columns[Index], so a model reading one entry need not+ // count positions.+ Column string `json:"column"`+ // Index is the column's position in columns and in each row, which tells+ // apart columns that share a name.+ Index int `json:"index"`+ SemanticType string `json:"semanticType,omitempty"`+ Algorithm string `json:"algorithm,omitempty"`+ Context string `json:"context,omitempty"`}// queryDatabaseDescription is the description for the query_database tool.@@ -51,6 +70,8 @@ const queryDatabaseDescription = `Execute a SQL query against a Bytebase databas| statement | Yes | SQL query to execute || instance | No | Workspace instance ID/name, or the full canonical name for a project instance || project | No | Project name or ID to narrow resolution |+| schema | No | Default schema for unqualified names (Postgres search path). An access grant applies only when this equals the grant's schema |+| container | No | CosmosDB container (required for CosmosDB). An access grant applies only when this equals the grant's container || limit | No | Max rows (default: 100, max: 1000) |**Examples:**@@ -59,7 +80,8 @@ query_database(database="employee", instance="prod-pg", statement="SELECT count(query_database(database="employee", instance="projects/hr/instances/prod-pg", statement="SELECT count(*) FROM orders")**Notes:**-- Masked data: a masked column reads back as "******". That is a placeholder, not a value anything holds, so never write it back and never filter on it. Any statement containing it is refused.+- Masked data: masking replaces a value fully (by default "******"), partly (e.g. "**rn**"), or with a hash. maskedColumns in the result names each masked column and why (not reported for MongoDB, CosmosDB or Elasticsearch). A masked value is a placeholder, not a value anything holds, so never write it back and never filter on it. Any statement containing "******" is refused. When showing a partly masked value, wrap it in backticks: "**rn**" renders as bold Markdown.+- Seeing masked values: the user can ask a project owner for a masking exemption, or, if the project allows just-in-time access, request an access grant with Unmask for this exact statement, schema and container. In a Read-write session, file the request with call_api(operationId="AccessGrantService/CreateAccessGrant"); otherwise the user requests it in the SQL Editor. After a person approves it, find the grant among the user's access grants, then rerun the granted statement unchanged with the grant's schema and container. appliedAccessGrant in the result names the grant that applied.`func (s *Server) registerQueryTool() {@@ -96,7 +118,7 @@ func (s *Server) handleQueryDatabase(ctx context.Context, req *mcp.CallToolRequequeryCtx, queryCancel := context.WithTimeout(ctx, queryTimeout)defer queryCancel()- output, err := s.executeQuery(queryCtx, resolved, input.Statement, limit)+ output, err := s.executeQuery(queryCtx, resolved, input, limit)if err != nil {return formatToolError(err), nil, nil}@@ -123,6 +145,13 @@ func formatQueryOutput(statement, resourceName string, output *QueryOutput) strifmt.Fprintf(&sb, "Result: %d rows, %d columns (%s) | %dms\n",output.RowCount, len(output.Columns), columnList, output.LatencyMs)}+ if len(output.MaskedColumns) > 0 {+ names := make([]string, 0, len(output.MaskedColumns))+ for _, column := range output.MaskedColumns {+ names = append(names, column.Column)+ }+ fmt.Fprintf(&sb, "Masked columns: %s.\n", strings.Join(names, ", "))+ }sb.WriteString("\n")jsonBytes, _ := json.Marshal(output)@@ -151,18 +180,27 @@ func formatToolError(err error) *mcp.CallToolResult {// queryResponse is the typed response from the SQL Query API.type queryResponse struct {- Results []queryResult `json:"results"`+ Results []queryResult `json:"results"`+ AppliedAccessGrant string `json:"appliedAccessGrant"`}// queryResult represents a single result set from a query.type queryResult struct {- ColumnNames []string `json:"columnNames"`- ColumnTypeNames []string `json:"columnTypeNames"`- Rows []queryRow `json:"rows"`- RowsCount json.Number `json:"rowsCount"`- Latency string `json:"latency"`- Error string `json:"error"`- Statement string `json:"statement"`+ ColumnNames []string `json:"columnNames"`+ ColumnTypeNames []string `json:"columnTypeNames"`+ Rows []queryRow `json:"rows"`+ RowsCount json.Number `json:"rowsCount"`+ Latency string `json:"latency"`+ Error string `json:"error"`+ Statement string `json:"statement"`+ Masked []maskingReason `json:"masked"`+}++// maskingReason holds the MaskingReason fields the tool reports.+type maskingReason struct {+ SemanticTypeTitle string `json:"semanticTypeTitle"`+ Algorithm string `json:"algorithm"`+ Context string `json:"context"`}// queryRow represents a row of values from a query result.@@ -171,11 +209,17 @@ type queryRow struct {}// executeQuery executes a SQL query against the resolved database.-func (s *Server) executeQuery(ctx context.Context, resolved *resolvedDatabase, statement string, limit int) (*QueryOutput, error) {+func (s *Server) executeQuery(ctx context.Context, resolved *resolvedDatabase, input QueryInput, limit int) (*QueryOutput, error) {body := map[string]any{"name": resolved.resourceName,"dataSourceId": resolved.dataSourceID,- "statement": statement,+ "statement": input.Statement,+ }+ if input.Schema != "" {+ body["schema"] = input.Schema+ }+ if input.Container != "" {+ body["container"] = input.Container}resp, err := s.apiRequest(ctx, "/bytebase.v1.SQLService/Query", body)if err != nil {@@ -214,9 +258,10 @@ func (s *Server) executeQuery(ctx context.Context, resolved *resolvedDatabase, s}if len(qr.Results) == 0 {return &QueryOutput{- Columns: []string{},- ColumnTypes: []string{},- Rows: [][]any{},+ Columns: []string{},+ ColumnTypes: []string{},+ Rows: [][]any{},+ AppliedAccessGrant: qr.AppliedAccessGrant,}, nil}@@ -246,15 +291,39 @@ func (s *Server) executeQuery(ctx context.Context, resolved *resolvedDatabase, s}return &QueryOutput{- Columns: result.ColumnNames,- ColumnTypes: result.ColumnTypeNames,- Rows: rows,- RowCount: len(rows),- Truncated: truncated,- LatencyMs: parseLatencyMs(result.Latency),+ Columns: result.ColumnNames,+ ColumnTypes: result.ColumnTypeNames,+ Rows: rows,+ RowCount: len(rows),+ Truncated: truncated,+ LatencyMs: parseLatencyMs(result.Latency),+ MaskedColumns: maskedColumns(result.ColumnNames, result.Masked),+ AppliedAccessGrant: qr.AppliedAccessGrant,}, nil}+// maskedColumns pairs each masked column with its reason. Query aligns masked+// with the columns by index and sends {} for an unmasked column, and the list+// can be shorter than the columns, leaving the rest unmasked (doMaskResult in+// backend/api/v1/query_result_masker.go).+func maskedColumns(columns []string, reasons []maskingReason) []MaskedColumn {+ var masked []MaskedColumn+ for i := range min(len(columns), len(reasons)) {+ reason := reasons[i]+ if reason == (maskingReason{}) {+ continue+ }+ masked = append(masked, MaskedColumn{+ Column: columns[i],+ Index: i,+ SemanticType: reason.SemanticTypeTitle,+ Algorithm: reason.Algorithm,+ Context: reason.Context,+ })+ }+ return masked+}+// flattenRowValue extracts a plain Go value from a protojson RowValue oneof.// Each value is a JSON object with exactly one key like {"stringValue": "x"}.func flattenRowValue(raw json.RawMessage) any {diff --git a/backend/api/mcp/tool_query_test.go b/backend/api/mcp/tool_query_test.goindex 4564e3f445..749ec937f6 100644--- a/backend/api/mcp/tool_query_test.go+++ b/backend/api/mcp/tool_query_test.go@@ -4,6 +4,7 @@ import ("context""encoding/json""fmt"+ "io""net/http""strings""testing"@@ -11,6 +12,10 @@ import (mcpsdk "github.com/modelcontextprotocol/go-sdk/mcp""github.com/stretchr/testify/require"+ "google.golang.org/protobuf/encoding/protojson"++ "github.com/bytebase/bytebase/backend/common"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1")// makeDatabase builds a database entry with an ADMIN datasource for mock responses.@@ -777,7 +782,259 @@ func TestQueryDatabase_Timeout(t *testing.T) {resourceName: "instances/prod-pg/databases/employee_db",dataSourceID: "ds-admin-1",}- _, err := s.executeQuery(ctx, resolved, "SELECT 1", 100)+ _, err := s.executeQuery(ctx, resolved, QueryInput{Statement: "SELECT 1"}, 100)require.Error(t, err)require.Contains(t, err.Error(), "QUERY_ERROR")}++// protoQueryResponse encodes resp with protojson.MarshalOptions{}, the options+// connect-go's JSON codec uses for the Query response.+func protoQueryResponse(t *testing.T, resp *v1pb.QueryResponse) map[string]any {+ t.Helper()+ raw, err := protojson.MarshalOptions{}.Marshal(resp)+ require.NoError(t, err)+ var body map[string]any+ require.NoError(t, json.Unmarshal(raw, &body))+ return body+}++func TestMaskedColumns(t *testing.T) {+ tests := []struct {+ name string+ result string+ want []MaskedColumn+ }{+ {+ name: "unmasked column entry is empty",+ result: `{"columnNames":["id","ssn"],"masked":[{},{"semanticTypeId":"ssn","semanticTypeTitle":"SSN","algorithm":"Full mask","context":"Global masking rule: PII"}]}`,+ want: []MaskedColumn{{Column: "ssn", Index: 1, SemanticType: "SSN", Algorithm: "Full mask", Context: "Global masking rule: PII"}},+ },+ {+ name: "column from several source columns has no semantic type",+ result: `{"columnNames":["contact"],"masked":[{"algorithm":"Full mask","context":"Multiple source columns"}]}`,+ want: []MaskedColumn{{Column: "contact", Index: 0, Algorithm: "Full mask", Context: "Multiple source columns"}},+ },+ {+ name: "list shorter than the columns",+ result: `{"columnNames":["ssn","id"],"masked":[{"semanticTypeId":"ssn","semanticTypeTitle":"SSN","algorithm":"Full mask"}]}`,+ want: []MaskedColumn{{Column: "ssn", Index: 0, SemanticType: "SSN", Algorithm: "Full mask"}},+ },+ {+ name: "list longer than the columns",+ result: `{"columnNames":["id"],"masked":[{},{"semanticTypeId":"ssn","algorithm":"Full mask"}]}`,+ },+ {+ name: "columns sharing a name",+ result: `{"columnNames":["email","email"],"masked":[{},{"semanticTypeId":"email","semanticTypeTitle":"Email","algorithm":"Partial mask"}]}`,+ want: []MaskedColumn{{Column: "email", Index: 1, SemanticType: "Email", Algorithm: "Partial mask"}},+ },+ {+ name: "no masked field",+ result: `{"columnNames":["id"]}`,+ },+ }+ for _, tc := range tests {+ t.Run(tc.name, func(t *testing.T) {+ var result queryResult+ require.NoError(t, json.Unmarshal([]byte(tc.result), &result))+ require.Equal(t, tc.want, maskedColumns(result.ColumnNames, result.Masked))+ })+ }+}++func TestQueryDatabase_MaskedColumnsNameTheirReasons(t *testing.T) {+ databases := []map[string]any{+ makeDatabase("instances/prod-pg/databases/employee_db", "instances/prod-pg", "projects/hr-system", "POSTGRES", "ds-admin-1"),+ }+ qr := protoQueryResponse(t, &v1pb.QueryResponse{+ Results: []*v1pb.QueryResult{{+ ColumnNames: []string{"id", "ssn", "email"},+ ColumnTypeNames: []string{"int4", "varchar", "varchar"},+ Rows: []*v1pb.QueryRow{{Values: []*v1pb.RowValue{+ {Kind: &v1pb.RowValue_Int32Value{Int32Value: 1}},+ {Kind: &v1pb.RowValue_StringValue{StringValue: "******"}},+ {Kind: &v1pb.RowValue_StringValue{StringValue: "j***@example.com"}},+ }}},+ Masked: []*v1pb.MaskingReason{+ nil,+ {SemanticTypeId: "ssn", SemanticTypeTitle: "SSN", Algorithm: "Full mask", Context: "Global masking rule: PII"},+ {SemanticTypeId: "email", SemanticTypeTitle: "Email", Algorithm: "Partial mask", Context: "Column-level semantic type: Email"},+ },+ }},+ })+ s := newTestServerWithMock(t, mockQueryServer(databases, qr))++ result, structured, err := s.handleQueryDatabase(testContext(), nil, QueryInput{+ Database: "employee_db",+ Statement: "SELECT id, ssn, email FROM users",+ })+ require.NoError(t, err)+ require.False(t, result.IsError)++ output, ok := structured.(*QueryOutput)+ require.True(t, ok)+ require.Equal(t, []MaskedColumn{+ {Column: "ssn", Index: 1, SemanticType: "SSN", Algorithm: "Full mask", Context: "Global masking rule: PII"},+ {Column: "email", Index: 2, SemanticType: "Email", Algorithm: "Partial mask", Context: "Column-level semantic type: Email"},+ }, output.MaskedColumns)+ require.Empty(t, output.AppliedAccessGrant)++ text := result.Content[0].(*mcpsdk.TextContent).Text+ require.Contains(t, text, "Masked columns: ssn, email.\n")+ require.Contains(t, text, `"maskedColumns":[{"column":"ssn","index":1,`)+}++func TestQueryDatabase_UnmaskedResultNamesNoMaskedColumns(t *testing.T) {+ databases := []map[string]any{+ makeDatabase("instances/prod-pg/databases/employee_db", "instances/prod-pg", "projects/hr-system", "POSTGRES", "ds-admin-1"),+ }+ tests := []struct {+ name string+ masked []*v1pb.MaskingReason+ wantOnWire any+ }{+ {+ name: "masking ran and masked nothing",+ masked: []*v1pb.MaskingReason{nil, nil},+ wantOnWire: []any{map[string]any{}, map[string]any{}},+ },+ {+ name: "masking did not run",+ wantOnWire: nil,+ },+ }+ for _, tc := range tests {+ t.Run(tc.name, func(t *testing.T) {+ qr := protoQueryResponse(t, &v1pb.QueryResponse{+ Results: []*v1pb.QueryResult{{+ ColumnNames: []string{"id", "name"},+ ColumnTypeNames: []string{"int4", "varchar"},+ Rows: []*v1pb.QueryRow{{Values: []*v1pb.RowValue{+ {Kind: &v1pb.RowValue_Int32Value{Int32Value: 1}},+ {Kind: &v1pb.RowValue_StringValue{StringValue: "John"}},+ }}},+ Masked: tc.masked,+ }},+ })+ results, ok := qr["results"].([]any)+ require.True(t, ok)+ wire, ok := results[0].(map[string]any)+ require.True(t, ok)+ require.Equal(t, tc.wantOnWire, wire["masked"])+ s := newTestServerWithMock(t, mockQueryServer(databases, qr))++ result, structured, err := s.handleQueryDatabase(testContext(), nil, QueryInput{+ Database: "employee_db",+ Statement: "SELECT id, name FROM users",+ })+ require.NoError(t, err)+ require.False(t, result.IsError)++ output, ok := structured.(*QueryOutput)+ require.True(t, ok)+ require.Empty(t, output.MaskedColumns)++ text := result.Content[0].(*mcpsdk.TextContent).Text+ require.NotContains(t, text, "Masked columns")+ require.NotContains(t, text, "maskedColumns")+ require.NotContains(t, text, "appliedAccessGrant")+ })+ }+}++func TestQueryDatabase_AppliedAccessGrantPassesThrough(t *testing.T) {+ const grant = "projects/hr-system/accessGrants/g1"+ databases := []map[string]any{+ makeDatabase("instances/prod-pg/databases/employee_db", "instances/prod-pg", "projects/hr-system", "POSTGRES", "ds-admin-1"),+ }+ qr := protoQueryResponse(t, &v1pb.QueryResponse{+ Results: []*v1pb.QueryResult{{+ ColumnNames: []string{"ssn"},+ ColumnTypeNames: []string{"varchar"},+ Rows: []*v1pb.QueryRow{{Values: []*v1pb.RowValue{+ {Kind: &v1pb.RowValue_StringValue{StringValue: "123-45-6789"}},+ }}},+ }},+ AppliedAccessGrant: grant,+ })+ s := newTestServerWithMock(t, mockQueryServer(databases, qr))++ result, structured, err := s.handleQueryDatabase(testContext(), nil, QueryInput{+ Database: "employee_db",+ Statement: "SELECT ssn FROM users",+ })+ require.NoError(t, err)+ require.False(t, result.IsError)++ output, ok := structured.(*QueryOutput)+ require.True(t, ok)+ require.Equal(t, grant, output.AppliedAccessGrant)+ require.Empty(t, output.MaskedColumns)++ text := result.Content[0].(*mcpsdk.TextContent).Text+ require.Contains(t, text, `"appliedAccessGrant":"`+grant+`"`)+ require.NotContains(t, text, "Masked columns")+}++func TestQueryDatabase_ForwardsSchemaAndContainerOnlyWhenSet(t *testing.T) {+ databases := []map[string]any{+ makeDatabase("instances/prod-pg/databases/employee_db", "instances/prod-pg", "projects/hr-system", "POSTGRES", "ds-admin-1"),+ }+ tests := []struct {+ name string+ schema string+ container string+ }{+ {name: "neither"},+ {name: "schema", schema: "public"},+ {name: "container", container: "employee"},+ {name: "both", schema: "public", container: "employee"},+ }+ for _, tc := range tests {+ t.Run(tc.name, func(t *testing.T) {+ // require must not run on the transport's goroutine, so the handler+ // only records the body.+ var queryBody []byte+ listHandler := mockListDatabases(databases)+ handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if strings.Contains(r.URL.Path, "SQLService/Query") {+ queryBody, _ = io.ReadAll(r.Body)+ w.Header().Set("Content-Type", "application/json")+ _ = json.NewEncoder(w).Encode(makeQueryResponse([]string{"id"}, []string{"int4"}, [][]any{{"1"}}, "0.001s"))+ return+ }+ listHandler.ServeHTTP(w, r)+ })+ s := newTestServerWithMock(t, handler)++ result, _, err := s.handleQueryDatabase(testContext(), nil, QueryInput{+ Database: "employee_db",+ Statement: "SELECT id FROM users",+ Schema: tc.schema,+ Container: tc.container,+ })+ require.NoError(t, err)+ require.False(t, result.IsError)++ // The server decodes the body with DiscardUnknown too, so a misnamed+ // key would lose the value without an error.+ var request v1pb.QueryRequest+ require.NoError(t, common.ProtojsonUnmarshaler.Unmarshal(queryBody, &request))+ for _, field := range []struct {+ name string+ want string+ got *string+ }{+ {name: "schema", want: tc.schema, got: request.Schema},+ {name: "container", want: tc.container, got: request.Container},+ } {+ if field.want == "" {+ require.Nil(t, field.got, "%s must be left out when unset, not sent empty", field.name)+ continue+ }+ require.NotNil(t, field.got, "%s must reach QueryRequest.%s", field.name, field.name)+ require.Equal(t, field.want, *field.got)+ }+ })+ }+}diff --git a/backend/api/v1/sql_service_access_grant_test.go b/backend/api/v1/sql_service_access_grant_test.goindex 3ac77954dd..d79ff770ab 100644--- a/backend/api/v1/sql_service_access_grant_test.go+++ b/backend/api/v1/sql_service_access_grant_test.go@@ -18,11 +18,15 @@ func TestPreCheckAccessQueryHash(t *testing.T) {t.Parallel()longSQL := "SELECT '" + strings.Repeat("x", 110_000) + "' AS v"for _, tc := range []struct {- name string- approved string- statement string- dropHash bool- want bool+ name string+ approved string+ statement string+ dropHash bool+ grantSchema string+ grantContainer string+ schema *string+ container string+ want bool}{{name: "plain", approved: "SELECT 1", statement: "SELECT 1", want: true},{name: "boundary whitespace", approved: "\v\fSELECT 1\r\n", statement: " \tSELECT 1\n", want: true},@@ -33,6 +37,9 @@ func TestPreCheckAccessQueryHash(t *testing.T) {{name: "Unicode boundary", approved: "\u00a0SELECT 1", statement: "SELECT 1"},{name: "missing stored hash", approved: "SELECT 1", statement: "SELECT 1", dropHash: true},{name: "write statement", approved: "DELETE FROM t", statement: "DELETE FROM t"},+ {name: "grant schema, query without", approved: "SELECT 1", statement: "SELECT 1", grantSchema: "public"},+ {name: "grant schema, query with it", approved: "SELECT 1", statement: "SELECT 1", grantSchema: "public", schema: new("public"), want: true},+ {name: "grant container, query with it", approved: "SELECT 1", statement: "SELECT 1", grantContainer: "employee", container: "employee", want: true},} {t.Run(tc.name, func(t *testing.T) {t.Parallel()@@ -49,6 +56,7 @@ func TestPreCheckAccessQueryHash(t *testing.T) {ProjectID: "grant-project", Creator: "[email protected]", Status: storepb.AccessGrant_ACTIVE, ExpireTime: &expires,Payload: &storepb.AccessGrantPayload{Query: tc.approved, Targets: []string{"instances/test/databases/db"}, Export: true, Unmask: true,+ Schema: tc.grantSchema, Container: tc.grantContainer,},})require.NoError(t, err)@@ -61,7 +69,7 @@ func TestPreCheckAccessQueryHash(t *testing.T) {instance := &store.InstanceMessage{ResourceID: "test", Metadata: &storepb.Instance{Engine: storepb.Engine_POSTGRES}}database := &store.DatabaseMessage{ProjectID: "grant-project", InstanceID: "test", DatabaseName: "db"}for _, requireExport := range []bool{false, true} {- got := service.preCheckAccess(ctx, tc.statement, instance, database, nil, "", requireExport)+ got := service.preCheckAccess(ctx, tc.statement, instance, database, tc.schema, tc.container, requireExport)if tc.want {require.NotNil(t, got)require.Equal(t, grant.ID, got.ID)diff --git a/backend/tests/mcp_masking_test.go b/backend/tests/mcp_masking_test.goindex 41e55eb1e5..90875b68eb 100644--- a/backend/tests/mcp_masking_test.go+++ b/backend/tests/mcp_masking_test.go@@ -426,13 +426,21 @@ func TestMCPMaskingFollowsTheCallersProvisioning(t *testing.T) {Name: exemption,}))a.NoError(err)- a.Equal(maskPlaceholder, f.agentReadsSecret(t, f.session),+ masked := queryDatabaseOnSession(f.ctx, t, f.session, f.name, secretQuery)+ a.False(masked.isError, masked.text)+ a.Equal([][]any{{maskPlaceholder}}, masked.output.Rows,"precondition: without the exemption the column masks again")+ a.Len(masked.output.MaskedColumns, 1)+ a.Equal("secret", masked.output.MaskedColumns[0].Column, "the agent is told which column is masked")f.grantUnmask(t, true /* export */)a.Equal(maskedSecret, f.consoleReadsSecret(t), "the grant unmasks in the console")- a.Equal(maskedSecret, f.agentReadsSecret(t, f.session),+ granted := queryDatabaseOnSession(f.ctx, t, f.session, f.name, secretQuery)+ a.False(granted.isError, granted.text)+ a.Equal([][]any{{maskedSecret}}, granted.output.Rows,"and the same grant unmasks the caller's MCP session")+ a.Empty(granted.output.MaskedColumns)+ a.NotEmpty(granted.output.AppliedAccessGrant, "the agent can tell a grant applied")a.Contains(f.consoleExportsCSV(t), maskedSecret,"the grant exports in the clear from the console")a.Contains(f.agentExportsCSV(t, f.session), maskedSecret,diff --git a/backend/tests/mcp_sql_clamp_test.go b/backend/tests/mcp_sql_clamp_test.goindex 9850f1fda1..9cc21527f0 100644--- a/backend/tests/mcp_sql_clamp_test.go+++ b/backend/tests/mcp_sql_clamp_test.go@@ -30,8 +30,12 @@ type queryToolResult struct {// QueryToolOutput mirrors the tool's structured output. Only the fields these// tests assert on are named.type QueryToolOutput struct {- Rows [][]any `json:"rows"`- RowCount int `json:"rowCount"`+ Rows [][]any `json:"rows"`+ RowCount int `json:"rowCount"`+ MaskedColumns []struct {+ Column string `json:"column"`+ } `json:"maskedColumns"`+ AppliedAccessGrant string `json:"appliedAccessGrant"`}// queryDatabaseOnSession runs the query_database tool the way a client would.