reflow_api_services 0.2.1

#![allow(clippy::all, unused_imports, dead_code)]

//! Auto-generated API actors for Spoonacular
//!
//! Service: Spoonacular (spoonacular)
//! Food and recipe API with nutrition, ingredients, and meal planning
//!
//! Required env var: SPOONACULAR_API_KEY (API key)
//!
//! Generated by api-schema-gen codegen — do not edit manually.

use crate::{Actor, ActorBehavior, ClientBuilderExt, Message, Port};
use anyhow::{Error, Result};
use reflow_actor::{message::EncodableValue, ActorContext};
use reflow_actor_macro::actor;
use serde_json::{json, Value};
use std::collections::HashMap;
use std::time::Duration;

const BASE_URL: &str = "https://api.spoonacular.com";
const ENV_KEY: &str = "SPOONACULAR_API_KEY";

/// Apply authentication to the request builder.
fn apply_auth(
    config: &reflow_actor::ActorConfig,
    mut builder: reqwest::RequestBuilder,
) -> Result<reqwest::RequestBuilder> {
    let credential = config
        .get_config_or_env(ENV_KEY)
        .ok_or_else(|| anyhow::anyhow!("Missing env var: {}", ENV_KEY))?;
    builder = builder.query(&[("apiKey", &credential)]);
    Ok(builder)
}

