@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 03:37 UTC

main
ts 415 lines 12.9 KB
Raw
1 import * as AcpCompat from "./compat.ts";
2 import * as Rpc from "effect/rpc/Rpc";
3 import * as RpcGroup from "effect/rpc/RpcGroup";
4 import * as Schema from "effect/Schema";
5
6 import * as AcpSchema from "./_generated/schema.gen.ts";
7 import * as AcpSchemaV1 from "./_generated/schema-v1.gen.ts";
8 import { AGENT_METHODS, CLIENT_METHODS } from "./_generated/meta.gen.ts";
9
10 export const V1_AGENT_METHODS = {
11 authenticate: "authenticate",
12 logout: "logout",
13 session_load: "session/load",
14 session_set_model: "session/set_model",
15 session_set_mode: "session/set_mode",
16 } as const;
17
18 export const V1_CLIENT_METHODS = {
19 session_elicitation: "session/elicitation",
20 unstable_session_elicitation: "_session/elicitation",
21 session_elicitation_complete: "session/elicitation/complete",
22 fs_read_text_file: "fs/read_text_file",
23 fs_write_text_file: "fs/write_text_file",
24 terminal_create: "terminal/create",
25 terminal_output: "terminal/output",
26 terminal_release: "terminal/release",
27 terminal_wait_for_exit: "terminal/wait_for_exit",
28 terminal_kill: "terminal/kill",
29 } as const;
30
31 const InitializeRpc = Rpc.make(AGENT_METHODS.initialize, {
32 payload: AcpSchema.InitializeRequest,
33 success: AcpSchema.InitializeResponse,
34 error: AcpSchema.Error,
35 });
36
37 const LoginRpc = Rpc.make(AGENT_METHODS.auth_login, {
38 payload: AcpSchema.LoginAuthRequest,
39 success: AcpSchema.LoginAuthResponse,
40 error: AcpSchema.Error,
41 });
42
43 const LogoutRpc = Rpc.make(AGENT_METHODS.auth_logout, {
44 payload: AcpSchema.LogoutAuthRequest,
45 success: AcpSchema.LogoutAuthResponse,
46 error: AcpSchema.Error,
47 });
48
49 const NewSessionRpc = Rpc.make(AGENT_METHODS.session_new, {
50 payload: AcpSchema.NewSessionRequest,
51 success: AcpSchema.NewSessionResponse,
52 error: AcpSchema.Error,
53 });
54
55 const ListSessionsRpc = Rpc.make(AGENT_METHODS.session_list, {
56 payload: AcpSchema.ListSessionsRequest,
57 success: AcpSchema.ListSessionsResponse,
58 error: AcpSchema.Error,
59 });
60
61 const ForkSessionRpc = Rpc.make(AGENT_METHODS.session_fork, {
62 payload: AcpSchema.ForkSessionRequest,
63 success: AcpSchema.ForkSessionResponse,
64 error: AcpSchema.Error,
65 });
66
67 const ResumeSessionRpc = Rpc.make(AGENT_METHODS.session_resume, {
68 payload: AcpSchema.ResumeSessionRequest,
69 success: AcpSchema.ResumeSessionResponse,
70 error: AcpSchema.Error,
71 });
72
73 const CloseSessionRpc = Rpc.make(AGENT_METHODS.session_close, {
74 payload: AcpSchema.CloseSessionRequest,
75 success: AcpSchema.CloseSessionResponse,
76 error: AcpSchema.Error,
77 });
78
79 const DeleteSessionRpc = Rpc.make(AGENT_METHODS.session_delete, {
80 payload: AcpSchema.DeleteSessionRequest,
81 success: AcpSchema.DeleteSessionResponse,
82 error: AcpSchema.Error,
83 });
84
85 const ListProvidersRpc = Rpc.make(AGENT_METHODS.providers_list, {
86 payload: AcpSchema.ListProvidersRequest,
87 success: AcpSchema.ListProvidersResponse,
88 error: AcpSchema.Error,
89 });
90
91 const SetProviderRpc = Rpc.make(AGENT_METHODS.providers_set, {
92 payload: AcpSchema.SetProviderRequest,
93 success: AcpSchema.SetProviderResponse,
94 error: AcpSchema.Error,
95 });
96
97 const DisableProviderRpc = Rpc.make(AGENT_METHODS.providers_disable, {
98 payload: AcpSchema.DisableProviderRequest,
99 success: AcpSchema.DisableProviderResponse,
100 error: AcpSchema.Error,
101 });
102
103 const PromptRpc = Rpc.make(AGENT_METHODS.session_prompt, {
104 payload: AcpSchema.PromptRequest,
105 success: AcpSchema.PromptResponse,
106 error: AcpSchema.Error,
107 });
108
109 const SetSessionConfigOptionRpc = Rpc.make(AGENT_METHODS.session_set_config_option, {
110 payload: AcpSchema.SetSessionConfigOptionRequest,
111 success: AcpSchema.SetSessionConfigOptionResponse,
112 error: AcpSchema.Error,
113 });
114
115 const RequestPermissionRpc = Rpc.make(CLIENT_METHODS.session_request_permission, {
116 payload: AcpSchema.RequestPermissionRequest,
117 success: AcpSchema.RequestPermissionResponse,
118 error: AcpSchema.Error,
119 });
120
121 const ElicitationRpc = Rpc.make(CLIENT_METHODS.elicitation_create, {
122 payload: AcpSchema.CreateElicitationRequest,
123 success: AcpSchema.CreateElicitationResponse,
124 error: AcpSchema.Error,
125 });
126
127 export const AgentRpcs = RpcGroup.make(
128 InitializeRpc,
129 LoginRpc,
130 LogoutRpc,
131 NewSessionRpc,
132 ListSessionsRpc,
133 ForkSessionRpc,
134 ResumeSessionRpc,
135 CloseSessionRpc,
136 DeleteSessionRpc,
137 ListProvidersRpc,
138 SetProviderRpc,
139 DisableProviderRpc,
140 PromptRpc,
141 SetSessionConfigOptionRpc,
142 );
143
144 const CompatInitializeRpc = Rpc.make(AGENT_METHODS.initialize, {
145 // The negotiation request intentionally carries both v1 and v2 capability
146 // field names. A union encoder would select one branch and discard the
147 // other generation's fields before they reach the agent.
148 payload: Schema.Unknown,
149 success: Schema.Union([AcpSchema.InitializeResponse, AcpSchemaV1.InitializeResponse]),
150 error: AcpSchema.Error,
151 });
152
153 const CompatAuthenticateV1Rpc = Rpc.make(V1_AGENT_METHODS.authenticate, {
154 payload: AcpSchemaV1.AuthenticateRequest,
155 success: AcpSchemaV1.AuthenticateResponse,
156 error: AcpSchemaV1.Error,
157 });
158
159 const CompatLogoutV1Rpc = Rpc.make(V1_AGENT_METHODS.logout, {
160 payload: AcpSchemaV1.LogoutRequest,
161 success: AcpSchemaV1.LogoutResponse,
162 error: AcpSchemaV1.Error,
163 });
164
165 const CompatNewSessionRpc = Rpc.make(AGENT_METHODS.session_new, {
166 payload: Schema.Union([AcpSchema.NewSessionRequest, AcpSchemaV1.NewSessionRequest]),
167 success: Schema.Union([
168 Schema.Struct({
169 ...AcpSchemaV1.NewSessionResponse.fields,
170 models: Schema.optionalKey(Schema.NullOr(AcpCompat.SessionModelState)),
171 }),
172 AcpSchema.NewSessionResponse,
173 ]),
174 error: AcpSchema.Error,
175 });
176
177 const CompatLoadSessionV1Rpc = Rpc.make(V1_AGENT_METHODS.session_load, {
178 payload: AcpSchemaV1.LoadSessionRequest,
179 success: Schema.Struct({
180 ...AcpSchemaV1.LoadSessionResponse.fields,
181 models: Schema.optionalKey(Schema.NullOr(AcpCompat.SessionModelState)),
182 }),
183 error: AcpSchemaV1.Error,
184 });
185
186 const CompatListSessionsRpc = Rpc.make(AGENT_METHODS.session_list, {
187 payload: Schema.Union([AcpSchema.ListSessionsRequest, AcpSchemaV1.ListSessionsRequest]),
188 success: Schema.Union([AcpSchemaV1.ListSessionsResponse, AcpSchema.ListSessionsResponse]),
189 error: AcpSchema.Error,
190 });
191
192 const CompatForkSessionRpc = Rpc.make(AGENT_METHODS.session_fork, {
193 payload: Schema.Union([AcpSchema.ForkSessionRequest, AcpSchemaV1.ForkSessionRequest]),
194 success: Schema.Union([
195 Schema.Struct({
196 ...AcpSchemaV1.ForkSessionResponse.fields,
197 models: Schema.optionalKey(Schema.NullOr(AcpCompat.SessionModelState)),
198 }),
199 AcpSchema.ForkSessionResponse,
200 ]),
201 error: AcpSchema.Error,
202 });
203
204 const CompatResumeSessionRpc = Rpc.make(AGENT_METHODS.session_resume, {
205 payload: Schema.Union([AcpSchema.ResumeSessionRequest, AcpSchemaV1.ResumeSessionRequest]),
206 success: Schema.Union([
207 Schema.Struct({
208 ...AcpSchemaV1.ResumeSessionResponse.fields,
209 models: Schema.optionalKey(Schema.NullOr(AcpCompat.SessionModelState)),
210 }),
211 AcpSchema.ResumeSessionResponse,
212 ]),
213 error: AcpSchema.Error,
214 });
215
216 const CompatCloseSessionRpc = Rpc.make(AGENT_METHODS.session_close, {
217 payload: Schema.Union([AcpSchema.CloseSessionRequest, AcpSchemaV1.CloseSessionRequest]),
218 success: Schema.Union([AcpSchema.CloseSessionResponse, AcpSchemaV1.CloseSessionResponse]),
219 error: AcpSchema.Error,
220 });
221
222 const CompatDeleteSessionRpc = Rpc.make(AGENT_METHODS.session_delete, {
223 payload: AcpSchema.DeleteSessionRequest,
224 success: AcpSchema.DeleteSessionResponse,
225 error: AcpSchema.Error,
226 });
227
228 const CompatListProvidersRpc = Rpc.make(AGENT_METHODS.providers_list, {
229 payload: AcpSchema.ListProvidersRequest,
230 success: AcpSchema.ListProvidersResponse,
231 error: AcpSchema.Error,
232 });
233
234 const CompatSetProviderRpc = Rpc.make(AGENT_METHODS.providers_set, {
235 payload: AcpSchema.SetProviderRequest,
236 success: AcpSchema.SetProviderResponse,
237 error: AcpSchema.Error,
238 });
239
240 const CompatDisableProviderRpc = Rpc.make(AGENT_METHODS.providers_disable, {
241 payload: AcpSchema.DisableProviderRequest,
242 success: AcpSchema.DisableProviderResponse,
243 error: AcpSchema.Error,
244 });
245
246 const CompatPromptRpc = Rpc.make(AGENT_METHODS.session_prompt, {
247 payload: Schema.Union([AcpSchema.PromptRequest, AcpSchemaV1.PromptRequest]),
248 success: Schema.Union([
249 AcpSchemaV1.PromptResponse,
250 // fx sends empty usage on cancellation; retain its stop reason when usage is invalid.
251 Schema.Struct({ stopReason: AcpSchemaV1.StopReason }),
252 AcpSchema.PromptResponse,
253 ]),
254 error: AcpSchema.Error,
255 });
256
257 const CompatSetSessionConfigOptionRpc = Rpc.make(AGENT_METHODS.session_set_config_option, {
258 payload: Schema.Union([
259 AcpSchema.SetSessionConfigOptionRequest,
260 AcpSchemaV1.SetSessionConfigOptionRequest,
261 ]),
262 success: Schema.Union([
263 AcpSchemaV1.SetSessionConfigOptionResponse,
264 AcpSchema.SetSessionConfigOptionResponse,
265 ]),
266 error: AcpSchema.Error,
267 });
268
269 const CompatSetSessionModelRpc = Rpc.make(V1_AGENT_METHODS.session_set_model, {
270 payload: AcpCompat.SetSessionModelRequest,
271 success: AcpCompat.SetSessionModelResponse,
272 error: AcpSchemaV1.Error,
273 });
274
275 const CompatSetSessionModeRpc = Rpc.make(V1_AGENT_METHODS.session_set_mode, {
276 payload: AcpSchemaV1.SetSessionModeRequest,
277 success: AcpSchemaV1.SetSessionModeResponse,
278 error: AcpSchemaV1.Error,
279 });
280
281 export const CompatAgentRpcs = RpcGroup.make(
282 CompatInitializeRpc,
283 CompatSetSessionModelRpc,
284 CompatSetSessionModeRpc,
285 LoginRpc,
286 CompatAuthenticateV1Rpc,
287 LogoutRpc,
288 CompatLogoutV1Rpc,
289 CompatNewSessionRpc,
290 CompatLoadSessionV1Rpc,
291 CompatListSessionsRpc,
292 CompatForkSessionRpc,
293 CompatResumeSessionRpc,
294 CompatCloseSessionRpc,
295 CompatDeleteSessionRpc,
296 CompatListProvidersRpc,
297 CompatSetProviderRpc,
298 CompatDisableProviderRpc,
299 CompatPromptRpc,
300 CompatSetSessionConfigOptionRpc,
301 );
302
303 const CompatRequestPermissionRpc = Rpc.make(CLIENT_METHODS.session_request_permission, {
304 payload: Schema.Union([AcpSchema.RequestPermissionRequest, AcpSchemaV1.RequestPermissionRequest]),
305 success: Schema.Union([
306 AcpSchema.RequestPermissionResponse,
307 AcpSchemaV1.RequestPermissionResponse,
308 ]),
309 error: AcpSchema.Error,
310 });
311
312 const CompatElicitationRpc = Rpc.make(CLIENT_METHODS.elicitation_create, {
313 payload: Schema.Unknown,
314 success: Schema.Union([
315 AcpSchema.CreateElicitationResponse,
316 AcpSchemaV1.CreateElicitationResponse,
317 ]),
318 error: AcpSchema.Error,
319 });
320
321 // Native ACP agents still use the older nested elicitation response.
322 const legacyElicitationRpc = <const Method extends string>(method: Method) =>
323 Rpc.make(method, {
324 payload: AcpSchema.CreateElicitationRequest,
325 success: Schema.Struct({
326 action: AcpSchema.CreateElicitationResponse,
327 _meta: Schema.optionalKey(Schema.NullOr(Schema.Record(Schema.String, Schema.Json))),
328 }),
329 error: AcpSchema.Error,
330 });
331
332 const ConnectMcpRpc = Rpc.make(CLIENT_METHODS.mcp_connect, {
333 payload: AcpSchema.ConnectMcpRequest,
334 success: AcpSchema.ConnectMcpResponse,
335 error: AcpSchema.Error,
336 });
337
338 const MessageMcpRpc = Rpc.make(CLIENT_METHODS.mcp_message, {
339 payload: AcpSchema.MessageMcpRequest,
340 success: AcpSchema.MessageMcpResponse,
341 error: AcpSchema.Error,
342 });
343
344 const DisconnectMcpRpc = Rpc.make(CLIENT_METHODS.mcp_disconnect, {
345 payload: AcpSchema.DisconnectMcpRequest,
346 success: AcpSchema.DisconnectMcpResponse,
347 error: AcpSchema.Error,
348 });
349
350 export const ClientRpcs = RpcGroup.make(
351 RequestPermissionRpc,
352 ElicitationRpc,
353 ConnectMcpRpc,
354 MessageMcpRpc,
355 DisconnectMcpRpc,
356 );
357
358 const ReadTextFileV1Rpc = Rpc.make(V1_CLIENT_METHODS.fs_read_text_file, {
359 payload: AcpSchemaV1.ReadTextFileRequest,
360 success: AcpSchemaV1.ReadTextFileResponse,
361 error: AcpSchemaV1.Error,
362 });
363
364 const WriteTextFileV1Rpc = Rpc.make(V1_CLIENT_METHODS.fs_write_text_file, {
365 payload: AcpSchemaV1.WriteTextFileRequest,
366 success: AcpSchemaV1.WriteTextFileResponse,
367 error: AcpSchemaV1.Error,
368 });
369
370 const CreateTerminalV1Rpc = Rpc.make(V1_CLIENT_METHODS.terminal_create, {
371 payload: AcpSchemaV1.CreateTerminalRequest,
372 success: AcpSchemaV1.CreateTerminalResponse,
373 error: AcpSchemaV1.Error,
374 });
375
376 const TerminalOutputV1Rpc = Rpc.make(V1_CLIENT_METHODS.terminal_output, {
377 payload: AcpSchemaV1.TerminalOutputRequest,
378 success: AcpSchemaV1.TerminalOutputResponse,
379 error: AcpSchemaV1.Error,
380 });
381
382 const ReleaseTerminalV1Rpc = Rpc.make(V1_CLIENT_METHODS.terminal_release, {
383 payload: AcpSchemaV1.ReleaseTerminalRequest,
384 success: AcpSchemaV1.ReleaseTerminalResponse,
385 error: AcpSchemaV1.Error,
386 });
387
388 const WaitForTerminalExitV1Rpc = Rpc.make(V1_CLIENT_METHODS.terminal_wait_for_exit, {
389 payload: AcpSchemaV1.WaitForTerminalExitRequest,
390 success: AcpSchemaV1.WaitForTerminalExitResponse,
391 error: AcpSchemaV1.Error,
392 });
393
394 const KillTerminalV1Rpc = Rpc.make(V1_CLIENT_METHODS.terminal_kill, {
395 payload: AcpSchemaV1.KillTerminalRequest,
396 success: AcpSchemaV1.KillTerminalResponse,
397 error: AcpSchemaV1.Error,
398 });
399
400 export const CompatClientRpcs = RpcGroup.make(
401 CompatRequestPermissionRpc,
402 CompatElicitationRpc,
403 legacyElicitationRpc(V1_CLIENT_METHODS.session_elicitation),
404 legacyElicitationRpc(V1_CLIENT_METHODS.unstable_session_elicitation),
405 ConnectMcpRpc,
406 MessageMcpRpc,
407 DisconnectMcpRpc,
408 ReadTextFileV1Rpc,
409 WriteTextFileV1Rpc,
410 CreateTerminalV1Rpc,
411 TerminalOutputV1Rpc,
412 ReleaseTerminalV1Rpc,
413 WaitForTerminalExitV1Rpc,
414 KillTerminalV1Rpc,
415 );