kcode_k1_chat_codex_codec/

lib.rs

#![forbid(unsafe_code)]

use kcode_k1_chat_chatend::{AGENT_RESPONSE_TYPE, BoxId, ChatBox};
use serde_json::Value;

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Call {
    pub name: String,
    pub arguments: String,
}

/// Preserved input for a malformed native action, for later recovery handling.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct MalformedNativeAction {
    kind: &'static str,
    native_tool: String,
    attempted_ktool: Option<String>,
    validation_code: &'static str,
    path: &'static str,
    expected: &'static str,
    received: String,
    native_arguments: Value,
}

impl MalformedNativeAction {
    pub fn kind(&self) -> &str {
        self.kind
    }

    pub fn native_tool(&self) -> &str {
        &self.native_tool
    }

    pub fn attempted_ktool(&self) -> Option<&str> {
        self.attempted_ktool.as_deref()
    }

    pub fn validation_code(&self) -> &str {
        self.validation_code
    }

    pub fn path(&self) -> &str {
        self.path
    }

    pub fn expected(&self) -> &str {
        self.expected
    }

    pub fn received(&self) -> &str {
        &self.received
    }

    pub fn native_arguments(&self) -> &Value {
        &self.native_arguments
    }

    pub fn native_arguments_json(&self) -> String {
        canonical_json(&self.native_arguments)
    }

    pub fn diagnostic(&self) -> String {
        format!(
            "malformed native action: kind={}; native_tool={}; attempted_ktool={}; validation_code={}; path={}; expected={}; received={}",
            self.kind,
            self.native_tool,
            self.attempted_ktool.as_deref().unwrap_or("<unknown>"),
            self.validation_code,
            self.path,
            self.expected,
            self.received,
        )
    }

    pub fn diagnostic_json(&self) -> String {
        canonical_json(&serde_json::json!({
            "kind": self.kind,
            "native_tool": self.native_tool,
            "attempted_ktool": self.attempted_ktool,
            "validation_code": self.validation_code,
            "path": self.path,
            "expected": self.expected,
            "received": self.received,
            "native_arguments": self.native_arguments,
        }))
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum BoxValue {
    History(String),
    Call(Result<Call, String>),
    AgentMessage(Result<String, String>),
    MalformedNativeAction(MalformedNativeAction),
}

#[derive(Default)]
pub struct Codec;

impl kcode_k1_codex_adapter::BoxCodec for Codec {
    type Box = BoxValue;

    fn tool_call_box(&mut self, call: &kcode_k1_codex_adapter::ToolCall) -> Self::Box {
        match call.name.as_str() {
            "call_ktool" => self.call_ktool_box(call),
            "agent_message" => self.agent_message_box(call),
            _ => malformed(
                "unknown_native_tool",
                call,
                None,
                "unknown_native_tool",
                "$.name",
                "call_ktool or agent_message",
                call.name.clone(),
            ),
        }
    }

    fn box_text<'a>(&self, box_: &'a Self::Box) -> &'a str {
        match box_ {
            BoxValue::History(text) => text,
            BoxValue::Call(_) | BoxValue::AgentMessage(_) | BoxValue::MalformedNativeAction(_) => {
                ""
            }
        }
    }

    fn malformed_tool_call_message(&self, box_: &Self::Box) -> Option<&'static str> {
        match box_ {
            BoxValue::Call(Err(error)) => Some(match error.as_str() {
                "tool arguments must be an object" => "tool arguments must be an object",
                "tool arguments must have name and arguments" => {
                    "tool arguments must have name and arguments"
                }
                "tool arguments name must be a string" => "tool arguments name must be a string",
                "tool arguments require arguments" => "tool arguments require arguments",
                "tool arguments cannot be encoded" => "tool arguments cannot be encoded",
                "tool name must be call_ktool or agent_message" => {
                    "tool name must be call_ktool or agent_message"
                }
                _ => "call_ktool value is malformed",
            }),
            BoxValue::AgentMessage(Err(error)) => Some(match error.as_str() {
                "agent_message arguments must be an object" => {
                    "agent_message arguments must be an object"
                }
                "agent_message arguments must have exactly one message field" => {
                    "agent_message arguments must have exactly one message field"
                }
                "agent_message message must be a string" => {
                    "agent_message message must be a string"
                }
                "agent_message message must not be empty" => {
                    "agent_message message must not be empty"
                }
                _ => "agent_message value is malformed",
            }),
            BoxValue::History(_)
            | BoxValue::Call(Ok(_))
            | BoxValue::AgentMessage(Ok(_))
            | BoxValue::MalformedNativeAction(_) => None,
        }
    }
}

