microsoft/semantic-kernel · error · FunctionExecutionException

No argument is found for the '{property_metadata.name}' payl

Error message

No argument is found for the '{property_metadata.name}' payload property.

What it means

Inside `build_json_object`, for each non-object payload property the runner looks up its argument by derived name; if the value is None and `property_metadata.is_required` is True, it raises `FunctionExecutionException` naming the property. Optional properties with no value are silently omitted.

Source

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

        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:
                raise FunctionExecutionException(
                    f"No argument is found for the '{property_metadata.name}' payload property."
                )
        return result

    def build_operation_payload(
        self, operation: RestApiOperation, arguments: KernelArguments
    ) -> tuple[str, str] | tuple[None, None]:
        """Build the operation payload."""
        if operation.request_body is None and self.payload_argument_name not in arguments:
            return None, None

        if operation.request_body is not None:
            return self.build_json_payload(operation.request_body, arguments)

        return None, None

    def get_argument_name_for_payload(self, property_name, property_namespace=None):
        """Get argument name for the payload."""

View on GitHub (pinned to c028a0c7dc)

Solutions

Provide the missing required property value under the argument name the runner expects (use `get_argument_name_for_payload` to compute it for nested props).
Mark the property as not required in the spec, or give it a default, if it is genuinely optional.
Inspect `payload_metadata.properties` to enumerate required fields and their expected argument names before invoking.
Switch to non-dynamic mode and pass the whole body as a JSON string if assembling fields is impractical.

Example fix

# before
args = {}  # required 'name' missing -> raises 1498
await runner.run_operation(op, args, options)

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

Defensive patterns

Strategy: validation

Validate before calling

def required_payload_props(payload) -> list[str]:
    out = []
    for p in (payload.properties if payload else []):
        if getattr(p, "is_required", False) and getattr(p, "type", None) != "object":
            out.append(p.name)
    return out

def missing_required_props(runner, payload, args) -> list[str]:
    missing = []
    for name in required_payload_props(payload):
        arg_name = runner.get_argument_name_for_payload(name, None)
        if args.get(arg_name) is None:
            missing.append(name)
    return missing

missing = missing_required_props(runner, op.payload, args)
assert not missing, f"Missing required payload props: {missing}"

Type guard

def is_required_payload_property(p) -> bool:
    return bool(getattr(p, "is_required", False))

Try / catch

from semantic_kernel.exceptions import FunctionExecutionException

try:
    await runner.run_operation(op, args, options)
except FunctionExecutionException as e:
    if "No argument is found for the" in str(e) and "payload property" in str(e):
        # extract property name, fill it, retry
        raise
    raise

Prevention

Enumerate required payload fields from `payload.properties` before invoking.
Compute argument names via `get_argument_name_for_payload` for nested props.
Make required fields optional or defaulted in the spec if they can be omitted.
Fall back to whole-body string mode if field assembly is fragile.

When it happens

Trigger: Dynamic payload building is on, and a required payload property has no matching argument (or is explicitly None). The argument name is derived via `get_argument_name_for_payload` which namespaces nested properties.

Common situations: Forgetting a required body field; passing it under the un-namespaced name when the property is nested; model/function-calling not surfacing the field; schema rename that changed the expected argument name.

Related errors

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