Function llm_call_execute

crates/python/src/py_api/mod.rs:711–762

(
    py: Python<'py>,
    name: String,
    request: PyLLMRequest,
    func: Py<PyAny>,
    handle: Option<PyScopeHandle>,
    attributes: Option<PyLLMAttributes>,
    data: Option<&Bound<'py, PyAny>

) -> "object", text_signature = "(name: str, request: LlmRequest, func: object, *, handle: ScopeHandle | None = None, attributes: LlmAttributes | None = None, data: object | None = None, metadata: object | None = None, model_name: str | None = None, codec: object | None = None, response_codec: object | None = None) -> object")]
#[allow(clippy::too_many_arguments)]
fn llm_call_execute<'py>(
    py: Python<'py>,
    name: String,
    request: PyLLMRequest,
    func: Py<PyAny>,
    handle: Option<PyScopeHandle>,
    attributes: Option<PyLLMAttributes>,
    data: Option<&Bound<'py, PyAny>>,
    metadata: Option<&Bound<'py, PyAny>>,
    model_name: Option<String>,
    codec: Option<&Bound<'py, PyAny>>,
    response_codec: Option<&Bound<'py, PyAny>>,
) -> PyResult<Bound<'py, PyAny>> {
    let attrs = attributes
        .map(|a| a.inner)
        .unwrap_or(LlmAttributes::empty());
    let data_json = opt_py_to_json(data)?;
    let metadata_json = opt_py_to_json(metadata)?;
    let exec_fn = py_callable::wrap_py_llm_exec_fn(func);
    let default_fn: LlmExecutionNextFn = Arc::new(move |req| exec_fn(req));
    let parent_handle = handle.map(|h| h.inner).unwrap_or_else(task_scope_top);
    let codec_arc: Option<Arc<dyn LlmCodec>> = codec.map(|c| {
        Arc::new(py_callable::PyLlmCodecWrapper {
            py_codec: c.clone().unbind(),
        }) as Arc<dyn LlmCodec>
    });
    let response_codec_arc = py_llm_response_codec(response_codec);

    let scope_stack = current_scope_stack_handle();
    pyo3_async_runtimes::tokio::future_into_py(py, async move {
        TASK_SCOPE_STACK
            .scope(scope_stack, async move {
                let params = core_llm_api::LlmCallExecuteParams::builder()
                    .name(name)
                    .request(request.inner)
                    .func(default_fn)
                    .parent(parent_handle)
                    .attributes(attrs)
                    .data_opt(data_json)
                    .metadata_opt(metadata_json)
                    .model_name_opt(model_name)
                    .codec_opt(codec_arc)
                    .response_codec_opt(response_codec_arc)
                    .build();
                let result = core_llm_api::llm_call_execute(params)
                    .await
                    .map_err(to_py_err)?;
                Python::attach(|py| json_to_py(py, &result))
            })
            .await
    })
}

/// Execute a streaming LLM call through the full middleware pipeline.
///