/// search recipes via Spoonacular API
///
/// Method: GET /recipes/complexSearch
#[actor(
    SpoonacularSearchRecipesActor,
    inports::<100>(query, cuisine, diet, intolerances, number, offset),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_search_recipes(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/recipes/complexSearch".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("query") {
        query_pairs.push(("query", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("cuisine") {
        query_pairs.push(("cuisine", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("diet") {
        query_pairs.push(("diet", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("intolerances") {
        query_pairs.push(("intolerances", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("number") {
        query_pairs.push(("number", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("offset") {
        query_pairs.push(("offset", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /recipes/complexSearch failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// read recipe_information via Spoonacular API
///
/// Method: GET /recipes/{id}/information
#[actor(
    SpoonacularReadRecipeInformationActor,
    inports::<100>(id, includeNutrition),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_recipe_information(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/recipes/{id}/information".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("includeNutrition") {
        query_pairs.push(("includeNutrition", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /recipes/{{id}}/information failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get full information about a recipe including ingredients, nutrition, and diet info
///
/// Method: GET /recipes/{id}/information
#[actor(
    SpoonacularReadRecipeActor,
    inports::<100>(id, apiKey, includeNutrition, addWinePairing, addTasteData),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_recipe(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/recipes/{id}/information".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("includeNutrition") {
        query_pairs.push(("includeNutrition", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("addWinePairing") {
        query_pairs.push(("addWinePairing", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("addTasteData") {
        query_pairs.push(("addTasteData", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /recipes/{{id}}/information failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get information about multiple recipes at once
///
/// Method: GET /recipes/informationBulk
#[actor(
    SpoonacularListRecipesActor,
    inports::<100>(apiKey, ids, includeNutrition),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_list_recipes(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/recipes/informationBulk".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("ids") {
        query_pairs.push(("ids", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("includeNutrition") {
        query_pairs.push(("includeNutrition", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /recipes/informationBulk failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Find recipes similar to a given recipe
///
/// Method: GET /recipes/{id}/similar
#[actor(
    SpoonacularListSimilarRecipesActor,
    inports::<100>(id, apiKey, number),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_list_similar_recipes(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/recipes/{id}/similar".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("number") {
        query_pairs.push(("number", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /recipes/{{id}}/similar failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get random (popular) recipes with optional tag filtering
///
/// Method: GET /recipes/random
#[actor(
    SpoonacularListRandomRecipesActor,
    inports::<100>(apiKey, includeNutrition, include_tags, exclude_tags, number),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_list_random_recipes(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/recipes/random".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("includeNutrition") {
        query_pairs.push(("includeNutrition", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("include_tags") {
        query_pairs.push(("include-tags", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("exclude_tags") {
        query_pairs.push(("exclude-tags", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("number") {
        query_pairs.push(("number", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /recipes/random failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get taste profile (sweetness, saltiness, sourness, etc.) for a recipe
///
/// Method: GET /recipes/{id}/tasteWidget.json
#[actor(
    SpoonacularReadRecipeTasteActor,
    inports::<100>(id, apiKey, normalize),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_recipe_taste(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/recipes/{id}/tasteWidget.json".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("normalize") {
        query_pairs.push(("normalize", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /recipes/{{id}}/tasteWidget.json failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Get equipment needed for a recipe
///
/// Method: GET /recipes/{id}/equipmentWidget.json
#[actor(
    SpoonacularListRecipeEquipmentActor,
    inports::<100>(id, apiKey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_list_recipe_equipment(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/recipes/{id}/equipmentWidget.json".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /recipes/{{id}}/equipmentWidget.json failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Get price breakdown for recipe ingredients
///
/// Method: GET /recipes/{id}/priceBreakdownWidget.json
#[actor(
    SpoonacularReadRecipePriceBreakdownActor,
    inports::<100>(id, apiKey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_recipe_price_breakdown(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/recipes/{id}/priceBreakdownWidget.json".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "GET /recipes/{{id}}/priceBreakdownWidget.json failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Get ingredients for a recipe
///
/// Method: GET /recipes/{id}/ingredientWidget.json
#[actor(
    SpoonacularListRecipeIngredientsActor,
    inports::<100>(id, apiKey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_list_recipe_ingredients(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/recipes/{id}/ingredientWidget.json".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /recipes/{{id}}/ingredientWidget.json failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Get nutrition data for a recipe
///
/// Method: GET /recipes/{id}/nutritionWidget.json
#[actor(
    SpoonacularReadRecipeNutritionActor,
    inports::<100>(id, apiKey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_recipe_nutrition(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/recipes/{id}/nutritionWidget.json".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /recipes/{{id}}/nutritionWidget.json failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Get analyzed step-by-step cooking instructions for a recipe
///
/// Method: GET /recipes/{id}/analyzedInstructions
#[actor(
    SpoonacularListRecipeInstructionsActor,
    inports::<100>(id, apiKey, stepBreakdown),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_list_recipe_instructions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/recipes/{id}/analyzedInstructions".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("stepBreakdown") {
        query_pairs.push(("stepBreakdown", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /recipes/{{id}}/analyzedInstructions failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Extract recipe data from a website URL
///
/// Method: POST /recipes/extract
#[actor(
    SpoonacularAnalyzeRecipeActor,
    inports::<100>(apiKey, url, forceExtraction, analyze, includeNutrition, includeTaste),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_analyze_recipe(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/recipes/extract".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("url") {
        query_pairs.push(("url", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("forceExtraction") {
        query_pairs.push(("forceExtraction", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("analyze") {
        query_pairs.push(("analyze", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("includeNutrition") {
        query_pairs.push(("includeNutrition", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("includeTaste") {
        query_pairs.push(("includeTaste", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /recipes/extract failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get an automatically generated summary for a recipe
///
/// Method: GET /recipes/{id}/summary
#[actor(
    SpoonacularReadRecipeSummaryActor,
    inports::<100>(id, apiKey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_recipe_summary(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/recipes/{id}/summary".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /recipes/{{id}}/summary failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Extract and analyze step-by-step cooking instructions from text
///
/// Method: POST /recipes/analyzeInstructions
#[actor(
    SpoonacularAnalyzeRecipeInstructionsActor,
    inports::<100>(apiKey, instructions),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_analyze_recipe_instructions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/recipes/analyzeInstructions".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("instructions") {
        body.insert("instructions".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /recipes/analyzeInstructions failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Classify the cuisine of a recipe
///
/// Method: POST /recipes/cuisine
#[actor(
    SpoonacularAnalyzeCuisineActor,
    inports::<100>(apiKey, title, ingredientList, language),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_analyze_cuisine(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/recipes/cuisine".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("language") {
        query_pairs.push(("language", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("title") {
        body.insert("title".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("ingredientList") {
        body.insert("ingredientList".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /recipes/cuisine failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Parse and analyze a recipe search query
///
/// Method: GET /recipes/queries/analyze
#[actor(
    SpoonacularAnalyzeRecipeSearchQueryActor,
    inports::<100>(apiKey, q, language),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_analyze_recipe_search_query(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/recipes/queries/analyze".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("q") {
        query_pairs.push(("q", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("language") {
        query_pairs.push(("language", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /recipes/queries/analyze failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Autocomplete a recipe search query
///
/// Method: GET /recipes/autocomplete
#[actor(
    SpoonacularReadRecipeAutocompleteActor,
    inports::<100>(apiKey, query, number),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_recipe_autocomplete(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/recipes/autocomplete".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("query") {
        query_pairs.push(("query", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("number") {
        query_pairs.push(("number", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /recipes/autocomplete failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Estimate nutrition from a dish name
///
/// Method: GET /recipes/guessNutrition
#[actor(
    SpoonacularAnalyzeRecipeNutritionEstimateActor,
    inports::<100>(apiKey, title),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_analyze_recipe_nutrition_estimate(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/recipes/guessNutrition".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("title") {
        query_pairs.push(("title", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /recipes/guessNutrition failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Analyze a food image for nutrition and ingredient information
///
/// Method: POST /food/images/analyze
#[actor(
    SpoonacularAnalyzeFoodImageActor,
    inports::<100>(apiKey, file),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_analyze_food_image(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/images/analyze".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("file") {
        body.insert("file".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /food/images/analyze failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Search for ingredients and their details
///
/// Method: GET /food/ingredients/search
#[actor(
    SpoonacularSearchIngredientsActor,
    inports::<100>(apiKey, query, addChildren, minProteinPercent, maxProteinPercent, minFatPercent, maxFatPercent, minCarbsPercent, maxCarbsPercent, metaInformation, intolerances, sort, sortDirection, offset, number, language),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_search_ingredients(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/ingredients/search".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("query") {
        query_pairs.push(("query", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("addChildren") {
        query_pairs.push(("addChildren", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("minProteinPercent") {
        query_pairs.push(("minProteinPercent", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("maxProteinPercent") {
        query_pairs.push(("maxProteinPercent", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("minFatPercent") {
        query_pairs.push(("minFatPercent", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("maxFatPercent") {
        query_pairs.push(("maxFatPercent", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("minCarbsPercent") {
        query_pairs.push(("minCarbsPercent", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("maxCarbsPercent") {
        query_pairs.push(("maxCarbsPercent", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("metaInformation") {
        query_pairs.push(("metaInformation", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("intolerances") {
        query_pairs.push(("intolerances", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("sort") {
        query_pairs.push(("sort", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("sortDirection") {
        query_pairs.push(("sortDirection", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("offset") {
        query_pairs.push(("offset", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("number") {
        query_pairs.push(("number", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("language") {
        query_pairs.push(("language", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/ingredients/search failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get detailed information about an ingredient by ID
///
/// Method: GET /food/ingredients/{id}/information
#[actor(
    SpoonacularReadIngredientActor,
    inports::<100>(id, apiKey, amount, unit),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_ingredient(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/food/ingredients/{id}/information".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("amount") {
        query_pairs.push(("amount", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("unit") {
        query_pairs.push(("unit", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /food/ingredients/{{id}}/information failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Compute the amount of a ingredient you need to achieve a certain nutritional goal
///
/// Method: GET /food/ingredients/{id}/amount
#[actor(
    SpoonacularReadIngredientAmountActor,
    inports::<100>(id, apiKey, nutrient, target, unit),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_ingredient_amount(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/food/ingredients/{id}/amount".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("nutrient") {
        query_pairs.push(("nutrient", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("target") {
        query_pairs.push(("target", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("unit") {
        query_pairs.push(("unit", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/ingredients/{{id}}/amount failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Convert ingredient amounts between units
///
/// Method: GET /recipes/convert
#[actor(
    SpoonacularReadIngredientConversionActor,
    inports::<100>(apiKey, ingredientName, sourceAmount, sourceUnit, targetUnit),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_ingredient_conversion(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/recipes/convert".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("ingredientName") {
        query_pairs.push(("ingredientName", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("sourceAmount") {
        query_pairs.push(("sourceAmount", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("sourceUnit") {
        query_pairs.push(("sourceUnit", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("targetUnit") {
        query_pairs.push(("targetUnit", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /recipes/convert failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Parse and analyze a list of ingredients
///
/// Method: POST /recipes/parseIngredients
#[actor(
    SpoonacularAnalyzeIngredientsActor,
    inports::<100>(apiKey, ingredientList, servings, language, includeNutrition),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_analyze_ingredients(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/recipes/parseIngredients".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("language") {
        query_pairs.push(("language", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("ingredientList") {
        body.insert("ingredientList".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("servings") {
        body.insert("servings".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("includeNutrition") {
        body.insert("includeNutrition".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /recipes/parseIngredients failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Compute glycemic load of ingredients
///
/// Method: POST /food/ingredients/glycemicLoad
#[actor(
    SpoonacularReadGlycemicLoadActor,
    inports::<100>(apiKey, ingredients),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_glycemic_load(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/ingredients/glycemicLoad".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("ingredients") {
        body.insert("ingredients".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /food/ingredients/glycemicLoad failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get substitutes for an ingredient by name
///
/// Method: GET /food/ingredients/substitutes
#[actor(
    SpoonacularSearchIngredientSubstitutesActor,
    inports::<100>(apiKey, ingredientName),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_search_ingredient_substitutes(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/ingredients/substitutes".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("ingredientName") {
        query_pairs.push(("ingredientName", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/ingredients/substitutes failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Autocomplete ingredient search queries
///
/// Method: GET /food/ingredients/autocomplete
#[actor(
    SpoonacularReadIngredientAutocompleteActor,
    inports::<100>(apiKey, query, number, metaInformation, intolerances, language),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_ingredient_autocomplete(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/ingredients/autocomplete".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("query") {
        query_pairs.push(("query", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("number") {
        query_pairs.push(("number", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("metaInformation") {
        query_pairs.push(("metaInformation", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("intolerances") {
        query_pairs.push(("intolerances", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("language") {
        query_pairs.push(("language", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/ingredients/autocomplete failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Search grocery products
///
/// Method: GET /food/products/search
#[actor(
    SpoonacularSearchGroceryProductsActor,
    inports::<100>(apiKey, query, minCalories, maxCalories, minCarbs, maxCarbs, minProtein, maxProtein, minFat, maxFat, addProductInformation, offset, number),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_search_grocery_products(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/products/search".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("query") {
        query_pairs.push(("query", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("minCalories") {
        query_pairs.push(("minCalories", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("maxCalories") {
        query_pairs.push(("maxCalories", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("minCarbs") {
        query_pairs.push(("minCarbs", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("maxCarbs") {
        query_pairs.push(("maxCarbs", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("minProtein") {
        query_pairs.push(("minProtein", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("maxProtein") {
        query_pairs.push(("maxProtein", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("minFat") {
        query_pairs.push(("minFat", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("maxFat") {
        query_pairs.push(("maxFat", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("addProductInformation") {
        query_pairs.push(("addProductInformation", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("offset") {
        query_pairs.push(("offset", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("number") {
        query_pairs.push(("number", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/products/search failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get product information by UPC barcode
///
/// Method: GET /food/products/upc/{upc}
#[actor(
    SpoonacularReadGroceryProductActor,
    inports::<100>(upc, apiKey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_grocery_product(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/food/products/upc/{upc}".to_string();
    if let Some(val) = inputs.get("upc") {
        endpoint = endpoint.replace("{{upc}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/products/upc/{{upc}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Find products comparable to a given product
///
/// Method: GET /food/products/comparable/{id}
#[actor(
    SpoonacularListComparableProductsActor,
    inports::<100>(id, apiKey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_list_comparable_products(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/food/products/comparable/{id}".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /food/products/comparable/{{id}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Autocomplete product search queries
///
/// Method: GET /food/products/suggest
#[actor(
    SpoonacularReadProductAutocompleteActor,
    inports::<100>(apiKey, query, number),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_product_autocomplete(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/products/suggest".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("query") {
        query_pairs.push(("query", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("number") {
        query_pairs.push(("number", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/products/suggest failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Classify a grocery product by category
///
/// Method: POST /food/products/classify
#[actor(
    SpoonacularAnalyzeGroceryProductActor,
    inports::<100>(apiKey, title, upc, pureIngredient),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_analyze_grocery_product(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/products/classify".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("title") {
        body.insert("title".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("upc") {
        body.insert("upc".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("pureIngredient") {
        body.insert("pureIngredient".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /food/products/classify failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Classify a batch of grocery products
///
/// Method: POST /food/products/classifyBatch
#[actor(
    SpoonacularAnalyzeGroceryProductsActor,
    inports::<100>(apiKey, products),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_analyze_grocery_products(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/products/classifyBatch".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("products") {
        body.insert("products".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /food/products/classifyBatch failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Search restaurant menu items
///
/// Method: GET /food/menuItems/search
#[actor(
    SpoonacularSearchMenuItemsActor,
    inports::<100>(apiKey, query, minCalories, maxCalories, minCarbs, maxCarbs, minProtein, maxProtein, minFat, maxFat, addMenuItemInformation, offset, number),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_search_menu_items(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/menuItems/search".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("query") {
        query_pairs.push(("query", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("minCalories") {
        query_pairs.push(("minCalories", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("maxCalories") {
        query_pairs.push(("maxCalories", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("minCarbs") {
        query_pairs.push(("minCarbs", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("maxCarbs") {
        query_pairs.push(("maxCarbs", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("minProtein") {
        query_pairs.push(("minProtein", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("maxProtein") {
        query_pairs.push(("maxProtein", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("minFat") {
        query_pairs.push(("minFat", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("maxFat") {
        query_pairs.push(("maxFat", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("addMenuItemInformation") {
        query_pairs.push(("addMenuItemInformation", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("offset") {
        query_pairs.push(("offset", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("number") {
        query_pairs.push(("number", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/menuItems/search failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get menu item information by ID
///
/// Method: GET /food/menuItems/{id}
#[actor(
    SpoonacularReadMenuItemActor,
    inports::<100>(id, apiKey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_menu_item(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/food/menuItems/{id}".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/menuItems/{{id}} failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Autocomplete menu item search queries
///
/// Method: GET /food/menuItems/suggest
#[actor(
    SpoonacularReadMenuItemAutocompleteActor,
    inports::<100>(apiKey, query, number),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_menu_item_autocomplete(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/menuItems/suggest".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("query") {
        query_pairs.push(("query", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("number") {
        query_pairs.push(("number", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/menuItems/suggest failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get a user's meal plan for a given week
///
/// Method: GET /mealplanner/{username}/week/{start-date}
#[actor(
    SpoonacularReadMealPlanWeekActor,
    inports::<100>(username, start_date, apiKey, hash),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_meal_plan_week(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/mealplanner/{username}/week/{start-date}".to_string();
    if let Some(val) = inputs.get("username") {
        endpoint = endpoint.replace("{{username}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("start_date") {
        endpoint = endpoint.replace("{{start-date}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("hash") {
        query_pairs.push(("hash", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "GET /mealplanner/{{username}}/week/{{start-date}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Get a user's meal plan for a given day
///
/// Method: GET /mealplanner/{username}/day/{date}
#[actor(
    SpoonacularReadMealPlanDayActor,
    inports::<100>(username, date, apiKey, hash),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_meal_plan_day(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/mealplanner/{username}/day/{date}".to_string();
    if let Some(val) = inputs.get("username") {
        endpoint = endpoint.replace("{{username}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("date") {
        endpoint = endpoint.replace("{{date}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("hash") {
        query_pairs.push(("hash", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /mealplanner/{{username}}/day/{{date}} failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Generate a meal plan for a given time frame
///
/// Method: GET /mealplanner/generate
#[actor(
    SpoonacularGenerateMealPlanActor,
    inports::<100>(apiKey, timeFrame, targetCalories, diet, exclude),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_generate_meal_plan(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/mealplanner/generate".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("timeFrame") {
        query_pairs.push(("timeFrame", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("targetCalories") {
        query_pairs.push(("targetCalories", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("diet") {
        query_pairs.push(("diet", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("exclude") {
        query_pairs.push(("exclude", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /mealplanner/generate failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Add an item to a user's meal plan
///
/// Method: POST /mealplanner/{username}/items
#[actor(
    SpoonacularCreateMealPlanItemActor,
    inports::<100>(username, apiKey, hash, date, slot, position, type_, value),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_create_meal_plan_item(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/mealplanner/{username}/items".to_string();
    if let Some(val) = inputs.get("username") {
        endpoint = endpoint.replace("{{username}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("hash") {
        query_pairs.push(("hash", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("date") {
        body.insert("date".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("slot") {
        body.insert("slot".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("position") {
        body.insert("position".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("type_") {
        body.insert("type".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("value") {
        body.insert("value".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("POST /mealplanner/{{username}}/items failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Clear all meals for a specific day from the meal plan
///
/// Method: DELETE /mealplanner/{username}/day/{date}
#[actor(
    SpoonacularDeleteMealPlanDayActor,
    inports::<100>(username, date, apiKey, hash),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_delete_meal_plan_day(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/mealplanner/{username}/day/{date}".to_string();
    if let Some(val) = inputs.get("username") {
        endpoint = endpoint.replace("{{username}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("date") {
        endpoint = endpoint.replace("{{date}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("hash") {
        query_pairs.push(("hash", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "DELETE /mealplanner/{{username}}/day/{{date}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Delete a specific item from the meal plan
///
/// Method: DELETE /mealplanner/{username}/items/{id}
#[actor(
    SpoonacularDeleteMealPlanItemActor,
    inports::<100>(username, id, apiKey, hash),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_delete_meal_plan_item(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/mealplanner/{username}/items/{id}".to_string();
    if let Some(val) = inputs.get("username") {
        endpoint = endpoint.replace("{{username}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("hash") {
        query_pairs.push(("hash", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "DELETE /mealplanner/{{username}}/items/{{id}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Get the user's shopping list
///
/// Method: GET /mealplanner/{username}/shopping-list
#[actor(
    SpoonacularReadShoppingListActor,
    inports::<100>(username, apiKey, hash),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_shopping_list(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/mealplanner/{username}/shopping-list".to_string();
    if let Some(val) = inputs.get("username") {
        endpoint = endpoint.replace("{{username}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("hash") {
        query_pairs.push(("hash", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /mealplanner/{{username}}/shopping-list failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Add an item to the shopping list
///
/// Method: POST /mealplanner/{username}/shopping-list/items
#[actor(
    SpoonacularCreateShoppingListItemActor,
    inports::<100>(username, apiKey, hash, item, aisle, parse),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_create_shopping_list_item(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/mealplanner/{username}/shopping-list/items".to_string();
    if let Some(val) = inputs.get("username") {
        endpoint = endpoint.replace("{{username}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("hash") {
        query_pairs.push(("hash", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("item") {
        body.insert("item".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("aisle") {
        body.insert("aisle".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("parse") {
        body.insert("parse".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "POST /mealplanner/{{username}}/shopping-list/items failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Delete an item from the shopping list
///
/// Method: DELETE /mealplanner/{username}/shopping-list/items/{id}
#[actor(
    SpoonacularDeleteShoppingListItemActor,
    inports::<100>(username, id, apiKey, hash),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_delete_shopping_list_item(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/mealplanner/{username}/shopping-list/items/{id}".to_string();
    if let Some(val) = inputs.get("username") {
        endpoint = endpoint.replace("{{username}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("hash") {
        query_pairs.push(("hash", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "DELETE /mealplanner/{{username}}/shopping-list/items/{{id}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Generate a shopping list from meal plan over a date range
///
/// Method: POST /mealplanner/{username}/shopping-list/{start-date}/{end-date}
#[actor(
    SpoonacularGenerateShoppingListActor,
    inports::<100>(username, start_date, end_date, apiKey, hash),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_generate_shopping_list(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/mealplanner/{username}/shopping-list/{start-date}/{end-date}".to_string();
    if let Some(val) = inputs.get("username") {
        endpoint = endpoint.replace("{{username}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("start_date") {
        endpoint = endpoint.replace("{{start-date}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("end_date") {
        endpoint = endpoint.replace("{{end-date}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("hash") {
        query_pairs.push(("hash", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert("error".to_string(), Message::Error(format!("POST /mealplanner/{{username}}/shopping-list/{{start-date}}/{{end-date}} failed: {}", e).into()));
        }
    }

    Ok(output)
}

/// Connect a user to the meal planner to get a hash for subsequent requests
///
/// Method: GET /users/connect
#[actor(
    SpoonacularCreateUserActor,
    inports::<100>(apiKey, username, firstName, lastName, email),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_create_user(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/users/connect".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /users/connect failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get wine pairings for a food item
///
/// Method: GET /food/wine/pairing
#[actor(
    SpoonacularReadWinePairingActor,
    inports::<100>(apiKey, food, maxPrice),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_wine_pairing(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/wine/pairing".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("food") {
        query_pairs.push(("food", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("maxPrice") {
        query_pairs.push(("maxPrice", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/wine/pairing failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get dishes that pair well with a given wine
///
/// Method: GET /food/wine/dishes
#[actor(
    SpoonacularReadDishPairingActor,
    inports::<100>(apiKey, wine),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_dish_pairing(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/wine/dishes".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("wine") {
        query_pairs.push(("wine", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/wine/dishes failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get a description of a wine variety
///
/// Method: GET /food/wine/description
#[actor(
    SpoonacularReadWineDescriptionActor,
    inports::<100>(apiKey, wine),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_wine_description(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/wine/description".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("wine") {
        query_pairs.push(("wine", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/wine/description failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get wine product recommendations for a given wine variety
///
/// Method: GET /food/wine/recommendation
#[actor(
    SpoonacularListWineRecommendationsActor,
    inports::<100>(apiKey, wine, maxPrice, minRating, number),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_list_wine_recommendations(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/wine/recommendation".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("wine") {
        query_pairs.push(("wine", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("maxPrice") {
        query_pairs.push(("maxPrice", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("minRating") {
        query_pairs.push(("minRating", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("number") {
        query_pairs.push(("number", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/wine/recommendation failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Search all food (recipes, grocery products, menu items, simple foods)
///
/// Method: GET /food/search
#[actor(
    SpoonacularSearchFoodActor,
    inports::<100>(apiKey, query, type_, cuisine, diet, intolerances, offset, number),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_search_food(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/search".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("query") {
        query_pairs.push(("query", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("type_") {
        query_pairs.push(("type", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("cuisine") {
        query_pairs.push(("cuisine", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("diet") {
        query_pairs.push(("diet", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("intolerances") {
        query_pairs.push(("intolerances", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("offset") {
        query_pairs.push(("offset", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("number") {
        query_pairs.push(("number", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/search failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Search for food videos
///
/// Method: GET /food/videos/search
#[actor(
    SpoonacularSearchFoodVideosActor,
    inports::<100>(apiKey, query, type_, cuisine, diet, includeIngredients, excludeIngredients, minLength, maxLength, offset, number),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_search_food_videos(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/videos/search".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("query") {
        query_pairs.push(("query", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("type_") {
        query_pairs.push(("type", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("cuisine") {
        query_pairs.push(("cuisine", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("diet") {
        query_pairs.push(("diet", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("includeIngredients") {
        query_pairs.push(("includeIngredients", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("excludeIngredients") {
        query_pairs.push(("excludeIngredients", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("minLength") {
        query_pairs.push(("minLength", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("maxLength") {
        query_pairs.push(("maxLength", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("offset") {
        query_pairs.push(("offset", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("number") {
        query_pairs.push(("number", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/videos/search failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Answer a food-related question using natural language
///
/// Method: GET /recipes/quickAnswer
#[actor(
    SpoonacularReadQuickAnswerActor,
    inports::<100>(apiKey, q),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_quick_answer(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/recipes/quickAnswer".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("q") {
        query_pairs.push(("q", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /recipes/quickAnswer failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Detect food items in a text body
///
/// Method: POST /food/detect
#[actor(
    SpoonacularAnalyzeFoodTextActor,
    inports::<100>(apiKey, text),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_analyze_food_text(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/detect".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("text") {
        body.insert("text".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /food/detect failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Search spoonacular.com site content
///
/// Method: GET /food/site/search
#[actor(
    SpoonacularSearchSiteContentActor,
    inports::<100>(apiKey, query),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_search_site_content(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/site/search".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("query") {
        query_pairs.push(("query", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/site/search failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get a random food joke
///
/// Method: GET /food/jokes/random
#[actor(
    SpoonacularReadRandomFoodJokeActor,
    inports::<100>(apiKey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_random_food_joke(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/jokes/random".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/jokes/random failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get a random food trivia fact
///
/// Method: GET /food/trivia/random
#[actor(
    SpoonacularReadRandomFoodTriviaActor,
    inports::<100>(apiKey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_random_food_trivia(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/trivia/random".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/trivia/random failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Talk to the food chatbot for recipe recommendations
///
/// Method: GET /food/converse
#[actor(
    SpoonacularReadChatbotActor,
    inports::<100>(apiKey, text, contextId),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_chatbot(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/converse".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("text") {
        query_pairs.push(("text", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("contextId") {
        query_pairs.push(("contextId", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/converse failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get conversation suggestions for the chatbot
///
/// Method: GET /food/converse/suggest
#[actor(
    SpoonacularListChatbotSuggestionsActor,
    inports::<100>(apiKey, query, number),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_list_chatbot_suggestions(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/food/converse/suggest".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("query") {
        query_pairs.push(("query", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("number") {
        query_pairs.push(("number", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /food/converse/suggest failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Create a recipe card image
///
/// Method: POST /recipes/visualizeRecipe
#[actor(
    SpoonacularCreateRecipeCardActor,
    inports::<100>(apiKey, title, ingredients, instructions, readyInMinutes, servings, mask, backgroundImage, author, backgroundColor, fontColor, source),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_create_recipe_card(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let endpoint = "/recipes/visualizeRecipe".to_string();

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("title") {
        body.insert("title".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("ingredients") {
        body.insert("ingredients".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("instructions") {
        body.insert("instructions".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("readyInMinutes") {
        body.insert("readyInMinutes".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("servings") {
        body.insert("servings".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("mask") {
        body.insert("mask".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("backgroundImage") {
        body.insert("backgroundImage".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("author") {
        body.insert("author".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("backgroundColor") {
        body.insert("backgroundColor".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("fontColor") {
        body.insert("fontColor".to_string(), val.clone().into());
    }
    if let Some(val) = inputs.get("source") {
        body.insert("source".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("POST /recipes/visualizeRecipe failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get the recipe card for an existing recipe
///
/// Method: GET /recipes/{id}/card
#[actor(
    SpoonacularReadRecipeCardActor,
    inports::<100>(id, apiKey),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_recipe_card(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/recipes/{id}/card".to_string();
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(format!("GET /recipes/{{id}}/card failed: {}", e).into()),
            );
        }
    }

    Ok(output)
}

/// Get all meal plan templates for a user
///
/// Method: GET /mealplanner/{username}/templates
#[actor(
    SpoonacularListMealPlanTemplatesActor,
    inports::<100>(username, apiKey, hash),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_list_meal_plan_templates(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/mealplanner/{username}/templates".to_string();
    if let Some(val) = inputs.get("username") {
        endpoint = endpoint.replace("{{username}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("hash") {
        query_pairs.push(("hash", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("GET /mealplanner/{{username}}/templates failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Get a specific meal plan template
///
/// Method: GET /mealplanner/{username}/templates/{id}
#[actor(
    SpoonacularReadMealPlanTemplateActor,
    inports::<100>(username, id, apiKey, hash),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_read_meal_plan_template(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/mealplanner/{username}/templates/{id}".to_string();
    if let Some(val) = inputs.get("username") {
        endpoint = endpoint.replace("{{username}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.get(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("hash") {
        query_pairs.push(("hash", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "GET /mealplanner/{{username}}/templates/{{id}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Create a meal plan template
///
/// Method: POST /mealplanner/{username}/templates
#[actor(
    SpoonacularCreateMealPlanTemplateActor,
    inports::<100>(username, apiKey, hash, name),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_create_meal_plan_template(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/mealplanner/{username}/templates".to_string();
    if let Some(val) = inputs.get("username") {
        endpoint = endpoint.replace("{{username}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.post(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("hash") {
        query_pairs.push(("hash", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut body = serde_json::Map::new();
    if let Some(val) = inputs.get("name") {
        body.insert("name".to_string(), val.clone().into());
    }
    if !body.is_empty() {
        builder = builder.json(&serde_json::Value::Object(body));
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!("POST /mealplanner/{{username}}/templates failed: {}", e).into(),
                ),
            );
        }
    }

    Ok(output)
}

/// Delete a meal plan template
///
/// Method: DELETE /mealplanner/{username}/templates/{id}
#[actor(
    SpoonacularDeleteMealPlanTemplateActor,
    inports::<100>(username, id, apiKey, hash),
    outports::<50>(response, error),
    state(MemoryState)
)]
pub async fn spoonacular_delete_meal_plan_template(
    context: ActorContext,
) -> Result<HashMap<String, Message>, Error> {
    let inputs = context.get_payload();
    let actor_config = context.get_config();

    let mut endpoint = "/mealplanner/{username}/templates/{id}".to_string();
    if let Some(val) = inputs.get("username") {
        endpoint = endpoint.replace("{{username}}", &super::message_to_str(val));
    }
    if let Some(val) = inputs.get("id") {
        endpoint = endpoint.replace("{{id}}", &super::message_to_str(val));
    }

    let url = format!("{}{}", BASE_URL.trim_end_matches('/'), endpoint);

    let client = reqwest::Client::builder()
        .timeout_compat(Duration::from_secs(30))
        .build()?;

    let mut builder = client.delete(&url);
    builder = builder.header("Content-Type", "application/json");
    builder = apply_auth(actor_config, builder)?;

    let mut query_pairs: Vec<(&str, String)> = Vec::new();
    if let Some(val) = inputs.get("apiKey") {
        query_pairs.push(("apiKey", super::message_to_str(val)));
    }
    if let Some(val) = inputs.get("hash") {
        query_pairs.push(("hash", super::message_to_str(val)));
    }
    if !query_pairs.is_empty() {
        builder = builder.query(&query_pairs);
    }

    let mut output = HashMap::new();
    match builder.send().await {
        Ok(resp) => {
            let status = resp.status().as_u16();
            let headers: HashMap<String, String> = resp
                .headers()
                .iter()
                .filter_map(|(k, v)| v.to_str().ok().map(|val| (k.to_string(), val.to_string())))
                .collect();
            let body_text = resp.text().await.unwrap_or_default();
            let body_value: Value =
                serde_json::from_str(&body_text).unwrap_or(Value::String(body_text));
            output.insert(
                "response".to_string(),
                Message::object(EncodableValue::from(json!({
                    "status": status,
                    "headers": headers,
                    "body": body_value,
                }))),
            );
        }
        Err(e) => {
            output.insert(
                "error".to_string(),
                Message::Error(
                    format!(
                        "DELETE /mealplanner/{{username}}/templates/{{id}} failed: {}",
                        e
                    )
                    .into(),
                ),
            );
        }
    }

    Ok(output)
}