gestalt-sdk 0.0.1-alpha.26

// Code generated by sdkgen. DO NOT EDIT.

//! Generated wire conversions for agent.proto.

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

use crate::codec::agent::{
    to_wire_agent_message, to_wire_agent_output, to_wire_agent_session_start_config,
    to_wire_agent_tool_config, to_wire_agent_workspace, to_wire_prepared_agent_workspace,
};
use crate::codec::support::to_wire_struct;
use crate::generated::v1;
use crate::public::generated::agent::{
    CancelAgentProviderTurnRequest, CreateAgentProviderSessionRequest,
    CreateAgentProviderTurnRequest, GetAgentProviderSessionRequest, GetAgentProviderTurnRequest,
    ListAgentProviderInteractionsRequest, ListAgentProviderSessionsRequest,
    ListAgentProviderTurnEventsRequest, ListAgentProviderTurnsRequest,
    ResolveAgentProviderInteractionRequest, UpdateAgentProviderSessionRequest,
};
use crate::public::generated::codec::app::{
    decode_wire_agent_tool_ref_json, decode_wire_operation_annotations_json,
    decode_wire_request_context_json, encode_wire_agent_tool_ref_json,
    encode_wire_operation_annotations_json, encode_wire_request_context_json,
};

/// Encodes a wire `ListedAgentTool` as protobuf JSON.
pub(crate) fn encode_wire_listed_agent_tool_json(value: &v1::ListedAgentTool) -> 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.mcp_name.is_empty() {
        object.insert(
            "mcpName".into(),
            serde_json::Value::String(value.mcp_name.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.input_schema.is_empty() {
        object.insert(
            "inputSchema".into(),
            serde_json::Value::String(value.input_schema.to_string()),
        );
    }
    if !value.output_schema.is_empty() {
        object.insert(
            "outputSchema".into(),
            serde_json::Value::String(value.output_schema.to_string()),
        );
    }
    if let Some(inner) = &value.annotations {
        object.insert(
            "annotations".into(),
            encode_wire_operation_annotations_json(inner),
        );
    }
    if let Some(inner) = &value.r#ref {
        object.insert("ref".into(), encode_wire_agent_tool_ref_json(inner));
    }
    if !value.tags.is_empty() {
        object.insert(
            "tags".into(),
            serde_json::Value::Array(
                value
                    .tags
                    .iter()
                    .map(|item| serde_json::Value::String(item.to_string()))
                    .collect(),
            ),
        );
    }
    if !value.search_text.is_empty() {
        object.insert(
            "searchText".into(),
            serde_json::Value::String(value.search_text.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListedAgentTool`.
pub(crate) fn decode_wire_listed_agent_tool_json(
    value: &serde_json::Value,
) -> Result<v1::ListedAgentTool, 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::ListedAgentTool {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        mcp_name: match object.get("mcpName") {
            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(),
        },
        input_schema: match object.get("inputSchema") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        output_schema: match object.get("outputSchema") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        annotations: object
            .get("annotations")
            .map(|value| decode_wire_operation_annotations_json(value))
            .transpose()?,
        r#ref: object
            .get("ref")
            .map(|value| decode_wire_agent_tool_ref_json(value))
            .transpose()?,
        tags: match object.get("tags") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for tags")
                })?
                .iter()
                .map(|item| {
                    Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                        crate::public::proto_json::decode_string(item)?,
                    )
                })
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        search_text: match object.get("searchText") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `AgentCatalogToolConfig`.
pub(crate) fn decode_wire_agent_catalog_tool_config_json(
    value: &serde_json::Value,
) -> Result<v1::AgentCatalogToolConfig, 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::AgentCatalogToolConfig {
        refs: match object.get("refs") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for refs")
                })?
                .iter()
                .map(|item| decode_wire_agent_tool_ref_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        tools: match object.get("tools") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for tools")
                })?
                .iter()
                .map(|item| decode_wire_listed_agent_tool_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `AgentInteraction` as protobuf JSON.
pub(crate) fn encode_wire_agent_interaction_json(
    value: &v1::AgentInteraction,
) -> 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.r#type != 0 {
        object.insert("type".into(), {
            let v = value.r#type;
            if let Some(name) = match value.r#type {
                0 => Some("AGENT_INTERACTION_TYPE_UNSPECIFIED"),
                1 => Some("AGENT_INTERACTION_TYPE_APPROVAL"),
                2 => Some("AGENT_INTERACTION_TYPE_CLARIFICATION"),
                3 => Some("AGENT_INTERACTION_TYPE_INPUT"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    if value.state != 0 {
        object.insert("state".into(), {
            let v = value.state;
            if let Some(name) = match value.state {
                0 => Some("AGENT_INTERACTION_STATE_UNSPECIFIED"),
                1 => Some("AGENT_INTERACTION_STATE_PENDING"),
                2 => Some("AGENT_INTERACTION_STATE_RESOLVED"),
                3 => Some("AGENT_INTERACTION_STATE_CANCELED"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    if !value.title.is_empty() {
        object.insert(
            "title".into(),
            serde_json::Value::String(value.title.to_string()),
        );
    }
    if !value.prompt.is_empty() {
        object.insert(
            "prompt".into(),
            serde_json::Value::String(value.prompt.to_string()),
        );
    }
    if let Some(inner) = &value.request {
        object.insert(
            "request".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if let Some(inner) = &value.resolution {
        object.insert(
            "resolution".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if let Some(inner) = &value.created_at {
        object.insert(
            "createdAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if let Some(inner) = &value.resolved_at {
        object.insert(
            "resolvedAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if !value.turn_id.is_empty() {
        object.insert(
            "turnId".into(),
            serde_json::Value::String(value.turn_id.to_string()),
        );
    }
    if !value.session_id.is_empty() {
        object.insert(
            "sessionId".into(),
            serde_json::Value::String(value.session_id.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentInteraction`.
pub(crate) fn decode_wire_agent_interaction_json(
    value: &serde_json::Value,
) -> Result<v1::AgentInteraction, 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::AgentInteraction {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        r#type: object
            .get("type")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "AGENT_INTERACTION_TYPE_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "AGENT_INTERACTION_TYPE_APPROVAL" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "AGENT_INTERACTION_TYPE_CLARIFICATION" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    "AGENT_INTERACTION_TYPE_INPUT" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(3)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        state: object
            .get("state")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "AGENT_INTERACTION_STATE_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "AGENT_INTERACTION_STATE_PENDING" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "AGENT_INTERACTION_STATE_RESOLVED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    "AGENT_INTERACTION_STATE_CANCELED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(3)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        title: match object.get("title") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        prompt: match object.get("prompt") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        request: object
            .get("request")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        resolution: object
            .get("resolution")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        created_at: object
            .get("createdAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        resolved_at: object
            .get("resolvedAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        turn_id: match object.get("turnId") {
            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(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `AgentMessagePartToolCall` as protobuf JSON.
pub(crate) fn encode_wire_agent_message_part_tool_call_json(
    value: &v1::AgentMessagePartToolCall,
) -> 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.tool_id.is_empty() {
        object.insert(
            "toolId".into(),
            serde_json::Value::String(value.tool_id.to_string()),
        );
    }
    if let Some(inner) = &value.arguments {
        object.insert(
            "arguments".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentMessagePartToolCall`.
pub(crate) fn decode_wire_agent_message_part_tool_call_json(
    value: &serde_json::Value,
) -> Result<v1::AgentMessagePartToolCall, 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::AgentMessagePartToolCall {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        tool_id: match object.get("toolId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        arguments: object
            .get("arguments")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `AgentMessagePartToolResult` as protobuf JSON.
pub(crate) fn encode_wire_agent_message_part_tool_result_json(
    value: &v1::AgentMessagePartToolResult,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.tool_call_id.is_empty() {
        object.insert(
            "toolCallId".into(),
            serde_json::Value::String(value.tool_call_id.to_string()),
        );
    }
    if value.status != 0 {
        object.insert("status".into(), serde_json::json!(value.status));
    }
    if !value.content.is_empty() {
        object.insert(
            "content".into(),
            serde_json::Value::String(value.content.to_string()),
        );
    }
    if let Some(inner) = &value.output {
        object.insert(
            "output".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentMessagePartToolResult`.
pub(crate) fn decode_wire_agent_message_part_tool_result_json(
    value: &serde_json::Value,
) -> Result<v1::AgentMessagePartToolResult, 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::AgentMessagePartToolResult {
        tool_call_id: match object.get("toolCallId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        status: match object.get("status") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        content: match object.get("content") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        output: object
            .get("output")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `AgentMessagePartImageRef`.
pub(crate) fn decode_wire_agent_message_part_image_ref_json(
    value: &serde_json::Value,
) -> Result<v1::AgentMessagePartImageRef, 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::AgentMessagePartImageRef {
        uri: match object.get("uri") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        mime_type: match object.get("mimeType") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `AgentMessagePart` as protobuf JSON.
pub(crate) fn encode_wire_agent_message_part_json(
    value: &v1::AgentMessagePart,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if value.r#type != 0 {
        object.insert("type".into(), {
            let v = value.r#type;
            if let Some(name) = match value.r#type {
                0 => Some("AGENT_MESSAGE_PART_TYPE_UNSPECIFIED"),
                1 => Some("AGENT_MESSAGE_PART_TYPE_TEXT"),
                2 => Some("AGENT_MESSAGE_PART_TYPE_JSON"),
                3 => Some("AGENT_MESSAGE_PART_TYPE_TOOL_CALL"),
                4 => Some("AGENT_MESSAGE_PART_TYPE_TOOL_RESULT"),
                5 => Some("AGENT_MESSAGE_PART_TYPE_IMAGE_REF"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    if !value.text.is_empty() {
        object.insert(
            "text".into(),
            serde_json::Value::String(value.text.to_string()),
        );
    }
    if let Some(inner) = &value.json {
        object.insert(
            "json".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if let Some(inner) = &value.tool_call {
        object.insert(
            "toolCall".into(),
            encode_wire_agent_message_part_tool_call_json(inner),
        );
    }
    if let Some(inner) = &value.tool_result {
        object.insert(
            "toolResult".into(),
            encode_wire_agent_message_part_tool_result_json(inner),
        );
    }
    if let Some(inner) = &value.image_ref {
        object.insert(
            "imageRef".into(),
            encode_wire_agent_message_part_image_ref_json(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentMessagePart`.
pub(crate) fn decode_wire_agent_message_part_json(
    value: &serde_json::Value,
) -> Result<v1::AgentMessagePart, 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::AgentMessagePart {
        r#type: object
            .get("type")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "AGENT_MESSAGE_PART_TYPE_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "AGENT_MESSAGE_PART_TYPE_TEXT" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "AGENT_MESSAGE_PART_TYPE_JSON" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    "AGENT_MESSAGE_PART_TYPE_TOOL_CALL" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(3)
                    }
                    "AGENT_MESSAGE_PART_TYPE_TOOL_RESULT" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(4)
                    }
                    "AGENT_MESSAGE_PART_TYPE_IMAGE_REF" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(5)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        text: match object.get("text") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        json: object
            .get("json")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        tool_call: object
            .get("toolCall")
            .map(|value| decode_wire_agent_message_part_tool_call_json(value))
            .transpose()?,
        tool_result: object
            .get("toolResult")
            .map(|value| decode_wire_agent_message_part_tool_result_json(value))
            .transpose()?,
        image_ref: object
            .get("imageRef")
            .map(|value| decode_wire_agent_message_part_image_ref_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `AgentMessage` as protobuf JSON.
pub(crate) fn encode_wire_agent_message_json(value: &v1::AgentMessage) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.role.is_empty() {
        object.insert(
            "role".into(),
            serde_json::Value::String(value.role.to_string()),
        );
    }
    if !value.text.is_empty() {
        object.insert(
            "text".into(),
            serde_json::Value::String(value.text.to_string()),
        );
    }
    if !value.parts.is_empty() {
        object.insert(
            "parts".into(),
            serde_json::Value::Array(
                value
                    .parts
                    .iter()
                    .map(|item| encode_wire_agent_message_part_json(item))
                    .collect(),
            ),
        );
    }
    if let Some(inner) = &value.metadata {
        object.insert(
            "metadata".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentMessage`.
pub(crate) fn decode_wire_agent_message_json(
    value: &serde_json::Value,
) -> Result<v1::AgentMessage, 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::AgentMessage {
        role: match object.get("role") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        text: match object.get("text") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        parts: match object.get("parts") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for parts")
                })?
                .iter()
                .map(|item| decode_wire_agent_message_part_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        metadata: object
            .get("metadata")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `AgentNoTools` as protobuf JSON.
pub(crate) fn encode_wire_agent_no_tools_json(value: &v1::AgentNoTools) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentNoTools`.
pub(crate) fn decode_wire_agent_no_tools_json(
    value: &serde_json::Value,
) -> Result<v1::AgentNoTools, 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::AgentNoTools {
        ..Default::default()
    })
}

/// Encodes a wire `AgentTextOutput` as protobuf JSON.
pub(crate) fn encode_wire_agent_text_output_json(value: &v1::AgentTextOutput) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentTextOutput`.
pub(crate) fn decode_wire_agent_text_output_json(
    value: &serde_json::Value,
) -> Result<v1::AgentTextOutput, 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::AgentTextOutput {
        ..Default::default()
    })
}

/// Encodes a wire `AgentStructuredOutput` as protobuf JSON.
pub(crate) fn encode_wire_agent_structured_output_json(
    value: &v1::AgentStructuredOutput,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(inner) = &value.schema {
        object.insert(
            "schema".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentStructuredOutput`.
pub(crate) fn decode_wire_agent_structured_output_json(
    value: &serde_json::Value,
) -> Result<v1::AgentStructuredOutput, 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::AgentStructuredOutput {
        schema: object
            .get("schema")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `AgentOutput` as protobuf JSON.
pub(crate) fn encode_wire_agent_output_json(value: &v1::AgentOutput) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(active) = &value.kind {
        match active {
            v1::agent_output::Kind::Text(inner) => {
                object.insert("text".into(), encode_wire_agent_text_output_json(inner));
            }
            v1::agent_output::Kind::Structured(inner) => {
                object.insert(
                    "structured".into(),
                    encode_wire_agent_structured_output_json(inner),
                );
            }
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentOutput`.
pub(crate) fn decode_wire_agent_output_json(
    value: &serde_json::Value,
) -> Result<v1::AgentOutput, 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::AgentOutput {
        kind: {
            let mut active = None;
            if let Some(value) = object.get("text") {
                active = Some(v1::agent_output::Kind::Text(
                    decode_wire_agent_text_output_json(value)?,
                ));
            }
            if let Some(value) = object.get("structured") {
                active = Some(v1::agent_output::Kind::Structured(
                    decode_wire_agent_structured_output_json(value)?,
                ));
            }
            active
        },
        ..Default::default()
    })
}

/// Encodes a wire `AgentSession` as protobuf JSON.
pub(crate) fn encode_wire_agent_session_json(value: &v1::AgentSession) -> 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.provider_name.is_empty() {
        object.insert(
            "providerName".into(),
            serde_json::Value::String(value.provider_name.to_string()),
        );
    }
    if !value.model.is_empty() {
        object.insert(
            "model".into(),
            serde_json::Value::String(value.model.to_string()),
        );
    }
    if !value.client_ref.is_empty() {
        object.insert(
            "clientRef".into(),
            serde_json::Value::String(value.client_ref.to_string()),
        );
    }
    if value.state != 0 {
        object.insert("state".into(), {
            let v = value.state;
            if let Some(name) = match value.state {
                0 => Some("AGENT_SESSION_STATE_UNSPECIFIED"),
                1 => Some("AGENT_SESSION_STATE_ACTIVE"),
                2 => Some("AGENT_SESSION_STATE_ARCHIVED"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    if let Some(inner) = &value.metadata {
        object.insert(
            "metadata".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if !value.created_by_subject_id.is_empty() {
        object.insert(
            "createdBySubjectId".into(),
            serde_json::Value::String(value.created_by_subject_id.to_string()),
        );
    }
    if let Some(inner) = &value.created_at {
        object.insert(
            "createdAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if let Some(inner) = &value.updated_at {
        object.insert(
            "updatedAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if let Some(inner) = &value.last_turn_at {
        object.insert(
            "lastTurnAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentSession`.
pub(crate) fn decode_wire_agent_session_json(
    value: &serde_json::Value,
) -> Result<v1::AgentSession, 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::AgentSession {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        provider_name: match object.get("providerName") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        model: match object.get("model") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        client_ref: match object.get("clientRef") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        state: object
            .get("state")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "AGENT_SESSION_STATE_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "AGENT_SESSION_STATE_ACTIVE" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "AGENT_SESSION_STATE_ARCHIVED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        metadata: object
            .get("metadata")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        created_by_subject_id: match object.get("createdBySubjectId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        created_at: object
            .get("createdAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        updated_at: object
            .get("updatedAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        last_turn_at: object
            .get("lastTurnAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `AgentSessionStartHookOutput` as protobuf JSON.
pub(crate) fn encode_wire_agent_session_start_hook_output_json(
    value: &v1::AgentSessionStartHookOutput,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if value.additional_context {
        object.insert(
            "additionalContext".into(),
            serde_json::Value::Bool(value.additional_context),
        );
    }
    if value.metadata {
        object.insert("metadata".into(), serde_json::Value::Bool(value.metadata));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentSessionStartHookOutput`.
pub(crate) fn decode_wire_agent_session_start_hook_output_json(
    value: &serde_json::Value,
) -> Result<v1::AgentSessionStartHookOutput, 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::AgentSessionStartHookOutput {
        additional_context: match object.get("additionalContext") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        metadata: match object.get("metadata") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        ..Default::default()
    })
}

/// Encodes a wire `AgentSessionStartHook` as protobuf JSON.
pub(crate) fn encode_wire_agent_session_start_hook_json(
    value: &v1::AgentSessionStartHook,
) -> 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.r#type.is_empty() {
        object.insert(
            "type".into(),
            serde_json::Value::String(value.r#type.to_string()),
        );
    }
    if !value.command.is_empty() {
        object.insert(
            "command".into(),
            serde_json::Value::Array(
                value
                    .command
                    .iter()
                    .map(|item| serde_json::Value::String(item.to_string()))
                    .collect(),
            ),
        );
    }
    if !value.cwd.is_empty() {
        object.insert(
            "cwd".into(),
            serde_json::Value::String(value.cwd.to_string()),
        );
    }
    if !value.timeout.is_empty() {
        object.insert(
            "timeout".into(),
            serde_json::Value::String(value.timeout.to_string()),
        );
    }
    if !value.env.is_empty() {
        let mut map = serde_json::Map::new();
        for (key, value) in &value.env {
            map.insert(key.clone(), serde_json::Value::String(value.to_string()));
        }
        object.insert("env".into(), serde_json::Value::Object(map));
    }
    if let Some(inner) = &value.output {
        object.insert(
            "output".into(),
            encode_wire_agent_session_start_hook_output_json(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentSessionStartHook`.
pub(crate) fn decode_wire_agent_session_start_hook_json(
    value: &serde_json::Value,
) -> Result<v1::AgentSessionStartHook, 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::AgentSessionStartHook {
        id: match object.get("id") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        r#type: match object.get("type") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        command: match object.get("command") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for command")
                })?
                .iter()
                .map(|item| {
                    Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                        crate::public::proto_json::decode_string(item)?,
                    )
                })
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        cwd: match object.get("cwd") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        timeout: match object.get("timeout") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        env: match object.get("env") {
            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(),
        },
        output: object
            .get("output")
            .map(|value| decode_wire_agent_session_start_hook_output_json(value))
            .transpose()?,
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `AgentSessionStartConfig`.
pub(crate) fn decode_wire_agent_session_start_config_json(
    value: &serde_json::Value,
) -> Result<v1::AgentSessionStartConfig, 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::AgentSessionStartConfig {
        hooks: match object.get("hooks") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for hooks")
                })?
                .iter()
                .map(|item| decode_wire_agent_session_start_hook_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `AgentToolConfig` as protobuf JSON.
pub(crate) fn encode_wire_agent_tool_config_json(value: &v1::AgentToolConfig) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if let Some(active) = &value.source {
        match active {
            v1::agent_tool_config::Source::None(inner) => {
                object.insert("none".into(), encode_wire_agent_no_tools_json(inner));
            }
            v1::agent_tool_config::Source::Catalog(inner) => {
                object.insert(
                    "catalog".into(),
                    encode_wire_agent_catalog_tool_config_json(inner),
                );
            }
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentToolConfig`.
pub(crate) fn decode_wire_agent_tool_config_json(
    value: &serde_json::Value,
) -> Result<v1::AgentToolConfig, 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::AgentToolConfig {
        source: {
            let mut active = None;
            if let Some(value) = object.get("none") {
                active = Some(v1::agent_tool_config::Source::None(
                    decode_wire_agent_no_tools_json(value)?,
                ));
            }
            if let Some(value) = object.get("catalog") {
                active = Some(v1::agent_tool_config::Source::Catalog(
                    decode_wire_agent_catalog_tool_config_json(value)?,
                ));
            }
            active
        },
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `AgentTurnTextOutput`.
pub(crate) fn decode_wire_agent_turn_text_output_json(
    value: &serde_json::Value,
) -> Result<v1::AgentTurnTextOutput, 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::AgentTurnTextOutput {
        text: match object.get("text") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `AgentTurnStructuredOutput` as protobuf JSON.
pub(crate) fn encode_wire_agent_turn_structured_output_json(
    value: &v1::AgentTurnStructuredOutput,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.text.is_empty() {
        object.insert(
            "text".into(),
            serde_json::Value::String(value.text.to_string()),
        );
    }
    if let Some(inner) = &value.value {
        object.insert(
            "value".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentTurnStructuredOutput`.
pub(crate) fn decode_wire_agent_turn_structured_output_json(
    value: &serde_json::Value,
) -> Result<v1::AgentTurnStructuredOutput, 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::AgentTurnStructuredOutput {
        text: match object.get("text") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        value: object
            .get("value")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `AgentTurn` as protobuf JSON.
pub(crate) fn encode_wire_agent_turn_json(value: &v1::AgentTurn) -> 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.session_id.is_empty() {
        object.insert(
            "sessionId".into(),
            serde_json::Value::String(value.session_id.to_string()),
        );
    }
    if !value.provider_name.is_empty() {
        object.insert(
            "providerName".into(),
            serde_json::Value::String(value.provider_name.to_string()),
        );
    }
    if !value.model.is_empty() {
        object.insert(
            "model".into(),
            serde_json::Value::String(value.model.to_string()),
        );
    }
    if value.status != 0 {
        object.insert("status".into(), {
            let v = value.status;
            if let Some(name) = match value.status {
                0 => Some("AGENT_EXECUTION_STATUS_UNSPECIFIED"),
                1 => Some("AGENT_EXECUTION_STATUS_PENDING"),
                2 => Some("AGENT_EXECUTION_STATUS_RUNNING"),
                3 => Some("AGENT_EXECUTION_STATUS_SUCCEEDED"),
                4 => Some("AGENT_EXECUTION_STATUS_FAILED"),
                5 => Some("AGENT_EXECUTION_STATUS_CANCELED"),
                6 => Some("AGENT_EXECUTION_STATUS_WAITING_FOR_INPUT"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    if !value.messages.is_empty() {
        object.insert(
            "messages".into(),
            serde_json::Value::Array(
                value
                    .messages
                    .iter()
                    .map(|item| encode_wire_agent_message_json(item))
                    .collect(),
            ),
        );
    }
    if !value.status_message.is_empty() {
        object.insert(
            "statusMessage".into(),
            serde_json::Value::String(value.status_message.to_string()),
        );
    }
    if !value.created_by_subject_id.is_empty() {
        object.insert(
            "createdBySubjectId".into(),
            serde_json::Value::String(value.created_by_subject_id.to_string()),
        );
    }
    if let Some(inner) = &value.created_at {
        object.insert(
            "createdAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if let Some(inner) = &value.started_at {
        object.insert(
            "startedAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if let Some(inner) = &value.completed_at {
        object.insert(
            "completedAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if !value.execution_ref.is_empty() {
        object.insert(
            "executionRef".into(),
            serde_json::Value::String(value.execution_ref.to_string()),
        );
    }
    if let Some(active) = &value.output {
        match active {
            v1::agent_turn::Output::Text(inner) => {
                object.insert(
                    "text".into(),
                    encode_wire_agent_turn_text_output_json(inner),
                );
            }
            v1::agent_turn::Output::Structured(inner) => {
                object.insert(
                    "structured".into(),
                    encode_wire_agent_turn_structured_output_json(inner),
                );
            }
        }
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentTurn`.
pub(crate) fn decode_wire_agent_turn_json(
    value: &serde_json::Value,
) -> Result<v1::AgentTurn, 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::AgentTurn {
        id: match object.get("id") {
            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(),
        },
        provider_name: match object.get("providerName") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        model: match object.get("model") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        status: object
            .get("status")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "AGENT_EXECUTION_STATUS_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "AGENT_EXECUTION_STATUS_PENDING" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "AGENT_EXECUTION_STATUS_RUNNING" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    "AGENT_EXECUTION_STATUS_SUCCEEDED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(3)
                    }
                    "AGENT_EXECUTION_STATUS_FAILED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(4)
                    }
                    "AGENT_EXECUTION_STATUS_CANCELED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(5)
                    }
                    "AGENT_EXECUTION_STATUS_WAITING_FOR_INPUT" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(6)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        messages: match object.get("messages") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for messages")
                })?
                .iter()
                .map(|item| decode_wire_agent_message_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        status_message: match object.get("statusMessage") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        created_by_subject_id: match object.get("createdBySubjectId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        created_at: object
            .get("createdAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        started_at: object
            .get("startedAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        completed_at: object
            .get("completedAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        execution_ref: match object.get("executionRef") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        output: {
            let mut active = None;
            if let Some(value) = object.get("text") {
                active = Some(v1::agent_turn::Output::Text(
                    decode_wire_agent_turn_text_output_json(value)?,
                ));
            }
            if let Some(value) = object.get("structured") {
                active = Some(v1::agent_turn::Output::Structured(
                    decode_wire_agent_turn_structured_output_json(value)?,
                ));
            }
            active
        },
        ..Default::default()
    })
}

/// Encodes a wire `AgentTurnDisplay` as protobuf JSON.
pub(crate) fn encode_wire_agent_turn_display_json(
    value: &v1::AgentTurnDisplay,
) -> 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.phase.is_empty() {
        object.insert(
            "phase".into(),
            serde_json::Value::String(value.phase.to_string()),
        );
    }
    if !value.text.is_empty() {
        object.insert(
            "text".into(),
            serde_json::Value::String(value.text.to_string()),
        );
    }
    if !value.label.is_empty() {
        object.insert(
            "label".into(),
            serde_json::Value::String(value.label.to_string()),
        );
    }
    if !value.r#ref.is_empty() {
        object.insert(
            "ref".into(),
            serde_json::Value::String(value.r#ref.to_string()),
        );
    }
    if !value.parent_ref.is_empty() {
        object.insert(
            "parentRef".into(),
            serde_json::Value::String(value.parent_ref.to_string()),
        );
    }
    if let Some(inner) = &value.input {
        object.insert(
            "input".into(),
            crate::public::proto_json::encode_value(inner),
        );
    }
    if let Some(inner) = &value.output {
        object.insert(
            "output".into(),
            crate::public::proto_json::encode_value(inner),
        );
    }
    if let Some(inner) = &value.error {
        object.insert(
            "error".into(),
            crate::public::proto_json::encode_value(inner),
        );
    }
    if !value.action.is_empty() {
        object.insert(
            "action".into(),
            serde_json::Value::String(value.action.to_string()),
        );
    }
    if !value.format.is_empty() {
        object.insert(
            "format".into(),
            serde_json::Value::String(value.format.to_string()),
        );
    }
    if !value.language.is_empty() {
        object.insert(
            "language".into(),
            serde_json::Value::String(value.language.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentTurnDisplay`.
pub(crate) fn decode_wire_agent_turn_display_json(
    value: &serde_json::Value,
) -> Result<v1::AgentTurnDisplay, 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::AgentTurnDisplay {
        kind: match object.get("kind") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        phase: match object.get("phase") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        text: match object.get("text") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        label: match object.get("label") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        r#ref: match object.get("ref") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        parent_ref: match object.get("parentRef") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        input: object
            .get("input")
            .map(|value| crate::public::proto_json::decode_value(value))
            .transpose()?,
        output: object
            .get("output")
            .map(|value| crate::public::proto_json::decode_value(value))
            .transpose()?,
        error: object
            .get("error")
            .map(|value| crate::public::proto_json::decode_value(value))
            .transpose()?,
        action: match object.get("action") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        format: match object.get("format") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        language: match object.get("language") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `AgentTurnEvent` as protobuf JSON.
pub(crate) fn encode_wire_agent_turn_event_json(value: &v1::AgentTurnEvent) -> 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.turn_id.is_empty() {
        object.insert(
            "turnId".into(),
            serde_json::Value::String(value.turn_id.to_string()),
        );
    }
    if value.seq != 0 {
        object.insert(
            "seq".into(),
            crate::public::proto_json::encode_i64(value.seq),
        );
    }
    if !value.r#type.is_empty() {
        object.insert(
            "type".into(),
            serde_json::Value::String(value.r#type.to_string()),
        );
    }
    if !value.source.is_empty() {
        object.insert(
            "source".into(),
            serde_json::Value::String(value.source.to_string()),
        );
    }
    if !value.visibility.is_empty() {
        object.insert(
            "visibility".into(),
            serde_json::Value::String(value.visibility.to_string()),
        );
    }
    if let Some(inner) = &value.data {
        object.insert(
            "data".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if let Some(inner) = &value.created_at {
        object.insert(
            "createdAt".into(),
            crate::public::proto_json::encode_timestamp(inner),
        );
    }
    if let Some(inner) = &value.display {
        object.insert("display".into(), encode_wire_agent_turn_display_json(inner));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentTurnEvent`.
pub(crate) fn decode_wire_agent_turn_event_json(
    value: &serde_json::Value,
) -> Result<v1::AgentTurnEvent, 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::AgentTurnEvent {
        id: match object.get("id") {
            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(),
        },
        seq: match object.get("seq") {
            Some(value) => crate::public::proto_json::decode_i64(value)?,
            None => 0,
        },
        r#type: match object.get("type") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        source: match object.get("source") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        visibility: match object.get("visibility") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        data: object
            .get("data")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        created_at: object
            .get("createdAt")
            .map(|value| crate::public::proto_json::decode_timestamp(value))
            .transpose()?,
        display: object
            .get("display")
            .map(|value| decode_wire_agent_turn_display_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Encodes a wire `AgentWorkspaceGitCheckout` as protobuf JSON.
pub(crate) fn encode_wire_agent_workspace_git_checkout_json(
    value: &v1::AgentWorkspaceGitCheckout,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.url.is_empty() {
        object.insert(
            "url".into(),
            serde_json::Value::String(value.url.to_string()),
        );
    }
    if !value.r#ref.is_empty() {
        object.insert(
            "ref".into(),
            serde_json::Value::String(value.r#ref.to_string()),
        );
    }
    if !value.path.is_empty() {
        object.insert(
            "path".into(),
            serde_json::Value::String(value.path.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `AgentWorkspaceGitCheckout`.
pub(crate) fn decode_wire_agent_workspace_git_checkout_json(
    value: &serde_json::Value,
) -> Result<v1::AgentWorkspaceGitCheckout, 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::AgentWorkspaceGitCheckout {
        url: match object.get("url") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        r#ref: match object.get("ref") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        path: match object.get("path") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `AgentWorkspace`.
pub(crate) fn decode_wire_agent_workspace_json(
    value: &serde_json::Value,
) -> Result<v1::AgentWorkspace, 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::AgentWorkspace {
        checkouts: match object.get("checkouts") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for checkouts")
                })?
                .iter()
                .map(|item| decode_wire_agent_workspace_git_checkout_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        cwd: match object.get("cwd") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `CancelAgentProviderTurnRequest` to its wire message.
pub(crate) fn to_wire_cancel_agent_provider_turn_request(
    value: CancelAgentProviderTurnRequest,
) -> v1::CancelAgentProviderTurnRequest {
    v1::CancelAgentProviderTurnRequest {
        turn_id: value.turn_id,
        reason: value.reason,
        context: None,
        provider_name: value.provider_name,
        session_id: value.session_id,
        ..Default::default()
    }
}

/// Encodes a wire `CancelAgentProviderTurnRequest` as protobuf JSON.
pub(crate) fn encode_wire_cancel_agent_provider_turn_request_json(
    value: &v1::CancelAgentProviderTurnRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.turn_id.is_empty() {
        object.insert(
            "turnId".into(),
            serde_json::Value::String(value.turn_id.to_string()),
        );
    }
    if !value.reason.is_empty() {
        object.insert(
            "reason".into(),
            serde_json::Value::String(value.reason.to_string()),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    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()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `CancelAgentProviderTurnRequest`.
pub(crate) fn decode_wire_cancel_agent_provider_turn_request_json(
    value: &serde_json::Value,
) -> Result<v1::CancelAgentProviderTurnRequest, 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::CancelAgentProviderTurnRequest {
        turn_id: match object.get("turnId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        reason: match object.get("reason") {
            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()?,
        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(),
        },
        ..Default::default()
    })
}

/// Converts a native `CreateAgentProviderSessionRequest` to its wire message.
pub(crate) fn to_wire_create_agent_provider_session_request(
    value: CreateAgentProviderSessionRequest,
) -> v1::CreateAgentProviderSessionRequest {
    v1::CreateAgentProviderSessionRequest {
        idempotency_key: value.idempotency_key,
        model: value.model,
        client_ref: value.client_ref,
        metadata: value.metadata.map(to_wire_struct),
        session_start: value.session_start.map(to_wire_agent_session_start_config),
        prepared_workspace: value
            .prepared_workspace
            .map(to_wire_prepared_agent_workspace),
        provider_name: value.provider_name,
        workspace: value.workspace.map(to_wire_agent_workspace),
        context: None,
        tools: value.tools.map(to_wire_agent_tool_config),
        ..Default::default()
    }
}

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

/// Decodes protobuf JSON into a wire `PreparedAgentWorkspace`.
pub(crate) fn decode_wire_prepared_agent_workspace_json(
    value: &serde_json::Value,
) -> Result<v1::PreparedAgentWorkspace, 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::PreparedAgentWorkspace {
        root: match object.get("root") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        cwd: match object.get("cwd") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Encodes a wire `CreateAgentProviderSessionRequest` as protobuf JSON.
pub(crate) fn encode_wire_create_agent_provider_session_request_json(
    value: &v1::CreateAgentProviderSessionRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.idempotency_key.is_empty() {
        object.insert(
            "idempotencyKey".into(),
            serde_json::Value::String(value.idempotency_key.to_string()),
        );
    }
    if !value.model.is_empty() {
        object.insert(
            "model".into(),
            serde_json::Value::String(value.model.to_string()),
        );
    }
    if !value.client_ref.is_empty() {
        object.insert(
            "clientRef".into(),
            serde_json::Value::String(value.client_ref.to_string()),
        );
    }
    if let Some(inner) = &value.metadata {
        object.insert(
            "metadata".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if let Some(inner) = &value.session_start {
        object.insert(
            "sessionStart".into(),
            encode_wire_agent_session_start_config_json(inner),
        );
    }
    if let Some(inner) = &value.prepared_workspace {
        object.insert(
            "preparedWorkspace".into(),
            encode_wire_prepared_agent_workspace_json(inner),
        );
    }
    if !value.provider_name.is_empty() {
        object.insert(
            "providerName".into(),
            serde_json::Value::String(value.provider_name.to_string()),
        );
    }
    if let Some(inner) = &value.workspace {
        object.insert("workspace".into(), encode_wire_agent_workspace_json(inner));
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if let Some(inner) = &value.tools {
        object.insert("tools".into(), encode_wire_agent_tool_config_json(inner));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `CreateAgentProviderSessionRequest`.
pub(crate) fn decode_wire_create_agent_provider_session_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::CreateAgentProviderSessionRequest,
    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::CreateAgentProviderSessionRequest {
        idempotency_key: match object.get("idempotencyKey") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        model: match object.get("model") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        client_ref: match object.get("clientRef") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        metadata: object
            .get("metadata")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        session_start: object
            .get("sessionStart")
            .map(|value| decode_wire_agent_session_start_config_json(value))
            .transpose()?,
        prepared_workspace: object
            .get("preparedWorkspace")
            .map(|value| decode_wire_prepared_agent_workspace_json(value))
            .transpose()?,
        provider_name: match object.get("providerName") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        workspace: object
            .get("workspace")
            .map(|value| decode_wire_agent_workspace_json(value))
            .transpose()?,
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        tools: object
            .get("tools")
            .map(|value| decode_wire_agent_tool_config_json(value))
            .transpose()?,
        ..Default::default()
    })
}

/// Converts a native `CreateAgentProviderTurnRequest` to its wire message.
pub(crate) fn to_wire_create_agent_provider_turn_request(
    value: CreateAgentProviderTurnRequest,
) -> v1::CreateAgentProviderTurnRequest {
    v1::CreateAgentProviderTurnRequest {
        turn_id: value.turn_id,
        session_id: value.session_id,
        idempotency_key: value.idempotency_key,
        model: value.model,
        messages: value
            .messages
            .into_iter()
            .map(to_wire_agent_message)
            .collect(),
        metadata: value.metadata.map(to_wire_struct),
        execution_ref: value.execution_ref,
        model_options: value.model_options.map(to_wire_struct),
        timeout_seconds: value.timeout_seconds,
        output: value.output.map(to_wire_agent_output),
        context: None,
        provider_name: value.provider_name,
        ..Default::default()
    }
}

/// Encodes a wire `CreateAgentProviderTurnRequest` as protobuf JSON.
pub(crate) fn encode_wire_create_agent_provider_turn_request_json(
    value: &v1::CreateAgentProviderTurnRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.turn_id.is_empty() {
        object.insert(
            "turnId".into(),
            serde_json::Value::String(value.turn_id.to_string()),
        );
    }
    if !value.session_id.is_empty() {
        object.insert(
            "sessionId".into(),
            serde_json::Value::String(value.session_id.to_string()),
        );
    }
    if !value.idempotency_key.is_empty() {
        object.insert(
            "idempotencyKey".into(),
            serde_json::Value::String(value.idempotency_key.to_string()),
        );
    }
    if !value.model.is_empty() {
        object.insert(
            "model".into(),
            serde_json::Value::String(value.model.to_string()),
        );
    }
    if !value.messages.is_empty() {
        object.insert(
            "messages".into(),
            serde_json::Value::Array(
                value
                    .messages
                    .iter()
                    .map(|item| encode_wire_agent_message_json(item))
                    .collect(),
            ),
        );
    }
    if let Some(inner) = &value.metadata {
        object.insert(
            "metadata".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if !value.execution_ref.is_empty() {
        object.insert(
            "executionRef".into(),
            serde_json::Value::String(value.execution_ref.to_string()),
        );
    }
    if let Some(inner) = &value.model_options {
        object.insert(
            "modelOptions".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if value.timeout_seconds != 0 {
        object.insert(
            "timeoutSeconds".into(),
            serde_json::json!(value.timeout_seconds),
        );
    }
    if let Some(inner) = &value.output {
        object.insert("output".into(), encode_wire_agent_output_json(inner));
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.provider_name.is_empty() {
        object.insert(
            "providerName".into(),
            serde_json::Value::String(value.provider_name.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `CreateAgentProviderTurnRequest`.
pub(crate) fn decode_wire_create_agent_provider_turn_request_json(
    value: &serde_json::Value,
) -> Result<v1::CreateAgentProviderTurnRequest, 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::CreateAgentProviderTurnRequest {
        turn_id: match object.get("turnId") {
            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(),
        },
        idempotency_key: match object.get("idempotencyKey") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        model: match object.get("model") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        messages: match object.get("messages") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for messages")
                })?
                .iter()
                .map(|item| decode_wire_agent_message_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        metadata: object
            .get("metadata")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        execution_ref: match object.get("executionRef") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        model_options: object
            .get("modelOptions")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        timeout_seconds: match object.get("timeoutSeconds") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        output: object
            .get("output")
            .map(|value| decode_wire_agent_output_json(value))
            .transpose()?,
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        provider_name: match object.get("providerName") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `GetAgentProviderSessionRequest` to its wire message.
pub(crate) fn to_wire_get_agent_provider_session_request(
    value: GetAgentProviderSessionRequest,
) -> v1::GetAgentProviderSessionRequest {
    v1::GetAgentProviderSessionRequest {
        session_id: value.session_id,
        context: None,
        provider_name: value.provider_name,
        ..Default::default()
    }
}

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

/// Decodes protobuf JSON into a wire `GetAgentProviderSessionRequest`.
pub(crate) fn decode_wire_get_agent_provider_session_request_json(
    value: &serde_json::Value,
) -> Result<v1::GetAgentProviderSessionRequest, 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::GetAgentProviderSessionRequest {
        session_id: match object.get("sessionId") {
            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()?,
        provider_name: match object.get("providerName") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `GetAgentProviderTurnRequest` to its wire message.
pub(crate) fn to_wire_get_agent_provider_turn_request(
    value: GetAgentProviderTurnRequest,
) -> v1::GetAgentProviderTurnRequest {
    v1::GetAgentProviderTurnRequest {
        turn_id: value.turn_id,
        context: None,
        provider_name: value.provider_name,
        session_id: value.session_id,
        ..Default::default()
    }
}

/// Encodes a wire `GetAgentProviderTurnRequest` as protobuf JSON.
pub(crate) fn encode_wire_get_agent_provider_turn_request_json(
    value: &v1::GetAgentProviderTurnRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.turn_id.is_empty() {
        object.insert(
            "turnId".into(),
            serde_json::Value::String(value.turn_id.to_string()),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    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()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `GetAgentProviderTurnRequest`.
pub(crate) fn decode_wire_get_agent_provider_turn_request_json(
    value: &serde_json::Value,
) -> Result<v1::GetAgentProviderTurnRequest, 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::GetAgentProviderTurnRequest {
        turn_id: match object.get("turnId") {
            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()?,
        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(),
        },
        ..Default::default()
    })
}

/// Converts a native `ListAgentProviderInteractionsRequest` to its wire message.
pub(crate) fn to_wire_list_agent_provider_interactions_request(
    value: ListAgentProviderInteractionsRequest,
) -> v1::ListAgentProviderInteractionsRequest {
    v1::ListAgentProviderInteractionsRequest {
        turn_id: value.turn_id,
        context: None,
        provider_name: value.provider_name,
        ..Default::default()
    }
}

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

/// Decodes protobuf JSON into a wire `ListAgentProviderInteractionsRequest`.
pub(crate) fn decode_wire_list_agent_provider_interactions_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::ListAgentProviderInteractionsRequest,
    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::ListAgentProviderInteractionsRequest {
        turn_id: match object.get("turnId") {
            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()?,
        provider_name: match object.get("providerName") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `ListAgentProviderInteractionsResponse`.
pub(crate) fn decode_wire_list_agent_provider_interactions_response_json(
    value: &serde_json::Value,
) -> Result<
    v1::ListAgentProviderInteractionsResponse,
    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::ListAgentProviderInteractionsResponse {
        interactions: match object.get("interactions") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for interactions")
                })?
                .iter()
                .map(|item| decode_wire_agent_interaction_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `ListAgentProviderSessionsRequest` to its wire message.
pub(crate) fn to_wire_list_agent_provider_sessions_request(
    value: ListAgentProviderSessionsRequest,
) -> v1::ListAgentProviderSessionsRequest {
    v1::ListAgentProviderSessionsRequest {
        session_ids: value.session_ids,
        state: value.state,
        limit: value.limit,
        summary_only: value.summary_only,
        provider_name: value.provider_name,
        context: None,
        ..Default::default()
    }
}

/// Encodes a wire `ListAgentProviderSessionsRequest` as protobuf JSON.
pub(crate) fn encode_wire_list_agent_provider_sessions_request_json(
    value: &v1::ListAgentProviderSessionsRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.session_ids.is_empty() {
        object.insert(
            "sessionIds".into(),
            serde_json::Value::Array(
                value
                    .session_ids
                    .iter()
                    .map(|item| serde_json::Value::String(item.to_string()))
                    .collect(),
            ),
        );
    }
    if value.state != 0 {
        object.insert("state".into(), {
            let v = value.state;
            if let Some(name) = match value.state {
                0 => Some("AGENT_SESSION_STATE_UNSPECIFIED"),
                1 => Some("AGENT_SESSION_STATE_ACTIVE"),
                2 => Some("AGENT_SESSION_STATE_ARCHIVED"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    if value.limit != 0 {
        object.insert("limit".into(), serde_json::json!(value.limit));
    }
    if value.summary_only {
        object.insert(
            "summaryOnly".into(),
            serde_json::Value::Bool(value.summary_only),
        );
    }
    if !value.provider_name.is_empty() {
        object.insert(
            "providerName".into(),
            serde_json::Value::String(value.provider_name.to_string()),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListAgentProviderSessionsRequest`.
pub(crate) fn decode_wire_list_agent_provider_sessions_request_json(
    value: &serde_json::Value,
) -> Result<v1::ListAgentProviderSessionsRequest, 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::ListAgentProviderSessionsRequest {
        session_ids: match object.get("sessionIds") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for sessionIds")
                })?
                .iter()
                .map(|item| {
                    Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                        crate::public::proto_json::decode_string(item)?,
                    )
                })
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        state: object
            .get("state")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "AGENT_SESSION_STATE_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "AGENT_SESSION_STATE_ACTIVE" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "AGENT_SESSION_STATE_ARCHIVED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        limit: match object.get("limit") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        summary_only: match object.get("summaryOnly") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        provider_name: match object.get("providerName") {
            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()?,
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `ListAgentProviderSessionsResponse`.
pub(crate) fn decode_wire_list_agent_provider_sessions_response_json(
    value: &serde_json::Value,
) -> Result<
    v1::ListAgentProviderSessionsResponse,
    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::ListAgentProviderSessionsResponse {
        sessions: match object.get("sessions") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for sessions")
                })?
                .iter()
                .map(|item| decode_wire_agent_session_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `ListAgentProviderTurnEventsRequest` to its wire message.
pub(crate) fn to_wire_list_agent_provider_turn_events_request(
    value: ListAgentProviderTurnEventsRequest,
) -> v1::ListAgentProviderTurnEventsRequest {
    v1::ListAgentProviderTurnEventsRequest {
        turn_id: value.turn_id,
        after_seq: value.after_seq,
        limit: value.limit,
        context: None,
        provider_name: value.provider_name,
        session_id: value.session_id,
        ..Default::default()
    }
}

/// Encodes a wire `ListAgentProviderTurnEventsRequest` as protobuf JSON.
pub(crate) fn encode_wire_list_agent_provider_turn_events_request_json(
    value: &v1::ListAgentProviderTurnEventsRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.turn_id.is_empty() {
        object.insert(
            "turnId".into(),
            serde_json::Value::String(value.turn_id.to_string()),
        );
    }
    if value.after_seq != 0 {
        object.insert(
            "afterSeq".into(),
            crate::public::proto_json::encode_i64(value.after_seq),
        );
    }
    if value.limit != 0 {
        object.insert("limit".into(), serde_json::json!(value.limit));
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    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()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListAgentProviderTurnEventsRequest`.
pub(crate) fn decode_wire_list_agent_provider_turn_events_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::ListAgentProviderTurnEventsRequest,
    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::ListAgentProviderTurnEventsRequest {
        turn_id: match object.get("turnId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        after_seq: match object.get("afterSeq") {
            Some(value) => crate::public::proto_json::decode_i64(value)?,
            None => 0,
        },
        limit: match object.get("limit") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        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(),
        },
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `ListAgentProviderTurnEventsResponse`.
pub(crate) fn decode_wire_list_agent_provider_turn_events_response_json(
    value: &serde_json::Value,
) -> Result<
    v1::ListAgentProviderTurnEventsResponse,
    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::ListAgentProviderTurnEventsResponse {
        events: match object.get("events") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for events")
                })?
                .iter()
                .map(|item| decode_wire_agent_turn_event_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `ListAgentProviderTurnsRequest` to its wire message.
pub(crate) fn to_wire_list_agent_provider_turns_request(
    value: ListAgentProviderTurnsRequest,
) -> v1::ListAgentProviderTurnsRequest {
    v1::ListAgentProviderTurnsRequest {
        session_id: value.session_id,
        turn_ids: value.turn_ids,
        status: value.status,
        limit: value.limit,
        summary_only: value.summary_only,
        context: None,
        provider_name: value.provider_name,
        ..Default::default()
    }
}

/// Encodes a wire `ListAgentProviderTurnsRequest` as protobuf JSON.
pub(crate) fn encode_wire_list_agent_provider_turns_request_json(
    value: &v1::ListAgentProviderTurnsRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.session_id.is_empty() {
        object.insert(
            "sessionId".into(),
            serde_json::Value::String(value.session_id.to_string()),
        );
    }
    if !value.turn_ids.is_empty() {
        object.insert(
            "turnIds".into(),
            serde_json::Value::Array(
                value
                    .turn_ids
                    .iter()
                    .map(|item| serde_json::Value::String(item.to_string()))
                    .collect(),
            ),
        );
    }
    if value.status != 0 {
        object.insert("status".into(), {
            let v = value.status;
            if let Some(name) = match value.status {
                0 => Some("AGENT_EXECUTION_STATUS_UNSPECIFIED"),
                1 => Some("AGENT_EXECUTION_STATUS_PENDING"),
                2 => Some("AGENT_EXECUTION_STATUS_RUNNING"),
                3 => Some("AGENT_EXECUTION_STATUS_SUCCEEDED"),
                4 => Some("AGENT_EXECUTION_STATUS_FAILED"),
                5 => Some("AGENT_EXECUTION_STATUS_CANCELED"),
                6 => Some("AGENT_EXECUTION_STATUS_WAITING_FOR_INPUT"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    if value.limit != 0 {
        object.insert("limit".into(), serde_json::json!(value.limit));
    }
    if value.summary_only {
        object.insert(
            "summaryOnly".into(),
            serde_json::Value::Bool(value.summary_only),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.provider_name.is_empty() {
        object.insert(
            "providerName".into(),
            serde_json::Value::String(value.provider_name.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ListAgentProviderTurnsRequest`.
pub(crate) fn decode_wire_list_agent_provider_turns_request_json(
    value: &serde_json::Value,
) -> Result<v1::ListAgentProviderTurnsRequest, 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::ListAgentProviderTurnsRequest {
        session_id: match object.get("sessionId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        turn_ids: match object.get("turnIds") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for turnIds")
                })?
                .iter()
                .map(|item| {
                    Ok::<String, crate::public::generated::rpc_support::GestaltError>(
                        crate::public::proto_json::decode_string(item)?,
                    )
                })
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        status: object
            .get("status")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "AGENT_EXECUTION_STATUS_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "AGENT_EXECUTION_STATUS_PENDING" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "AGENT_EXECUTION_STATUS_RUNNING" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    "AGENT_EXECUTION_STATUS_SUCCEEDED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(3)
                    }
                    "AGENT_EXECUTION_STATUS_FAILED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(4)
                    }
                    "AGENT_EXECUTION_STATUS_CANCELED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(5)
                    }
                    "AGENT_EXECUTION_STATUS_WAITING_FOR_INPUT" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(6)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        limit: match object.get("limit") {
            Some(value) => crate::public::proto_json::decode_i32(value)?,
            None => 0,
        },
        summary_only: match object.get("summaryOnly") {
            Some(value) => crate::public::proto_json::decode_bool(value)?,
            None => false,
        },
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        provider_name: match object.get("providerName") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

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

/// Decodes protobuf JSON into a wire `ListAgentProviderTurnsResponse`.
pub(crate) fn decode_wire_list_agent_provider_turns_response_json(
    value: &serde_json::Value,
) -> Result<v1::ListAgentProviderTurnsResponse, 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::ListAgentProviderTurnsResponse {
        turns: match object.get("turns") {
            Some(value) => value
                .as_array()
                .ok_or_else(|| {
                    crate::public::proto_json::invalid_proto_json("expected array for turns")
                })?
                .iter()
                .map(|item| decode_wire_agent_turn_json(item))
                .collect::<Result<Vec<_>, _>>()?,
            None => Vec::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `ResolveAgentProviderInteractionRequest` to its wire message.
pub(crate) fn to_wire_resolve_agent_provider_interaction_request(
    value: ResolveAgentProviderInteractionRequest,
) -> v1::ResolveAgentProviderInteractionRequest {
    v1::ResolveAgentProviderInteractionRequest {
        interaction_id: value.interaction_id,
        resolution: value.resolution.map(to_wire_struct),
        turn_id: value.turn_id,
        context: None,
        provider_name: value.provider_name,
        ..Default::default()
    }
}

/// Encodes a wire `ResolveAgentProviderInteractionRequest` as protobuf JSON.
pub(crate) fn encode_wire_resolve_agent_provider_interaction_request_json(
    value: &v1::ResolveAgentProviderInteractionRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.interaction_id.is_empty() {
        object.insert(
            "interactionId".into(),
            serde_json::Value::String(value.interaction_id.to_string()),
        );
    }
    if let Some(inner) = &value.resolution {
        object.insert(
            "resolution".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if !value.turn_id.is_empty() {
        object.insert(
            "turnId".into(),
            serde_json::Value::String(value.turn_id.to_string()),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.provider_name.is_empty() {
        object.insert(
            "providerName".into(),
            serde_json::Value::String(value.provider_name.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `ResolveAgentProviderInteractionRequest`.
pub(crate) fn decode_wire_resolve_agent_provider_interaction_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::ResolveAgentProviderInteractionRequest,
    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::ResolveAgentProviderInteractionRequest {
        interaction_id: match object.get("interactionId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        resolution: object
            .get("resolution")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        turn_id: match object.get("turnId") {
            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()?,
        provider_name: match object.get("providerName") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}

/// Converts a native `UpdateAgentProviderSessionRequest` to its wire message.
pub(crate) fn to_wire_update_agent_provider_session_request(
    value: UpdateAgentProviderSessionRequest,
) -> v1::UpdateAgentProviderSessionRequest {
    v1::UpdateAgentProviderSessionRequest {
        session_id: value.session_id,
        client_ref: value.client_ref,
        state: value.state,
        metadata: value.metadata.map(to_wire_struct),
        context: None,
        provider_name: value.provider_name,
        ..Default::default()
    }
}

/// Encodes a wire `UpdateAgentProviderSessionRequest` as protobuf JSON.
pub(crate) fn encode_wire_update_agent_provider_session_request_json(
    value: &v1::UpdateAgentProviderSessionRequest,
) -> serde_json::Value {
    let mut object = serde_json::Map::new();
    if !value.session_id.is_empty() {
        object.insert(
            "sessionId".into(),
            serde_json::Value::String(value.session_id.to_string()),
        );
    }
    if !value.client_ref.is_empty() {
        object.insert(
            "clientRef".into(),
            serde_json::Value::String(value.client_ref.to_string()),
        );
    }
    if value.state != 0 {
        object.insert("state".into(), {
            let v = value.state;
            if let Some(name) = match value.state {
                0 => Some("AGENT_SESSION_STATE_UNSPECIFIED"),
                1 => Some("AGENT_SESSION_STATE_ACTIVE"),
                2 => Some("AGENT_SESSION_STATE_ARCHIVED"),
                _ => None,
            } {
                serde_json::Value::String(name.to_string())
            } else {
                serde_json::json!(v)
            }
        });
    }
    if let Some(inner) = &value.metadata {
        object.insert(
            "metadata".into(),
            crate::public::proto_json::encode_struct(inner),
        );
    }
    if let Some(inner) = &value.context {
        object.insert("context".into(), encode_wire_request_context_json(inner));
    }
    if !value.provider_name.is_empty() {
        object.insert(
            "providerName".into(),
            serde_json::Value::String(value.provider_name.to_string()),
        );
    }
    serde_json::Value::Object(object)
}

/// Decodes protobuf JSON into a wire `UpdateAgentProviderSessionRequest`.
pub(crate) fn decode_wire_update_agent_provider_session_request_json(
    value: &serde_json::Value,
) -> Result<
    v1::UpdateAgentProviderSessionRequest,
    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::UpdateAgentProviderSessionRequest {
        session_id: match object.get("sessionId") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        client_ref: match object.get("clientRef") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        state: object
            .get("state")
            .map(|value| match value {
                serde_json::Value::String(text) => match text.as_str() {
                    "AGENT_SESSION_STATE_UNSPECIFIED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(0)
                    }
                    "AGENT_SESSION_STATE_ACTIVE" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(1)
                    }
                    "AGENT_SESSION_STATE_ARCHIVED" => {
                        Ok::<i32, crate::public::generated::rpc_support::GestaltError>(2)
                    }
                    _ => Err(crate::public::proto_json::invalid_proto_json(
                        "unknown enum value",
                    )),
                },
                serde_json::Value::Number(number) => number
                    .as_i64()
                    .and_then(|v| i32::try_from(v).ok())
                    .ok_or_else(|| {
                        crate::public::proto_json::invalid_proto_json("enum number out of range")
                    }),
                _ => Err(crate::public::proto_json::invalid_proto_json(
                    "expected enum value",
                )),
            })
            .transpose()?
            .unwrap_or(0),
        metadata: object
            .get("metadata")
            .map(|value| crate::public::proto_json::decode_struct(value))
            .transpose()?,
        context: object
            .get("context")
            .map(|value| decode_wire_request_context_json(value))
            .transpose()?,
        provider_name: match object.get("providerName") {
            Some(value) => crate::public::proto_json::decode_string(value)?,
            None => String::new(),
        },
        ..Default::default()
    })
}