impl Codec {
    fn call_ktool_box(&self, call: &kcode_k1_codex_adapter::ToolCall) -> BoxValue {
        let Value::Object(values) = &call.arguments else {
            return malformed(
                "malformed_call_ktool",
                call,
                None,
                "arguments_not_object",
                "$",
                "object with name and arguments",
                value_kind(&call.arguments).into(),
            );
        };
        let attempted_ktool = values
            .get("name")
            .and_then(Value::as_str)
            .map(str::to_owned);
        if values.len() != 2 || !values.contains_key("name") || !values.contains_key("arguments") {
            return malformed(
                "malformed_call_ktool",
                call,
                attempted_ktool,
                "invalid_wrapper_fields",
                "$",
                "object with exactly name and arguments",
                canonical_json(&call.arguments),
            );
        }
        let Some(Value::String(name)) = values.get("name") else {
            return malformed(
                "malformed_call_ktool",
                call,
                None,
                "name_not_string",
                "$.name",
                "string",
                canonical_json(&values["name"]),
            );
        };
        let arguments = &values["arguments"];
        BoxValue::Call(Ok(Call {
            name: name.clone(),
            arguments: canonical_json(arguments),
        }))
    }

    fn agent_message_box(&self, call: &kcode_k1_codex_adapter::ToolCall) -> BoxValue {
        let Value::Object(values) = &call.arguments else {
            return malformed(
                "malformed_agent_message",
                call,
                None,
                "arguments_not_object",
                "$",
                "object with exactly one message field",
                value_kind(&call.arguments).into(),
            );
        };
        if values.len() != 1 || !values.contains_key("message") {
            return malformed(
                "malformed_agent_message",
                call,
                None,
                "invalid_message_fields",
                "$",
                "object with exactly one message field",
                canonical_json(&call.arguments),
            );
        }
        let Some(Value::String(message)) = values.get("message") else {
            return malformed(
                "malformed_agent_message",
                call,
                None,
                "message_not_string",
                "$.message",
                "string",
                canonical_json(&values["message"]),
            );
        };
        if message.is_empty() {
            return malformed(
                "malformed_agent_message",
                call,
                None,
                "message_empty",
                "$.message",
                "nonempty string",
                "empty string".into(),
            );
        }
        BoxValue::AgentMessage(Ok(message.clone()))
    }
}

fn malformed(
    kind: &'static str,
    call: &kcode_k1_codex_adapter::ToolCall,
    attempted_ktool: Option<String>,
    validation_code: &'static str,
    path: &'static str,
    expected: &'static str,
    received: String,
) -> BoxValue {
    BoxValue::MalformedNativeAction(MalformedNativeAction {
        kind,
        native_tool: call.name.clone(),
        attempted_ktool,
        validation_code,
        path,
        expected,
        received,
        native_arguments: call.arguments.clone(),
    })
}

fn canonical_json(value: &Value) -> String {
    match value {
        Value::Null | Value::Bool(_) | Value::Number(_) | Value::String(_) => {
            serde_json::to_string(value).unwrap_or_default()
        }
        Value::Array(values) => format!(
            "[{}]",
            values
                .iter()
                .map(canonical_json)
                .collect::<Vec<_>>()
                .join(",")
        ),
        Value::Object(values) => {
            let mut entries = values.iter().collect::<Vec<_>>();
            entries.sort_unstable_by(|left, right| left.0.cmp(right.0));
            format!(
                "{{{}}}",
                entries
                    .into_iter()
                    .map(|(key, value)| format!(
                        "{}:{}",
                        canonical_json(&Value::String(key.clone())),
                        canonical_json(value)
                    ))
                    .collect::<Vec<_>>()
                    .join(",")
            )
        }
    }
}

fn value_kind(value: &Value) -> &'static str {
    match value {
        Value::Null => "null",
        Value::Bool(_) => "boolean",
        Value::Number(_) => "number",
        Value::String(_) => "string",
        Value::Array(_) => "array",
        Value::Object(_) => "object",
    }
}

pub fn project(box_: &ChatBox) -> BoxValue {
    BoxValue::History(format!(
        "[Box {} | {}]\n{}",
        box_.id().get(),
        box_.box_type(),
        box_.contents()
    ))
}

pub fn open_agent_response(id: BoxId) -> BoxValue {
    BoxValue::History(format!("[Box {} | {}]\n", id.get(), AGENT_RESPONSE_TYPE))
}