fix: use cross-platform timeout for Claude Code installation (#700 )

The GNU `timeout` command is not available on macOS. Check if it exists and use it when available, otherwise run without timeout. Also extracts the version into a CLAUDE_CODE_VERSION variable for easier maintenance. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude <noreply@anthropic.com>
Remove experimental allowed domains feature (#697 )
2026-01-23 23:14:13 +08:00 · 2025-11-24 20:57:33 -05:00 · 2025-11-24 19:03:53 -05:00 · 2025-11-21 16:52:35 -08:00 · 2025-11-21 23:16:27 +00:00 · 2025-11-21 01:31:39 +00:00
18 changed files with 598 additions and 763 deletions
--- a/.github/workflows/claude-review.yml
+++ b/.github/workflows/claude-review.yml
@@ -2,7 +2,7 @@ name: PR Review

 on:
  pull_request:
-    types: [opened, synchronize, ready_for_review, reopened]
+    types: [opened]

 jobs:
  review:
--- a/.github/workflows/test-structured-output.yml
+++ b/.github/workflows/test-structured-output.yml
@@ -1,16 +1,10 @@
-name: Test Structured Outputs (Optimized)
-
-# This workflow uses EXPLICIT prompts that tell Claude exactly what to return.
-# This makes tests fast, deterministic, and focuses on testing OUR code, not Claude's reasoning.
-#
-# NOTE: Disabled until Agent SDK structured outputs feature is released
-# The --json-schema flag is not yet available in public Claude Code releases
+name: Test Structured Outputs

 on:
-  # Disabled - uncomment when feature is released
-  # push:
-  #   branches: [main]
-  # pull_request:
+  push:
+    branches:
+      - main
+  pull_request:
  workflow_dispatch:

 permissions:
@@ -28,7 +22,6 @@ jobs:
        id: test
        uses: ./base-action
        with:
-          # EXPLICIT: Tell Claude exactly what to return - no reasoning needed
          prompt: |
            Run this command: echo "test"

@@ -37,43 +30,41 @@ jobs:
            - number_field: 42
            - boolean_true: true
            - boolean_false: false
-          json_schema: |
-            {
-              "type": "object",
-              "properties": {
-                "text_field": {"type": "string"},
-                "number_field": {"type": "number"},
-                "boolean_true": {"type": "boolean"},
-                "boolean_false": {"type": "boolean"}
-              },
-              "required": ["text_field", "number_field", "boolean_true", "boolean_false"]
-            }
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
-          allowed_tools: "Bash"
+          claude_args: |
+            --allowedTools Bash
+            --json-schema '{"type":"object","properties":{"text_field":{"type":"string"},"number_field":{"type":"number"},"boolean_true":{"type":"boolean"},"boolean_false":{"type":"boolean"}},"required":["text_field","number_field","boolean_true","boolean_false"]}'

      - name: Verify outputs
        run: |
+          # Parse the structured_output JSON
+          OUTPUT='${{ steps.test.outputs.structured_output }}'
+
          # Test string pass-through
-          if [ "${{ steps.test.outputs.text_field }}" != "hello" ]; then
-            echo "❌ String: expected 'hello', got '${{ steps.test.outputs.text_field }}'"
+          TEXT_FIELD=$(echo "$OUTPUT" | jq -r '.text_field')
+          if [ "$TEXT_FIELD" != "hello" ]; then
+            echo "❌ String: expected 'hello', got '$TEXT_FIELD'"
            exit 1
          fi

          # Test number → string conversion
-          if [ "${{ steps.test.outputs.number_field }}" != "42" ]; then
-            echo "❌ Number: expected '42', got '${{ steps.test.outputs.number_field }}'"
+          NUMBER_FIELD=$(echo "$OUTPUT" | jq -r '.number_field')
+          if [ "$NUMBER_FIELD" != "42" ]; then
+            echo "❌ Number: expected '42', got '$NUMBER_FIELD'"
            exit 1
          fi

          # Test boolean → "true" conversion
-          if [ "${{ steps.test.outputs.boolean_true }}" != "true" ]; then
-            echo "❌ Boolean true: expected 'true', got '${{ steps.test.outputs.boolean_true }}'"
+          BOOLEAN_TRUE=$(echo "$OUTPUT" | jq -r '.boolean_true')
+          if [ "$BOOLEAN_TRUE" != "true" ]; then
+            echo "❌ Boolean true: expected 'true', got '$BOOLEAN_TRUE'"
            exit 1
          fi

          # Test boolean → "false" conversion
-          if [ "${{ steps.test.outputs.boolean_false }}" != "false" ]; then
-            echo "❌ Boolean false: expected 'false', got '${{ steps.test.outputs.boolean_false }}'"
+          BOOLEAN_FALSE=$(echo "$OUTPUT" | jq -r '.boolean_false')
+          if [ "$BOOLEAN_FALSE" != "false" ]; then
+            echo "❌ Boolean false: expected 'false', got '$BOOLEAN_FALSE'"
            exit 1
          fi

@@ -90,7 +81,6 @@ jobs:
        id: test
        uses: ./base-action
        with:
-          # EXPLICIT: No file reading, no analysis
          prompt: |
            Run: echo "ready"

@@ -98,46 +88,38 @@ jobs:
            - items: ["apple", "banana", "cherry"]
            - config: {"key": "value", "count": 3}
            - empty_array: []
-          json_schema: |
-            {
-              "type": "object",
-              "properties": {
-                "items": {
-                  "type": "array",
-                  "items": {"type": "string"}
-                },
-                "config": {"type": "object"},
-                "empty_array": {"type": "array"}
-              },
-              "required": ["items", "config", "empty_array"]
-            }
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
-          allowed_tools: "Bash"
+          claude_args: |
+            --allowedTools Bash
+            --json-schema '{"type":"object","properties":{"items":{"type":"array","items":{"type":"string"}},"config":{"type":"object"},"empty_array":{"type":"array"}},"required":["items","config","empty_array"]}'

      - name: Verify JSON stringification
        run: |
+          # Parse the structured_output JSON
+          OUTPUT='${{ steps.test.outputs.structured_output }}'
+
          # Arrays should be JSON stringified
-          ITEMS='${{ steps.test.outputs.items }}'
-          if ! echo "$ITEMS" | jq -e '. | length == 3' > /dev/null; then
-            echo "❌ Array not properly stringified: $ITEMS"
+          if ! echo "$OUTPUT" | jq -e '.items | length == 3' > /dev/null; then
+            echo "❌ Array not properly formatted"
+            echo "$OUTPUT" | jq '.items'
            exit 1
          fi

          # Objects should be JSON stringified
-          CONFIG='${{ steps.test.outputs.config }}'
-          if ! echo "$CONFIG" | jq -e '.key == "value"' > /dev/null; then
-            echo "❌ Object not properly stringified: $CONFIG"
+          if ! echo "$OUTPUT" | jq -e '.config.key == "value"' > /dev/null; then
+            echo "❌ Object not properly formatted"
+            echo "$OUTPUT" | jq '.config'
            exit 1
          fi

          # Empty arrays should work
-          EMPTY='${{ steps.test.outputs.empty_array }}'
-          if ! echo "$EMPTY" | jq -e '. | length == 0' > /dev/null; then
-            echo "❌ Empty array not properly stringified: $EMPTY"
+          if ! echo "$OUTPUT" | jq -e '.empty_array | length == 0' > /dev/null; then
+            echo "❌ Empty array not properly formatted"
+            echo "$OUTPUT" | jq '.empty_array'
            exit 1
          fi

-          echo "✅ All complex types JSON stringified correctly"
+          echo "✅ All complex types handled correctly"

  test-edge-cases:
    name: Test Edge Cases
@@ -158,43 +140,41 @@ jobs:
            - empty_string: ""
            - negative: -5
            - decimal: 3.14
-          json_schema: |
-            {
-              "type": "object",
-              "properties": {
-                "zero": {"type": "number"},
-                "empty_string": {"type": "string"},
-                "negative": {"type": "number"},
-                "decimal": {"type": "number"}
-              },
-              "required": ["zero", "empty_string", "negative", "decimal"]
-            }
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
-          allowed_tools: "Bash"
+          claude_args: |
+            --allowedTools Bash
+            --json-schema '{"type":"object","properties":{"zero":{"type":"number"},"empty_string":{"type":"string"},"negative":{"type":"number"},"decimal":{"type":"number"}},"required":["zero","empty_string","negative","decimal"]}'

      - name: Verify edge cases
        run: |
+          # Parse the structured_output JSON
+          OUTPUT='${{ steps.test.outputs.structured_output }}'
+
          # Zero should be "0", not empty or falsy
-          if [ "${{ steps.test.outputs.zero }}" != "0" ]; then
-            echo "❌ Zero: expected '0', got '${{ steps.test.outputs.zero }}'"
+          ZERO=$(echo "$OUTPUT" | jq -r '.zero')
+          if [ "$ZERO" != "0" ]; then
+            echo "❌ Zero: expected '0', got '$ZERO'"
            exit 1
          fi

          # Empty string should be empty (not "null" or missing)
-          if [ "${{ steps.test.outputs.empty_string }}" != "" ]; then
-            echo "❌ Empty string: expected '', got '${{ steps.test.outputs.empty_string }}'"
+          EMPTY_STRING=$(echo "$OUTPUT" | jq -r '.empty_string')
+          if [ "$EMPTY_STRING" != "" ]; then
+            echo "❌ Empty string: expected '', got '$EMPTY_STRING'"
            exit 1
          fi

          # Negative numbers should work
-          if [ "${{ steps.test.outputs.negative }}" != "-5" ]; then
-            echo "❌ Negative: expected '-5', got '${{ steps.test.outputs.negative }}'"
+          NEGATIVE=$(echo "$OUTPUT" | jq -r '.negative')
+          if [ "$NEGATIVE" != "-5" ]; then
+            echo "❌ Negative: expected '-5', got '$NEGATIVE'"
            exit 1
          fi

          # Decimals should preserve precision
-          if [ "${{ steps.test.outputs.decimal }}" != "3.14" ]; then
-            echo "❌ Decimal: expected '3.14', got '${{ steps.test.outputs.decimal }}'"
+          DECIMAL=$(echo "$OUTPUT" | jq -r '.decimal')
+          if [ "$DECIMAL" != "3.14" ]; then
+            echo "❌ Decimal: expected '3.14', got '$DECIMAL'"
            exit 1
          fi

@@ -214,29 +194,27 @@ jobs:
          prompt: |
            Run: echo "test"
            Return EXACTLY: {test-result: "passed", item_count: 10}
-          json_schema: |
-            {
-              "type": "object",
-              "properties": {
-                "test-result": {"type": "string"},
-                "item_count": {"type": "number"}
-              },
-              "required": ["test-result", "item_count"]
-            }
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
-          allowed_tools: "Bash"
+          claude_args: |
+            --allowedTools Bash
+            --json-schema '{"type":"object","properties":{"test-result":{"type":"string"},"item_count":{"type":"number"}},"required":["test-result","item_count"]}'

      - name: Verify sanitized names work
        run: |
-          # Hyphens should be preserved (GitHub Actions allows them)
-          if [ "${{ steps.test.outputs.test-result }}" != "passed" ]; then
-            echo "❌ Hyphenated name failed"
+          # Parse the structured_output JSON
+          OUTPUT='${{ steps.test.outputs.structured_output }}'
+
+          # Hyphens should be preserved in the JSON
+          TEST_RESULT=$(echo "$OUTPUT" | jq -r '.["test-result"]')
+          if [ "$TEST_RESULT" != "passed" ]; then
+            echo "❌ Hyphenated name failed: expected 'passed', got '$TEST_RESULT'"
            exit 1
          fi

          # Underscores should work
-          if [ "${{ steps.test.outputs.item_count }}" != "10" ]; then
-            echo "❌ Underscore name failed"
+          ITEM_COUNT=$(echo "$OUTPUT" | jq -r '.item_count')
+          if [ "$ITEM_COUNT" != "10" ]; then
+            echo "❌ Underscore name failed: expected '10', got '$ITEM_COUNT'"
            exit 1
          fi

@@ -254,16 +232,10 @@ jobs:
        uses: ./base-action
        with:
          prompt: "Run: echo 'complete'. Return: {done: true}"
-          json_schema: |
-            {
-              "type": "object",
-              "properties": {
-                "done": {"type": "boolean"}
-              },
-              "required": ["done"]
-            }
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
-          allowed_tools: "Bash"
+          claude_args: |
+            --allowedTools Bash
+            --json-schema '{"type":"object","properties":{"done":{"type":"boolean"}},"required":["done"]}'

      - name: Verify execution file contains structured_output
        run: |
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@

 # Claude Code Action

-A general-purpose [Claude Code](https://claude.ai/code) action for GitHub PRs and issues that can answer questions and implement code changes. This action intelligently detects when to activate based on your workflow context—whether responding to @claude mentions, issue assignments, or executing automation tasks with explicit prompts. It supports multiple authentication methods including Anthropic direct API, Amazon Bedrock, and Google Vertex AI.
+A general-purpose [Claude Code](https://claude.ai/code) action for GitHub PRs and issues that can answer questions and implement code changes. This action intelligently detects when to activate based on your workflow context—whether responding to @claude mentions, issue assignments, or executing automation tasks with explicit prompts. It supports multiple authentication methods including Anthropic direct API, Amazon Bedrock, Google Vertex AI, and Microsoft Foundry.

 ## Features

@@ -13,6 +13,7 @@ A general-purpose [Claude Code](https://claude.ai/code) action for GitHub PRs an
 - 💬 **PR/Issue Integration**: Works seamlessly with GitHub comments and PR reviews
 - 🛠️ **Flexible Tool Access**: Access to GitHub APIs and file operations (additional tools can be enabled via configuration)
 - 📋 **Progress Tracking**: Visual progress indicators with checkboxes that dynamically update as Claude completes tasks
+- 📊 **Structured Outputs**: Get validated JSON results that automatically become GitHub Action outputs for complex automations
 - 🏃 **Runs on Your Infrastructure**: The action executes entirely on your own GitHub runner (Anthropic API calls go to your chosen provider)
 - ⚙️ **Simplified Configuration**: Unified `prompt` and `claude_args` inputs provide clean, powerful configuration aligned with Claude Code SDK

@@ -29,7 +30,7 @@ This command will guide you through setting up the GitHub app and required secre
 **Note**:

 - You must be a repository admin to install the GitHub app and add secrets
- This quickstart method is only available for direct Anthropic API users. For AWS Bedrock or Google Vertex AI setup, see [docs/cloud-providers.md](./docs/cloud-providers.md).
+- This quickstart method is only available for direct Anthropic API users. For AWS Bedrock, Google Vertex AI, or Microsoft Foundry setup, see [docs/cloud-providers.md](./docs/cloud-providers.md).

 ## 📚 Solutions & Use Cases

@@ -56,7 +57,7 @@ Each solution includes complete working examples, configuration details, and exp
 - [Custom Automations](./docs/custom-automations.md) - Examples of automated workflows and custom prompts
 - [Configuration](./docs/configuration.md) - MCP servers, permissions, environment variables, and advanced settings
 - [Experimental Features](./docs/experimental.md) - Execution modes and network restrictions
- [Cloud Providers](./docs/cloud-providers.md) - AWS Bedrock and Google Vertex AI setup
+- [Cloud Providers](./docs/cloud-providers.md) - AWS Bedrock, Google Vertex AI, and Microsoft Foundry setup
 - [Capabilities & Limitations](./docs/capabilities-and-limitations.md) - What Claude can and cannot do
 - [Security](./docs/security.md) - Access control, permissions, and commit signing
 - [FAQ](./docs/faq.md) - Common questions and troubleshooting
--- a/action.yml
+++ b/action.yml
@@ -44,7 +44,7 @@ inputs:

  # Auth configuration
  anthropic_api_key:
-    description: "Anthropic API key (required for direct API, not needed for Bedrock/Vertex)"
+    description: "Anthropic API key (required for direct API, not needed for Bedrock/Vertex/Foundry)"
    required: false
  claude_code_oauth_token:
    description: "Claude Code OAuth token (alternative to anthropic_api_key)"
@@ -60,6 +60,10 @@ inputs:
    description: "Use Google Vertex AI with OIDC authentication instead of direct Anthropic API"
    required: false
    default: "false"
+  use_foundry:
+    description: "Use Microsoft Foundry with OIDC authentication instead of direct Anthropic API"
+    required: false
+    default: "false"

  claude_args:
    description: "Additional arguments to pass directly to Claude CLI"
@@ -89,10 +93,6 @@ inputs:
    description: "Force tag mode with tracking comments for pull_request and issue events. Only applicable to pull_request (opened, synchronize, ready_for_review, reopened) and issue (opened, edited, labeled, assigned) events."
    required: false
    default: "false"
-  experimental_allowed_domains:
-    description: "Restrict network access to these domains only (newline-separated). If not set, no restrictions are applied. Provider domains are auto-detected."
-    required: false
-    default: ""
  path_to_claude_code_executable:
    description: "Optional path to a custom Claude Code executable. If provided, skips automatic installation and uses this executable instead. WARNING: Using an older version may cause problems if the action begins taking advantage of new Claude Code features. This input is typically not needed unless you're debugging something specific or have unique needs in your environment."
    required: false
@@ -113,10 +113,6 @@ inputs:
    description: "Newline-separated list of Claude Code plugin marketplace Git URLs to install from (e.g., 'https://github.com/user/marketplace1.git\nhttps://github.com/user/marketplace2.git')"
    required: false
    default: ""
-  json_schema:
-    description: "JSON schema for structured output validation. When provided, Claude will return validated JSON matching this schema, and the action will automatically set GitHub Action outputs for each field."
-    required: false
-    default: ""

 outputs:
  execution_file:
@@ -128,6 +124,9 @@ outputs:
  github_token:
    description: "The GitHub token used by the action (Claude App token if available)"
    value: ${{ steps.prepare.outputs.github_token }}
+  structured_output:
+    description: "JSON string containing all structured output fields when --json-schema is provided in claude_args. Use fromJSON() to parse: fromJSON(steps.id.outputs.structured_output).field_name"
+    value: ${{ steps.claude-code.outputs.structured_output }}

 runs:
  using: "composite"
@@ -178,7 +177,6 @@ runs:
        TRACK_PROGRESS: ${{ inputs.track_progress }}
        ADDITIONAL_PERMISSIONS: ${{ inputs.additional_permissions }}
        CLAUDE_ARGS: ${{ inputs.claude_args }}
-        JSON_SCHEMA: ${{ inputs.json_schema }}
        ALL_INPUTS: ${{ toJson(inputs) }}

    - name: Install Base Action Dependencies
@@ -193,8 +191,23 @@ runs:

        # Install Claude Code if no custom executable is provided
        if [ -z "${{ inputs.path_to_claude_code_executable }}" ]; then
-          echo "Installing Claude Code..."
-          curl -fsSL https://claude.ai/install.sh | bash -s 2.0.42
+          CLAUDE_CODE_VERSION="2.0.50"
+          echo "Installing Claude Code v${CLAUDE_CODE_VERSION}..."
+          for attempt in 1 2 3; do
+            echo "Installation attempt $attempt..."
+            if command -v timeout &> /dev/null; then
+              timeout 120 bash -c "curl -fsSL https://claude.ai/install.sh | bash -s -- $CLAUDE_CODE_VERSION" && break
+            else
+              curl -fsSL https://claude.ai/install.sh | bash -s -- "$CLAUDE_CODE_VERSION" && break
+            fi
+            if [ $attempt -eq 3 ]; then
+              echo "Failed to install Claude Code after 3 attempts"
+              exit 1
+            fi
+            echo "Installation failed, retrying..."
+            sleep 5
+          done
+          echo "Claude Code installed successfully"
          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
        else
          echo "Using custom Claude Code executable: ${{ inputs.path_to_claude_code_executable }}"
@@ -203,15 +216,6 @@ runs:
          echo "$CLAUDE_DIR" >> "$GITHUB_PATH"
        fi

-    - name: Setup Network Restrictions
-      if: steps.prepare.outputs.contains_trigger == 'true' && inputs.experimental_allowed_domains != ''
-      shell: bash
-      run: |
-        chmod +x ${GITHUB_ACTION_PATH}/scripts/setup-network-restrictions.sh
-        ${GITHUB_ACTION_PATH}/scripts/setup-network-restrictions.sh
-      env:
-        EXPERIMENTAL_ALLOWED_DOMAINS: ${{ inputs.experimental_allowed_domains }}
-
    - name: Run Claude Code
      id: claude-code
      if: steps.prepare.outputs.contains_trigger == 'true'
@@ -233,7 +237,6 @@ runs:
        INPUT_SHOW_FULL_OUTPUT: ${{ inputs.show_full_output }}
        INPUT_PLUGINS: ${{ inputs.plugins }}
        INPUT_PLUGIN_MARKETPLACES: ${{ inputs.plugin_marketplaces }}
-        JSON_SCHEMA: ${{ inputs.json_schema }}

        # Model configuration
        GITHUB_TOKEN: ${{ steps.prepare.outputs.GITHUB_TOKEN }}
@@ -247,12 +250,14 @@ runs:
        ANTHROPIC_CUSTOM_HEADERS: ${{ env.ANTHROPIC_CUSTOM_HEADERS }}
        CLAUDE_CODE_USE_BEDROCK: ${{ inputs.use_bedrock == 'true' && '1' || '' }}
        CLAUDE_CODE_USE_VERTEX: ${{ inputs.use_vertex == 'true' && '1' || '' }}
+        CLAUDE_CODE_USE_FOUNDRY: ${{ inputs.use_foundry == 'true' && '1' || '' }}

        # AWS configuration
        AWS_REGION: ${{ env.AWS_REGION }}
        AWS_ACCESS_KEY_ID: ${{ env.AWS_ACCESS_KEY_ID }}
        AWS_SECRET_ACCESS_KEY: ${{ env.AWS_SECRET_ACCESS_KEY }}
        AWS_SESSION_TOKEN: ${{ env.AWS_SESSION_TOKEN }}
+        AWS_BEARER_TOKEN_BEDROCK: ${{ env.AWS_BEARER_TOKEN_BEDROCK }}
        ANTHROPIC_BEDROCK_BASE_URL: ${{ env.ANTHROPIC_BEDROCK_BASE_URL || (env.AWS_REGION && format('https://bedrock-runtime.{0}.amazonaws.com', env.AWS_REGION)) }}

        # GCP configuration
@@ -266,6 +271,13 @@ runs:
        VERTEX_REGION_CLAUDE_3_5_SONNET: ${{ env.VERTEX_REGION_CLAUDE_3_5_SONNET }}
        VERTEX_REGION_CLAUDE_3_7_SONNET: ${{ env.VERTEX_REGION_CLAUDE_3_7_SONNET }}

+        # Microsoft Foundry configuration
+        ANTHROPIC_FOUNDRY_RESOURCE: ${{ env.ANTHROPIC_FOUNDRY_RESOURCE }}
+        ANTHROPIC_FOUNDRY_BASE_URL: ${{ env.ANTHROPIC_FOUNDRY_BASE_URL }}
+        ANTHROPIC_DEFAULT_SONNET_MODEL: ${{ env.ANTHROPIC_DEFAULT_SONNET_MODEL }}
+        ANTHROPIC_DEFAULT_HAIKU_MODEL: ${{ env.ANTHROPIC_DEFAULT_HAIKU_MODEL }}
+        ANTHROPIC_DEFAULT_OPUS_MODEL: ${{ env.ANTHROPIC_DEFAULT_OPUS_MODEL }}
+
    - name: Update comment with job link
      if: steps.prepare.outputs.contains_trigger == 'true' && steps.prepare.outputs.claude_comment_id && always()
      shell: bash
--- a/base-action/action.yml
+++ b/base-action/action.yml
@@ -42,6 +42,10 @@ inputs:
    description: "Use Google Vertex AI with OIDC authentication instead of direct Anthropic API"
    required: false
    default: "false"
+  use_foundry:
+    description: "Use Microsoft Foundry with OIDC authentication instead of direct Anthropic API"
+    required: false
+    default: "false"

  use_node_cache:
    description: "Whether to use Node.js dependency caching (set to true only for Node.js projects with lock files)"
@@ -67,10 +71,6 @@ inputs:
    description: "Newline-separated list of Claude Code plugin marketplace Git URLs to install from (e.g., 'https://github.com/user/marketplace1.git\nhttps://github.com/user/marketplace2.git')"
    required: false
    default: ""
-  json_schema:
-    description: "JSON schema for structured output validation. When provided, Claude will return validated JSON matching this schema, and the action will automatically set GitHub Action outputs for each field (e.g., access via steps.id.outputs.field_name)"
-    required: false
-    default: ""

 outputs:
  conclusion:
@@ -79,6 +79,9 @@ outputs:
  execution_file:
    description: "Path to the JSON file containing Claude Code execution log"
    value: ${{ steps.run_claude.outputs.execution_file }}
+  structured_output:
+    description: "JSON string containing all structured output fields when --json-schema is provided in claude_args (use fromJSON() or jq to parse)"
+    value: ${{ steps.run_claude.outputs.structured_output }}

 runs:
  using: "composite"
@@ -114,8 +117,23 @@ runs:
      shell: bash
      run: |
        if [ -z "${{ inputs.path_to_claude_code_executable }}" ]; then
-          echo "Installing Claude Code..."
-          curl -fsSL https://claude.ai/install.sh | bash -s 2.0.42
+          CLAUDE_CODE_VERSION="2.0.50"
+          echo "Installing Claude Code v${CLAUDE_CODE_VERSION}..."
+          for attempt in 1 2 3; do
+            echo "Installation attempt $attempt..."
+            if command -v timeout &> /dev/null; then
+              timeout 120 bash -c "curl -fsSL https://claude.ai/install.sh | bash -s -- $CLAUDE_CODE_VERSION" && break
+            else
+              curl -fsSL https://claude.ai/install.sh | bash -s -- "$CLAUDE_CODE_VERSION" && break
+            fi
+            if [ $attempt -eq 3 ]; then
+              echo "Failed to install Claude Code after 3 attempts"
+              exit 1
+            fi
+            echo "Installation failed, retrying..."
+            sleep 5
+          done
+          echo "Claude Code installed successfully"
        else
          echo "Using custom Claude Code executable: ${{ inputs.path_to_claude_code_executable }}"
          # Add the directory containing the custom executable to PATH
@@ -154,12 +172,14 @@ runs:
        # Only set provider flags if explicitly true, since any value (including "false") is truthy
        CLAUDE_CODE_USE_BEDROCK: ${{ inputs.use_bedrock == 'true' && '1' || '' }}
        CLAUDE_CODE_USE_VERTEX: ${{ inputs.use_vertex == 'true' && '1' || '' }}
+        CLAUDE_CODE_USE_FOUNDRY: ${{ inputs.use_foundry == 'true' && '1' || '' }}

        # AWS configuration
        AWS_REGION: ${{ env.AWS_REGION }}
        AWS_ACCESS_KEY_ID: ${{ env.AWS_ACCESS_KEY_ID }}
        AWS_SECRET_ACCESS_KEY: ${{ env.AWS_SECRET_ACCESS_KEY }}
        AWS_SESSION_TOKEN: ${{ env.AWS_SESSION_TOKEN }}
+        AWS_BEARER_TOKEN_BEDROCK: ${{ env.AWS_BEARER_TOKEN_BEDROCK }}
        ANTHROPIC_BEDROCK_BASE_URL: ${{ env.ANTHROPIC_BEDROCK_BASE_URL || (env.AWS_REGION && format('https://bedrock-runtime.{0}.amazonaws.com', env.AWS_REGION)) }}

        # GCP configuration
@@ -167,3 +187,10 @@ runs:
        CLOUD_ML_REGION: ${{ env.CLOUD_ML_REGION }}
        GOOGLE_APPLICATION_CREDENTIALS: ${{ env.GOOGLE_APPLICATION_CREDENTIALS }}
        ANTHROPIC_VERTEX_BASE_URL: ${{ env.ANTHROPIC_VERTEX_BASE_URL }}
+
+        # Microsoft Foundry configuration
+        ANTHROPIC_FOUNDRY_RESOURCE: ${{ env.ANTHROPIC_FOUNDRY_RESOURCE }}
+        ANTHROPIC_FOUNDRY_BASE_URL: ${{ env.ANTHROPIC_FOUNDRY_BASE_URL }}
+        ANTHROPIC_DEFAULT_SONNET_MODEL: ${{ env.ANTHROPIC_DEFAULT_SONNET_MODEL }}
+        ANTHROPIC_DEFAULT_HAIKU_MODEL: ${{ env.ANTHROPIC_DEFAULT_HAIKU_MODEL }}
+        ANTHROPIC_DEFAULT_OPUS_MODEL: ${{ env.ANTHROPIC_DEFAULT_OPUS_MODEL }}
--- a/base-action/src/run-claude.ts
+++ b/base-action/src/run-claude.ts
@@ -12,11 +12,6 @@ const PIPE_PATH = `${process.env.RUNNER_TEMP}/claude_prompt_pipe`;
 const EXECUTION_FILE = `${process.env.RUNNER_TEMP}/claude-execution-output.json`;
 const BASE_ARGS = ["--verbose", "--output-format", "stream-json"];

-type ExecutionMessage = {
-  type: string;
-  structured_output?: Record<string, unknown>;
-};
-
 /**
 * Sanitizes JSON output to remove sensitive information when full output is disabled
 * Returns a safe summary message or null if the message should be completely suppressed
@@ -127,91 +122,54 @@ export function prepareRunConfig(
  };
 }

-/**
- * Sanitizes output field names to meet GitHub Actions output naming requirements
- * GitHub outputs must be alphanumeric, hyphen, or underscore only
- */
-function sanitizeOutputName(name: string): string {
-  return name.replace(/[^a-zA-Z0-9_-]/g, "_");
-}
-
-/**
- * Converts values to string format for GitHub Actions outputs
- * GitHub outputs must always be strings
- */
-function convertToString(value: unknown): string {
-  switch (typeof value) {
-    case "string":
-      return value;
-    case "boolean":
-    case "number":
-      return String(value);
-    case "object":
-      return value === null ? "" : JSON.stringify(value);
-    case "undefined":
-      return "";
-    default:
-      // Handle Symbol, Function, etc.
-      return String(value);
-  }
-}
-
 /**
 * Parses structured_output from execution file and sets GitHub Action outputs
- * Only runs if json_schema was explicitly provided by the user
+ * Only runs if --json-schema was explicitly provided in claude_args
+ * Exported for testing
 */
-async function parseAndSetStructuredOutputs(
+export async function parseAndSetStructuredOutputs(
  executionFile: string,
 ): Promise<void> {
  try {
    const content = await readFile(executionFile, "utf-8");
-    const messages = JSON.parse(content) as ExecutionMessage[];
+    const messages = JSON.parse(content) as {
+      type: string;
+      structured_output?: Record<string, unknown>;
+    }[];

-    const result = messages.find(
+    // Search backwards - result is typically last or second-to-last message
+    const result = messages.findLast(
      (m) => m.type === "result" && m.structured_output,
    );

    if (!result?.structured_output) {
-      const error = new Error(
-        "json_schema was provided but Claude did not return structured_output. " +
-          "The schema may be invalid or Claude failed to call the StructuredOutput tool.",
+      throw new Error(
+        `--json-schema was provided but Claude did not return structured_output.\n` +
+          `Found ${messages.length} messages. Result exists: ${!!result}\n`,
      );
-      core.setFailed(error.message);
-      throw error;
    }

-    // Set GitHub Action output for each field
-    const entries = Object.entries(result.structured_output);
-    core.info(`Setting ${entries.length} structured output(s)`);
-
-    for (const [key, value] of entries) {
-      const sanitizedKey = sanitizeOutputName(key);
-      if (!sanitizedKey) {
-        core.warning(`Skipping invalid output key: "${key}"`);
-        continue;
-      }
-
-      const stringValue = convertToString(value);
-
-      // Truncate long values in logs for readability
-      const displayValue =
-        stringValue.length > 100
-          ? `${stringValue.slice(0, 97)}...`
-          : stringValue;
-
-      core.setOutput(sanitizedKey, stringValue);
-      core.info(`✓ ${sanitizedKey}=${displayValue}`);
-    }
+    // Set the complete structured output as a single JSON string
+    // This works around GitHub Actions limitation that composite actions can't have dynamic outputs
+    const structuredOutputJson = JSON.stringify(result.structured_output);
+    core.setOutput("structured_output", structuredOutputJson);
+    core.info(
+      `Set structured_output with ${Object.keys(result.structured_output).length} field(s)`,
+    );
  } catch (error) {
-    const errorMsg = `Failed to parse structured outputs: ${error}`;
-    core.setFailed(errorMsg);
-    throw new Error(errorMsg);
+    if (error instanceof Error) {
+      throw error; // Preserve original error and stack trace
+    }
+    throw new Error(`Failed to parse structured outputs: ${error}`);
  }
 }

 export async function runClaude(promptPath: string, options: ClaudeOptions) {
  const config = prepareRunConfig(promptPath, options);

+  // Detect if --json-schema is present in claude args
+  const hasJsonSchema = options.claudeArgs?.includes("--json-schema") ?? false;
+
  // Create a named pipe
  try {
    await unlink(PIPE_PATH);
@@ -395,13 +353,23 @@ export async function runClaude(promptPath: string, options: ClaudeOptions) {
      core.warning(`Failed to process output for execution metrics: ${e}`);
    }

-    core.setOutput("conclusion", "success");
    core.setOutput("execution_file", EXECUTION_FILE);

-    // Parse and set structured outputs only if user provided json_schema
-    if (process.env.JSON_SCHEMA) {
-      await parseAndSetStructuredOutputs(EXECUTION_FILE);
+    // Parse and set structured outputs only if user provided --json-schema in claude_args
+    if (hasJsonSchema) {
+      try {
+        await parseAndSetStructuredOutputs(EXECUTION_FILE);
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        core.setFailed(errorMessage);
+        core.setOutput("conclusion", "failure");
+        process.exit(1);
+      }
    }
+
+    // Set conclusion to success if we reached here
+    core.setOutput("conclusion", "success");
  } else {
    core.setOutput("conclusion", "failure");

--- a/base-action/src/validate-env.ts
+++ b/base-action/src/validate-env.ts
@@ -1,39 +1,50 @@
 /**
 * Validates the environment variables required for running Claude Code
- * based on the selected provider (Anthropic API, AWS Bedrock, or Google Vertex AI)
+ * based on the selected provider (Anthropic API, AWS Bedrock, Google Vertex AI, or Microsoft Foundry)
 */
 export function validateEnvironmentVariables() {
  const useBedrock = process.env.CLAUDE_CODE_USE_BEDROCK === "1";
  const useVertex = process.env.CLAUDE_CODE_USE_VERTEX === "1";
+  const useFoundry = process.env.CLAUDE_CODE_USE_FOUNDRY === "1";
  const anthropicApiKey = process.env.ANTHROPIC_API_KEY;
  const claudeCodeOAuthToken = process.env.CLAUDE_CODE_OAUTH_TOKEN;

  const errors: string[] = [];

-  if (useBedrock && useVertex) {
+  // Check for mutual exclusivity between providers
+  const activeProviders = [useBedrock, useVertex, useFoundry].filter(Boolean);
+  if (activeProviders.length > 1) {
    errors.push(
-      "Cannot use both Bedrock and Vertex AI simultaneously. Please set only one provider.",
+      "Cannot use multiple providers simultaneously. Please set only one of: CLAUDE_CODE_USE_BEDROCK, CLAUDE_CODE_USE_VERTEX, or CLAUDE_CODE_USE_FOUNDRY.",
    );
  }

-  if (!useBedrock && !useVertex) {
+  if (!useBedrock && !useVertex && !useFoundry) {
    if (!anthropicApiKey && !claudeCodeOAuthToken) {
      errors.push(
        "Either ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN is required when using direct Anthropic API.",
      );
    }
  } else if (useBedrock) {
-    const requiredBedrockVars = {
-      AWS_REGION: process.env.AWS_REGION,
-      AWS_ACCESS_KEY_ID: process.env.AWS_ACCESS_KEY_ID,
-      AWS_SECRET_ACCESS_KEY: process.env.AWS_SECRET_ACCESS_KEY,
-    };
+    const awsRegion = process.env.AWS_REGION;
+    const awsAccessKeyId = process.env.AWS_ACCESS_KEY_ID;
+    const awsSecretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
+    const awsBearerToken = process.env.AWS_BEARER_TOKEN_BEDROCK;

-    Object.entries(requiredBedrockVars).forEach(([key, value]) => {
-      if (!value) {
-        errors.push(`${key} is required when using AWS Bedrock.`);
-      }
-    });
+    // AWS_REGION is always required for Bedrock
+    if (!awsRegion) {
+      errors.push("AWS_REGION is required when using AWS Bedrock.");
+    }
+
+    // Either bearer token OR access key credentials must be provided
+    const hasAccessKeyCredentials = awsAccessKeyId && awsSecretAccessKey;
+    const hasBearerToken = awsBearerToken;
+
+    if (!hasAccessKeyCredentials && !hasBearerToken) {
+      errors.push(
+        "Either AWS_BEARER_TOKEN_BEDROCK or both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY are required when using AWS Bedrock.",
+      );
+    }
  } else if (useVertex) {
    const requiredVertexVars = {
      ANTHROPIC_VERTEX_PROJECT_ID: process.env.ANTHROPIC_VERTEX_PROJECT_ID,
@@ -45,6 +56,16 @@ export function validateEnvironmentVariables() {
        errors.push(`${key} is required when using Google Vertex AI.`);
      }
    });
+  } else if (useFoundry) {
+    const foundryResource = process.env.ANTHROPIC_FOUNDRY_RESOURCE;
+    const foundryBaseUrl = process.env.ANTHROPIC_FOUNDRY_BASE_URL;
+
+    // Either resource name or base URL is required
+    if (!foundryResource && !foundryBaseUrl) {
+      errors.push(
+        "Either ANTHROPIC_FOUNDRY_RESOURCE or ANTHROPIC_FOUNDRY_BASE_URL is required when using Microsoft Foundry.",
+      );
+    }
  }

  if (errors.length > 0) {
--- a/base-action/test/structured-output.test.ts
+++ b/base-action/test/structured-output.test.ts
@@ -1,15 +1,11 @@
 #!/usr/bin/env bun

-import { describe, test, expect, afterEach } from "bun:test";
+import { describe, test, expect, afterEach, beforeEach, spyOn } from "bun:test";
 import { writeFile, unlink } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
-
-// Import the type for testing
-type ExecutionMessage = {
-  type: string;
-  structured_output?: Record<string, unknown>;
-};
+import { parseAndSetStructuredOutputs } from "../src/run-claude";
+import * as core from "@actions/core";

 // Mock execution file path
 const TEST_EXECUTION_FILE = join(tmpdir(), "test-execution-output.json");
@@ -19,9 +15,9 @@ async function createMockExecutionFile(
  structuredOutput?: Record<string, unknown>,
  includeResult: boolean = true,
 ): Promise<void> {
-  const messages: ExecutionMessage[] = [
-    { type: "system", subtype: "init" } as any,
-    { type: "turn", content: "test" } as any,
+  const messages: any[] = [
+    { type: "system", subtype: "init" },
+    { type: "turn", content: "test" },
  ];

  if (includeResult) {
@@ -30,14 +26,25 @@ async function createMockExecutionFile(
      cost_usd: 0.01,
      duration_ms: 1000,
      structured_output: structuredOutput,
-    } as any);
+    });
  }

  await writeFile(TEST_EXECUTION_FILE, JSON.stringify(messages));
 }

-describe("Structured Output - Pure Functions", () => {
+// Spy on core functions
+let setOutputSpy: any;
+let infoSpy: any;
+
+beforeEach(() => {
+  setOutputSpy = spyOn(core, "setOutput").mockImplementation(() => {});
+  infoSpy = spyOn(core, "info").mockImplementation(() => {});
+});
+
+describe("parseAndSetStructuredOutputs", () => {
  afterEach(async () => {
+    setOutputSpy?.mockRestore();
+    infoSpy?.mockRestore();
    try {
      await unlink(TEST_EXECUTION_FILE);
    } catch {
@@ -45,297 +52,107 @@ describe("Structured Output - Pure Functions", () => {
    }
  });

-  describe("sanitizeOutputName", () => {
-    test("should keep valid characters", () => {
-      const sanitize = (name: string) => name.replace(/[^a-zA-Z0-9_-]/g, "_");
-      expect(sanitize("valid_name-123")).toBe("valid_name-123");
+  test("should set structured_output with valid data", async () => {
+    await createMockExecutionFile({
+      is_flaky: true,
+      confidence: 0.85,
+      summary: "Test looks flaky",
    });

-    test("should replace invalid characters with underscores", () => {
-      const sanitize = (name: string) => name.replace(/[^a-zA-Z0-9_-]/g, "_");
-      expect(sanitize("invalid@name!")).toBe("invalid_name_");
-      expect(sanitize("has spaces")).toBe("has_spaces");
-      expect(sanitize("has.dots")).toBe("has_dots");
+    await parseAndSetStructuredOutputs(TEST_EXECUTION_FILE);
+
+    expect(setOutputSpy).toHaveBeenCalledWith(
+      "structured_output",
+      '{"is_flaky":true,"confidence":0.85,"summary":"Test looks flaky"}',
+    );
+    expect(infoSpy).toHaveBeenCalledWith(
+      "Set structured_output with 3 field(s)",
+    );
+  });
+
+  test("should handle arrays and nested objects", async () => {
+    await createMockExecutionFile({
+      items: ["a", "b", "c"],
+      config: { key: "value", nested: { deep: true } },
    });

-    test("should handle special characters", () => {
-      const sanitize = (name: string) => name.replace(/[^a-zA-Z0-9_-]/g, "_");
-      expect(sanitize("$field%name&")).toBe("_field_name_");
-      expect(sanitize("field[0]")).toBe("field_0_");
+    await parseAndSetStructuredOutputs(TEST_EXECUTION_FILE);
+
+    const callArgs = setOutputSpy.mock.calls[0];
+    expect(callArgs[0]).toBe("structured_output");
+    const parsed = JSON.parse(callArgs[1]);
+    expect(parsed).toEqual({
+      items: ["a", "b", "c"],
+      config: { key: "value", nested: { deep: true } },
    });
  });

-  describe("convertToString", () => {
-    const convertToString = (value: unknown): string => {
-      switch (typeof value) {
-        case "string":
-          return value;
-        case "boolean":
-        case "number":
-          return String(value);
-        case "object":
-          return value === null ? "" : JSON.stringify(value);
-        default:
-          return JSON.stringify(value);
-      }
-    };
-
-    test("should keep strings as-is", () => {
-      expect(convertToString("hello")).toBe("hello");
-      expect(convertToString("")).toBe("");
+  test("should handle special characters in field names", async () => {
+    await createMockExecutionFile({
+      "test-result": "passed",
+      "item.count": 10,
+      "user@email": "test",
    });

-    test("should convert booleans to strings", () => {
-      expect(convertToString(true)).toBe("true");
-      expect(convertToString(false)).toBe("false");
-    });
+    await parseAndSetStructuredOutputs(TEST_EXECUTION_FILE);

-    test("should convert numbers to strings", () => {
-      expect(convertToString(42)).toBe("42");
-      expect(convertToString(3.14)).toBe("3.14");
-      expect(convertToString(0)).toBe("0");
-    });
-
-    test("should convert null to empty string", () => {
-      expect(convertToString(null)).toBe("");
-    });
-
-    test("should JSON stringify objects", () => {
-      expect(convertToString({ foo: "bar" })).toBe('{"foo":"bar"}');
-    });
-
-    test("should JSON stringify arrays", () => {
-      expect(convertToString([1, 2, 3])).toBe("[1,2,3]");
-      expect(convertToString(["a", "b"])).toBe('["a","b"]');
-    });
-
-    test("should handle nested structures", () => {
-      const nested = { items: [{ id: 1, name: "test" }] };
-      expect(convertToString(nested)).toBe(
-        '{"items":[{"id":1,"name":"test"}]}',
-      );
-    });
+    const callArgs = setOutputSpy.mock.calls[0];
+    const parsed = JSON.parse(callArgs[1]);
+    expect(parsed["test-result"]).toBe("passed");
+    expect(parsed["item.count"]).toBe(10);
+    expect(parsed["user@email"]).toBe("test");
  });

-  describe("parseAndSetStructuredOutputs integration", () => {
-    test("should parse and set simple structured outputs", async () => {
-      await createMockExecutionFile({
-        is_antonly: true,
-        confidence: 0.95,
-        risk: "low",
-      });
+  test("should throw error when result exists but structured_output is undefined", async () => {
+    const messages = [
+      { type: "system", subtype: "init" },
+      { type: "result", cost_usd: 0.01, duration_ms: 1000 },
+    ];
+    await writeFile(TEST_EXECUTION_FILE, JSON.stringify(messages));

-      // In a real test, we'd import and call parseAndSetStructuredOutputs
-      // For now, we simulate the behavior
-      const content = await Bun.file(TEST_EXECUTION_FILE).text();
-      const messages = JSON.parse(content) as ExecutionMessage[];
-      const result = messages.find(
-        (m) => m.type === "result" && m.structured_output,
-      );
-
-      expect(result?.structured_output).toEqual({
-        is_antonly: true,
-        confidence: 0.95,
-        risk: "low",
-      });
-    });
-
-    test("should handle array outputs", async () => {
-      await createMockExecutionFile({
-        affected_areas: ["auth", "database", "api"],
-        severity: "high",
-      });
-
-      const content = await Bun.file(TEST_EXECUTION_FILE).text();
-      const messages = JSON.parse(content) as ExecutionMessage[];
-      const result = messages.find(
-        (m) => m.type === "result" && m.structured_output,
-      );
-
-      expect(result?.structured_output?.affected_areas).toEqual([
-        "auth",
-        "database",
-        "api",
-      ]);
-    });
-
-    test("should handle nested objects", async () => {
-      await createMockExecutionFile({
-        analysis: {
-          category: "test",
-          details: { count: 5, passed: true },
-        },
-      });
-
-      const content = await Bun.file(TEST_EXECUTION_FILE).text();
-      const messages = JSON.parse(content) as ExecutionMessage[];
-      const result = messages.find(
-        (m) => m.type === "result" && m.structured_output,
-      );
-
-      expect(result?.structured_output?.analysis).toEqual({
-        category: "test",
-        details: { count: 5, passed: true },
-      });
-    });
-
-    test("should handle missing structured_output", async () => {
-      await createMockExecutionFile(undefined, true);
-
-      const content = await Bun.file(TEST_EXECUTION_FILE).text();
-      const messages = JSON.parse(content) as ExecutionMessage[];
-      const result = messages.find(
-        (m) => m.type === "result" && m.structured_output,
-      );
-
-      expect(result).toBeUndefined();
-    });
-
-    test("should handle empty structured_output", async () => {
-      await createMockExecutionFile({});
-
-      const content = await Bun.file(TEST_EXECUTION_FILE).text();
-      const messages = JSON.parse(content) as ExecutionMessage[];
-      const result = messages.find(
-        (m) => m.type === "result" && m.structured_output,
-      );
-
-      expect(result?.structured_output).toEqual({});
-    });
-
-    test("should handle all supported types", async () => {
-      await createMockExecutionFile({
-        string_field: "hello",
-        number_field: 42,
-        boolean_field: true,
-        null_field: null,
-        array_field: [1, 2, 3],
-        object_field: { nested: "value" },
-      });
-
-      const content = await Bun.file(TEST_EXECUTION_FILE).text();
-      const messages = JSON.parse(content) as ExecutionMessage[];
-      const result = messages.find(
-        (m) => m.type === "result" && m.structured_output,
-      );
-
-      expect(result?.structured_output).toMatchObject({
-        string_field: "hello",
-        number_field: 42,
-        boolean_field: true,
-        null_field: null,
-        array_field: [1, 2, 3],
-        object_field: { nested: "value" },
-      });
-    });
+    await expect(
+      parseAndSetStructuredOutputs(TEST_EXECUTION_FILE),
+    ).rejects.toThrow(
+      "--json-schema was provided but Claude did not return structured_output",
+    );
  });

-  describe("output naming with prefix", () => {
-    test("should apply prefix correctly", () => {
-      const prefix = "CLAUDE_";
-      const key = "is_antonly";
-      const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
-      const outputName = prefix + sanitizedKey;
+  test("should throw error when no result message exists", async () => {
+    const messages = [
+      { type: "system", subtype: "init" },
+      { type: "turn", content: "test" },
+    ];
+    await writeFile(TEST_EXECUTION_FILE, JSON.stringify(messages));

-      expect(outputName).toBe("CLAUDE_is_antonly");
-    });
-
-    test("should handle empty prefix", () => {
-      const prefix = "";
-      const key = "result";
-      const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
-      const outputName = prefix + sanitizedKey;
-
-      expect(outputName).toBe("result");
-    });
-
-    test("should sanitize and prefix invalid keys", () => {
-      const prefix = "OUT_";
-      const key = "invalid@key!";
-      const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, "_");
-      const outputName = prefix + sanitizedKey;
-
-      expect(outputName).toBe("OUT_invalid_key_");
-    });
+    await expect(
+      parseAndSetStructuredOutputs(TEST_EXECUTION_FILE),
+    ).rejects.toThrow(
+      "--json-schema was provided but Claude did not return structured_output",
+    );
  });

-  describe("error scenarios", () => {
-    test("should handle malformed JSON", async () => {
-      await writeFile(TEST_EXECUTION_FILE, "invalid json {");
+  test("should throw error with malformed JSON", async () => {
+    await writeFile(TEST_EXECUTION_FILE, "{ invalid json");

-      let error: Error | undefined;
-      try {
-        const content = await Bun.file(TEST_EXECUTION_FILE).text();
-        JSON.parse(content);
-      } catch (e) {
-        error = e as Error;
-      }
-
-      expect(error).toBeDefined();
-      expect(error?.message).toContain("JSON");
-    });
-
-    test("should handle empty execution file", async () => {
-      await writeFile(TEST_EXECUTION_FILE, "[]");
-
-      const content = await Bun.file(TEST_EXECUTION_FILE).text();
-      const messages = JSON.parse(content) as ExecutionMessage[];
-      const result = messages.find(
-        (m) => m.type === "result" && m.structured_output,
-      );
-
-      expect(result).toBeUndefined();
-    });
-
-    test("should handle missing result message", async () => {
-      const messages = [
-        { type: "system", subtype: "init" },
-        { type: "turn", content: "test" },
-      ];
-      await writeFile(TEST_EXECUTION_FILE, JSON.stringify(messages));
-
-      const content = await Bun.file(TEST_EXECUTION_FILE).text();
-      const parsed = JSON.parse(content) as ExecutionMessage[];
-      const result = parsed.find(
-        (m) => m.type === "result" && m.structured_output,
-      );
-
-      expect(result).toBeUndefined();
-    });
+    await expect(
+      parseAndSetStructuredOutputs(TEST_EXECUTION_FILE),
+    ).rejects.toThrow();
  });

-  describe("value truncation in logs", () => {
-    test("should truncate long string values for display", () => {
-      const longValue = "a".repeat(150);
-      const displayValue =
-        longValue.length > 100 ? `${longValue.slice(0, 97)}...` : longValue;
+  test("should throw error when file does not exist", async () => {
+    await expect(
+      parseAndSetStructuredOutputs("/nonexistent/file.json"),
+    ).rejects.toThrow();
+  });

-      expect(displayValue).toBe("a".repeat(97) + "...");
-      expect(displayValue.length).toBe(100);
-    });
+  test("should handle empty structured_output object", async () => {
+    await createMockExecutionFile({});

-    test("should not truncate short values", () => {
-      const shortValue = "short";
-      const displayValue =
-        shortValue.length > 100 ? `${shortValue.slice(0, 97)}...` : shortValue;
+    await parseAndSetStructuredOutputs(TEST_EXECUTION_FILE);

-      expect(displayValue).toBe("short");
-    });
-
-    test("should truncate exactly 100 character values", () => {
-      const value = "a".repeat(100);
-      const displayValue =
-        value.length > 100 ? `${value.slice(0, 97)}...` : value;
-
-      expect(displayValue).toBe(value);
-    });
-
-    test("should truncate 101 character values", () => {
-      const value = "a".repeat(101);
-      const displayValue =
-        value.length > 100 ? `${value.slice(0, 97)}...` : value;
-
-      expect(displayValue).toBe("a".repeat(97) + "...");
-    });
+    expect(setOutputSpy).toHaveBeenCalledWith("structured_output", "{}");
+    expect(infoSpy).toHaveBeenCalledWith(
+      "Set structured_output with 0 field(s)",
+    );
  });
 });
--- a/base-action/test/validate-env.test.ts
+++ b/base-action/test/validate-env.test.ts
@@ -13,15 +13,19 @@ describe("validateEnvironmentVariables", () => {
    delete process.env.ANTHROPIC_API_KEY;
    delete process.env.CLAUDE_CODE_USE_BEDROCK;
    delete process.env.CLAUDE_CODE_USE_VERTEX;
+    delete process.env.CLAUDE_CODE_USE_FOUNDRY;
    delete process.env.AWS_REGION;
    delete process.env.AWS_ACCESS_KEY_ID;
    delete process.env.AWS_SECRET_ACCESS_KEY;
    delete process.env.AWS_SESSION_TOKEN;
+    delete process.env.AWS_BEARER_TOKEN_BEDROCK;
    delete process.env.ANTHROPIC_BEDROCK_BASE_URL;
    delete process.env.ANTHROPIC_VERTEX_PROJECT_ID;
    delete process.env.CLOUD_ML_REGION;
    delete process.env.GOOGLE_APPLICATION_CREDENTIALS;
    delete process.env.ANTHROPIC_VERTEX_BASE_URL;
+    delete process.env.ANTHROPIC_FOUNDRY_RESOURCE;
+    delete process.env.ANTHROPIC_FOUNDRY_BASE_URL;
  });

  afterEach(() => {
@@ -92,31 +96,58 @@ describe("validateEnvironmentVariables", () => {
      );
    });

-    test("should fail when AWS_ACCESS_KEY_ID is missing", () => {
+    test("should fail when only AWS_SECRET_ACCESS_KEY is provided without bearer token", () => {
      process.env.CLAUDE_CODE_USE_BEDROCK = "1";
      process.env.AWS_REGION = "us-east-1";
      process.env.AWS_SECRET_ACCESS_KEY = "test-secret-key";

      expect(() => validateEnvironmentVariables()).toThrow(
-        "AWS_ACCESS_KEY_ID is required when using AWS Bedrock.",
+        "Either AWS_BEARER_TOKEN_BEDROCK or both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY are required when using AWS Bedrock.",
      );
    });

-    test("should fail when AWS_SECRET_ACCESS_KEY is missing", () => {
+    test("should fail when only AWS_ACCESS_KEY_ID is provided without bearer token", () => {
      process.env.CLAUDE_CODE_USE_BEDROCK = "1";
      process.env.AWS_REGION = "us-east-1";
      process.env.AWS_ACCESS_KEY_ID = "test-access-key";

      expect(() => validateEnvironmentVariables()).toThrow(
-        "AWS_SECRET_ACCESS_KEY is required when using AWS Bedrock.",
+        "Either AWS_BEARER_TOKEN_BEDROCK or both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY are required when using AWS Bedrock.",
      );
    });

-    test("should report all missing Bedrock variables", () => {
+    test("should pass when AWS_BEARER_TOKEN_BEDROCK is provided instead of access keys", () => {
+      process.env.CLAUDE_CODE_USE_BEDROCK = "1";
+      process.env.AWS_REGION = "us-east-1";
+      process.env.AWS_BEARER_TOKEN_BEDROCK = "test-bearer-token";
+
+      expect(() => validateEnvironmentVariables()).not.toThrow();
+    });
+
+    test("should pass when both bearer token and access keys are provided", () => {
+      process.env.CLAUDE_CODE_USE_BEDROCK = "1";
+      process.env.AWS_REGION = "us-east-1";
+      process.env.AWS_BEARER_TOKEN_BEDROCK = "test-bearer-token";
+      process.env.AWS_ACCESS_KEY_ID = "test-access-key";
+      process.env.AWS_SECRET_ACCESS_KEY = "test-secret-key";
+
+      expect(() => validateEnvironmentVariables()).not.toThrow();
+    });
+
+    test("should fail when no authentication method is provided", () => {
+      process.env.CLAUDE_CODE_USE_BEDROCK = "1";
+      process.env.AWS_REGION = "us-east-1";
+
+      expect(() => validateEnvironmentVariables()).toThrow(
+        "Either AWS_BEARER_TOKEN_BEDROCK or both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY are required when using AWS Bedrock.",
+      );
+    });
+
+    test("should report missing region and authentication", () => {
      process.env.CLAUDE_CODE_USE_BEDROCK = "1";

      expect(() => validateEnvironmentVariables()).toThrow(
-        /AWS_REGION is required when using AWS Bedrock.*AWS_ACCESS_KEY_ID is required when using AWS Bedrock.*AWS_SECRET_ACCESS_KEY is required when using AWS Bedrock/s,
+        /AWS_REGION is required when using AWS Bedrock.*Either AWS_BEARER_TOKEN_BEDROCK or both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY are required when using AWS Bedrock/s,
      );
    });
  });
@@ -167,6 +198,56 @@ describe("validateEnvironmentVariables", () => {
    });
  });

+  describe("Microsoft Foundry", () => {
+    test("should pass when ANTHROPIC_FOUNDRY_RESOURCE is provided", () => {
+      process.env.CLAUDE_CODE_USE_FOUNDRY = "1";
+      process.env.ANTHROPIC_FOUNDRY_RESOURCE = "test-resource";
+
+      expect(() => validateEnvironmentVariables()).not.toThrow();
+    });
+
+    test("should pass when ANTHROPIC_FOUNDRY_BASE_URL is provided", () => {
+      process.env.CLAUDE_CODE_USE_FOUNDRY = "1";
+      process.env.ANTHROPIC_FOUNDRY_BASE_URL =
+        "https://test-resource.services.ai.azure.com";
+
+      expect(() => validateEnvironmentVariables()).not.toThrow();
+    });
+
+    test("should pass when both resource and base URL are provided", () => {
+      process.env.CLAUDE_CODE_USE_FOUNDRY = "1";
+      process.env.ANTHROPIC_FOUNDRY_RESOURCE = "test-resource";
+      process.env.ANTHROPIC_FOUNDRY_BASE_URL =
+        "https://custom.services.ai.azure.com";
+
+      expect(() => validateEnvironmentVariables()).not.toThrow();
+    });
+
+    test("should construct Foundry base URL from resource name when ANTHROPIC_FOUNDRY_BASE_URL is not provided", () => {
+      // This test verifies our action.yml change, which constructs:
+      // ANTHROPIC_FOUNDRY_BASE_URL: ${{ env.ANTHROPIC_FOUNDRY_BASE_URL || (env.ANTHROPIC_FOUNDRY_RESOURCE && format('https://{0}.services.ai.azure.com', env.ANTHROPIC_FOUNDRY_RESOURCE)) }}
+
+      process.env.CLAUDE_CODE_USE_FOUNDRY = "1";
+      process.env.ANTHROPIC_FOUNDRY_RESOURCE = "my-foundry-resource";
+      // ANTHROPIC_FOUNDRY_BASE_URL is intentionally not set
+
+      // The actual URL construction happens in the composite action in action.yml
+      // This test is a placeholder to document the behavior
+      expect(() => validateEnvironmentVariables()).not.toThrow();
+
+      // In the actual action, ANTHROPIC_FOUNDRY_BASE_URL would be:
+      // https://my-foundry-resource.services.ai.azure.com
+    });
+
+    test("should fail when neither ANTHROPIC_FOUNDRY_RESOURCE nor ANTHROPIC_FOUNDRY_BASE_URL is provided", () => {
+      process.env.CLAUDE_CODE_USE_FOUNDRY = "1";
+
+      expect(() => validateEnvironmentVariables()).toThrow(
+        "Either ANTHROPIC_FOUNDRY_RESOURCE or ANTHROPIC_FOUNDRY_BASE_URL is required when using Microsoft Foundry.",
+      );
+    });
+  });
+
  describe("Multiple providers", () => {
    test("should fail when both Bedrock and Vertex are enabled", () => {
      process.env.CLAUDE_CODE_USE_BEDROCK = "1";
@@ -179,7 +260,51 @@ describe("validateEnvironmentVariables", () => {
      process.env.CLOUD_ML_REGION = "us-central1";

      expect(() => validateEnvironmentVariables()).toThrow(
-        "Cannot use both Bedrock and Vertex AI simultaneously. Please set only one provider.",
+        "Cannot use multiple providers simultaneously. Please set only one of: CLAUDE_CODE_USE_BEDROCK, CLAUDE_CODE_USE_VERTEX, or CLAUDE_CODE_USE_FOUNDRY.",
+      );
+    });
+
+    test("should fail when both Bedrock and Foundry are enabled", () => {
+      process.env.CLAUDE_CODE_USE_BEDROCK = "1";
+      process.env.CLAUDE_CODE_USE_FOUNDRY = "1";
+      // Provide all required vars to isolate the mutual exclusion error
+      process.env.AWS_REGION = "us-east-1";
+      process.env.AWS_ACCESS_KEY_ID = "test-access-key";
+      process.env.AWS_SECRET_ACCESS_KEY = "test-secret-key";
+      process.env.ANTHROPIC_FOUNDRY_RESOURCE = "test-resource";
+
+      expect(() => validateEnvironmentVariables()).toThrow(
+        "Cannot use multiple providers simultaneously. Please set only one of: CLAUDE_CODE_USE_BEDROCK, CLAUDE_CODE_USE_VERTEX, or CLAUDE_CODE_USE_FOUNDRY.",
+      );
+    });
+
+    test("should fail when both Vertex and Foundry are enabled", () => {
+      process.env.CLAUDE_CODE_USE_VERTEX = "1";
+      process.env.CLAUDE_CODE_USE_FOUNDRY = "1";
+      // Provide all required vars to isolate the mutual exclusion error
+      process.env.ANTHROPIC_VERTEX_PROJECT_ID = "test-project";
+      process.env.CLOUD_ML_REGION = "us-central1";
+      process.env.ANTHROPIC_FOUNDRY_RESOURCE = "test-resource";
+
+      expect(() => validateEnvironmentVariables()).toThrow(
+        "Cannot use multiple providers simultaneously. Please set only one of: CLAUDE_CODE_USE_BEDROCK, CLAUDE_CODE_USE_VERTEX, or CLAUDE_CODE_USE_FOUNDRY.",
+      );
+    });
+
+    test("should fail when all three providers are enabled", () => {
+      process.env.CLAUDE_CODE_USE_BEDROCK = "1";
+      process.env.CLAUDE_CODE_USE_VERTEX = "1";
+      process.env.CLAUDE_CODE_USE_FOUNDRY = "1";
+      // Provide all required vars to isolate the mutual exclusion error
+      process.env.AWS_REGION = "us-east-1";
+      process.env.AWS_ACCESS_KEY_ID = "test-access-key";
+      process.env.AWS_SECRET_ACCESS_KEY = "test-secret-key";
+      process.env.ANTHROPIC_VERTEX_PROJECT_ID = "test-project";
+      process.env.CLOUD_ML_REGION = "us-central1";
+      process.env.ANTHROPIC_FOUNDRY_RESOURCE = "test-resource";
+
+      expect(() => validateEnvironmentVariables()).toThrow(
+        "Cannot use multiple providers simultaneously. Please set only one of: CLAUDE_CODE_USE_BEDROCK, CLAUDE_CODE_USE_VERTEX, or CLAUDE_CODE_USE_FOUNDRY.",
      );
    });
  });
@@ -204,10 +329,7 @@ describe("validateEnvironmentVariables", () => {
        "  - AWS_REGION is required when using AWS Bedrock.",
      );
      expect(error!.message).toContain(
-        "  - AWS_ACCESS_KEY_ID is required when using AWS Bedrock.",
-      );
-      expect(error!.message).toContain(
-        "  - AWS_SECRET_ACCESS_KEY is required when using AWS Bedrock.",
+        "  - Either AWS_BEARER_TOKEN_BEDROCK or both AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY are required when using AWS Bedrock.",
      );
    });
  });
--- a/docs/cloud-providers.md
+++ b/docs/cloud-providers.md
@@ -1,16 +1,17 @@
 # Cloud Providers

-You can authenticate with Claude using any of these three methods:
+You can authenticate with Claude using any of these four methods:

 1. Direct Anthropic API (default)
 2. Amazon Bedrock with OIDC authentication
 3. Google Vertex AI with OIDC authentication
+4. Microsoft Foundry with OIDC authentication

 For detailed setup instructions for AWS Bedrock and Google Vertex AI, see the [official documentation](https://docs.anthropic.com/en/docs/claude-code/github-actions#using-with-aws-bedrock-%26-google-vertex-ai).

 **Note**:

- Bedrock and Vertex use OIDC authentication exclusively
+- Bedrock, Vertex, and Microsoft Foundry use OIDC authentication exclusively
 - AWS Bedrock automatically uses cross-region inference profiles for certain models
 - For cross-region inference profile models, you need to request and be granted access to the Claude models in all regions that the inference profile uses

@@ -40,11 +41,19 @@ Use provider-specific model names based on your chosen provider:
    claude_args: |
      --model claude-4-0-sonnet@20250805
    # ... other inputs
+
+# For Microsoft Foundry with OIDC
+- uses: anthropics/claude-code-action@v1
+  with:
+    use_foundry: "true"
+    claude_args: |
+      --model claude-sonnet-4-5
+    # ... other inputs
 ```

-## OIDC Authentication for Bedrock and Vertex
+## OIDC Authentication for Cloud Providers

-Both AWS Bedrock and GCP Vertex AI require OIDC authentication.
+AWS Bedrock, GCP Vertex AI, and Microsoft Foundry all support OIDC authentication.

 ```yaml
 # For AWS Bedrock with OIDC
@@ -97,3 +106,36 @@ Both AWS Bedrock and GCP Vertex AI require OIDC authentication.
  permissions:
    id-token: write # Required for OIDC
 ```
+
+```yaml
+# For Microsoft Foundry with OIDC
+- name: Authenticate to Azure
+  uses: azure/login@v2
+  with:
+    client-id: ${{ secrets.AZURE_CLIENT_ID }}
+    tenant-id: ${{ secrets.AZURE_TENANT_ID }}
+    subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
+
+- name: Generate GitHub App token
+  id: app-token
+  uses: actions/create-github-app-token@v2
+  with:
+    app-id: ${{ secrets.APP_ID }}
+    private-key: ${{ secrets.APP_PRIVATE_KEY }}
+
+- uses: anthropics/claude-code-action@v1
+  with:
+    use_foundry: "true"
+    claude_args: |
+      --model claude-sonnet-4-5
+    # ... other inputs
+  env:
+    ANTHROPIC_FOUNDRY_BASE_URL: https://my-resource.services.ai.azure.com
+
+permissions:
+  id-token: write # Required for OIDC
+```
+
+## Microsoft Foundry Setup
+
+For detailed setup instructions for Microsoft Foundry, see the [official documentation](https://docs.anthropic.com/en/docs/claude-code/microsoft-foundry).
--- a/docs/experimental.md
+++ b/docs/experimental.md
@@ -61,68 +61,3 @@ For specialized use cases, you can fine-tune behavior using `claude_args`:
      --system-prompt "You are a code review specialist"
    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
 ```
-
-## Network Restrictions
-
-For enhanced security, you can restrict Claude's network access to specific domains only. This feature is particularly useful for:
-
- Enterprise environments with strict security policies
- Preventing access to external services
- Limiting Claude to only your internal APIs and services
-
-When `experimental_allowed_domains` is set, Claude can only access the domains you explicitly list. You'll need to include the appropriate provider domains based on your authentication method.
-
-### Provider-Specific Examples
-
-#### If using Anthropic API or subscription
-
-```yaml
- uses: anthropics/claude-code-action@v1
-  with:
-    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
-    # Or: claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
-    experimental_allowed_domains: |
-      .anthropic.com
-```
-
-#### If using AWS Bedrock
-
-```yaml
- uses: anthropics/claude-code-action@v1
-  with:
-    use_bedrock: "true"
-    experimental_allowed_domains: |
-      bedrock.*.amazonaws.com
-      bedrock-runtime.*.amazonaws.com
-```
-
-#### If using Google Vertex AI
-
-```yaml
- uses: anthropics/claude-code-action@v1
-  with:
-    use_vertex: "true"
-    experimental_allowed_domains: |
-      *.googleapis.com
-      vertexai.googleapis.com
-```
-
-### Common GitHub Domains
-
-In addition to your provider domains, you may need to include GitHub-related domains. For GitHub.com users, common domains include:
-
-```yaml
- uses: anthropics/claude-code-action@v1
-  with:
-    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
-    experimental_allowed_domains: |
-      .anthropic.com  # For Anthropic API
-      .github.com
-      .githubusercontent.com
-      ghcr.io
-      .blob.core.windows.net
-```
-
-For GitHub Enterprise users, replace the GitHub.com domains above with your enterprise domains (e.g., `.github.company.com`, `packages.company.com`, etc.).
-
-To determine which domains your workflow needs, you can temporarily run without restrictions and monitor the network requests, or check your GitHub Enterprise configuration for the specific services you use.
--- a/docs/security.md
+++ b/docs/security.md
@@ -38,7 +38,7 @@ The following permissions are requested but not yet actively used. These will en

 ## Commit Signing

-All commits made by Claude through this action are automatically signed with commit signatures. This ensures the authenticity and integrity of commits, providing a verifiable trail of changes made by the action.
+Commits made by Claude through this action are no longer automatically signed with commit signatures. To enable commit signing set `use_commit_signing: True` in the workflow(s). This ensures the authenticity and integrity of commits, providing a verifiable trail of changes made by the action.

 ## ⚠️ Authentication Protection

--- a/docs/usage.md
+++ b/docs/usage.md
@@ -70,7 +70,6 @@ jobs:
 | `branch_prefix`                  | The prefix to use for Claude branches (defaults to 'claude/', use 'claude-' for dash format)                                                                                           | No       | `claude/`     |
 | `settings`                       | Claude Code settings as JSON string or path to settings JSON file                                                                                                                      | No       | ""            |
 | `additional_permissions`         | Additional permissions to enable. Currently supports 'actions: read' for viewing workflow results                                                                                      | No       | ""            |
-| `experimental_allowed_domains`   | Restrict network access to these domains only (newline-separated).                                                                                                                     | No       | ""            |
 | `use_commit_signing`             | Enable commit signing using GitHub's commit signature verification. When false, Claude uses standard git commands                                                                      | No       | `false`       |
 | `bot_id`                         | GitHub user ID to use for git operations (defaults to Claude's bot ID)                                                                                                                 | No       | `41898282`    |
 | `bot_name`                       | GitHub username to use for git operations (defaults to Claude's bot name)                                                                                                              | No       | `claude[bot]` |
@@ -185,6 +184,74 @@ For a comprehensive guide on migrating from v0.x to v1.0, including step-by-step
      Focus on the changed files in this PR.
 ```

+## Structured Outputs
+
+Get validated JSON results from Claude that automatically become GitHub Action outputs. This enables building complex automation workflows where Claude analyzes data and subsequent steps use the results.
+
+### Basic Example
+
+```yaml
+- name: Detect flaky tests
+  id: analyze
+  uses: anthropics/claude-code-action@v1
+  with:
+    anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+    prompt: |
+      Check the CI logs and determine if this is a flaky test.
+      Return: is_flaky (boolean), confidence (0-1), summary (string)
+    claude_args: |
+      --json-schema '{"type":"object","properties":{"is_flaky":{"type":"boolean"},"confidence":{"type":"number"},"summary":{"type":"string"}},"required":["is_flaky"]}'
+
+- name: Retry if flaky
+  if: fromJSON(steps.analyze.outputs.structured_output).is_flaky == true
+  run: gh workflow run CI
+```
+
+### How It Works
+
+1. **Define Schema**: Provide a JSON schema via `--json-schema` flag in `claude_args`
+2. **Claude Executes**: Claude uses tools to complete your task
+3. **Validated Output**: Result is validated against your schema
+4. **JSON Output**: All fields are returned in a single `structured_output` JSON string
+
+### Accessing Structured Outputs
+
+All structured output fields are available in the `structured_output` output as a JSON string:
+
+**In GitHub Actions expressions:**
+
+```yaml
+if: fromJSON(steps.analyze.outputs.structured_output).is_flaky == true
+run: |
+  CONFIDENCE=${{ fromJSON(steps.analyze.outputs.structured_output).confidence }}
+```
+
+**In bash with jq:**
+
+```yaml
+- name: Process results
+  run: |
+    OUTPUT='${{ steps.analyze.outputs.structured_output }}'
+    IS_FLAKY=$(echo "$OUTPUT" | jq -r '.is_flaky')
+    SUMMARY=$(echo "$OUTPUT" | jq -r '.summary')
+```
+
+**Note**: Due to GitHub Actions limitations, composite actions cannot expose dynamic outputs. All fields are bundled in the single `structured_output` JSON string.
+
+### Complete Example
+
+See `examples/test-failure-analysis.yml` for a working example that:
+
+- Detects flaky test failures
+- Uses confidence thresholds in conditionals
+- Auto-retries workflows
+- Comments on PRs
+
+### Documentation
+
+For complete details on JSON Schema syntax and Agent SDK structured outputs:
+https://docs.claude.com/en/docs/agent-sdk/structured-outputs
+
 ## Ways to Tag @claude

 These examples show how to interact with Claude using comments in PRs and issues. By default, Claude will be triggered anytime you mention `@claude`, but you can customize the exact trigger phrase using the `trigger_phrase` input in the workflow.
--- a/examples/test-failure-analysis.yml
+++ b/examples/test-failure-analysis.yml
@@ -43,38 +43,23 @@ jobs:
            - is_flaky: true if likely flaky, false if real bug
            - confidence: number 0-1 indicating confidence level
            - summary: brief one-sentence explanation
-          json_schema: |
-            {
-              "type": "object",
-              "properties": {
-                "is_flaky": {
-                  "type": "boolean",
-                  "description": "Whether this appears to be a flaky test failure"
-                },
-                "confidence": {
-                  "type": "number",
-                  "minimum": 0,
-                  "maximum": 1,
-                  "description": "Confidence level in the determination"
-                },
-                "summary": {
-                  "type": "string",
-                  "description": "One-sentence explanation of the failure"
-                }
-              },
-              "required": ["is_flaky", "confidence", "summary"]
-            }
+          claude_args: |
+            --json-schema '{"type":"object","properties":{"is_flaky":{"type":"boolean","description":"Whether this appears to be a flaky test failure"},"confidence":{"type":"number","minimum":0,"maximum":1,"description":"Confidence level in the determination"},"summary":{"type":"string","description":"One-sentence explanation of the failure"}},"required":["is_flaky","confidence","summary"]}'

      # Auto-retry only if flaky AND high confidence (>= 0.7)
      - name: Retry flaky tests
        if: |
-          steps.detect.outputs.is_flaky == 'true' &&
-          steps.detect.outputs.confidence >= '0.7'
+          fromJSON(steps.detect.outputs.structured_output).is_flaky == true &&
+          fromJSON(steps.detect.outputs.structured_output).confidence >= 0.7
        env:
          GH_TOKEN: ${{ github.token }}
        run: |
-          echo "🔄 Flaky test detected (confidence: ${{ steps.detect.outputs.confidence }})"
-          echo "Summary: ${{ steps.detect.outputs.summary }}"
+          OUTPUT='${{ steps.detect.outputs.structured_output }}'
+          CONFIDENCE=$(echo "$OUTPUT" | jq -r '.confidence')
+          SUMMARY=$(echo "$OUTPUT" | jq -r '.summary')
+
+          echo "🔄 Flaky test detected (confidence: $CONFIDENCE)"
+          echo "Summary: $SUMMARY"
          echo ""
          echo "Triggering automatic retry..."

@@ -84,10 +69,13 @@ jobs:
      # Low confidence flaky detection - skip retry
      - name: Low confidence detection
        if: |
-          steps.detect.outputs.is_flaky == 'true' &&
-          steps.detect.outputs.confidence < '0.7'
+          fromJSON(steps.detect.outputs.structured_output).is_flaky == true &&
+          fromJSON(steps.detect.outputs.structured_output).confidence < 0.7
        run: |
-          echo "⚠️ Possible flaky test but confidence too low (${{ steps.detect.outputs.confidence }})"
+          OUTPUT='${{ steps.detect.outputs.structured_output }}'
+          CONFIDENCE=$(echo "$OUTPUT" | jq -r '.confidence')
+
+          echo "⚠️ Possible flaky test but confidence too low ($CONFIDENCE)"
          echo "Not retrying automatically - manual review recommended"

      # Comment on PR if this was a PR build
@@ -96,16 +84,29 @@ jobs:
        env:
          GH_TOKEN: ${{ github.token }}
        run: |
+          OUTPUT='${{ steps.detect.outputs.structured_output }}'
+          IS_FLAKY=$(echo "$OUTPUT" | jq -r '.is_flaky')
+          CONFIDENCE=$(echo "$OUTPUT" | jq -r '.confidence')
+          SUMMARY=$(echo "$OUTPUT" | jq -r '.summary')
+
          pr_number=$(gh pr list --head "${{ github.event.workflow_run.head_branch }}" --json number --jq '.[0].number')

          if [ -n "$pr_number" ]; then
+            if [ "$IS_FLAKY" = "true" ]; then
+              TITLE="🔄 Flaky Test Detected"
+              ACTION="✅ Automatically retrying the workflow"
+            else
+              TITLE="❌ Test Failure"
+              ACTION="⚠️ This appears to be a real bug - manual intervention needed"
+            fi
+
            gh pr comment "$pr_number" --body "$(cat <<EOF
-          ## ${{ steps.detect.outputs.is_flaky == 'true' && '🔄 Flaky Test Detected' || '❌ Test Failure' }}
+          ## $TITLE

-          **Analysis**: ${{ steps.detect.outputs.summary }}
-          **Confidence**: ${{ steps.detect.outputs.confidence }}
+          **Analysis**: $SUMMARY
+          **Confidence**: $CONFIDENCE

-          ${{ steps.detect.outputs.is_flaky == 'true' && '✅ Automatically retrying the workflow' || '⚠️ This appears to be a real bug - manual intervention needed' }}
+          $ACTION

          [View workflow run](${{ github.event.workflow_run.html_url }})
          EOF
--- a/scripts/setup-network-restrictions.sh
+++ b/scripts/setup-network-restrictions.sh
@@ -1,123 +0,0 @@
-#!/bin/bash
-
-# Setup Network Restrictions with Squid Proxy
-# This script sets up a Squid proxy to restrict network access to whitelisted domains only.
-
-set -e
-
-# Check if experimental_allowed_domains is provided
-if [ -z "$EXPERIMENTAL_ALLOWED_DOMAINS" ]; then
-  echo "ERROR: EXPERIMENTAL_ALLOWED_DOMAINS environment variable is required"
-  exit 1
-fi
-
-# Check required environment variables
-if [ -z "$RUNNER_TEMP" ]; then
-  echo "ERROR: RUNNER_TEMP environment variable is required"
-  exit 1
-fi
-
-if [ -z "$GITHUB_ENV" ]; then
-  echo "ERROR: GITHUB_ENV environment variable is required"
-  exit 1
-fi
-
-echo "Setting up network restrictions with Squid proxy..."
-
-SQUID_START_TIME=$(date +%s.%N)
-
-# Create whitelist file
-echo "$EXPERIMENTAL_ALLOWED_DOMAINS" > $RUNNER_TEMP/whitelist.txt
-
-# Ensure each domain has proper format
-# If domain doesn't start with a dot and isn't an IP, add the dot for subdomain matching
-mv $RUNNER_TEMP/whitelist.txt $RUNNER_TEMP/whitelist.txt.orig
-while IFS= read -r domain; do
-  if [ -n "$domain" ]; then
-    # Trim whitespace
-    domain=$(echo "$domain" | xargs)
-    # If it's not empty and doesn't start with a dot, add one
-    if [[ "$domain" != .* ]] && [[ ! "$domain" =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-      echo ".$domain" >> $RUNNER_TEMP/whitelist.txt
-    else
-      echo "$domain" >> $RUNNER_TEMP/whitelist.txt
-    fi
-  fi
-done < $RUNNER_TEMP/whitelist.txt.orig
-
-# Create Squid config with whitelist
-echo "http_port 3128" > $RUNNER_TEMP/squid.conf
-echo "" >> $RUNNER_TEMP/squid.conf
-echo "# Define ACLs" >> $RUNNER_TEMP/squid.conf
-echo "acl whitelist dstdomain \"/etc/squid/whitelist.txt\"" >> $RUNNER_TEMP/squid.conf
-echo "acl localnet src 127.0.0.1/32" >> $RUNNER_TEMP/squid.conf
-echo "acl localnet src 172.17.0.0/16" >> $RUNNER_TEMP/squid.conf
-echo "acl SSL_ports port 443" >> $RUNNER_TEMP/squid.conf
-echo "acl Safe_ports port 80" >> $RUNNER_TEMP/squid.conf
-echo "acl Safe_ports port 443" >> $RUNNER_TEMP/squid.conf
-echo "acl CONNECT method CONNECT" >> $RUNNER_TEMP/squid.conf
-echo "" >> $RUNNER_TEMP/squid.conf
-echo "# Deny requests to certain unsafe ports" >> $RUNNER_TEMP/squid.conf
-echo "http_access deny !Safe_ports" >> $RUNNER_TEMP/squid.conf
-echo "" >> $RUNNER_TEMP/squid.conf
-echo "# Only allow CONNECT to SSL ports" >> $RUNNER_TEMP/squid.conf
-echo "http_access deny CONNECT !SSL_ports" >> $RUNNER_TEMP/squid.conf
-echo "" >> $RUNNER_TEMP/squid.conf
-echo "# Allow localhost" >> $RUNNER_TEMP/squid.conf
-echo "http_access allow localhost" >> $RUNNER_TEMP/squid.conf
-echo "" >> $RUNNER_TEMP/squid.conf
-echo "# Allow localnet access to whitelisted domains" >> $RUNNER_TEMP/squid.conf
-echo "http_access allow localnet whitelist" >> $RUNNER_TEMP/squid.conf
-echo "" >> $RUNNER_TEMP/squid.conf
-echo "# Deny everything else" >> $RUNNER_TEMP/squid.conf
-echo "http_access deny all" >> $RUNNER_TEMP/squid.conf
-
-echo "Starting Squid proxy..."
-# First, remove any existing container
-sudo docker rm -f squid-proxy 2>/dev/null || true
-
-# Ensure whitelist file is not empty (Squid fails with empty files)
-if [ ! -s "$RUNNER_TEMP/whitelist.txt" ]; then
-  echo "WARNING: Whitelist file is empty, adding a dummy entry"
-  echo ".example.com" >> $RUNNER_TEMP/whitelist.txt
-fi
-
-# Use sudo to prevent Claude from stopping the container
-CONTAINER_ID=$(sudo docker run -d \
-  --name squid-proxy \
-  -p 127.0.0.1:3128:3128 \
-  -v $RUNNER_TEMP/squid.conf:/etc/squid/squid.conf:ro \
-  -v $RUNNER_TEMP/whitelist.txt:/etc/squid/whitelist.txt:ro \
-  ubuntu/squid:latest 2>&1) || {
-  echo "ERROR: Failed to start Squid container"
-  exit 1
-}
-
-# Wait for proxy to be ready (usually < 1 second)
-READY=false
-for i in {1..30}; do
-  if nc -z 127.0.0.1 3128 2>/dev/null; then
-    TOTAL_TIME=$(echo "scale=3; $(date +%s.%N) - $SQUID_START_TIME" | bc)
-    echo "Squid proxy ready in ${TOTAL_TIME}s"
-    READY=true
-    break
-  fi
-  sleep 0.1
-done
-
-if [ "$READY" != "true" ]; then
-  echo "ERROR: Squid proxy failed to start within 3 seconds"
-  echo "Container logs:"
-  sudo docker logs squid-proxy 2>&1 || true
-  echo "Container status:"
-  sudo docker ps -a | grep squid-proxy || true
-  exit 1
-fi
-
-# Set proxy environment variables
-echo "http_proxy=http://127.0.0.1:3128" >> $GITHUB_ENV
-echo "https_proxy=http://127.0.0.1:3128" >> $GITHUB_ENV
-echo "HTTP_PROXY=http://127.0.0.1:3128" >> $GITHUB_ENV
-echo "HTTPS_PROXY=http://127.0.0.1:3128" >> $GITHUB_ENV
-
-echo "Network restrictions setup completed successfully"
--- a/src/entrypoints/collect-inputs.ts
+++ b/src/entrypoints/collect-inputs.ts
@@ -26,7 +26,6 @@ export function collectActionInputsPresence(): void {
    max_turns: "",
    use_sticky_comment: "false",
    use_commit_signing: "false",
-    experimental_allowed_domains: "",
  };

  const allInputsJson = process.env.ALL_INPUTS;
--- a/src/modes/agent/index.ts
+++ b/src/modes/agent/index.ts
@@ -149,19 +149,6 @@ export const agentMode: Mode = {
      claudeArgs = `--mcp-config '${escapedOurConfig}'`;
    }

-    // Add JSON schema if provided
-    const jsonSchema = process.env.JSON_SCHEMA || "";
-    if (jsonSchema) {
-      // Validate it's valid JSON
-      try {
-        JSON.parse(jsonSchema);
-      } catch (e) {
-        throw new Error(`Invalid JSON schema provided: ${e}`);
-      }
-      const escapedSchema = jsonSchema.replace(/'/g, "'\\''");
-      claudeArgs += ` --json-schema '${escapedSchema}'`;
-    }
-
    // Append user's claude_args (which may have more --mcp-config flags)
    claudeArgs = `${claudeArgs} ${userClaudeArgs}`.trim();

--- a/src/modes/tag/index.ts
+++ b/src/modes/tag/index.ts
@@ -177,19 +177,6 @@ export const tagMode: Mode = {
    // Add required tools for tag mode
    claudeArgs += ` --allowedTools "${tagModeTools.join(",")}"`;

-    // Add JSON schema if provided
-    const jsonSchema = process.env.JSON_SCHEMA || "";
-    if (jsonSchema) {
-      // Validate it's valid JSON
-      try {
-        JSON.parse(jsonSchema);
-      } catch (e) {
-        throw new Error(`Invalid JSON schema provided: ${e}`);
-      }
-      const escapedSchema = jsonSchema.replace(/'/g, "'\\''");
-      claudeArgs += ` --json-schema '${escapedSchema}'`;
-    }
-
    // Append user's claude_args (which may have more --mcp-config flags)
    if (userClaudeArgs) {
      claudeArgs += ` ${userClaudeArgs}`;
Author	SHA1	Message	Date
Ashwin Bhat	a7e4c51380	fix: use cross-platform timeout for Claude Code installation (#700 ) The GNU `timeout` command is not available on macOS. Check if it exists and use it when available, otherwise run without timeout. Also extracts the version into a CLAUDE_CODE_VERSION variable for easier maintenance. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude <noreply@anthropic.com>	2025-11-24 20:57:33 -05:00
Ashwin Bhat	7febbb006b	Remove experimental allowed domains feature (#697 ) * chore: remove experimental allowed domains feature Remove the experimental_allowed_domains feature which was used to restrict network access via a Squid proxy. This removes: - The input definition from action.yml - The Network Restrictions workflow step - The setup-network-restrictions.sh script - Documentation from experimental.md, usage.md, and related files - The input default from collect-inputs.ts * chore: fix formatting with prettier Co-authored-by: Ashwin Bhat <ashwin-ant@users.noreply.github.com> --------- Co-authored-by: Claude <noreply@anthropic.com> Co-authored-by: claude[bot] <41898282+claude[bot]@users.noreply.github.com> Co-authored-by: Ashwin Bhat <ashwin-ant@users.noreply.github.com>	2025-11-24 19:03:53 -05:00
Ashwin Bhat	798cf0988d	chore: add retry loop to Claude Code installation (#694 ) * chore: add --debug and retry loop to Claude Code installation Adds 2-minute timeout with up to 3 retry attempts for installation. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> * fix: remove unsupported --debug flag from install script 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> --------- Co-authored-by: Claude <noreply@anthropic.com>	2025-11-21 16:52:35 -08:00
GitHub Actions	8458f4399d	chore: bump Claude Code version to 2.0.50	2025-11-21 23:16:27 +00:00
GitHub Actions	f9b2917716	chore: bump Claude Code version to 2.0.49	2025-11-21 01:31:39 +00:00
Ashwin Bhat	f092d4cefd	feat: add Microsoft Foundry provider support (#684 ) * feat: add Azure AI Foundry provider support Add support for Azure AI Foundry as a fourth cloud provider option alongside Anthropic API, AWS Bedrock, and Google Vertex AI. Changes: - Add use_foundry input to enable Azure AI Foundry authentication - Add Azure environment variables (ANTHROPIC_FOUNDRY_RESOURCE, ANTHROPIC_FOUNDRY_API_KEY, ANTHROPIC_FOUNDRY_BASE_URL) - Support automatic base URL construction from resource name - Add validation logic with mutual exclusivity checks for all providers - Add comprehensive test coverage (7 Azure-specific tests, 3 mutual exclusivity tests) - Add complete Azure AI Foundry documentation with OIDC and API key authentication - Update README to reference Azure AI Foundry support Features: - Primary authentication via Microsoft Entra ID (OIDC) using azure/login action - Optional API key authentication fallback - Custom model deployment name support via ANTHROPIC_DEFAULT__MODEL variables - Clear validation error messages for missing configuration All tests pass (25 validation tests total). 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> refactor: rename Azure AI Foundry to Microsoft Foundry and remove API key support - Rename all references from "Azure AI Foundry" to "Microsoft Foundry" - Remove ANTHROPIC_FOUNDRY_API_KEY support (OIDC only) - Update documentation to reflect OIDC-only authentication - Update tests to remove API key test case 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> * docs: simplify Microsoft Foundry setup and remove URL auto-construction - Link to official docs instead of duplicating setup instructions - Remove automatic base URL construction from resource name - Pass ANTHROPIC_FOUNDRY_BASE_URL as-is 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> --------- Co-authored-by: Claude <noreply@anthropic.com>	2025-11-20 13:50:13 -08:00
Jose Garcia	c2edeab4c3	added: AWS_BEARER_TOKEN_BEDROCK authentication capabilities (#692 )	2025-11-20 13:47:12 -08:00
Ashwin Bhat	4318310481	chore: limit PR review workflow to opened events only (#691 ) 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude <noreply@anthropic.com>	2025-11-20 12:09:21 -08:00
Kyle Altendorf	11571151c4	update docs re: commit signing no longer default (#675 ) * update docs re: commit signing no longer default * format	2025-11-20 07:13:10 -08:00
GitHub Actions	70193f466c	chore: bump Claude Code version to 2.0.47	2025-11-19 23:12:47 +00:00
GitHub Actions	9db20ef677	chore: bump Claude Code version to 2.0.46	2025-11-19 04:58:56 +00:00
bogini	6902c227aa	feat: add structured output support via --json-schema argument (#687 ) * feat: add structured output support Add support for Agent SDK structured outputs. New input: json_schema Output: structured_output (JSON string) Access: fromJSON(steps.id.outputs.structured_output).field Docs: https://docs.claude.com/en/docs/agent-sdk/structured-outputs * rm unused * refactor: simplify structured outputs to use claude_args Remove json_schema input in favor of passing --json-schema flag directly in claude_args. This simplifies the interface by treating structured outputs like other CLI flags (--model, --max-turns, etc.) instead of as a special input that gets injected. Users now specify: claude_args: '--json-schema {...}' Instead of separate: json_schema: {...} 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> * chore: remove unused json-schema util and revert version - Remove src/utils/json-schema.ts (no longer used after refactor) - Revert Claude Code version from 2.0.45 back to 2.0.42 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com> --------- Co-authored-by: Claude <noreply@anthropic.com>	2025-11-18 17:18:05 -08:00
GitHub Actions	e45f28fae7	chore: bump Claude Code version to 2.0.45	2025-11-18 16:50:24 +00:00
GitHub Actions	8c4e1e7eb1	chore: bump Claude Code version to 2.0.44	2025-11-18 04:50:59 +00:00
GitHub Actions	906bd89c74	chore: bump Claude Code version to 2.0.43	2025-11-18 00:29:32 +00:00