objectiveai-sdk 2.1.0

pub mod standard;
pub mod swiss_system;

/// CLI-surface form for the `--function-inline` argument: either a fully
/// resolved inline-or-remote spec, or a bare favorite name that the CLI
/// resolves to one of those at handler time. Untagged: an inline function
/// object or remote-path object lands on `Resolved`; a bare JSON string
/// lands on `Favorite`.
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
#[serde(untagged)]
#[schemars(rename = "cli.command.functions.executions.create.FunctionSpec")]
pub enum FunctionSpec {
    #[schemars(title = "Resolved")]
    Resolved(crate::functions::FullInlineFunctionOrRemoteCommitOptional),
    #[schemars(title = "Favorite")]
    Favorite(String),
}

/// CLI-surface form for the `--profile-inline` argument: either a fully
/// resolved inline-or-remote spec, or a bare favorite name that the CLI
/// resolves to one of those at handler time. Untagged: an inline profile
/// object or remote-path object lands on `Resolved`; a bare JSON string
/// lands on `Favorite`.
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
#[serde(untagged)]
#[schemars(rename = "cli.command.functions.executions.create.ProfileSpec")]
pub enum ProfileSpec {
    #[schemars(title = "Resolved")]
    Resolved(crate::functions::InlineProfileOrRemoteCommitOptional),
    #[schemars(title = "Favorite")]
    Favorite(String),
}

