coder · SasSwart · Aug 3, 2026 · Jul 22, 2026 · Jul 23, 2026 · Jul 28, 2026
diff --git a/coderd/apidoc/docs.go b/coderd/apidoc/docs.go
diff --git a/coderd/apidoc/swagger.json b/coderd/apidoc/swagger.json
diff --git a/coderd/database/db2sdk/db2sdk.go b/coderd/database/db2sdk/db2sdk.go
@@ -1142,34 +1142,43 @@ func AIBridgeSession(row database.ListAIBridgeSessionsRow) codersdk.AIBridgeSess
 	return session
 }
 
+// AIBridgeSessionThreadsParams groups the session row and its subresources for
+// AIBridgeSessionThreads. Named fields avoid transposing the several adjacent
+// slice arguments (notably TopDomains and NetworkCalls) at the call site.
+type AIBridgeSessionThreadsParams struct {
+	Session       database.ListAIBridgeSessionsRow
+	Interceptions []database.ListAIBridgeSessionThreadsRow
+	TokenUsages   []database.AIBridgeTokenUsage
+	ToolUsages    []database.AIBridgeToolUsage
+	UserPrompts   []database.AIBridgeUserPrompt
+	ModelThoughts []database.AIBridgeModelThought
+	TopDomains    []database.GetAIBridgeSessionTopDomainsRow
+	NetworkCalls  []database.BoundaryLog
+}
+
 // AIBridgeSessionThreads converts session metadata and thread interceptions
 // into the threads response. It groups interceptions into threads, builds
 // agentic actions from tool usages and model thoughts, and aggregates
 // token usage with metadata.
