ai-agent 0.88.0

Idiomatic agent sdk inspired by the claude code source leak
Documentation 
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
108
109
110
111
112
113
114
115
116
117
118
119
120

// Source: ~/claudecode/openclaudecode/src/tasks/types.ts

#![allow(dead_code)]

use serde::{Deserialize, Serialize};

/// Union of all concrete task state types.
/// Use this for components that need to work with any task type.
pub enum TaskState {
    LocalShell(crate::tasks::guards::LocalShellTaskState),
    LocalAgent(std::collections::HashMap<String, serde_json::Value>),
    RemoteAgent(std::collections::HashMap<String, serde_json::Value>),
    InProcessTeammate(std::collections::HashMap<String, serde_json::Value>),
    LocalWorkflow(crate::tasks::local_workflow_task::LocalWorkflowTaskState),
    MonitorMcp(crate::tasks::monitor_mcp_task::MonitorMcpTaskState),
    Dream(std::collections::HashMap<String, serde_json::Value>),
}

/// Task types that can appear in the background tasks indicator.
pub enum BackgroundTaskState {
    LocalShell(crate::tasks::guards::LocalShellTaskState),
    LocalAgent(std::collections::HashMap<String, serde_json::Value>),
    RemoteAgent(std::collections::HashMap<String, serde_json::Value>),
    InProcessTeammate(std::collections::HashMap<String, serde_json::Value>),
    LocalWorkflow(crate::tasks::local_workflow_task::LocalWorkflowTaskState),
    MonitorMcp(crate::tasks::monitor_mcp_task::MonitorMcpTaskState),
    Dream(std::collections::HashMap<String, serde_json::Value>),
}

impl BackgroundTaskState {
    /// Returns the task type string.
    pub fn task_type(&self) -> &'static str {
        match self {
            BackgroundTaskState::LocalShell(_) => "local_bash",
            BackgroundTaskState::LocalAgent(_) => "local_agent",
            BackgroundTaskState::RemoteAgent(_) => "remote_agent",
            BackgroundTaskState::InProcessTeammate(_) => "in_process_teammate",
            BackgroundTaskState::LocalWorkflow(_) => "local_workflow",
            BackgroundTaskState::MonitorMcp(_) => "monitor_mcp",
            BackgroundTaskState::Dream(_) => "dream",
        }
    }

    /// Returns the task status.
    pub fn status(&self) -> crate::task::TaskStatus {
        match self {
            BackgroundTaskState::LocalShell(t) => t.status.clone(),
            BackgroundTaskState::LocalAgent(t) => t
                .get("status")
                .and_then(|v| v.as_str())
                .and_then(|s| match s {
                    "pending" => Some(crate::task::TaskStatus::pending),
                    "running" => Some(crate::task::TaskStatus::running),
                    "completed" => Some(crate::task::TaskStatus::completed),
                    "failed" => Some(crate::task::TaskStatus::failed),
                    "killed" => Some(crate::task::TaskStatus::killed),
                    _ => None,
                })
                .unwrap_or(crate::task::TaskStatus::pending),
            BackgroundTaskState::RemoteAgent(t) => t
                .get("status")
                .and_then(|v| v.as_str())
                .and_then(|s| match s {
                    "pending" => Some(crate::task::TaskStatus::pending),
                    "running" => Some(crate::task::TaskStatus::running),
                    "completed" => Some(crate::task::TaskStatus::completed),
                    "failed" => Some(crate::task::TaskStatus::failed),
                    "killed" => Some(crate::task::TaskStatus::killed),
                    _ => None,
                })
                .unwrap_or(crate::task::TaskStatus::pending),
            BackgroundTaskState::InProcessTeammate(t) => t
                .get("status")
                .and_then(|v| v.as_str())
                .and_then(|s| match s {
                    "pending" => Some(crate::task::TaskStatus::pending),
                    "running" => Some(crate::task::TaskStatus::running),
                    "completed" => Some(crate::task::TaskStatus::completed),
                    "failed" => Some(crate::task::TaskStatus::failed),
                    "killed" => Some(crate::task::TaskStatus::killed),
                    _ => None,
                })
                .unwrap_or(crate::task::TaskStatus::pending),
            BackgroundTaskState::LocalWorkflow(t) => t.status.clone(),
            BackgroundTaskState::MonitorMcp(t) => t.status.clone(),
            BackgroundTaskState::Dream(t) => t
                .get("status")
                .and_then(|v| v.as_str())
                .and_then(|s| match s {
                    "pending" => Some(crate::task::TaskStatus::pending),
                    "running" => Some(crate::task::TaskStatus::running),
                    "completed" => Some(crate::task::TaskStatus::completed),
                    "failed" => Some(crate::task::TaskStatus::failed),
                    "killed" => Some(crate::task::TaskStatus::killed),
                    _ => None,
                })
                .unwrap_or(crate::task::TaskStatus::pending),
        }
    }
}

/// Check if a task should be shown in the background tasks indicator.
/// A task is considered a background task if:
/// 1. It is running or pending
/// 2. It has been explicitly backgrounded (not a foreground task)
pub fn is_background_task(task: &BackgroundTaskState) -> bool {
    let status = task.status();
    if status != crate::task::TaskStatus::running && status != crate::task::TaskStatus::pending {
        return false;
    }

    // Foreground tasks (is_backgrounded === false) are not yet "background tasks"
    if let BackgroundTaskState::LocalShell(t) = task {
        if t.is_backgrounded == Some(false) {
            return false;
        }
    }

    true
}