objectiveai-cli 2.0.5

ObjectiveAI command-line interface and embeddable library
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use clap::Args;

/// Shared response format arguments for agent completions.
#[derive(Args)]
pub struct ResponseFormatArgs {
    /// Use JSON object response format.
    #[arg(long, group = "response_format")]
    pub response_format_json_object: bool,

    /// Use JSON schema response format with inline JSON schema.
    #[arg(long, group = "response_format")]
    pub response_format_json_schema_inline: Option<String>,

    /// Use JSON schema response format with inline Python code that produces the schema.
    #[arg(long, group = "response_format")]
    pub response_format_json_schema_python_inline: Option<String>,

    /// Use JSON schema response format with a Python file that produces the schema.
    #[arg(long, group = "response_format")]
    pub response_format_json_schema_python_file: Option<std::path::PathBuf>,

    /// Use grammar response format.
    #[arg(long, group = "response_format")]
    pub response_format_grammar: Option<String>,

    /// Use Python response format.
    #[arg(long, group = "response_format")]
    pub response_format_python: bool,

    /// Use tool call response format — tool name.
    #[arg(long, group = "response_format", requires = "response_format_tool_call_description")]
    pub response_format_tool_call_name: Option<String>,

    /// Tool call response format — tool description.
    #[arg(long)]
    pub response_format_tool_call_description: Option<String>,

    /// Tool call response format — schema as inline JSON.
    #[arg(long, group = "tool_call_schema")]
    pub response_format_tool_call_schema_inline: Option<String>,

    /// Tool call response format — schema from inline Python code.
    #[arg(long, group = "tool_call_schema")]
    pub response_format_tool_call_schema_python_inline: Option<String>,

    /// Tool call response format — schema from a Python file.
    #[arg(long, group = "tool_call_schema")]
    pub response_format_tool_call_schema_python_file: Option<std::path::PathBuf>,

    /// Tool call response format — whether the tool call is required.
    #[arg(long)]
    pub response_format_tool_call_required: bool,
}

impl ResponseFormatArgs {
    pub fn resolve(self) -> Result<Option<objectiveai_sdk::agent::completions::request::ResponseFormat>, crate::error::Error> {
        use objectiveai_sdk::agent::completions::request::ResponseFormat;

        if self.response_format_json_object {
            return Ok(Some(ResponseFormat::JsonObject));
        }

        if let Some(inline) = self.response_format_json_schema_inline {
            let schema = {
                let mut de = serde_json::Deserializer::from_str(&inline);
                serde_path_to_error::deserialize(&mut de)
                    .map_err(crate::error::Error::InlineDeserialize)?
            };
            return Ok(Some(ResponseFormat::JsonSchema { schema }));
        }
        if let Some(code) = self.response_format_json_schema_python_inline {
            let schema = crate::python::exec_code(&code)?;
            return Ok(Some(ResponseFormat::JsonSchema { schema }));
        }
        if let Some(path) = self.response_format_json_schema_python_file {
            let schema = crate::python::exec_file(&path)?;
            return Ok(Some(ResponseFormat::JsonSchema { schema }));
        }

        if let Some(grammar) = self.response_format_grammar {
            return Ok(Some(ResponseFormat::Grammar { grammar }));
        }

        if self.response_format_python {
            return Ok(Some(ResponseFormat::Python));
        }

        if let Some(name) = self.response_format_tool_call_name {
            let description = self.response_format_tool_call_description.unwrap_or_default();
            let schema = if let Some(inline) = self.response_format_tool_call_schema_inline {
                let mut de = serde_json::Deserializer::from_str(&inline);
                serde_path_to_error::deserialize(&mut de)
                    .map_err(crate::error::Error::InlineDeserialize)?
            } else if let Some(code) = self.response_format_tool_call_schema_python_inline {
                crate::python::exec_code(&code)?
            } else if let Some(path) = self.response_format_tool_call_schema_python_file {
                crate::python::exec_file(&path)?
            } else {
                Default::default()
            };
            let required = if self.response_format_tool_call_required { Some(true) } else { None };
            return Ok(Some(ResponseFormat::ToolCall { name, description, schema, required }));
        }

        Ok(None)
    }
}