gestalt-sdk 0.0.1-alpha.26

// Code generated by sdkgen. DO NOT EDIT.

//! Generated wire conversions for app.proto.

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

use crate::codec::support::to_wire_struct;
use crate::generated::v1;
use crate::public::generated::app::{AppInvokeGraphQLRequest, AppInvokeRequest};

/// Encodes a wire `SubjectPermissionContext` as protobuf JSON.
pub(crate) fn encode_wire_subject_permission_context_json(
    value: &v1::SubjectPermissionContext,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.app.is_empty() {
        object.insert(
            "app".into(),
            serde_json::Value::String(value.app.to_string()),
        );
    }
    if !value.operations.is_empty() {
        object.insert(
            "operations".into(),
            serde_json::Value::Array(
                value
                    .operations
                    .iter()
                    .map(|item| serde_json::Value::String(item.to_string()))
                    .collect(),
            ),
        );
    }
    if value.all_operations {
        object.insert(
            "allOperations".into(),
            serde_json::Value::Bool(value.all_operations),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `SubjectPermissionContext`.
pub(crate) fn decode_wire_subject_permission_context_json(
    value: &serde_json::Value,
) -> Result<v1::SubjectPermissionContext, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::SubjectPermissionContext {
        app: match object.get("app") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        operations: match object.get("operations") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for operations")
                })?
                .iter()
                .map(|item| {
                    Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                        crate::public::proto_json::decode_string(item)?,
                    )
                })
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        all_operations: match object.get("allOperations") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        ..Default::default()
    })
}

