tenant.openagents/omega

1use lsp::{Uri, VersionedTextDocumentIdentifier};
2use serde::{Deserialize, Serialize};
3
4pub enum CheckStatus {}
5
6#[derive(Debug, Serialize, Deserialize)]
7#[serde(rename_all = "camelCase")]
8pub struct CheckStatusParams {
9    pub local_checks_only: bool,
10}
11
12impl lsp::request::Request for CheckStatus {
13    type Params = CheckStatusParams;
14    type Result = SignInStatus;
15    const METHOD: &'static str = "checkStatus";
16}
17
18pub enum SignIn {}
19
20#[derive(Debug, Serialize, Deserialize)]
21pub struct SignInParams {}
22
23#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
24#[serde(rename_all = "camelCase")]
25pub struct PromptUserDeviceFlow {
26    pub user_code: String,
27    pub command: lsp::Command,
28}
29
30impl lsp::request::Request for SignIn {
31    type Params = SignInParams;
32    type Result = PromptUserDeviceFlow;
33    const METHOD: &'static str = "signIn";
34}
35
36#[derive(Debug, Serialize, Deserialize)]
37#[serde(tag = "status")]
38pub enum SignInStatus {
39    #[serde(rename = "OK")]
40    Ok {
41        user: Option<String>,
42    },
43    MaybeOk {
44        user: String,
45    },
46    AlreadySignedIn {
47        user: String,
48    },
49    NotAuthorized {
50        user: String,
51    },
52    NotSignedIn,
53}
54
55pub enum SignOut {}
56
57#[derive(Debug, Serialize, Deserialize)]
58#[serde(rename_all = "camelCase")]
59pub struct SignOutParams {}
60
61#[derive(Debug, Serialize, Deserialize)]
62#[serde(rename_all = "camelCase")]
63pub struct SignOutResult {}
64
65impl lsp::request::Request for SignOut {
66    type Params = SignOutParams;
67    type Result = SignOutResult;
68    const METHOD: &'static str = "signOut";
69}
70
71pub enum DidChangeStatus {}
72
73#[derive(Debug, Serialize, Deserialize)]
74pub struct DidChangeStatusParams {
75    #[serde(default)]
76    pub message: Option<String>,
77    pub kind: StatusKind,
78}
79
80#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
81pub enum StatusKind {
82    Normal,
83    Error,
84    Warning,
85    Inactive,
86}
87
88impl lsp::notification::Notification for DidChangeStatus {
89    type Params = DidChangeStatusParams;
90    const METHOD: &'static str = "didChangeStatus";
91}
92
93pub enum SetEditorInfo {}
94
95#[derive(Debug, Serialize, Deserialize)]
96#[serde(rename_all = "camelCase")]
97pub struct SetEditorInfoParams {
98    pub editor_info: EditorInfo,
99    pub editor_plugin_info: EditorPluginInfo,
100}
101
102impl lsp::request::Request for SetEditorInfo {
103    type Params = SetEditorInfoParams;
104    type Result = String;
105    const METHOD: &'static str = "setEditorInfo";
106}
107
108#[derive(Debug, Serialize, Deserialize)]
109#[serde(rename_all = "camelCase")]
110pub struct EditorInfo {
111    pub name: String,
112    pub version: String,
113}
114
115#[derive(Debug, Serialize, Deserialize)]
116#[serde(rename_all = "camelCase")]
117pub struct EditorPluginInfo {
118    pub name: String,
119    pub version: String,
120}
121
122pub enum NotifyAccepted {}
123
124#[derive(Debug, Serialize, Deserialize)]
125#[serde(rename_all = "camelCase")]
126pub struct NotifyAcceptedParams {
127    pub uuid: String,
128}
129
130impl lsp::request::Request for NotifyAccepted {
131    type Params = NotifyAcceptedParams;
132    type Result = String;
133    const METHOD: &'static str = "notifyAccepted";
134}
135
136pub enum NotifyRejected {}
137
138#[derive(Debug, Serialize, Deserialize)]
139#[serde(rename_all = "camelCase")]
140pub struct NotifyRejectedParams {
141    pub uuids: Vec<String>,
142}
143
144impl lsp::request::Request for NotifyRejected {
145    type Params = NotifyRejectedParams;
146    type Result = String;
147    const METHOD: &'static str = "notifyRejected";
148}
149
150#[derive(Debug, Serialize, Deserialize)]
151#[serde(rename_all = "camelCase")]
152pub struct NextEditSuggestions;
153
154#[derive(Debug, Serialize, Deserialize)]
155#[serde(rename_all = "camelCase")]
156pub struct NextEditSuggestionsParams {
157    pub(crate) text_document: VersionedTextDocumentIdentifier,
158    pub(crate) position: lsp::Position,
159}
160
161#[derive(Clone, Debug, Serialize, Deserialize)]
162#[serde(rename_all = "camelCase")]
163pub struct NextEditSuggestion {
164    pub text: String,
165    pub text_document: VersionedTextDocumentIdentifier,
166    pub range: lsp::Range,
167    pub command: Option<lsp::Command>,
168}
169
170#[derive(Debug, Serialize, Deserialize)]
171#[serde(rename_all = "camelCase")]
172pub struct NextEditSuggestionsResult {
173    pub edits: Vec<NextEditSuggestion>,
174}
175
176impl lsp::request::Request for NextEditSuggestions {
177    type Params = NextEditSuggestionsParams;
178    type Result = NextEditSuggestionsResult;
179
180    const METHOD: &'static str = "textDocument/copilotInlineEdit";
181}
182
183pub(crate) struct DidFocus;
184
185#[derive(Serialize, Deserialize)]
186pub(crate) struct DidFocusParams {
187    #[serde(skip_serializing_if = "Option::is_none")]
188    pub(crate) uri: Option<Uri>,
189}
190
191impl lsp::notification::Notification for DidFocus {
192    type Params = DidFocusParams;
193    const METHOD: &'static str = "textDocument/didFocus";
194}
195
196pub(crate) struct DidShowInlineEdit;
197
198#[derive(Serialize, Deserialize)]
199pub(crate) struct DidShowInlineEditParams {
200    pub(crate) item: serde_json::Value,
201}
202
203impl lsp::notification::Notification for DidShowInlineEdit {
204    type Params = DidShowInlineEditParams;
205    const METHOD: &'static str = "textDocument/didShowInlineEdit";
206}
207
208// Inline Completions (non-NES) - textDocument/inlineCompletion
209
210pub enum InlineCompletions {}
211
212#[derive(Debug, Serialize, Deserialize)]
213#[serde(rename_all = "camelCase")]
214pub struct InlineCompletionsParams {
215    pub text_document: VersionedTextDocumentIdentifier,
216    pub position: lsp::Position,
217    pub context: InlineCompletionContext,
218    #[serde(skip_serializing_if = "Option::is_none")]
219    pub formatting_options: Option<FormattingOptions>,
220}
221
222#[derive(Debug, Serialize, Deserialize)]
223#[serde(rename_all = "camelCase")]
224pub struct InlineCompletionContext {
225    pub trigger_kind: InlineCompletionTriggerKind,
226}
227
228#[derive(Debug, Clone, Copy)]
229pub enum InlineCompletionTriggerKind {
230    Invoked = 1,
231    Automatic = 2,
232}
233
234impl Serialize for InlineCompletionTriggerKind {
235    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
236    where
237        S: serde::Serializer,
238    {
239        serializer.serialize_u8(*self as u8)
240    }
241}
242
243impl<'de> Deserialize<'de> for InlineCompletionTriggerKind {
244    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
245    where
246        D: serde::Deserializer<'de>,
247    {
248        let value = u8::deserialize(deserializer)?;
249        match value {
250            1 => Ok(InlineCompletionTriggerKind::Invoked),
251            2 => Ok(InlineCompletionTriggerKind::Automatic),
252            _ => Err(serde::de::Error::custom("invalid trigger kind")),
253        }
254    }
255}
256
257#[derive(Debug, Serialize, Deserialize)]
258#[serde(rename_all = "camelCase")]
259pub struct FormattingOptions {
260    pub tab_size: u32,
261    pub insert_spaces: bool,
262}
263
264#[derive(Debug, Serialize, Deserialize)]
265#[serde(rename_all = "camelCase")]
266pub struct InlineCompletionsResult {
267    pub items: Vec<InlineCompletionItem>,
268}
269
270#[derive(Clone, Debug, Serialize, Deserialize)]
271#[serde(rename_all = "camelCase")]
272pub struct InlineCompletionItem {
273    pub insert_text: String,
274    pub range: lsp::Range,
275    #[serde(skip_serializing_if = "Option::is_none")]
276    pub command: Option<lsp::Command>,
277}
278
279impl lsp::request::Request for InlineCompletions {
280    type Params = InlineCompletionsParams;
281    type Result = InlineCompletionsResult;
282
283    const METHOD: &'static str = "textDocument/inlineCompletion";
284}
285
286// Telemetry notifications for inline completions
287
288pub(crate) struct DidShowCompletion;
289
290#[derive(Debug, Serialize, Deserialize)]
291#[serde(rename_all = "camelCase")]
292pub(crate) struct DidShowCompletionParams {
293    pub(crate) item: InlineCompletionItem,
294}
295
296impl lsp::notification::Notification for DidShowCompletion {
297    type Params = DidShowCompletionParams;
298    const METHOD: &'static str = "textDocument/didShowCompletion";
299}
300