microsoft/semantic-kernel · error · FunctionExecutionException

No payload is provided by the argument '{self.payload_argume

Error message

No payload is provided by the argument '{self.payload_argument_name}'.

What it means

When `enable_dynamic_payload` is False, `build_json_payload` expects the caller to supply the entire body as a string under `payload_argument_name`. If that argument is missing or not a `str`, it raises `FunctionExecutionException`.

Source

Thrown at python/semantic_kernel/connectors/openapi_plugin/openapi_runner.py:83

        """Build the operation URL."""
        url = operation.build_operation_url(arguments, server_url_override, api_host_url)
        return self.build_full_url(url, operation.build_query_string(arguments))

    def build_json_payload(self, payload_metadata: RestApiPayload, arguments: dict[str, Any]) -> tuple[str, str]:
        """Build the JSON payload."""
        if self.enable_dynamic_payload:
            if payload_metadata is None:
                raise FunctionExecutionException(
                    "Payload can't be built dynamically due to the missing payload metadata."
                )

            payload = self.build_json_object(payload_metadata.properties, arguments)
            content = json.dumps(payload)
            return content, payload_metadata.media_type

        argument = arguments.get(self.payload_argument_name)
        if not isinstance(argument, str):
            raise FunctionExecutionException(f"No payload is provided by the argument '{self.payload_argument_name}'.")

        return argument, argument

    def build_json_object(self, properties, arguments, property_namespace=None):
        """Build the JSON payload object."""
        result = {}

        for property_metadata in properties:
            argument_name = self.get_argument_name_for_payload(property_metadata.name, property_namespace)
            if property_metadata.type == "object":
                node = self.build_json_object(property_metadata.properties, arguments, argument_name)
                result[property_metadata.name] = node
                continue
            property_value = arguments.get(argument_name)
            if property_value is not None:
                result[property_metadata.name] = property_value
                continue
            if property_metadata.is_required:

View on GitHub (pinned to c028a0c7dc)

Solutions

Pass the body as a JSON string under the configured `payload_argument_name` (default is typically `body`/`payload`).
Or enable `enable_dynamic_payload=True` so individual property arguments are assembled into the body.
`json.dumps(...)` any dict/list before assigning it to the payload argument.
Print the runner's `payload_argument_name` to confirm the expected key.

Example fix

# before
args = {"id": 1}  # body missing / not a string -> raises 1497
await runner.run_operation(op, args, options)

# after
import json
args = {"id": 1, runner.payload_argument_name: json.dumps({"name": "Rex"})}
await runner.run_operation(op, args, options)

Defensive patterns

Strategy: validation

Validate before calling

import json

def ensure_body_argument(runner, args, body):
    key = runner.payload_argument_name
    if key not in args or not isinstance(args[key], str):
        args[key] = body if isinstance(body, str) else json.dumps(body)
    return args

args = ensure_body_argument(runner, args, {"name": "Rex"})
await runner.run_operation(op, args, options)

Type guard

def has_string_payload(args, payload_arg_name) -> bool:
    return isinstance(args.get(payload_arg_name), str)

Try / catch

from semantic_kernel.exceptions import FunctionExecutionException

try:
    await runner.run_operation(op, args, options)
except FunctionExecutionException as e:
    if "No payload is provided" in str(e):
        args[runner.payload_argument_name] = json.dumps(body_dict)
        await runner.run_operation(op, args, options)
    else:
        raise

Prevention

When dynamic payload is off, always pass a JSON string body.
Use `json.dumps` on dicts/lists before assigning to the payload arg.
Print `runner.payload_argument_name` to confirm the expected key.
Wrap invocations to auto-fill the body argument.

When it happens

Trigger: Invoking an operation with a request body while `enable_dynamic_payload=False` and either not passing `payload_argument_name` in arguments, or passing a non-string (dict/list/None).

Common situations: Default mode (dynamic payload off) where the caller forgets the body; passing a dict expecting it to be serialized automatically; mismatch between the configured `payload_argument_name` and the key the caller used.

Related errors

AI-assisted analysis of microsoft/semantic-kernel@c028a0c7dc (2026-08-13). Data as JSON: /api/errors/0e8e23d6cb66e00c. Report an issue: GitHub.