/// Encodes a wire `SubjectContext` as protobuf JSON.
pub(crate) fn encode_wire_subject_context_json(value: &v1::SubjectContext) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.id.is_empty() {
        object.insert("id".into(), serde_json::Value::String(value.id.to_string()));
    }
    if !value.email.is_empty() {
        object.insert(
            "email".into(),
            serde_json::Value::String(value.email.to_string()),
        );
    }
    if !value.display_name.is_empty() {
        object.insert(
            "displayName".into(),
            serde_json::Value::String(value.display_name.to_string()),
        );
    }
    if !value.scopes.is_empty() {
        object.insert(
            "scopes".into(),
            serde_json::Value::Array(
                value
                    .scopes
                    .iter()
                    .map(|item| serde_json::Value::String(item.to_string()))
                    .collect(),
            ),
        );
    }
    if !value.permissions.is_empty() {
        object.insert(
            "permissions".into(),
            serde_json::Value::Array(
                value
                    .permissions
                    .iter()
                    .map(|item| encode_wire_subject_permission_context_json(item))
                    .collect(),
            ),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `SubjectContext`.
pub(crate) fn decode_wire_subject_context_json(
    value: &serde_json::Value,
) -> Result<v1::SubjectContext, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::SubjectContext {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        email: match object.get("email") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        display_name: match object.get("displayName") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        scopes: match object.get("scopes") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for scopes")
                })?
                .iter()
                .map(|item| {
                    Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                        crate::public::proto_json::decode_string(item)?,
                    )
                })
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        permissions: match object.get("permissions") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for permissions")
                })?
                .iter()
                .map(|item| decode_wire_subject_permission_context_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `AgentToolRef` as protobuf JSON.
pub(crate) fn encode_wire_agent_tool_ref_json(value: &v1::AgentToolRef) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.app.is_empty() {
        object.insert(
            "app".into(),
            serde_json::Value::String(value.app.to_string()),
        );
    }
    if !value.operation.is_empty() {
        object.insert(
            "operation".into(),
            serde_json::Value::String(value.operation.to_string()),
        );
    }
    if !value.connection.is_empty() {
        object.insert(
            "connection".into(),
            serde_json::Value::String(value.connection.to_string()),
        );
    }
    if !value.instance.is_empty() {
        object.insert(
            "instance".into(),
            serde_json::Value::String(value.instance.to_string()),
        );
    }
    if !value.title.is_empty() {
        object.insert(
            "title".into(),
            serde_json::Value::String(value.title.to_string()),
        );
    }
    if !value.description.is_empty() {
        object.insert(
            "description".into(),
            serde_json::Value::String(value.description.to_string()),
        );
    }
    if !value.credential_mode.is_empty() {
        object.insert(
            "credentialMode".into(),
            serde_json::Value::String(value.credential_mode.to_string()),
        );
    }
    if !value.system.is_empty() {
        object.insert(
            "system".into(),
            serde_json::Value::String(value.system.to_string()),
        );
    }
    if let Some(inner) = &value.run_as {
        object.insert("runAs".into(), encode_wire_subject_context_json(inner));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentToolRef`.
pub(crate) fn decode_wire_agent_tool_ref_json(
    value: &serde_json::Value,
) -> Result<v1::AgentToolRef, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::AgentToolRef {
        app: match object.get("app") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        operation: match object.get("operation") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        connection: match object.get("connection") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        instance: match object.get("instance") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        title: match object.get("title") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        description: match object.get("description") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        credential_mode: match object.get("credentialMode") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        system: match object.get("system") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        run_as: object
            .get("runAs")
            .map(|value| decode_wire_subject_context_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Converts a native `AppInvokeGraphQLRequest` to its wire message.
pub(crate) fn to_wire_app_invoke_graphql_request(
    value: AppInvokeGraphQLRequest,
) -> v1::AppInvokeGraphQlRequest {
    v1::AppInvokeGraphQlRequest {
        app: value.app,
        document: value.document,
        variables: value.variables.map(to_wire_struct),
        connection: value.connection,
        instance: value.instance,
        idempotency_key: value.idempotency_key,
        context: None,
        headers: value.headers,
        ..Default::default()
    }
}

/// Encodes a wire `CredentialContext` as protobuf JSON.
pub(crate) fn encode_wire_credential_context_json(
    value: &v1::CredentialContext,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.mode.is_empty() {
        object.insert(
            "mode".into(),
            serde_json::Value::String(value.mode.to_string()),
        );
    }
    if !value.subject_id.is_empty() {
        object.insert(
            "subjectId".into(),
            serde_json::Value::String(value.subject_id.to_string()),
        );
    }
    if !value.connection.is_empty() {
        object.insert(
            "connection".into(),
            serde_json::Value::String(value.connection.to_string()),
        );
    }
    if !value.instance.is_empty() {
        object.insert(
            "instance".into(),
            serde_json::Value::String(value.instance.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `CredentialContext`.
pub(crate) fn decode_wire_credential_context_json(
    value: &serde_json::Value,
) -> Result<v1::CredentialContext, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::CredentialContext {
        mode: match object.get("mode") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        subject_id: match object.get("subjectId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        connection: match object.get("connection") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        instance: match object.get("instance") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `AccessContext` as protobuf JSON.
pub(crate) fn encode_wire_access_context_json(value: &v1::AccessContext) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.policy.is_empty() {
        object.insert(
            "policy".into(),
            serde_json::Value::String(value.policy.to_string()),
        );
    }
    if !value.role.is_empty() {
        object.insert(
            "role".into(),
            serde_json::Value::String(value.role.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AccessContext`.
pub(crate) fn decode_wire_access_context_json(
    value: &serde_json::Value,
) -> Result<v1::AccessContext, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::AccessContext {
        policy: match object.get("policy") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        role: match object.get("role") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `HostContext` as protobuf JSON.
pub(crate) fn encode_wire_host_context_json(value: &v1::HostContext) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.public_base_url.is_empty() {
        object.insert(
            "publicBaseUrl".into(),
            serde_json::Value::String(value.public_base_url.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `HostContext`.
pub(crate) fn decode_wire_host_context_json(
    value: &serde_json::Value,
) -> Result<v1::HostContext, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::HostContext {
        public_base_url: match object.get("publicBaseUrl") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `ProviderContext` as protobuf JSON.
pub(crate) fn encode_wire_provider_context_json(value: &v1::ProviderContext) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.kind.is_empty() {
        object.insert(
            "kind".into(),
            serde_json::Value::String(value.kind.to_string()),
        );
    }
    if !value.name.is_empty() {
        object.insert(
            "name".into(),
            serde_json::Value::String(value.name.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ProviderContext`.
pub(crate) fn decode_wire_provider_context_json(
    value: &serde_json::Value,
) -> Result<v1::ProviderContext, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::ProviderContext {
        kind: match object.get("kind") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        name: match object.get("name") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `InvocationContext` as protobuf JSON.
pub(crate) fn encode_wire_invocation_context_json(
    value: &v1::InvocationContext,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.request_id.is_empty() {
        object.insert(
            "requestId".into(),
            serde_json::Value::String(value.request_id.to_string()),
        );
    }
    if value.depth != 0 {
        object.insert("depth".into(), serde_json::json!(value.depth));
    }
    if !value.call_chain.is_empty() {
        object.insert(
            "callChain".into(),
            serde_json::Value::Array(
                value
                    .call_chain
                    .iter()
                    .map(|item| serde_json::Value::String(item.to_string()))
                    .collect(),
            ),
        );
    }
    if !value.surface.is_empty() {
        object.insert(
            "surface".into(),
            serde_json::Value::String(value.surface.to_string()),
        );
    }
    if value.internal_connection_access {
        object.insert(
            "internalConnectionAccess".into(),
            serde_json::Value::Bool(value.internal_connection_access),
        );
    }
    if !value.connection.is_empty() {
        object.insert(
            "connection".into(),
            serde_json::Value::String(value.connection.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `InvocationContext`.
pub(crate) fn decode_wire_invocation_context_json(
    value: &serde_json::Value,
) -> Result<v1::InvocationContext, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::InvocationContext {
        request_id: match object.get("requestId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        depth: match object.get("depth") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        call_chain: match object.get("callChain") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for callChain")
                })?
                .iter()
                .map(|item| {
                    Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                        crate::public::proto_json::decode_string(item)?,
                    )
                })
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        surface: match object.get("surface") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        internal_connection_access: match object.get("internalConnectionAccess") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        connection: match object.get("connection") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `RequestMetaContext` as protobuf JSON.
pub(crate) fn encode_wire_request_meta_context_json(
    value: &v1::RequestMetaContext,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.client_ip.is_empty() {
        object.insert(
            "clientIp".into(),
            serde_json::Value::String(value.client_ip.to_string()),
        );
    }
    if !value.remote_addr.is_empty() {
        object.insert(
            "remoteAddr".into(),
            serde_json::Value::String(value.remote_addr.to_string()),
        );
    }
    if !value.user_agent.is_empty() {
        object.insert(
            "userAgent".into(),
            serde_json::Value::String(value.user_agent.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `RequestMetaContext`.
pub(crate) fn decode_wire_request_meta_context_json(
    value: &serde_json::Value,
) -> Result<v1::RequestMetaContext, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::RequestMetaContext {
        client_ip: match object.get("clientIp") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        remote_addr: match object.get("remoteAddr") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        user_agent: match object.get("userAgent") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `AgentInvocationContext` as protobuf JSON.
pub(crate) fn encode_wire_agent_invocation_context_json(
    value: &v1::AgentInvocationContext,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.provider_name.is_empty() {
        object.insert(
            "providerName".into(),
            serde_json::Value::String(value.provider_name.to_string()),
        );
    }
    if !value.session_id.is_empty() {
        object.insert(
            "sessionId".into(),
            serde_json::Value::String(value.session_id.to_string()),
        );
    }
    if !value.turn_id.is_empty() {
        object.insert(
            "turnId".into(),
            serde_json::Value::String(value.turn_id.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentInvocationContext`.
pub(crate) fn decode_wire_agent_invocation_context_json(
    value: &serde_json::Value,
) -> Result<v1::AgentInvocationContext, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::AgentInvocationContext {
        provider_name: match object.get("providerName") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        session_id: match object.get("sessionId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        turn_id: match object.get("turnId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `RequestContext` as protobuf JSON.
pub(crate) fn encode_wire_request_context_json(value: &v1::RequestContext) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.subject {
        object.insert("subject".into(), encode_wire_subject_context_json(inner));
    }
    if let Some(inner) = &value.credential {
        object.insert(
            "credential".into(),
            encode_wire_credential_context_json(inner),
        );
    }
    if let Some(inner) = &value.access {
        object.insert("access".into(), encode_wire_access_context_json(inner));
    }
    if let Some(inner) = &value.workflow {
        object.insert(
            "workflow".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if let Some(inner) = &value.host {
        object.insert("host".into(), encode_wire_host_context_json(inner));
    }
    if let Some(inner) = &value.agent_subject {
        object.insert(
            "agentSubject".into(),
            encode_wire_subject_context_json(inner),
        );
    }
    if let Some(inner) = &value.caller {
        object.insert("caller".into(), encode_wire_provider_context_json(inner));
    }
    if let Some(inner) = &value.invocation {
        object.insert(
            "invocation".into(),
            encode_wire_invocation_context_json(inner),
        );
    }
    if !value.tool_refs.is_empty() {
        object.insert(
            "toolRefs".into(),
            serde_json::Value::Array(
                value
                    .tool_refs
                    .iter()
                    .map(|item| encode_wire_agent_tool_ref_json(item))
                    .collect(),
            ),
        );
    }
    if value.tool_refs_set {
        object.insert(
            "toolRefsSet".into(),
            serde_json::Value::Bool(value.tool_refs_set),
        );
    }
    if let Some(inner) = &value.request_meta {
        object.insert(
            "requestMeta".into(),
            encode_wire_request_meta_context_json(inner),
        );
    }
    if let Some(inner) = &value.agent {
        object.insert(
            "agent".into(),
            encode_wire_agent_invocation_context_json(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `RequestContext`.
pub(crate) fn decode_wire_request_context_json(
    value: &serde_json::Value,
) -> Result<v1::RequestContext, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::RequestContext {
        subject: object
            .get("subject")
            .map(|value| decode_wire_subject_context_json(value))
            .transpose()?,
        credential: object
            .get("credential")
            .map(|value| decode_wire_credential_context_json(value))
            .transpose()?,
        access: object
            .get("access")
            .map(|value| decode_wire_access_context_json(value))
            .transpose()?,
        workflow: object
            .get("workflow")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        host: object
            .get("host")
            .map(|value| decode_wire_host_context_json(value))
            .transpose()?,
        agent_subject: object
            .get("agentSubject")
            .map(|value| decode_wire_subject_context_json(value))
            .transpose()?,
        caller: object
            .get("caller")
            .map(|value| decode_wire_provider_context_json(value))
            .transpose()?,
        invocation: object
            .get("invocation")
            .map(|value| decode_wire_invocation_context_json(value))
            .transpose()?,
        tool_refs: match object.get("toolRefs") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for toolRefs")
                })?
                .iter()
                .map(|item| decode_wire_agent_tool_ref_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        tool_refs_set: match object.get("toolRefsSet") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        request_meta: object
            .get("requestMeta")
            .map(|value| decode_wire_request_meta_context_json(value))
            .transpose()?,
        agent: object
            .get("agent")
            .map(|value| decode_wire_agent_invocation_context_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `AppInvokeGraphQlRequest` as protobuf JSON.
pub(crate) fn encode_wire_app_invoke_graphql_request_json(
    value: &v1::AppInvokeGraphQlRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.app.is_empty() {
        object.insert(
            "app".into(),
            serde_json::Value::String(value.app.to_string()),
        );
    }
    if !value.document.is_empty() {
        object.insert(
            "document".into(),
            serde_json::Value::String(value.document.to_string()),
        );
    }
    if let Some(inner) = &value.variables {
        object.insert(
            "variables".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if !value.connection.is_empty() {
        object.insert(
            "connection".into(),
            serde_json::Value::String(value.connection.to_string()),
        );
    }
    if !value.instance.is_empty() {
        object.insert(
            "instance".into(),
            serde_json::Value::String(value.instance.to_string()),
        );
    }
    if !value.idempotency_key.is_empty() {
        object.insert(
            "idempotencyKey".into(),
            serde_json::Value::String(value.idempotency_key.to_string()),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.headers.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.headers {
            map.insert(key.clone(), serde_json::Value::String(value.to_string()));
        }
        object.insert("headers".into(), serde_json::Value::Object(map));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AppInvokeGraphQlRequest`.
pub(crate) fn decode_wire_app_invoke_graphql_request_json(
    value: &serde_json::Value,
) -> Result<v1::AppInvokeGraphQlRequest, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::AppInvokeGraphQlRequest {
        app: match object.get("app") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        document: match object.get("document") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        variables: object
            .get("variables")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        connection: match object.get("connection") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        instance: match object.get("instance") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        idempotency_key: match object.get("idempotencyKey") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        headers: match object.get("headers") {
            Some(value) => {
                let mut out = std::collections::BTreeMap::new();
                let Some(entries) = value.as_object() else {
                    return Err(crate::public::proto_json::invalid_proto_json(
                        "expected object for map",
                    ));
                };
                for (key, value) in entries {
                    out.insert(
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            key.to_string(),
                        )?,
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            crate::public::proto_json::decode_string(value)?,
                        )?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `AppInvokeRequest` to its wire message.
pub(crate) fn to_wire_app_invoke_request(value: AppInvokeRequest) -> v1::AppInvokeRequest {
    v1::AppInvokeRequest {
        app: value.app,
        operation: value.operation,
        params: value.params.map(to_wire_struct),
        connection: value.connection,
        instance: value.instance,
        idempotency_key: value.idempotency_key,
        credential_mode: value.credential_mode,
        context: None,
        run_as: None,
        headers: value.headers,
        ..Default::default()
    }
}

/// Encodes a wire `AppInvokeRequest` as protobuf JSON.
pub(crate) fn encode_wire_app_invoke_request_json(
    value: &v1::AppInvokeRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.app.is_empty() {
        object.insert(
            "app".into(),
            serde_json::Value::String(value.app.to_string()),
        );
    }
    if !value.operation.is_empty() {
        object.insert(
            "operation".into(),
            serde_json::Value::String(value.operation.to_string()),
        );
    }
    if let Some(inner) = &value.params {
        object.insert(
            "params".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if !value.connection.is_empty() {
        object.insert(
            "connection".into(),
            serde_json::Value::String(value.connection.to_string()),
        );
    }
    if !value.instance.is_empty() {
        object.insert(
            "instance".into(),
            serde_json::Value::String(value.instance.to_string()),
        );
    }
    if !value.idempotency_key.is_empty() {
        object.insert(
            "idempotencyKey".into(),
            serde_json::Value::String(value.idempotency_key.to_string()),
        );
    }
    if !value.credential_mode.is_empty() {
        object.insert(
            "credentialMode".into(),
            serde_json::Value::String(value.credential_mode.to_string()),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if let Some(inner) = &value.run_as {
        object.insert("runAs".into(), encode_wire_subject_context_json(inner));
    }
    if !value.headers.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.headers {
            map.insert(key.clone(), serde_json::Value::String(value.to_string()));
        }
        object.insert("headers".into(), serde_json::Value::Object(map));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AppInvokeRequest`.
pub(crate) fn decode_wire_app_invoke_request_json(
    value: &serde_json::Value,
) -> Result<v1::AppInvokeRequest, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::AppInvokeRequest {
        app: match object.get("app") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        operation: match object.get("operation") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        params: object
            .get("params")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        connection: match object.get("connection") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        instance: match object.get("instance") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        idempotency_key: match object.get("idempotencyKey") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        credential_mode: match object.get("credentialMode") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        run_as: object
            .get("runAs")
            .map(|value| decode_wire_subject_context_json(value))
            .transpose()?,
        headers: match object.get("headers") {
            Some(value) => {
                let mut out = std::collections::BTreeMap::new();
                let Some(entries) = value.as_object() else {
                    return Err(crate::public::proto_json::invalid_proto_json(
                        "expected object for map",
                    ));
                };
                for (key, value) in entries {
                    out.insert(
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            key.to_string(),
                        )?,
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            crate::public::proto_json::decode_string(value)?,
                        )?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `StringList` as protobuf JSON.
pub(crate) fn encode_wire_string_list_json(value: &v1::StringList) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.values.is_empty() {
        object.insert(
            "values".into(),
            serde_json::Value::Array(
                value
                    .values
                    .iter()
                    .map(|item| serde_json::Value::String(item.to_string()))
                    .collect(),
            ),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `StringList`.
pub(crate) fn decode_wire_string_list_json(
    value: &serde_json::Value,
) -> Result<v1::StringList, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::StringList {
        values: match object.get("values") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for values")
                })?
                .iter()
                .map(|item| {
                    Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                        crate::public::proto_json::decode_string(item)?,
                    )
                })
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `InvokeMetadata` as protobuf JSON.
pub(crate) fn encode_wire_invoke_metadata_json(value: &v1::InvokeMetadata) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if value.status != 0 {
        object.insert("status".into(), serde_json::json!(value.status));
    }
    if !value.headers.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.headers {
            map.insert(key.clone(), encode_wire_string_list_json(value));
        }
        object.insert("headers".into(), serde_json::Value::Object(map));
    }
    if !value.media_type.is_empty() {
        object.insert(
            "mediaType".into(),
            serde_json::Value::String(value.media_type.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `InvokeMetadata`.
pub(crate) fn decode_wire_invoke_metadata_json(
    value: &serde_json::Value,
) -> Result<v1::InvokeMetadata, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::InvokeMetadata {
        status: match object.get("status") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        headers: match object.get("headers") {
            Some(value) => {
                let mut out = std::collections::BTreeMap::new();
                let Some(entries) = value.as_object() else {
                    return Err(crate::public::proto_json::invalid_proto_json(
                        "expected object for map",
                    ));
                };
                for (key, value) in entries {
                    out.insert(
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            key.to_string(),
                        )?,
                        decode_wire_string_list_json(value)?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        media_type: match object.get("mediaType") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `InvokeFrame` as protobuf JSON.
pub(crate) fn encode_wire_invoke_frame_json(value: &v1::InvokeFrame) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(active) = &value.value {
        match active {
            v1::invoke_frame::Value::Metadata(inner) => {
                object.insert("metadata".into(), encode_wire_invoke_metadata_json(inner));
            }
            v1::invoke_frame::Value::Data(inner) => {
                object.insert(
                    "data".into(),
                    crate::public::proto_json::encode_bytes(inner),
                );
            }
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `InvokeFrame`.
pub(crate) fn decode_wire_invoke_frame_json(
    value: &serde_json::Value,
) -> Result<v1::InvokeFrame, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::InvokeFrame {
        value: {
            let mut active = None;
            if let Some(value) = object.get("metadata") {
                active = Some(v1::invoke_frame::Value::Metadata(
                    decode_wire_invoke_metadata_json(value)?,
                ));
            }
            if let Some(value) = object.get("data") {
                active = Some(v1::invoke_frame::Value::Data(
                    crate::public::proto_json::decode_bytes(value)?,
                ));
            }
            active
        },
        ..Default::default()
    })
}

/// Encodes a wire `OperationAnnotations` as protobuf JSON.
pub(crate) fn encode_wire_operation_annotations_json(
    value: &v1::OperationAnnotations,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.read_only_hint {
        if *inner {
            object.insert("readOnlyHint".into(), serde_json::Value::Bool(*inner));
        }
    }
    if let Some(inner) = &value.idempotent_hint {
        if *inner {
            object.insert("idempotentHint".into(), serde_json::Value::Bool(*inner));
        }
    }
    if let Some(inner) = &value.destructive_hint {
        if *inner {
            object.insert("destructiveHint".into(), serde_json::Value::Bool(*inner));
        }
    }
    if let Some(inner) = &value.open_world_hint {
        if *inner {
            object.insert("openWorldHint".into(), serde_json::Value::Bool(*inner));
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `OperationAnnotations`.
pub(crate) fn decode_wire_operation_annotations_json(
    value: &serde_json::Value,
) -> Result<v1::OperationAnnotations, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::OperationAnnotations {
        read_only_hint: object
            .get("readOnlyHint")
            .map(|value| crate::public::proto_json::decode_bool(value))
            .transpose()?,
        idempotent_hint: object
            .get("idempotentHint")
            .map(|value| crate::public::proto_json::decode_bool(value))
            .transpose()?,
        destructive_hint: object
            .get("destructiveHint")
            .map(|value| crate::public::proto_json::decode_bool(value))
            .transpose()?,
        open_world_hint: object
            .get("openWorldHint")
            .map(|value| crate::public::proto_json::decode_bool(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `OperationResult` as protobuf JSON.
pub(crate) fn encode_wire_operation_result_json(value: &v1::OperationResult) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if value.status != 0 {
        object.insert("status".into(), serde_json::json!(value.status));
    }
    if !value.body.is_empty() {
        object.insert(
            "body".into(),
            crate::public::proto_json::encode_bytes(&value.body),
        );
    }
    if !value.headers.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.headers {
            map.insert(key.clone(), encode_wire_string_list_json(value));
        }
        object.insert("headers".into(), serde_json::Value::Object(map));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `OperationResult`.
pub(crate) fn decode_wire_operation_result_json(
    value: &serde_json::Value,
) -> Result<v1::OperationResult, crate::public::generated::rpc_support::GestaltError> {
    let Some(object) = value.as_object() else {
        return Err(crate::public::generated::rpc_support::GestaltError::new(
            crate::public::generated::rpc_support::gestalt_error_code::INVALID_ARGUMENT,
            "expected JSON object",
        ));
    };
    Ok(v1::OperationResult {
        status: match object.get("status") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        body: match object.get("body") {
            Some(value) => crate::public::proto_json::decode_bytes(value)?,
            None => Vec::new(),
        },
        headers: match object.get("headers") {
            Some(value) => {
                let mut out = std::collections::BTreeMap::new();
                let Some(entries) = value.as_object() else {
                    return Err(crate::public::proto_json::invalid_proto_json(
                        "expected object for map",
                    ));
                };
                for (key, value) in entries {
                    out.insert(
                        Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                            key.to_string(),
                        )?,
                        decode_wire_string_list_json(value)?,
                    );
                }
                out
            }
            None => std::collections::BTreeMap::new(),
        },
        ..Default::default()
    })
}