feat: add workflow results endpoints and UI integration

- Implemented new backend endpoints for retrieving workflow results:
  - `GET /content/workflow-results` for fetching results based on session.
  - `GET /api/projects/:projectName/agentic-sessions/:sessionName/workflow/results` for project-specific results.

- Updated frontend to display workflow results in a tabbed interface, allowing users to view output files and their statuses.
- Enhanced the `useWorkflowResults` hook for fetching results with polling every 5 seconds.

These changes improve the user experience by providing access to workflow output files directly within the session interface.

Author: Gkrumbach07

components/backend/handlers/content.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/base64"
 	"encoding/json"
+	"fmt"
 	"log"
 	"net/http"
 	"os"
@@ -601,10 +602,11 @@ func parseFrontmatter(filePath string) map[string]string {
 
 // AmbientConfig represents the ambient.json configuration
 type AmbientConfig struct {
-	Name         string `json:"name"`
-	Description  string `json:"description"`
-	SystemPrompt string `json:"systemPrompt"`
-	ArtifactsDir string `json:"artifactsDir"`
+	Name         string            `json:"name"`
+	Description  string            `json:"description"`
+	SystemPrompt string            `json:"systemPrompt"`
+	ArtifactsDir string            `json:"artifactsDir"`
+	Results      map[string]string `json:"results,omitempty"` // displayName -> glob pattern
 }
 
 // parseAmbientConfig reads and parses ambient.json from workflow directory
@@ -640,6 +642,83 @@ func parseAmbientConfig(workflowDir string) *AmbientConfig {
 	return &config
 }
 
+// ResultFile represents a workflow result file
+type ResultFile struct {
+	DisplayName string `json:"displayName"`
+	Path        string `json:"path"` // Relative path from workspace
+	Exists      bool   `json:"exists"`
+	Content     string `json:"content,omitempty"`
+	Error       string `json:"error,omitempty"`
+}
+
+// ContentWorkflowResults handles GET /content/workflow-results?session=
+func ContentWorkflowResults(c *gin.Context) {
+	sessionName := c.Query("session")
+	if sessionName == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"error": "missing session parameter"})
+		return
+	}
+
+	workflowDir := findActiveWorkflowDir(sessionName)
+	if workflowDir == "" {
+		c.JSON(http.StatusOK, gin.H{"results": []ResultFile{}})
+		return
+	}
+
+	ambientConfig := parseAmbientConfig(workflowDir)
+	if len(ambientConfig.Results) == 0 {
+		c.JSON(http.StatusOK, gin.H{"results": []ResultFile{}})
+		return
+	}
+
+	workspaceBase := filepath.Join(StateBaseDir, "sessions", sessionName, "workspace")
+	results := []ResultFile{}
+
+	for displayName, pattern := range ambientConfig.Results {
+		absPattern := filepath.Join(workspaceBase, pattern)
+		matches, err := filepath.Glob(absPattern)
+
+		if err != nil {
+			results = append(results, ResultFile{
+				DisplayName: displayName,
+				Path:        pattern,
+				Exists:      false,
+				Error:       fmt.Sprintf("Invalid pattern: %v", err),
+			})
+			continue
+		}
+
+		if len(matches) == 0 {
+			results = append(results, ResultFile{
+				DisplayName: displayName,
+				Path:        pattern,
+				Exists:      false,
+			})
+		} else {
+			for _, matchedPath := range matches {
+				relPath, _ := filepath.Rel(workspaceBase, matchedPath)
+				content, readErr := os.ReadFile(matchedPath)
+
+				result := ResultFile{
+					DisplayName: displayName,
+					Path:        relPath,
+					Exists:      true,
+				}
+
+				if readErr != nil {
+					result.Error = fmt.Sprintf("Failed to read: %v", readErr)
+				} else {
+					result.Content = string(content)
+				}
+
+				results = append(results, result)
+			}
+		}
+	}
+
+	c.JSON(http.StatusOK, gin.H{"results": results})
+}
+
 // findActiveWorkflowDir finds the active workflow directory for a session
 func findActiveWorkflowDir(sessionName string) string {
 	// Workflows are stored at {StateBaseDir}/sessions/{session-name}/workspace/workflows/{workflow-name}

components/backend/handlers/sessions.go

@@ -1329,6 +1329,64 @@ func GetWorkflowMetadata(c *gin.Context) {
 	c.Data(resp.StatusCode, "application/json", b)
 }
 
+// GetWorkflowResults retrieves workflow result files from the active workflow
+// GET /api/projects/:projectName/agentic-sessions/:sessionName/workflow/results
+func GetWorkflowResults(c *gin.Context) {
+	project := c.GetString("project")
+	if project == "" {
+		project = c.Param("projectName")
+	}
+	sessionName := c.Param("sessionName")
+
+	if project == "" {
+		log.Printf("GetWorkflowResults: project is empty, session=%s", sessionName)
+		c.JSON(http.StatusBadRequest, gin.H{"error": "Project namespace required"})
+		return
+	}
+
+	// Get authorization token
+	token := c.GetHeader("Authorization")
+	if strings.TrimSpace(token) == "" {
+		token = c.GetHeader("X-Forwarded-Access-Token")
+	}
+
+	// Try temp service first (for completed sessions), then regular service
+	serviceName := fmt.Sprintf("temp-content-%s", sessionName)
+	reqK8s, _ := GetK8sClientsForRequest(c)
+	if reqK8s != nil {
+		if _, err := reqK8s.CoreV1().Services(project).Get(c.Request.Context(), serviceName, v1.GetOptions{}); err != nil {
+			// Temp service doesn't exist, use regular service
+			serviceName = fmt.Sprintf("ambient-content-%s", sessionName)
+		}
+	} else {
+		serviceName = fmt.Sprintf("ambient-content-%s", sessionName)
+	}
+
+	// Build URL to content service
+	endpoint := fmt.Sprintf("http://%s.%s.svc:8080", serviceName, project)
+	u := fmt.Sprintf("%s/content/workflow-results?session=%s", endpoint, sessionName)
+
+	log.Printf("GetWorkflowResults: project=%s session=%s endpoint=%s", project, sessionName, endpoint)
+
+	// Create and send request to content pod
+	req, _ := http.NewRequestWithContext(c.Request.Context(), http.MethodGet, u, nil)
+	if strings.TrimSpace(token) != "" {
+		req.Header.Set("Authorization", token)
+	}
+	client := &http.Client{Timeout: 4 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		log.Printf("GetWorkflowResults: content service request failed: %v", err)
+		// Return empty results on error
+		c.JSON(http.StatusOK, gin.H{"results": []interface{}{}})
+		return
+	}
+	defer resp.Body.Close()
+
+	b, _ := io.ReadAll(resp.Body)
+	c.Data(resp.StatusCode, "application/json", b)
+}
+
 // fetchGitHubFileContent fetches a file from GitHub via API
 // token is optional - works for public repos without authentication (but has rate limits)
 func fetchGitHubFileContent(ctx context.Context, owner, repo, ref, path, token string) ([]byte, error) {

components/backend/routes.go

@@ -18,6 +18,7 @@ func registerContentRoutes(r *gin.Engine) {
 	r.POST("/content/git-configure-remote", handlers.ContentGitConfigureRemote)
 	r.POST("/content/git-sync", handlers.ContentGitSync)
 	r.GET("/content/workflow-metadata", handlers.ContentWorkflowMetadata)
+	r.GET("/content/workflow-results", handlers.ContentWorkflowResults)
 	r.GET("/content/git-merge-status", handlers.ContentGitMergeStatus)
 	r.POST("/content/git-pull", handlers.ContentGitPull)
 	r.POST("/content/git-push", handlers.ContentGitPushToBranch)
@@ -74,6 +75,7 @@ func registerRoutes(r *gin.Engine) {
 			projectGroup.DELETE("/agentic-sessions/:sessionName/content-pod", handlers.DeleteContentPod)
 			projectGroup.POST("/agentic-sessions/:sessionName/workflow", handlers.SelectWorkflow)
 			projectGroup.GET("/agentic-sessions/:sessionName/workflow/metadata", handlers.GetWorkflowMetadata)
+			projectGroup.GET("/agentic-sessions/:sessionName/workflow/results", handlers.GetWorkflowResults)
 			projectGroup.POST("/agentic-sessions/:sessionName/repos", handlers.AddRepo)
 			projectGroup.DELETE("/agentic-sessions/:sessionName/repos/:repoName", handlers.RemoveRepo)
 

components/frontend/package-lock.json

@@ -42,6 +42,7 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3",
     "@tailwindcss/postcss": "^4",
+    "@tailwindcss/typography": "^0.5.19",
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-dom": "^19",

components/frontend/package.json

@@ -0,0 +1,17 @@
+import { BACKEND_URL } from '@/lib/config';
+import { buildForwardHeadersAsync } from '@/lib/auth';
+
+export async function GET(
+  request: Request,
+  { params }: { params: Promise<{ name: string; sessionName: string }> },
+) {
+  const { name, sessionName } = await params;
+  const headers = await buildForwardHeadersAsync(request);
+  const resp = await fetch(
+    `${BACKEND_URL}/projects/${encodeURIComponent(name)}/agentic-sessions/${encodeURIComponent(sessionName)}/workflow/results`,
+    { headers }
+  );
+  const data = await resp.text();
+  return new Response(data, { status: resp.status, headers: { 'Content-Type': 'application/json' } });
+}
+