#[derive(clap::Subcommand)]
pub enum Command {
    Standard(standard::Command),
    SwissSystem(swiss_system::Command),
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
#[serde(untagged)]
#[schemars(rename = "cli.command.functions.executions.create.Request")]
pub enum Request {
    #[schemars(title = "Standard")]
    Standard(standard::Request),
    #[schemars(title = "StandardRequestSchema")]
    StandardRequestSchema(standard::request_schema::Request),
    #[schemars(title = "StandardResponseSchema")]
    StandardResponseSchema(standard::response_schema::Request),
    #[schemars(title = "SwissSystem")]
    SwissSystem(swiss_system::Request),
    #[schemars(title = "SwissSystemRequestSchema")]
    SwissSystemRequestSchema(swiss_system::request_schema::Request),
    #[schemars(title = "SwissSystemResponseSchema")]
    SwissSystemResponseSchema(swiss_system::response_schema::Request),
}

// Exempt from json-schema coverage: tier aggregate (see the root
// `ResponseItem` in command.rs - TS7056).
#[objectiveai_sdk_macros::json_schema_ignore]
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
#[schemars(rename = "cli.command.functions.executions.create.ResponseItem")]
#[serde(untagged)]
pub enum ResponseItem {
    #[schemars(title = "Standard")]
    Standard(standard::ResponseItem),
    #[schemars(title = "StandardRequestSchema")]
    StandardRequestSchema(standard::request_schema::Response),
    #[schemars(title = "StandardResponseSchema")]
    StandardResponseSchema(standard::response_schema::Response),
    #[schemars(title = "SwissSystem")]
    SwissSystem(swiss_system::ResponseItem),
    #[schemars(title = "SwissSystemRequestSchema")]
    SwissSystemRequestSchema(swiss_system::request_schema::Response),
    #[schemars(title = "SwissSystemResponseSchema")]
    SwissSystemResponseSchema(swiss_system::response_schema::Response),
}

#[cfg(feature = "mcp")]
impl crate::cli::command::CommandResponse for ResponseItem {
    fn into_mcp(self) -> crate::cli::command::McpResponseItem {
        match self {
            ResponseItem::Standard(v) => v.into_mcp(),
            ResponseItem::StandardRequestSchema(v) => v.into_mcp(),
            ResponseItem::StandardResponseSchema(v) => v.into_mcp(),
            ResponseItem::SwissSystem(v) => v.into_mcp(),
            ResponseItem::SwissSystemRequestSchema(v) => v.into_mcp(),
            ResponseItem::SwissSystemResponseSchema(v) => v.into_mcp(),
        }
    }
}

impl TryFrom<Command> for Request {
    type Error = crate::cli::command::FromArgsError;
    fn try_from(command: Command) -> Result<Self, Self::Error> {
        match command {
            Command::Standard(cmd) => match cmd.schema {
                None => Ok(Request::Standard(standard::Request::try_from(cmd.args)?)),
                Some(standard::Schema::RequestSchema(args)) =>
                    Ok(Request::StandardRequestSchema(standard::request_schema::Request::try_from(args)?)),
                Some(standard::Schema::ResponseSchema(args)) =>
                    Ok(Request::StandardResponseSchema(standard::response_schema::Request::try_from(args)?)),
            },
            Command::SwissSystem(cmd) => match cmd.schema {
                None => Ok(Request::SwissSystem(swiss_system::Request::try_from(cmd.args)?)),
                Some(swiss_system::Schema::RequestSchema(args)) =>
                    Ok(Request::SwissSystemRequestSchema(swiss_system::request_schema::Request::try_from(args)?)),
                Some(swiss_system::Schema::ResponseSchema(args)) =>
                    Ok(Request::SwissSystemResponseSchema(swiss_system::response_schema::Request::try_from(args)?)),
            },
        }
    }
}

impl crate::cli::command::CommandRequest for Request {
    fn into_command(&self) -> Vec<String> {
        match self {
            Request::Standard(inner) => inner.into_command(),
            Request::StandardRequestSchema(inner) => inner.into_command(),
            Request::StandardResponseSchema(inner) => inner.into_command(),
            Request::SwissSystem(inner) => inner.into_command(),
            Request::SwissSystemRequestSchema(inner) => inner.into_command(),
            Request::SwissSystemResponseSchema(inner) => inner.into_command(),
        }
    }
}

#[cfg(feature = "cli-executor")]
pub async fn execute<E: crate::cli::command::CommandExecutor>(
    executor: &E,
    request: Request,

        agent_arguments: Option<&crate::cli::command::AgentArguments>,
    ) -> Result<
    std::pin::Pin<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>>,
    E::Error,
> {
    use futures::StreamExt;
    let stream: std::pin::Pin<Box<dyn futures::Stream<Item = Result<ResponseItem, E::Error>> + Send>> =
        match request {
            Request::Standard(req) => {
                let want_streaming = req
                    .dangerous_advanced
                    .as_ref()
                    .and_then(|a| a.stream)
                    .unwrap_or(false);
                if want_streaming {
                    let inner = standard::execute_streaming(executor, req, agent_arguments).await?;
                    Box::pin(inner.map(|r| r.map(ResponseItem::Standard)))
                } else {
                    let value = standard::execute(executor, req, agent_arguments).await?;
                    Box::pin(crate::cli::command::StreamOnce::new(Ok(
                        ResponseItem::Standard(standard::ResponseItem::Id(value)),
                    )))
                }
            }
            Request::StandardRequestSchema(req) => {
                let value = standard::request_schema::execute(executor, req, agent_arguments).await?;
                Box::pin(crate::cli::command::StreamOnce::new(Ok(
                    ResponseItem::StandardRequestSchema(value),
                )))
            }
            Request::StandardResponseSchema(req) => {
                let value = standard::response_schema::execute(executor, req, agent_arguments).await?;
                Box::pin(crate::cli::command::StreamOnce::new(Ok(
                    ResponseItem::StandardResponseSchema(value),
                )))
            }
            Request::SwissSystem(req) => {
                let want_streaming = req
                    .dangerous_advanced
                    .as_ref()
                    .and_then(|a| a.stream)
                    .unwrap_or(false);
                if want_streaming {
                    let inner = swiss_system::execute_streaming(executor, req, agent_arguments).await?;
                    Box::pin(inner.map(|r| r.map(ResponseItem::SwissSystem)))
                } else {
                    let value = swiss_system::execute(executor, req, agent_arguments).await?;
                    Box::pin(crate::cli::command::StreamOnce::new(Ok(
                        ResponseItem::SwissSystem(swiss_system::ResponseItem::Id(value)),
                    )))
                }
            }
            Request::SwissSystemRequestSchema(req) => {
                let value = swiss_system::request_schema::execute(executor, req, agent_arguments).await?;
                Box::pin(crate::cli::command::StreamOnce::new(Ok(
                    ResponseItem::SwissSystemRequestSchema(value),
                )))
            }
            Request::SwissSystemResponseSchema(req) => {
                let value = swiss_system::response_schema::execute(executor, req, agent_arguments).await?;
                Box::pin(crate::cli::command::StreamOnce::new(Ok(
                    ResponseItem::SwissSystemResponseSchema(value),
                )))
            }
        };
    Ok(stream)
}

#[cfg(feature = "cli-executor")]
pub async fn execute_jq<E: crate::cli::command::CommandExecutor>(
    executor: &E,
    request: Request,
    jq: String,

        agent_arguments: Option<&crate::cli::command::AgentArguments>,
    ) -> Result<
    std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>>,
    E::Error,
> {
    let stream: std::pin::Pin<Box<dyn futures::Stream<Item = Result<serde_json::Value, E::Error>> + Send>> =
        match request {
            Request::Standard(req) => {
                let want_streaming = req
                    .dangerous_advanced
                    .as_ref()
                    .and_then(|a| a.stream)
                    .unwrap_or(false);
                if want_streaming {
                    let inner = standard::execute_streaming_jq(executor, req, jq, agent_arguments).await?;
                    Box::pin(inner)
                } else {
                    let value = standard::execute_jq(executor, req, jq, agent_arguments).await?;
                    Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
                }
            }
            Request::StandardRequestSchema(req) => {
                let value = standard::request_schema::execute_jq(executor, req, jq, agent_arguments).await?;
                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
            }
            Request::StandardResponseSchema(req) => {
                let value = standard::response_schema::execute_jq(executor, req, jq, agent_arguments).await?;
                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
            }
            Request::SwissSystem(req) => {
                let want_streaming = req
                    .dangerous_advanced
                    .as_ref()
                    .and_then(|a| a.stream)
                    .unwrap_or(false);
                if want_streaming {
                    let inner = swiss_system::execute_streaming_jq(executor, req, jq, agent_arguments).await?;
                    Box::pin(inner)
                } else {
                    let value = swiss_system::execute_jq(executor, req, jq, agent_arguments).await?;
                    Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
                }
            }
            Request::SwissSystemRequestSchema(req) => {
                let value = swiss_system::request_schema::execute_jq(executor, req, jq, agent_arguments).await?;
                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
            }
            Request::SwissSystemResponseSchema(req) => {
                let value = swiss_system::response_schema::execute_jq(executor, req, jq, agent_arguments).await?;
                Box::pin(crate::cli::command::StreamOnce::new(Ok(value)))
            }
        };
    Ok(stream)
}