Bedrock Agent Action Group Not Passing Objects/Arrays as Valid JSON to Lambda

Question

I'm encountering an issue with a Bedrock Agent where object and array parameters from an action group are not being passed to the backing Lambda function in a valid JSON format.

I have an action group defined with the following OpenAPI schema for the `requestBody`:

```json
{
  "requestBody": {
    "required": true,
    "content": {
      "application/json": {
        "schema": {
          "type": "object",
          "properties": {
            "userInfo": {
              "type": "object",
              "description": "User's personal information.",
              "properties": {
                "name": {
                  "type": "string",
                  "example": "test_name"
                },
                "title": {
                  "type": "string",
                  "example": "test_title"
                }
              },
              "required": ["name", "titlel"]
            },
            "tags": {
              "type": "array",
              "description": "Tags associated with the user.",
              "items": {
                "type": "string"
              },
              "example": ["customer", "vip"]
            }
          },
          "required": ["userInfo", "tags"]
        }
      }
    }
  }
}
```

When the Lambda function is invoked, the `event` contains the parameters as malformed strings, where keys and values are not enclosed in double quotes.

For the `userInfo` object, I receive a string like this:
`"{name:test_name, title:test_title}"`

And for the `tags` array, I receive:
`"[customer, vip]"`

My desired format, which is a valid JSON string that `json.loads()` can parse, is:
`{"name":"test_name", "title":"test_title"}`
`["customer", "vip"]`

Interestingly, if the Lambda function fails due to a format error and is retried, the parameters are sometimes passed in the correct, parseable JSON format on the subsequent attempt.

I have tried modifying the prompt to instruct the model to "please enclose parameters in double quotes," but this has not resolved the issue.

Is there a way to ensure that the Bedrock Agent consistently passes objects and arrays as properly formatted JSON strings to the Lambda function on the first attempt? Are there any known workarounds for this behavior?

Nick G · Answer

We ran into the same issue. [This documentation indicates](https://docs.aws.amazon.com/bedrock/latest/userguide/agents-action-add.html) that non-OpenAPI-defined action groups do not support nested objects. I suspect that action groups defined using an OpenAPI schema are subject to the same limitations, even though this is not documented at all. Ideally, Bedrock would also provide along the raw content generated by the agent so we could parse it in the application.

re:Post Agent · Answer

This is a known issue with Bedrock Agents when passing complex data types like objects and arrays to Lambda functions. The agent sometimes formats these parameters as strings with improper JSON formatting, making them difficult to parse in your Lambda function.

Here are some workarounds you can implement:

1. **Add defensive parsing in your Lambda function**: Create a helper function that attempts to clean and properly format the malformed JSON strings before parsing them. For example:
```python
def clean_json_string(json_str):
if isinstance(json_str, str):
# Replace unquoted keys and values with properly quoted ones
import re
# Add quotes to keys
json_str = re.sub(r'(\w+):', r'"\1":', json_str)
# Add quotes to string values that aren't already quoted
json_str = re.sub(r': *(\w+)', r': "\1"', json_str)
return json.loads(json_str)
return json_str
```

2. **Use string parameters and parse them in your Lambda**: Instead of defining complex object types in your OpenAPI schema, use string parameters and have your Lambda function parse them. This gives you more control over the parsing logic.

3. **Simplify your schema**: Break down complex objects into individual string parameters where possible, which tend to be handled more reliably.

4. **Wrap arrays in objects**: Instead of using top-level arrays, wrap them in objects, which sometimes helps with proper formatting.

5. **Add explicit formatting instructions in your action group description**: While you mentioned this didn't fully resolve the issue, including specific formatting instructions in your action group description or parameter descriptions can sometimes help.

The issue appears to be related to how the Bedrock Agent formats the parameters when invoking the Lambda function, rather than an issue with your OpenAPI schema definition. The inconsistent behavior you're seeing (where retries sometimes work correctly) suggests this is likely a limitation in the current implementation of Bedrock Agents.

If these workarounds don't resolve your issue, consider reaching out to AWS Support for additional guidance, as they may have more specific recommendations or information about upcoming fixes for this behavior.  
**Sources**  
[JSON Array in RequestBody not supported? | AWS re:Post](https://repost.aws/questions/QU6Jz_Xi7sRwKVArV9md6ChA/json-array-in-requestbody-not-supported)  
[Amazon.Lambda.AspNetCoreServer.Hosting as Bedrock Agent Action Group Lambda | AWS re:Post](https://repost.aws/questions/QUXj8PAYBRQiKqd5VRWHNQfQ/amazon-lambda-aspnetcoreserver-hosting-as-bedrock-agent-action-group-lambda)  
[Is this a Bug? Not been able to edit action group function in JSON Editor. | AWS re:Post](https://repost.aws/questions/QUwMp-Z0OtSW2OZtBcNwUOiA/is-this-a-bug-not-been-able-to-edit-action-group-function-in-json-editor)

Bedrock Agent Action Group Not Passing Objects/Arrays as Valid JSON to Lambda

Add your answer

Relevant content