-func AIBridgeSessionThreads(
-	session database.ListAIBridgeSessionsRow,
-	interceptions []database.ListAIBridgeSessionThreadsRow,
-	tokenUsages []database.AIBridgeTokenUsage,
-	toolUsages []database.AIBridgeToolUsage,
-	userPrompts []database.AIBridgeUserPrompt,
-	modelThoughts []database.AIBridgeModelThought,
-	topDomains []database.GetAIBridgeSessionTopDomainsRow,
-) codersdk.AIBridgeSessionThreadsResponse {
+func AIBridgeSessionThreads(p AIBridgeSessionThreadsParams) codersdk.AIBridgeSessionThreadsResponse {
+	session := p.Session
+	interceptions := p.Interceptions
+
 	// Index subresources by interception ID.
 	tokensByInterception := make(map[uuid.UUID][]database.AIBridgeTokenUsage, len(interceptions))
-	for _, tu := range tokenUsages {
+	for _, tu := range p.TokenUsages {
 		tokensByInterception[tu.InterceptionID] = append(tokensByInterception[tu.InterceptionID], tu)
 	}
 	toolsByInterception := make(map[uuid.UUID][]database.AIBridgeToolUsage, len(interceptions))
-	for _, tu := range toolUsages {
+	for _, tu := range p.ToolUsages {
 		toolsByInterception[tu.InterceptionID] = append(toolsByInterception[tu.InterceptionID], tu)
 	}
 	promptsByInterception := make(map[uuid.UUID][]database.AIBridgeUserPrompt, len(interceptions))
-	for _, up := range userPrompts {
+	for _, up := range p.UserPrompts {
 		promptsByInterception[up.InterceptionID] = append(promptsByInterception[up.InterceptionID], up)
 	}
 	thoughtsByInterception := make(map[uuid.UUID][]database.AIBridgeModelThought, len(interceptions))
-	for _, mt := range modelThoughts {
+	for _, mt := range p.ModelThoughts {
 		thoughtsByInterception[mt.InterceptionID] = append(thoughtsByInterception[mt.InterceptionID], mt)
 	}
 
@@ -1207,7 +1216,7 @@ func AIBridgeSessionThreads(
 
 	// Aggregate session-level token usage metadata from all token
 	// usages in the session (not just the page).
-	sessionTokenMeta := aggregateTokenMetadata(tokenUsages)
+	sessionTokenMeta := aggregateTokenMetadata(p.TokenUsages)
 
 	resp := codersdk.AIBridgeSessionThreadsResponse{
 		ID: session.SessionID,
@@ -1253,7 +1262,7 @@ func AIBridgeSessionThreads(
 			Blocked: session.NetworkCallsBlocked,
 		}
 	}
-	for _, d := range topDomains {
+	for _, d := range p.TopDomains {
 		resp.NetworkTopDomains = append(resp.NetworkTopDomains, codersdk.AIBridgeSessionNetworkDomain{
 			Domain: d.Domain,
 			Count:  d.Count,
@@ -1262,9 +1271,34 @@ func AIBridgeSessionThreads(
 		// from the last row processed.
 		resp.NetworkDomainCount = d.TotalDomains
 	}
+	resp.NetworkCallLogs = AgentFirewallLogs(p.NetworkCalls)
 	return resp
 }
 
+// AgentFirewallLogs converts boundary logs to their SDK representation.
+// Allowed is derived from MatchedRule being non-NULL.
+func AgentFirewallLogs(logs []database.BoundaryLog) []codersdk.AgentFirewallLog {
+	results := make([]codersdk.AgentFirewallLog, 0, len(logs))
+	for _, l := range logs {
+		bl := codersdk.AgentFirewallLog{
+			ID:             l.ID,
+			SessionID:      l.SessionID,
+			SequenceNumber: l.SequenceNumber,
+			Allowed:        l.MatchedRule.Valid,
+			CreatedAt:      l.CreatedAt,
+			Proto:          l.Proto,
+			Method:         l.Method,
+			Detail:         l.Detail,
+			CapturedAt:     &l.CapturedAt,
+		}
+		if l.MatchedRule.Valid {
+			bl.MatchedRule = &l.MatchedRule.String
+		}
+		results = append(results, bl)
+	}
+	return results
+}
+
 func buildAIBridgeThread(
 	threadID uuid.UUID,
 	interceptions []database.AIBridgeInterception,

diff --git a/coderd/database/dbauthz/dbauthz.go b/coderd/database/dbauthz/dbauthz.go
@@ -6836,6 +6836,13 @@ func (q *querier) ListAIBridgeModels(ctx context.Context, arg database.ListAIBri
 	return q.db.ListAuthorizedAIBridgeModels(ctx, arg, prep)
 }
 
+func (q *querier) ListAIBridgeSessionNetworkCalls(ctx context.Context, arg database.ListAIBridgeSessionNetworkCallsParams) ([]database.BoundaryLog, error) {
+	if err := q.authorizeContext(ctx, policy.ActionRead, rbac.ResourceAibridgeInterception); err != nil {
+		return nil, err
+	}
+	return q.db.ListAIBridgeSessionNetworkCalls(ctx, arg)
+}
+
 func (q *querier) ListAIBridgeSessionThreads(ctx context.Context, arg database.ListAIBridgeSessionThreadsParams) ([]database.ListAIBridgeSessionThreadsRow, error) {
 	prep, err := prepareSQLFilter(ctx, q.auth, policy.ActionRead, rbac.ResourceAibridgeInterception.Type)
 	if err != nil {

diff --git a/coderd/database/dbauthz/dbauthz_test.go b/coderd/database/dbauthz/dbauthz_test.go
@@ -6975,6 +6975,12 @@ func (s *MethodTestSuite) TestAIBridge() {
 		check.Args(params).Asserts(rbac.ResourceAibridgeInterception, policy.ActionRead).Returns([]database.GetAIBridgeSessionTopDomainsRow{})
 	}))
 
+	s.Run("ListAIBridgeSessionNetworkCalls", s.Mocked(func(db *dbmock.MockStore, faker *gofakeit.Faker, check *expects) {
+		params := database.ListAIBridgeSessionNetworkCallsParams{SessionID: "sess", Limit: 1000}
+		db.EXPECT().ListAIBridgeSessionNetworkCalls(gomock.Any(), params).Return([]database.BoundaryLog{}, nil).AnyTimes()
+		check.Args(params).Asserts(rbac.ResourceAibridgeInterception, policy.ActionRead).Returns([]database.BoundaryLog{})
+	}))
+
 	s.Run("ListAIBridgeTokenUsagesByInterceptionIDs", s.Mocked(func(db *dbmock.MockStore, faker *gofakeit.Faker, check *expects) {
 		ids := []uuid.UUID{{1}}
 		db.EXPECT().ListAIBridgeTokenUsagesByInterceptionIDs(gomock.Any(), ids).Return([]database.AIBridgeTokenUsage{}, nil).AnyTimes()

diff --git a/coderd/database/dbmetrics/querymetrics.go b/coderd/database/dbmetrics/querymetrics.go
diff --git a/coderd/database/dbmock/dbmock.go b/coderd/database/dbmock/dbmock.go
diff --git a/coderd/database/querier.go b/coderd/database/querier.go
diff --git a/coderd/database/queries.sql.go b/coderd/database/queries.sql.go
diff --git a/coderd/database/queries/aibridge.sql b/coderd/database/queries/aibridge.sql
@@ -618,6 +618,45 @@ FROM domains
 ORDER BY count DESC, domain ASC
 LIMIT COALESCE(NULLIF(@limit_::integer, 0), 5);
 
+-- name: ListAIBridgeSessionNetworkCalls :many
+-- Returns the individual Agent Firewall network calls made during an AI
+-- session, ordered chronologically. All protocols are included, unlike
+-- GetAIBridgeSessionTopDomains which considers only HTTP egress, so the list
+-- covers the same events the network_calls summary in ListAIBridgeSessions
+-- counts. The list is capped at @limit_ rows, so its length equals the summary
+-- total only for sessions at or below the cap. The summary stays authoritative
+-- for whole-session totals.
+--
+-- Windowing mirrors that summary and GetAIBridgeSessionTopDomains: each
+-- interception's boundary logs fall in the open interval (this seq, next
+-- interception's seq) within the same firewall session. The exclusive lower
+-- bound drops the interception's own LLM-provider call. next_seq considers all
+-- interceptions in the firewall session so windows never bleed across AI
+-- sessions that share one firewall session, and falls back to the maximum
+-- sequence_number for the last interception so the window stays an
+-- index-satisfiable range.
+SELECT bl.*
+FROM aibridge_interceptions afi
+LEFT JOIN LATERAL (
+	SELECT COALESCE(MIN(nxt.agent_firewall_sequence_number), 2147483647) AS next_seq
+	FROM aibridge_interceptions nxt
+	WHERE nxt.agent_firewall_session_id = afi.agent_firewall_session_id
+		AND nxt.agent_firewall_sequence_number > afi.agent_firewall_sequence_number
+) w ON true
+JOIN boundary_logs bl
+	ON bl.session_id = afi.agent_firewall_session_id
+	AND bl.sequence_number > afi.agent_firewall_sequence_number
+	AND bl.sequence_number < w.next_seq
+WHERE afi.session_id = @session_id::text
+	AND afi.ended_at IS NOT NULL
+	AND afi.agent_firewall_session_id IS NOT NULL
+	AND afi.agent_firewall_sequence_number IS NOT NULL
+-- created_at leads because a session can span several firewall sessions, whose
+-- sequence numbers are independent streams. id breaks remaining ties so the row
+-- that lands on the limit boundary is stable across identical requests.
+ORDER BY bl.created_at ASC, bl.sequence_number ASC, bl.id ASC
+LIMIT COALESCE(NULLIF(@limit_::integer, 0), 1000);
+
 -- name: ListAIBridgeSessionThreads :many
 -- Returns all interceptions belonging to paginated threads within a session.
 -- Threads are paginated by (started_at, thread_id) cursor.

diff --git a/codersdk/aibridge.go b/codersdk/aibridge.go
@@ -202,7 +202,13 @@ type AIBridgeSessionThreadsResponse struct {
 	// domains, used to render a "+N more" overflow beyond the listed domains.
 	NetworkTopDomains  []AIBridgeSessionNetworkDomain `json:"network_top_domains,omitempty"`
 	NetworkDomainCount int64                          `json:"network_domain_count,omitempty"`
-	Threads            []AIBridgeThread               `json:"threads"`
+	// NetworkCallLogs is the chronological list of individual network calls made
+	// during the session, holding the earliest calls up to a server-side cap.
+	// NetworkCalls remains authoritative for whole-session totals, so a shorter
+	// list than NetworkCalls.Total means the list was truncated. Empty when the
+	// session did not pass through Agent Firewall.
+	NetworkCallLogs []AgentFirewallLog `json:"network_call_logs,omitempty"`
+	Threads         []AIBridgeThread   `json:"threads"`
 }
 
 // AIBridgeSessionThreadsTokenUsage represents aggregated token usage

diff --git a/docs/reference/api/aigateway.md b/docs/reference/api/aigateway.md