test: add Responses API type conversion tests

Cover message→InputItem, tool_calls→FunctionCall, instructions extraction,
tool definition/choice conversion, and output text/tool_call extraction.

Author: gahyun-git

crates/cratos-llm/src/providers/openai/tests.rs

@@ -1,4 +1,6 @@
 use super::*;
+use crate::message::Message;
+use crate::tools::{ToolCall, ToolChoice, ToolDefinition};
 use crate::util::mask_api_key;
 use std::time::Duration;
 
@@ -126,3 +128,193 @@ fn test_provider_stores_auth_source() {
     let guard = provider.refreshed_api_key.lock().unwrap();
     assert!(guard.is_none());
 }
+
+// ── Responses API conversion tests ──────────────────────────────────
+
+#[test]
+fn test_responses_convert_messages_basic() {
+    use async_openai::types::responses::{InputItem, Role};
+
+    let messages = vec![Message::user("Hello"), Message::assistant("Hi there!")];
+
+    let items = responses::convert_messages_to_input(messages).unwrap();
+    assert_eq!(items.len(), 2);
+
+    // First item: user message
+    if let InputItem::EasyMessage(msg) = &items[0] {
+        assert!(matches!(msg.role, Role::User));
+    } else {
+        panic!("Expected EasyMessage for user");
+    }
+
+    // Second item: assistant message
+    if let InputItem::EasyMessage(msg) = &items[1] {
+        assert!(matches!(msg.role, Role::Assistant));
+    } else {
+        panic!("Expected EasyMessage for assistant");
+    }
+}
+
+#[test]
+fn test_responses_convert_messages_with_tool_calls() {
+    use async_openai::types::responses::{InputItem, Item};
+
+    let tool_calls = vec![ToolCall {
+        id: "call_123".to_string(),
+        name: "get_weather".to_string(),
+        arguments: r#"{"city":"Seoul"}"#.to_string(),
+        thought_signature: None,
+    }];
+
+    let messages = vec![
+        Message::assistant_with_tool_calls("Let me check", tool_calls),
+        Message::tool_response("call_123", r#"{"temp":20}"#),
+    ];
+
+    let items = responses::convert_messages_to_input(messages).unwrap();
+    assert_eq!(items.len(), 3); // text + function_call + function_call_output
+
+    // First: assistant text
+    assert!(matches!(&items[0], InputItem::EasyMessage(_)));
+
+    // Second: function call
+    if let InputItem::Item(Item::FunctionCall(fc)) = &items[1] {
+        assert_eq!(fc.call_id, "call_123");
+        assert_eq!(fc.name, "get_weather");
+        assert_eq!(fc.arguments, r#"{"city":"Seoul"}"#);
+    } else {
+        panic!("Expected Item::FunctionCall, got {:?}", &items[1]);
+    }
+
+    // Third: function call output
+    if let InputItem::Item(Item::FunctionCallOutput(fco)) = &items[2] {
+        assert_eq!(fco.call_id, "call_123");
+    } else {
+        panic!("Expected Item::FunctionCallOutput, got {:?}", &items[2]);
+    }
+}
+
+#[test]
+fn test_responses_extract_instructions() {
+    let messages = vec![
+        Message::system("You are helpful"),
+        Message::user("Hello"),
+        Message::system("Extra system msg"),
+    ];
+
+    let (instructions, rest) = responses::extract_instructions(messages);
+
+    assert_eq!(instructions, Some("You are helpful".to_string()));
+    assert_eq!(rest.len(), 2);
+    // First remaining is user
+    assert_eq!(rest[0].role, MessageRole::User);
+    // Second remaining is the extra system (handled as developer in convert_messages_to_input)
+    assert_eq!(rest[1].role, MessageRole::System);
+}
+
+#[test]
+fn test_responses_convert_tools() {
+    use async_openai::types::responses::Tool;
+
+    let tools = vec![
+        ToolDefinition::new(
+            "get_weather",
+            "Get weather for a location",
+            serde_json::json!({
+                "type": "object",
+                "properties": {
+                    "location": {"type": "string"}
+                },
+                "required": ["location"]
+            }),
+        ),
+        ToolDefinition::new("search", "Search the web", serde_json::json!({})),
+    ];
+
+    let converted = responses::convert_tools(tools);
+    assert_eq!(converted.len(), 2);
+
+    if let Tool::Function(ft) = &converted[0] {
+        assert_eq!(ft.name, "get_weather");
+        assert_eq!(ft.description.as_deref(), Some("Get weather for a location"));
+        assert!(ft.parameters.is_some());
+    } else {
+        panic!("Expected Tool::Function");
+    }
+}
+
+#[test]
+fn test_responses_convert_tool_choice() {
+    use async_openai::types::responses::{ToolChoiceOptions, ToolChoiceParam};
+
+    assert!(matches!(
+        responses::convert_tool_choice(&ToolChoice::Auto),
+        ToolChoiceParam::Mode(ToolChoiceOptions::Auto)
+    ));
+    assert!(matches!(
+        responses::convert_tool_choice(&ToolChoice::None),
+        ToolChoiceParam::Mode(ToolChoiceOptions::None)
+    ));
+    assert!(matches!(
+        responses::convert_tool_choice(&ToolChoice::Required),
+        ToolChoiceParam::Mode(ToolChoiceOptions::Required)
+    ));
+    // Tool(name) falls back to Auto
+    assert!(matches!(
+        responses::convert_tool_choice(&ToolChoice::Tool("foo".to_string())),
+        ToolChoiceParam::Mode(ToolChoiceOptions::Auto)
+    ));
+}
+
+#[test]
+fn test_responses_extract_text_from_output() {
+    use async_openai::types::responses::{
+        AssistantRole, OutputItem, OutputMessage, OutputMessageContent, OutputStatus,
+        OutputTextContent,
+    };
+
+    let output = vec![OutputItem::Message(OutputMessage {
+        id: "msg_1".to_string(),
+        role: AssistantRole::Assistant,
+        status: OutputStatus::Completed,
+        content: vec![OutputMessageContent::OutputText(OutputTextContent {
+            text: "Hello world".to_string(),
+            annotations: vec![],
+            logprobs: None,
+        })],
+    })];
+
+    let text = responses::extract_text(&output);
+    assert_eq!(text, "Hello world");
+}
+
+#[test]
+fn test_responses_extract_tool_calls_from_output() {
+    use async_openai::types::responses::{FunctionToolCall, OutputItem};
+
+    let output = vec![
+        OutputItem::FunctionCall(FunctionToolCall {
+            call_id: "call_abc".to_string(),
+            name: "search".to_string(),
+            arguments: r#"{"q":"rust"}"#.to_string(),
+            id: Some("fc_1".to_string()),
+            status: None,
+        }),
+        OutputItem::FunctionCall(FunctionToolCall {
+            call_id: "call_def".to_string(),
+            name: "read_file".to_string(),
+            arguments: r#"{"path":"/tmp"}"#.to_string(),
+            id: None,
+            status: None,
+        }),
+    ];
+
+    let calls = responses::extract_tool_calls(&output);
+    assert_eq!(calls.len(), 2);
+    assert_eq!(calls[0].id, "call_abc");
+    assert_eq!(calls[0].name, "search");
+    assert_eq!(calls[1].id, "call_def");
+    assert_eq!(calls[1].name, "read_file");
+    // thought_signature should be None
+    assert!(calls[0].thought_signature.is_none());
+}