orchestratord 0.5.0

Daemon process for the Agent Orchestrator — gRPC control plane and task execution
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
121
122
123
124
125
126
127
128
129
130
131
132

use orchestrator_proto::{
    CommandRun, Event, TaskGraphDebugBundle, TaskItem, TaskSummary, TimelineActorRef,
    TimelineEntry, TimelineEvidenceRef,
};

pub(super) fn summary_to_proto(t: agent_orchestrator::dto::TaskSummary) -> TaskSummary {
    TaskSummary {
        id: t.id,
        name: t.name,
        status: t.status,
        started_at: t.started_at,
        completed_at: t.completed_at,
        goal: t.goal,
        project_id: t.project_id,
        workspace_id: t.workspace_id,
        workflow_id: t.workflow_id,
        target_files: t.target_files,
        total_items: t.total_items,
        finished_items: t.finished_items,
        failed_items: t.failed_items,
        created_at: t.created_at,
        updated_at: t.updated_at,
        parent_task_id: t.parent_task_id,
        spawn_reason: t.spawn_reason,
        spawn_depth: t.spawn_depth,
    }
}

pub(super) fn item_to_proto(i: agent_orchestrator::dto::TaskItemDto) -> TaskItem {
    TaskItem {
        id: i.id,
        task_id: i.task_id,
        order_no: i.order_no,
        qa_file_path: i.qa_file_path,
        status: i.status,
        ticket_files: i.ticket_files,
        ticket_content_json: serde_json::to_string(&i.ticket_content).unwrap_or_default(),
        fix_required: i.fix_required,
        fixed: i.fixed,
        last_error: i.last_error,
        started_at: i.started_at,
        completed_at: i.completed_at,
        updated_at: i.updated_at,
    }
}

pub(super) fn run_to_proto(r: agent_orchestrator::dto::CommandRunDto) -> CommandRun {
    CommandRun {
        id: r.id,
        task_item_id: r.task_item_id,
        phase: r.phase,
        command: r.command,
        cwd: r.cwd,
        workspace_id: r.workspace_id,
        agent_id: r.agent_id,
        exit_code: r.exit_code,
        stdout_path: r.stdout_path,
        stderr_path: r.stderr_path,
        started_at: r.started_at,
        ended_at: r.ended_at,
        interrupted: r.interrupted,
    }
}

pub(super) fn event_to_proto(e: agent_orchestrator::dto::EventDto) -> Event {
    Event {
        id: e.id,
        task_id: e.task_id,
        task_item_id: e.task_item_id,
        event_type: e.event_type,
        payload_json: serde_json::to_string(&e.payload).unwrap_or_default(),
        created_at: e.created_at,
    }
}

pub(super) fn timeline_entry_to_proto(
    entry: orchestrator_scheduler::scheduler::timeline::TimelineEntry,
) -> TimelineEntry {
    TimelineEntry {
        id: entry.id,
        task_id: entry.task_id,
        occurred_at: entry.occurred_at,
        category: entry.category.as_str().to_string(),
        title: entry.title,
        summary: entry.summary,
        status: entry.status,
        actor: entry.actor.map(|actor| TimelineActorRef {
            actor_type: actor.actor_type,
            actor_id: actor.actor_id,
        }),
        step_id: entry.step_id,
        task_item_id: entry.task_item_id,
        command_run_id: entry.command_run_id,
        session_id: entry.session_id,
        checkpoint_id: entry.checkpoint_id,
        source_event_id: entry.source_event_id,
        evidence: entry
            .evidence
            .into_iter()
            .map(|evidence| TimelineEvidenceRef {
                kind: evidence.kind,
                label: evidence.label,
                uri: evidence.uri,
                content_type: evidence.content_type,
                digest: evidence.digest,
                redacted: evidence.redacted,
            })
            .collect(),
        raw_event_ids: entry.raw_event_ids,
        projection_version: entry.projection_version,
    }
}

pub(super) fn graph_debug_to_proto(
    bundle: agent_orchestrator::dto::TaskGraphDebugBundle,
) -> TaskGraphDebugBundle {
    TaskGraphDebugBundle {
        graph_run_id: bundle.graph_run_id,
        cycle: bundle.cycle,
        source: bundle.source,
        status: bundle.status,
        fallback_mode: bundle.fallback_mode,
        planner_failure_class: bundle.planner_failure_class,
        planner_failure_message: bundle.planner_failure_message,
        effective_graph_json: bundle.effective_graph_json,
        planner_raw_output_json: bundle.planner_raw_output_json,
        normalized_plan_json: bundle.normalized_plan_json,
        execution_replay_json: bundle.execution_replay_json,
        created_at: bundle.created_at,
        updated_at: bundle.updated_at,
    }
}