Merge branch 'main' into toolbox

Author: bhsu22

.github/workflows/ash-security-comment.yml

@@ -16,13 +16,18 @@ jobs:
     if: github.event.workflow_run.event == 'pull_request'
     steps:
       - name: Download artifacts
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
         with:
           name: ash-security-results
           path: /tmp/ash-results
           run-id: ${{ github.event.workflow_run.id }}
           github-token: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Debug artifact contents
+        run: |
+          echo "Artifact contents:"
+          find /tmp/ash-results -type f | head -20
+
       - name: Get PR information
         id: pr-info
         run: |
@@ -49,6 +54,8 @@ jobs:
           script: |
             const fs = require('fs');
             const commentPath = '/tmp/ash-results/pr_comment.md';
+            console.log('Looking for comment file at:', commentPath);
+            console.log('File exists:', fs.existsSync(commentPath));
 
             if (!fs.existsSync(commentPath)) {
               console.log('No comment file found in artifacts');

.github/workflows/ash-security-scan.yml

@@ -19,7 +19,7 @@ jobs:
 
       - name: Get changed files
         id: changed-files
-        uses: tj-actions/changed-files@ed68ef82c095e0d48ec87eccea555d944a631a4c # v46
+        uses: tj-actions/changed-files@22103cc46bda19c2b464ffe86db46df6922fd323 # v47.0.5
         with:
           files: |
             **/*.py
@@ -202,25 +202,24 @@ jobs:
             echo "has_findings=false" >> "$GITHUB_OUTPUT"
           fi
 
-      - name: Save PR metadata
+      - name: Prepare artifacts
         if: steps.changed-files.outputs.any_changed == 'true'
         env:
           PR_NUMBER: ${{ github.event.pull_request.number }}
           PR_SHA: ${{ github.event.pull_request.head.sha }}
         run: |
-          echo "${PR_NUMBER}" > /tmp/pr_number.txt
-          echo "${PR_SHA}" > /tmp/pr_sha.txt
+          mkdir -p /tmp/ash-artifacts
+          echo "${PR_NUMBER}" > /tmp/ash-artifacts/pr_number.txt
+          echo "${PR_SHA}" > /tmp/ash-artifacts/pr_sha.txt
+          cp /tmp/pr_comment.md /tmp/ash-artifacts/pr_comment.md
+          cp -r /tmp/ash-scan/.ash/ /tmp/ash-artifacts/.ash/ 2>/dev/null || true
 
       - name: Upload ASH results and PR metadata
         if: steps.changed-files.outputs.any_changed == 'true' && always()
         uses: actions/upload-artifact@v4
         with:
           name: ash-security-results
-          path: |
-            /tmp/ash-scan/.ash/
-            /tmp/pr_comment.md
-            /tmp/pr_number.txt
-            /tmp/pr_sha.txt
+          path: /tmp/ash-artifacts/
           retention-days: 30
 
       - name: Security scan summary

.github/workflows/dependabot.yml

@@ -1,8 +1,8 @@
 name: Dependabot auto-merge
 
 on:
-  pull_request:
-    types: [opened, synchronize]
+  pull_request_target:
+    types: [opened, synchronize, reopened]
 
 permissions:
   pull-requests: write
@@ -11,7 +11,7 @@ permissions:
 jobs:
   dependabot:
     runs-on: ubuntu-latest
-    if: github.event.pull_request.user.login == 'dependabot[bot]'
+    if: github.actor == 'dependabot[bot]'
     steps:
       - name: Dependabot metadata
         id: metadata

.github/workflows/label.yml

@@ -2,6 +2,10 @@ name: Labeler
 
 on: [pull_request_target]
 
+permissions:
+  contents: read
+  pull-requests: write
+
 jobs:
   label:
     runs-on: ubuntu-latest

.github/workflows/repo-stats.yml

@@ -10,6 +10,9 @@ on:
         - cron: "0 11 * * *"
     workflow_dispatch: # Allow manual triggering from the Actions tab.
 
+permissions:
+    contents: write
+
 jobs:
     collect-stats:
         name: collect-repo-stats

docker/Dockerfile.frontend.dev

@@ -17,5 +17,12 @@ COPY . .
 # Expose port
 EXPOSE 3000
 
+# Run as non-root user (node user is built into node:20-alpine)
+USER node
+
+# Healthcheck for container orchestration (dev server)
+HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
+  CMD wget -qO- http://localhost:3000/ || exit 1
+
 # Start development server (--host exposes to Docker network)
 CMD ["npm", "run", "dev", "--", "--host"]

docs/AGENTCORE_EVALUATIONS_GUIDE.md

@@ -481,7 +481,7 @@ Each log event contains a JSON object with OpenTelemetry-style attributes:
     "gen_ai.evaluation.score.label": "Very Helpful",
     "gen_ai.evaluation.explanation": "The response directly addresses the user's question with relevant and actionable information..."
   },
-  "traceId": "abc123def456",
+  "traceId": "abc123def456",  // pragma: allowlist secret (example placeholder, not a real secret)
   "spanId": "789ghi",
   "sessionId": "session-456",
   "timestamp": "2026-02-17T00:42:42.086Z"

docs/AGUI_INTEGRATION.md

@@ -0,0 +1,128 @@
+# AG-UI Protocol Integration
+
+Guide for using the AG-UI (Agent-User Interaction) protocol patterns in FAST.
+
+---
+
+## Overview
+
+[AG-UI](https://docs.ag-ui.com/concepts/overview) is an open protocol that defines a standard SSE event format for agent-to-frontend communication. Instead of each framework emitting its own event schema (Strands events, LangChain message chunks, etc.), AG-UI provides a unified event vocabulary: `TEXT_MESSAGE_CONTENT`, `TOOL_CALL_START`, `TOOL_CALL_ARGS`, `TOOL_CALL_RESULT`, `RUN_FINISHED`, and so on.
+
+FAST includes two AG-UI agent patterns:
+
+| Pattern | Framework | Location |
+|---------|-----------|----------|
+| `agui-strands-agent` | Strands + `ag-ui-strands` | `agent_patterns/agui-strands-agent/` |
+| `agui-langgraph-agent` | LangGraph + `copilotkit` | `agent_patterns/agui-langgraph-agent/` |
+
+Both patterns use `BedrockAgentCoreApp` as the entrypoint (same as the HTTP patterns), which means AgentCore Runtime headers (WorkloadAccessToken, Authorization, Session-Id) are available for Gateway auth, Memory, and secure user identity extraction.
+
+---
+
+## How It Works
+
+### Architecture
+
+```
+Frontend (Amplify)
+  │
+  │  POST /invocations  (AG-UI RunAgentInput payload)
+  ▼
+AgentCore Runtime
+  │
+  │  Proxies request to container port 8080
+  │  Injects: WorkloadAccessToken, Authorization, Session-Id headers
+  ▼
+Agent Container
+  │
+  │  BedrockAgentCoreApp reads headers → sets ContextVars
+  │  @entrypoint handler creates agent, runs it
+  ▼
+AG-UI Wrapper (StrandsAgent / LangGraphAGUIAgent)
+  │
+  │  Translates framework events → AG-UI SSE events
+  ▼
+Frontend Parser (parsers/agui.ts)
+  │
+  │  Maps AG-UI events → StreamEvent types
+  ▼
+ChatInterface.tsx renders messages
+```
+
+### Request Flow
+
+1. The frontend sends an AG-UI `RunAgentInput` payload (with `threadId`, `messages`, `runId`)
+2. AgentCore Runtime proxies the request, injecting auth headers
+3. `BedrockAgentCoreApp` reads headers and populates `BedrockAgentCoreContext` (ContextVars)
+4. The `@entrypoint` handler extracts user identity from the JWT, creates the agent with Memory and Gateway tools
+5. The AG-UI wrapper translates framework streaming events into AG-UI SSE events
+6. The frontend `parseAguiChunk` parser maps AG-UI events to the shared `StreamEvent` types
+
+### AG-UI vs HTTP Protocol on AgentCore Runtime
+
+AgentCore Runtime supports both `HTTP` and `AGUI` server protocols. The difference is minimal: with `AGUI`, platform-level errors are returned as AG-UI-compliant `RUN_ERROR` events in the SSE stream (HTTP 200) instead of HTTP error codes. Everything else — auth, session headers, payload passthrough — is identical.
+
+The AG-UI patterns in FAST deploy with `HTTP` protocol, which works correctly because the agent container handles AG-UI event formatting internally.
+
+---
+
+## Agent Patterns
+
+### AG-UI Strands (`agui-strands-agent`)
+
+**Location**: `agent_patterns/agui-strands-agent/`
+
+Uses `ag-ui-strands` (`StrandsAgent`) to wrap a Strands `Agent`. The agent is created per-request inside the `@entrypoint` handler, ensuring each request gets a fresh `Agent` with the correct `session_manager` and fresh MCP client connections.
+
+**Includes**: AgentCore Memory, Gateway MCP tools, Code Interpreter, AG-UI SSE streaming.
+
+### AG-UI LangGraph (`agui-langgraph-agent`)
+
+**Location**: `agent_patterns/agui-langgraph-agent/`
+
+Uses the `copilotkit` python library (`LangGraphAGUIAgent`) to wrap a LangGraph compiled graph. Uses `ActorAwareLangGraphAgent`, a subclass that rebuilds the graph per-request to ensure fresh Gateway MCP tool connections with valid tokens.
+
+**Includes**: AgentCore Memory (checkpointer), Gateway MCP tools, Code Interpreter, CopilotKit middleware, AG-UI SSE streaming.
+
+---
+
+## Frontend
+
+### Parser Auto-Selection
+
+The AG-UI parser is automatically selected based on the pattern name prefix. Any pattern starting with `agui-` uses the AG-UI parser (`parsers/agui.ts`). Unlike the HTTP patterns — which each require a framework-specific parser (Strands, LangGraph, Claude) to handle their different streaming formats — all AG-UI patterns share a single parser. This is one of the key benefits of the AG-UI protocol: the backend framework is abstracted away behind a standard event vocabulary, so the frontend doesn't need to know whether the agent uses Strands or LangGraph.
+
+See `frontend/src/lib/agentcore-client/client.ts` for the parser selection logic and `infra-cdk/config.yaml` comments for the full prefix-to-parser mapping.
+
+### AG-UI Payload Format
+
+The frontend automatically sends the correct payload format based on the pattern prefix. AG-UI patterns receive a `RunAgentInput` payload (with `threadId`, `messages`, `runId`), while HTTP patterns receive the standard `{ prompt, runtimeSessionId }` format. This is handled by `AgentCoreClient.invoke()`.
+
+---
+
+## Deployment
+
+Set the pattern in `infra-cdk/config.yaml`:
+
+```yaml
+backend:
+  pattern: agui-strands-agent    # or agui-langgraph-agent
+  deployment_type: docker
+```
+
+No CDK changes are required. The AG-UI patterns deploy as standard HTTP containers on AgentCore Runtime.
+
+---
+
+## CopilotKit Integration
+
+[CopilotKit](https://www.copilotkit.ai/) is a React UI library that natively understands the AG-UI protocol. While FAST's built-in frontend includes a lightweight AG-UI parser for basic chat streaming, CopilotKit provides a richer set of capabilities for building agent-powered applications. Fullstack FAST applications with deeper CopilotKit integration can be found in the FAST samples repository (coming soon).
+
+---
+
+## Additional Resources
+
+- [AG-UI Protocol Documentation](https://docs.ag-ui.com/concepts/overview)
+- [ag-ui-strands on PyPI](https://pypi.org/project/ag-ui-strands/)
+- [CopilotKit Documentation](https://docs.copilotkit.ai/)
+- [Strands AG-UI Integration Guide](https://strandsagents.com/docs/community/integrations/ag-ui/)