@moltzap/client 2026.721.1 → 2026.721.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. package/dist/cli/commands/test-transport.d.ts +5 -2
  2. package/dist/cli/commands/test-transport.d.ts.map +1 -1
  3. package/dist/cli/commands/test-transport.js +5 -1
  4. package/dist/cli/commands/test-transport.js.map +1 -1
  5. package/dist/local-daemon-rpc.d.ts +2843 -15
  6. package/dist/local-daemon-rpc.d.ts.map +1 -1
  7. package/dist/test-utils/fake-service.d.ts.map +1 -1
  8. package/dist/test-utils/fake-service.js +1 -4
  9. package/dist/test-utils/fake-service.js.map +1 -1
  10. package/dist/tsconfig.tsbuildinfo +1 -1
  11. package/package.json +3 -3
package/dist/local-daemon-rpc.d.ts CHANGED
@@ -94,9 +94,211 @@ declare const ServiceInputError_base: Schema.TaggedErrorClass<ServiceInputError,
94
94
  }>;
95
95
  export declare class ServiceInputError extends ServiceInputError_base {
96
96
  }
97
- declare const LocalDaemonErrorSchema: Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...Schema.Schema.AnyNoContext[]]>;
97
+ declare const LocalDaemonErrorSchema: Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...(Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
98
+ readonly _tag: "Unauthorized";
99
+ readonly message?: string | undefined;
100
+ readonly data?: unknown;
101
+ } | {
102
+ readonly _tag: "Forbidden";
103
+ readonly message?: string | undefined;
104
+ readonly data?: unknown;
105
+ } | {
106
+ readonly _tag: "InvalidParamsError";
107
+ readonly message?: string | undefined;
108
+ readonly data?: unknown;
109
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
110
+ readonly _tag: "Unauthorized";
111
+ readonly message?: string | undefined;
112
+ readonly data?: unknown;
113
+ } | {
114
+ readonly _tag: "Forbidden";
115
+ readonly message?: string | undefined;
116
+ readonly data?: unknown;
117
+ } | {
118
+ readonly _tag: "InvalidParamsError";
119
+ readonly message?: string | undefined;
120
+ readonly data?: unknown;
121
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ConflictError | import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
122
+ readonly _tag: "Conflict";
123
+ readonly message?: string | undefined;
124
+ readonly data?: unknown;
125
+ } | {
126
+ readonly _tag: "Unauthorized";
127
+ readonly message?: string | undefined;
128
+ readonly data?: unknown;
129
+ } | {
130
+ readonly _tag: "Forbidden";
131
+ readonly message?: string | undefined;
132
+ readonly data?: unknown;
133
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").ContactNotFoundError, {
134
+ readonly _tag: "Unauthorized";
135
+ readonly message?: string | undefined;
136
+ readonly data?: unknown;
137
+ } | {
138
+ readonly _tag: "Forbidden";
139
+ readonly message?: string | undefined;
140
+ readonly data?: unknown;
141
+ } | {
142
+ readonly _tag: "ContactNotFound";
143
+ readonly message?: string | undefined;
144
+ readonly data?: unknown;
145
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").AlreadyConnected, {
146
+ readonly _tag: "Unauthorized";
147
+ readonly message?: string | undefined;
148
+ readonly data?: unknown;
149
+ } | {
150
+ readonly _tag: "InvalidParamsError";
151
+ readonly message?: string | undefined;
152
+ readonly data?: unknown;
153
+ } | {
154
+ readonly _tag: "ProtocolMismatchError";
155
+ readonly data: {
156
+ readonly reason: "server-above-client-max" | "server-below-client-min";
157
+ readonly serverVersion: string;
158
+ readonly clientMinProtocol: string;
159
+ readonly clientMaxProtocol: string;
160
+ };
161
+ readonly message?: string | undefined;
162
+ } | {
163
+ readonly _tag: "AlreadyConnected";
164
+ readonly principal: "agent" | "app";
165
+ readonly message?: string | undefined;
166
+ readonly data?: unknown;
167
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError, {
168
+ readonly _tag: "Unauthorized";
169
+ readonly message?: string | undefined;
170
+ readonly data?: unknown;
171
+ } | {
172
+ readonly _tag: "Forbidden";
173
+ readonly message?: string | undefined;
174
+ readonly data?: unknown;
175
+ } | {
176
+ readonly _tag: "NotInContacts";
177
+ readonly message?: string | undefined;
178
+ readonly data?: unknown;
179
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/task").TaskRejectedError | import("@moltzap/protocol/conversation").ConversationFullError, {
180
+ readonly _tag: "Unauthorized";
181
+ readonly message?: string | undefined;
182
+ readonly data?: unknown;
183
+ } | {
184
+ readonly _tag: "Forbidden";
185
+ readonly message?: string | undefined;
186
+ readonly data?: unknown;
187
+ } | {
188
+ readonly _tag: "NotInContacts";
189
+ readonly message?: string | undefined;
190
+ readonly data?: unknown;
191
+ } | {
192
+ readonly _tag: "AgentNotFound";
193
+ readonly message?: string | undefined;
194
+ readonly data?: unknown;
195
+ } | {
196
+ readonly _tag: "TaskRejected";
197
+ readonly message?: string | undefined;
198
+ readonly data?: unknown;
199
+ } | {
200
+ readonly _tag: "ConversationFull";
201
+ readonly message?: string | undefined;
202
+ readonly data?: unknown;
203
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
204
+ readonly _tag: "Unauthorized";
205
+ readonly message?: string | undefined;
206
+ readonly data?: unknown;
207
+ } | {
208
+ readonly _tag: "Forbidden";
209
+ readonly message?: string | undefined;
210
+ readonly data?: unknown;
211
+ } | {
212
+ readonly _tag: "InvalidParamsError";
213
+ readonly message?: string | undefined;
214
+ readonly data?: unknown;
215
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError, {
216
+ readonly _tag: "Unauthorized";
217
+ readonly message?: string | undefined;
218
+ readonly data?: unknown;
219
+ } | {
220
+ readonly _tag: "Forbidden";
221
+ readonly message?: string | undefined;
222
+ readonly data?: unknown;
223
+ } | {
224
+ readonly _tag: "TaskNotFound";
225
+ readonly message?: string | undefined;
226
+ readonly data?: unknown;
227
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
228
+ readonly _tag: "Unauthorized";
229
+ readonly message?: string | undefined;
230
+ readonly data?: unknown;
231
+ } | {
232
+ readonly _tag: "Forbidden";
233
+ readonly message?: string | undefined;
234
+ readonly data?: unknown;
235
+ } | {
236
+ readonly _tag: "InvalidParamsError";
237
+ readonly message?: string | undefined;
238
+ readonly data?: unknown;
239
+ } | {
240
+ readonly _tag: "ConversationNotFound";
241
+ readonly message?: string | undefined;
242
+ readonly data?: unknown;
243
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/message").MessageNotFoundError | import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/task").TaskClosedError | import("@moltzap/protocol/conversation").ConversationArchivedError, {
244
+ readonly _tag: "Unauthorized";
245
+ readonly message?: string | undefined;
246
+ readonly data?: unknown;
247
+ } | {
248
+ readonly _tag: "Forbidden";
249
+ readonly message?: string | undefined;
250
+ readonly data?: unknown;
251
+ } | {
252
+ readonly _tag: "ConversationNotFound";
253
+ readonly message?: string | undefined;
254
+ readonly data?: unknown;
255
+ } | {
256
+ readonly _tag: "HookBlocked";
257
+ readonly message?: string | undefined;
258
+ readonly data?: unknown;
259
+ } | {
260
+ readonly _tag: "MessageNotFound";
261
+ readonly message?: string | undefined;
262
+ readonly data?: unknown;
263
+ } | {
264
+ readonly _tag: "DispatchNotFound";
265
+ readonly message?: string | undefined;
266
+ readonly data?: unknown;
267
+ } | {
268
+ readonly _tag: "TaskClosed";
269
+ readonly message?: string | undefined;
270
+ readonly data?: unknown;
271
+ } | {
272
+ readonly _tag: "ConversationArchived";
273
+ readonly message?: string | undefined;
274
+ readonly data?: unknown;
275
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
276
+ readonly _tag: "Unauthorized";
277
+ readonly message?: string | undefined;
278
+ readonly data?: unknown;
279
+ } | {
280
+ readonly _tag: "Forbidden";
281
+ readonly message?: string | undefined;
282
+ readonly data?: unknown;
283
+ } | {
284
+ readonly _tag: "TaskNotFound";
285
+ readonly message?: string | undefined;
286
+ readonly data?: unknown;
287
+ } | {
288
+ readonly _tag: "ConversationNotFound";
289
+ readonly message?: string | undefined;
290
+ readonly data?: unknown;
291
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
292
+ readonly _tag: "Unauthorized";
293
+ readonly message?: string | undefined;
294
+ readonly data?: unknown;
295
+ } | {
296
+ readonly _tag: "Forbidden";
297
+ readonly message?: string | undefined;
298
+ readonly data?: unknown;
299
+ }, never>)[]]>;
98
300
  export type LocalDaemonError = Schema.Schema.Type<typeof LocalDaemonErrorSchema>;
99
- export declare const isLocalDaemonError: (u: unknown, overrideOptions?: SchemaAST.ParseOptions | number) => u is any;
301
+ export declare const isLocalDaemonError: (u: unknown, overrideOptions?: SchemaAST.ParseOptions | number) => u is import("@moltzap/protocol/rpc").ConflictError | LocalDaemonInputError | StartTaskUsageError | StartTaskPartialFailure | ServiceInputError | import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/identity").ContactNotFoundError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").AlreadyConnected | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/task").TaskRejectedError | import("@moltzap/protocol/conversation").ConversationFullError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/message").MessageNotFoundError | import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/task").TaskClosedError | import("@moltzap/protocol/conversation").ConversationArchivedError | NotConnectedError | RpcTimeoutError;
100
302
  export declare const toLocalDaemonError: (error: unknown) => LocalDaemonError;
101
303
  export declare const MessagesListCommandRpc: Rpc.Rpc<"cli/messages/list", Schema.Struct<{
102
304
  taskId: Schema.Schema<TaskId, string, never>;
@@ -126,7 +328,209 @@ export declare const MessagesListCommandRpc: Rpc.Rpc<"cli/messages/list", Schema
126
328
  patchedBy: Schema.optional<typeof Schema.String>;
127
329
  createdAt: Schema.Schema<string, string, never>;
128
330
  }>>;
129
- }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...Schema.Schema.AnyNoContext[]]>, never>;
331
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...(Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
332
+ readonly _tag: "Unauthorized";
333
+ readonly message?: string | undefined;
334
+ readonly data?: unknown;
335
+ } | {
336
+ readonly _tag: "Forbidden";
337
+ readonly message?: string | undefined;
338
+ readonly data?: unknown;
339
+ } | {
340
+ readonly _tag: "InvalidParamsError";
341
+ readonly message?: string | undefined;
342
+ readonly data?: unknown;
343
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
344
+ readonly _tag: "Unauthorized";
345
+ readonly message?: string | undefined;
346
+ readonly data?: unknown;
347
+ } | {
348
+ readonly _tag: "Forbidden";
349
+ readonly message?: string | undefined;
350
+ readonly data?: unknown;
351
+ } | {
352
+ readonly _tag: "InvalidParamsError";
353
+ readonly message?: string | undefined;
354
+ readonly data?: unknown;
355
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ConflictError | import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
356
+ readonly _tag: "Conflict";
357
+ readonly message?: string | undefined;
358
+ readonly data?: unknown;
359
+ } | {
360
+ readonly _tag: "Unauthorized";
361
+ readonly message?: string | undefined;
362
+ readonly data?: unknown;
363
+ } | {
364
+ readonly _tag: "Forbidden";
365
+ readonly message?: string | undefined;
366
+ readonly data?: unknown;
367
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").ContactNotFoundError, {
368
+ readonly _tag: "Unauthorized";
369
+ readonly message?: string | undefined;
370
+ readonly data?: unknown;
371
+ } | {
372
+ readonly _tag: "Forbidden";
373
+ readonly message?: string | undefined;
374
+ readonly data?: unknown;
375
+ } | {
376
+ readonly _tag: "ContactNotFound";
377
+ readonly message?: string | undefined;
378
+ readonly data?: unknown;
379
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").AlreadyConnected, {
380
+ readonly _tag: "Unauthorized";
381
+ readonly message?: string | undefined;
382
+ readonly data?: unknown;
383
+ } | {
384
+ readonly _tag: "InvalidParamsError";
385
+ readonly message?: string | undefined;
386
+ readonly data?: unknown;
387
+ } | {
388
+ readonly _tag: "ProtocolMismatchError";
389
+ readonly data: {
390
+ readonly reason: "server-above-client-max" | "server-below-client-min";
391
+ readonly serverVersion: string;
392
+ readonly clientMinProtocol: string;
393
+ readonly clientMaxProtocol: string;
394
+ };
395
+ readonly message?: string | undefined;
396
+ } | {
397
+ readonly _tag: "AlreadyConnected";
398
+ readonly principal: "agent" | "app";
399
+ readonly message?: string | undefined;
400
+ readonly data?: unknown;
401
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError, {
402
+ readonly _tag: "Unauthorized";
403
+ readonly message?: string | undefined;
404
+ readonly data?: unknown;
405
+ } | {
406
+ readonly _tag: "Forbidden";
407
+ readonly message?: string | undefined;
408
+ readonly data?: unknown;
409
+ } | {
410
+ readonly _tag: "NotInContacts";
411
+ readonly message?: string | undefined;
412
+ readonly data?: unknown;
413
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/task").TaskRejectedError | import("@moltzap/protocol/conversation").ConversationFullError, {
414
+ readonly _tag: "Unauthorized";
415
+ readonly message?: string | undefined;
416
+ readonly data?: unknown;
417
+ } | {
418
+ readonly _tag: "Forbidden";
419
+ readonly message?: string | undefined;
420
+ readonly data?: unknown;
421
+ } | {
422
+ readonly _tag: "NotInContacts";
423
+ readonly message?: string | undefined;
424
+ readonly data?: unknown;
425
+ } | {
426
+ readonly _tag: "AgentNotFound";
427
+ readonly message?: string | undefined;
428
+ readonly data?: unknown;
429
+ } | {
430
+ readonly _tag: "TaskRejected";
431
+ readonly message?: string | undefined;
432
+ readonly data?: unknown;
433
+ } | {
434
+ readonly _tag: "ConversationFull";
435
+ readonly message?: string | undefined;
436
+ readonly data?: unknown;
437
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
438
+ readonly _tag: "Unauthorized";
439
+ readonly message?: string | undefined;
440
+ readonly data?: unknown;
441
+ } | {
442
+ readonly _tag: "Forbidden";
443
+ readonly message?: string | undefined;
444
+ readonly data?: unknown;
445
+ } | {
446
+ readonly _tag: "InvalidParamsError";
447
+ readonly message?: string | undefined;
448
+ readonly data?: unknown;
449
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError, {
450
+ readonly _tag: "Unauthorized";
451
+ readonly message?: string | undefined;
452
+ readonly data?: unknown;
453
+ } | {
454
+ readonly _tag: "Forbidden";
455
+ readonly message?: string | undefined;
456
+ readonly data?: unknown;
457
+ } | {
458
+ readonly _tag: "TaskNotFound";
459
+ readonly message?: string | undefined;
460
+ readonly data?: unknown;
461
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
462
+ readonly _tag: "Unauthorized";
463
+ readonly message?: string | undefined;
464
+ readonly data?: unknown;
465
+ } | {
466
+ readonly _tag: "Forbidden";
467
+ readonly message?: string | undefined;
468
+ readonly data?: unknown;
469
+ } | {
470
+ readonly _tag: "InvalidParamsError";
471
+ readonly message?: string | undefined;
472
+ readonly data?: unknown;
473
+ } | {
474
+ readonly _tag: "ConversationNotFound";
475
+ readonly message?: string | undefined;
476
+ readonly data?: unknown;
477
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/message").MessageNotFoundError | import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/task").TaskClosedError | import("@moltzap/protocol/conversation").ConversationArchivedError, {
478
+ readonly _tag: "Unauthorized";
479
+ readonly message?: string | undefined;
480
+ readonly data?: unknown;
481
+ } | {
482
+ readonly _tag: "Forbidden";
483
+ readonly message?: string | undefined;
484
+ readonly data?: unknown;
485
+ } | {
486
+ readonly _tag: "ConversationNotFound";
487
+ readonly message?: string | undefined;
488
+ readonly data?: unknown;
489
+ } | {
490
+ readonly _tag: "HookBlocked";
491
+ readonly message?: string | undefined;
492
+ readonly data?: unknown;
493
+ } | {
494
+ readonly _tag: "MessageNotFound";
495
+ readonly message?: string | undefined;
496
+ readonly data?: unknown;
497
+ } | {
498
+ readonly _tag: "DispatchNotFound";
499
+ readonly message?: string | undefined;
500
+ readonly data?: unknown;
501
+ } | {
502
+ readonly _tag: "TaskClosed";
503
+ readonly message?: string | undefined;
504
+ readonly data?: unknown;
505
+ } | {
506
+ readonly _tag: "ConversationArchived";
507
+ readonly message?: string | undefined;
508
+ readonly data?: unknown;
509
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
510
+ readonly _tag: "Unauthorized";
511
+ readonly message?: string | undefined;
512
+ readonly data?: unknown;
513
+ } | {
514
+ readonly _tag: "Forbidden";
515
+ readonly message?: string | undefined;
516
+ readonly data?: unknown;
517
+ } | {
518
+ readonly _tag: "TaskNotFound";
519
+ readonly message?: string | undefined;
520
+ readonly data?: unknown;
521
+ } | {
522
+ readonly _tag: "ConversationNotFound";
523
+ readonly message?: string | undefined;
524
+ readonly data?: unknown;
525
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
526
+ readonly _tag: "Unauthorized";
527
+ readonly message?: string | undefined;
528
+ readonly data?: unknown;
529
+ } | {
530
+ readonly _tag: "Forbidden";
531
+ readonly message?: string | undefined;
532
+ readonly data?: unknown;
533
+ }, never>)[]]>, never>;
130
534
  export declare const SendCommandRpc: Rpc.Rpc<"cli/send", Schema.Struct<{
131
535
  target: Schema.transformOrFail<typeof Schema.String, Schema.Struct<{
132
536
  taskId: Schema.Schema<TaskId, string, never>;
@@ -136,7 +540,209 @@ export declare const SendCommandRpc: Rpc.Rpc<"cli/send", Schema.Struct<{
136
540
  replyToId: Schema.optional<Schema.Schema<MessageId, string, never>>;
137
541
  }>, Schema.Struct<{
138
542
  messageId: Schema.Schema<MessageId, string, never>;
139
- }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...Schema.Schema.AnyNoContext[]]>, never>;
543
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...(Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
544
+ readonly _tag: "Unauthorized";
545
+ readonly message?: string | undefined;
546
+ readonly data?: unknown;
547
+ } | {
548
+ readonly _tag: "Forbidden";
549
+ readonly message?: string | undefined;
550
+ readonly data?: unknown;
551
+ } | {
552
+ readonly _tag: "InvalidParamsError";
553
+ readonly message?: string | undefined;
554
+ readonly data?: unknown;
555
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
556
+ readonly _tag: "Unauthorized";
557
+ readonly message?: string | undefined;
558
+ readonly data?: unknown;
559
+ } | {
560
+ readonly _tag: "Forbidden";
561
+ readonly message?: string | undefined;
562
+ readonly data?: unknown;
563
+ } | {
564
+ readonly _tag: "InvalidParamsError";
565
+ readonly message?: string | undefined;
566
+ readonly data?: unknown;
567
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ConflictError | import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
568
+ readonly _tag: "Conflict";
569
+ readonly message?: string | undefined;
570
+ readonly data?: unknown;
571
+ } | {
572
+ readonly _tag: "Unauthorized";
573
+ readonly message?: string | undefined;
574
+ readonly data?: unknown;
575
+ } | {
576
+ readonly _tag: "Forbidden";
577
+ readonly message?: string | undefined;
578
+ readonly data?: unknown;
579
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").ContactNotFoundError, {
580
+ readonly _tag: "Unauthorized";
581
+ readonly message?: string | undefined;
582
+ readonly data?: unknown;
583
+ } | {
584
+ readonly _tag: "Forbidden";
585
+ readonly message?: string | undefined;
586
+ readonly data?: unknown;
587
+ } | {
588
+ readonly _tag: "ContactNotFound";
589
+ readonly message?: string | undefined;
590
+ readonly data?: unknown;
591
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").AlreadyConnected, {
592
+ readonly _tag: "Unauthorized";
593
+ readonly message?: string | undefined;
594
+ readonly data?: unknown;
595
+ } | {
596
+ readonly _tag: "InvalidParamsError";
597
+ readonly message?: string | undefined;
598
+ readonly data?: unknown;
599
+ } | {
600
+ readonly _tag: "ProtocolMismatchError";
601
+ readonly data: {
602
+ readonly reason: "server-above-client-max" | "server-below-client-min";
603
+ readonly serverVersion: string;
604
+ readonly clientMinProtocol: string;
605
+ readonly clientMaxProtocol: string;
606
+ };
607
+ readonly message?: string | undefined;
608
+ } | {
609
+ readonly _tag: "AlreadyConnected";
610
+ readonly principal: "agent" | "app";
611
+ readonly message?: string | undefined;
612
+ readonly data?: unknown;
613
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError, {
614
+ readonly _tag: "Unauthorized";
615
+ readonly message?: string | undefined;
616
+ readonly data?: unknown;
617
+ } | {
618
+ readonly _tag: "Forbidden";
619
+ readonly message?: string | undefined;
620
+ readonly data?: unknown;
621
+ } | {
622
+ readonly _tag: "NotInContacts";
623
+ readonly message?: string | undefined;
624
+ readonly data?: unknown;
625
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/task").TaskRejectedError | import("@moltzap/protocol/conversation").ConversationFullError, {
626
+ readonly _tag: "Unauthorized";
627
+ readonly message?: string | undefined;
628
+ readonly data?: unknown;
629
+ } | {
630
+ readonly _tag: "Forbidden";
631
+ readonly message?: string | undefined;
632
+ readonly data?: unknown;
633
+ } | {
634
+ readonly _tag: "NotInContacts";
635
+ readonly message?: string | undefined;
636
+ readonly data?: unknown;
637
+ } | {
638
+ readonly _tag: "AgentNotFound";
639
+ readonly message?: string | undefined;
640
+ readonly data?: unknown;
641
+ } | {
642
+ readonly _tag: "TaskRejected";
643
+ readonly message?: string | undefined;
644
+ readonly data?: unknown;
645
+ } | {
646
+ readonly _tag: "ConversationFull";
647
+ readonly message?: string | undefined;
648
+ readonly data?: unknown;
649
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
650
+ readonly _tag: "Unauthorized";
651
+ readonly message?: string | undefined;
652
+ readonly data?: unknown;
653
+ } | {
654
+ readonly _tag: "Forbidden";
655
+ readonly message?: string | undefined;
656
+ readonly data?: unknown;
657
+ } | {
658
+ readonly _tag: "InvalidParamsError";
659
+ readonly message?: string | undefined;
660
+ readonly data?: unknown;
661
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError, {
662
+ readonly _tag: "Unauthorized";
663
+ readonly message?: string | undefined;
664
+ readonly data?: unknown;
665
+ } | {
666
+ readonly _tag: "Forbidden";
667
+ readonly message?: string | undefined;
668
+ readonly data?: unknown;
669
+ } | {
670
+ readonly _tag: "TaskNotFound";
671
+ readonly message?: string | undefined;
672
+ readonly data?: unknown;
673
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
674
+ readonly _tag: "Unauthorized";
675
+ readonly message?: string | undefined;
676
+ readonly data?: unknown;
677
+ } | {
678
+ readonly _tag: "Forbidden";
679
+ readonly message?: string | undefined;
680
+ readonly data?: unknown;
681
+ } | {
682
+ readonly _tag: "InvalidParamsError";
683
+ readonly message?: string | undefined;
684
+ readonly data?: unknown;
685
+ } | {
686
+ readonly _tag: "ConversationNotFound";
687
+ readonly message?: string | undefined;
688
+ readonly data?: unknown;
689
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/message").MessageNotFoundError | import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/task").TaskClosedError | import("@moltzap/protocol/conversation").ConversationArchivedError, {
690
+ readonly _tag: "Unauthorized";
691
+ readonly message?: string | undefined;
692
+ readonly data?: unknown;
693
+ } | {
694
+ readonly _tag: "Forbidden";
695
+ readonly message?: string | undefined;
696
+ readonly data?: unknown;
697
+ } | {
698
+ readonly _tag: "ConversationNotFound";
699
+ readonly message?: string | undefined;
700
+ readonly data?: unknown;
701
+ } | {
702
+ readonly _tag: "HookBlocked";
703
+ readonly message?: string | undefined;
704
+ readonly data?: unknown;
705
+ } | {
706
+ readonly _tag: "MessageNotFound";
707
+ readonly message?: string | undefined;
708
+ readonly data?: unknown;
709
+ } | {
710
+ readonly _tag: "DispatchNotFound";
711
+ readonly message?: string | undefined;
712
+ readonly data?: unknown;
713
+ } | {
714
+ readonly _tag: "TaskClosed";
715
+ readonly message?: string | undefined;
716
+ readonly data?: unknown;
717
+ } | {
718
+ readonly _tag: "ConversationArchived";
719
+ readonly message?: string | undefined;
720
+ readonly data?: unknown;
721
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
722
+ readonly _tag: "Unauthorized";
723
+ readonly message?: string | undefined;
724
+ readonly data?: unknown;
725
+ } | {
726
+ readonly _tag: "Forbidden";
727
+ readonly message?: string | undefined;
728
+ readonly data?: unknown;
729
+ } | {
730
+ readonly _tag: "TaskNotFound";
731
+ readonly message?: string | undefined;
732
+ readonly data?: unknown;
733
+ } | {
734
+ readonly _tag: "ConversationNotFound";
735
+ readonly message?: string | undefined;
736
+ readonly data?: unknown;
737
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
738
+ readonly _tag: "Unauthorized";
739
+ readonly message?: string | undefined;
740
+ readonly data?: unknown;
741
+ } | {
742
+ readonly _tag: "Forbidden";
743
+ readonly message?: string | undefined;
744
+ readonly data?: unknown;
745
+ }, never>)[]]>, never>;
140
746
  export declare const StartTaskCommandRpc: Rpc.Rpc<"cli/start-task", Schema.Struct<{
141
747
  name: Schema.filter<Schema.filter<typeof Schema.String>>;
142
748
  participants: Schema.Array$<Schema.transformOrFail<typeof Schema.String, Schema.Union<[Schema.Struct<{
@@ -154,7 +760,209 @@ export declare const StartTaskCommandRpc: Rpc.Rpc<"cli/start-task", Schema.Struc
154
760
  conversationId: Schema.Schema<ConversationId, string, never>;
155
761
  reusedConversation: typeof Schema.Boolean;
156
762
  sentMessageId: Schema.optional<Schema.Schema<MessageId, string, never>>;
157
- }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...Schema.Schema.AnyNoContext[]]>, never>;
763
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...(Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
764
+ readonly _tag: "Unauthorized";
765
+ readonly message?: string | undefined;
766
+ readonly data?: unknown;
767
+ } | {
768
+ readonly _tag: "Forbidden";
769
+ readonly message?: string | undefined;
770
+ readonly data?: unknown;
771
+ } | {
772
+ readonly _tag: "InvalidParamsError";
773
+ readonly message?: string | undefined;
774
+ readonly data?: unknown;
775
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
776
+ readonly _tag: "Unauthorized";
777
+ readonly message?: string | undefined;
778
+ readonly data?: unknown;
779
+ } | {
780
+ readonly _tag: "Forbidden";
781
+ readonly message?: string | undefined;
782
+ readonly data?: unknown;
783
+ } | {
784
+ readonly _tag: "InvalidParamsError";
785
+ readonly message?: string | undefined;
786
+ readonly data?: unknown;
787
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ConflictError | import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
788
+ readonly _tag: "Conflict";
789
+ readonly message?: string | undefined;
790
+ readonly data?: unknown;
791
+ } | {
792
+ readonly _tag: "Unauthorized";
793
+ readonly message?: string | undefined;
794
+ readonly data?: unknown;
795
+ } | {
796
+ readonly _tag: "Forbidden";
797
+ readonly message?: string | undefined;
798
+ readonly data?: unknown;
799
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").ContactNotFoundError, {
800
+ readonly _tag: "Unauthorized";
801
+ readonly message?: string | undefined;
802
+ readonly data?: unknown;
803
+ } | {
804
+ readonly _tag: "Forbidden";
805
+ readonly message?: string | undefined;
806
+ readonly data?: unknown;
807
+ } | {
808
+ readonly _tag: "ContactNotFound";
809
+ readonly message?: string | undefined;
810
+ readonly data?: unknown;
811
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").AlreadyConnected, {
812
+ readonly _tag: "Unauthorized";
813
+ readonly message?: string | undefined;
814
+ readonly data?: unknown;
815
+ } | {
816
+ readonly _tag: "InvalidParamsError";
817
+ readonly message?: string | undefined;
818
+ readonly data?: unknown;
819
+ } | {
820
+ readonly _tag: "ProtocolMismatchError";
821
+ readonly data: {
822
+ readonly reason: "server-above-client-max" | "server-below-client-min";
823
+ readonly serverVersion: string;
824
+ readonly clientMinProtocol: string;
825
+ readonly clientMaxProtocol: string;
826
+ };
827
+ readonly message?: string | undefined;
828
+ } | {
829
+ readonly _tag: "AlreadyConnected";
830
+ readonly principal: "agent" | "app";
831
+ readonly message?: string | undefined;
832
+ readonly data?: unknown;
833
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError, {
834
+ readonly _tag: "Unauthorized";
835
+ readonly message?: string | undefined;
836
+ readonly data?: unknown;
837
+ } | {
838
+ readonly _tag: "Forbidden";
839
+ readonly message?: string | undefined;
840
+ readonly data?: unknown;
841
+ } | {
842
+ readonly _tag: "NotInContacts";
843
+ readonly message?: string | undefined;
844
+ readonly data?: unknown;
845
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/task").TaskRejectedError | import("@moltzap/protocol/conversation").ConversationFullError, {
846
+ readonly _tag: "Unauthorized";
847
+ readonly message?: string | undefined;
848
+ readonly data?: unknown;
849
+ } | {
850
+ readonly _tag: "Forbidden";
851
+ readonly message?: string | undefined;
852
+ readonly data?: unknown;
853
+ } | {
854
+ readonly _tag: "NotInContacts";
855
+ readonly message?: string | undefined;
856
+ readonly data?: unknown;
857
+ } | {
858
+ readonly _tag: "AgentNotFound";
859
+ readonly message?: string | undefined;
860
+ readonly data?: unknown;
861
+ } | {
862
+ readonly _tag: "TaskRejected";
863
+ readonly message?: string | undefined;
864
+ readonly data?: unknown;
865
+ } | {
866
+ readonly _tag: "ConversationFull";
867
+ readonly message?: string | undefined;
868
+ readonly data?: unknown;
869
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
870
+ readonly _tag: "Unauthorized";
871
+ readonly message?: string | undefined;
872
+ readonly data?: unknown;
873
+ } | {
874
+ readonly _tag: "Forbidden";
875
+ readonly message?: string | undefined;
876
+ readonly data?: unknown;
877
+ } | {
878
+ readonly _tag: "InvalidParamsError";
879
+ readonly message?: string | undefined;
880
+ readonly data?: unknown;
881
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError, {
882
+ readonly _tag: "Unauthorized";
883
+ readonly message?: string | undefined;
884
+ readonly data?: unknown;
885
+ } | {
886
+ readonly _tag: "Forbidden";
887
+ readonly message?: string | undefined;
888
+ readonly data?: unknown;
889
+ } | {
890
+ readonly _tag: "TaskNotFound";
891
+ readonly message?: string | undefined;
892
+ readonly data?: unknown;
893
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
894
+ readonly _tag: "Unauthorized";
895
+ readonly message?: string | undefined;
896
+ readonly data?: unknown;
897
+ } | {
898
+ readonly _tag: "Forbidden";
899
+ readonly message?: string | undefined;
900
+ readonly data?: unknown;
901
+ } | {
902
+ readonly _tag: "InvalidParamsError";
903
+ readonly message?: string | undefined;
904
+ readonly data?: unknown;
905
+ } | {
906
+ readonly _tag: "ConversationNotFound";
907
+ readonly message?: string | undefined;
908
+ readonly data?: unknown;
909
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/message").MessageNotFoundError | import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/task").TaskClosedError | import("@moltzap/protocol/conversation").ConversationArchivedError, {
910
+ readonly _tag: "Unauthorized";
911
+ readonly message?: string | undefined;
912
+ readonly data?: unknown;
913
+ } | {
914
+ readonly _tag: "Forbidden";
915
+ readonly message?: string | undefined;
916
+ readonly data?: unknown;
917
+ } | {
918
+ readonly _tag: "ConversationNotFound";
919
+ readonly message?: string | undefined;
920
+ readonly data?: unknown;
921
+ } | {
922
+ readonly _tag: "HookBlocked";
923
+ readonly message?: string | undefined;
924
+ readonly data?: unknown;
925
+ } | {
926
+ readonly _tag: "MessageNotFound";
927
+ readonly message?: string | undefined;
928
+ readonly data?: unknown;
929
+ } | {
930
+ readonly _tag: "DispatchNotFound";
931
+ readonly message?: string | undefined;
932
+ readonly data?: unknown;
933
+ } | {
934
+ readonly _tag: "TaskClosed";
935
+ readonly message?: string | undefined;
936
+ readonly data?: unknown;
937
+ } | {
938
+ readonly _tag: "ConversationArchived";
939
+ readonly message?: string | undefined;
940
+ readonly data?: unknown;
941
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
942
+ readonly _tag: "Unauthorized";
943
+ readonly message?: string | undefined;
944
+ readonly data?: unknown;
945
+ } | {
946
+ readonly _tag: "Forbidden";
947
+ readonly message?: string | undefined;
948
+ readonly data?: unknown;
949
+ } | {
950
+ readonly _tag: "TaskNotFound";
951
+ readonly message?: string | undefined;
952
+ readonly data?: unknown;
953
+ } | {
954
+ readonly _tag: "ConversationNotFound";
955
+ readonly message?: string | undefined;
956
+ readonly data?: unknown;
957
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
958
+ readonly _tag: "Unauthorized";
959
+ readonly message?: string | undefined;
960
+ readonly data?: unknown;
961
+ } | {
962
+ readonly _tag: "Forbidden";
963
+ readonly message?: string | undefined;
964
+ readonly data?: unknown;
965
+ }, never>)[]]>, never>;
158
966
  declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list", Schema.Struct<{
159
967
  taskId: Schema.Schema<TaskId, string, never>;
160
968
  conversationId: Schema.Schema<ConversationId, string, never>;
@@ -183,7 +991,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
183
991
  patchedBy: Schema.optional<typeof Schema.String>;
184
992
  createdAt: Schema.Schema<string, string, never>;
185
993
  }>>;
186
- }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...Schema.Schema.AnyNoContext[]]>, never> | Rpc.Rpc<"cli/send", Schema.Struct<{
994
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...(Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
995
+ readonly _tag: "Unauthorized";
996
+ readonly message?: string | undefined;
997
+ readonly data?: unknown;
998
+ } | {
999
+ readonly _tag: "Forbidden";
1000
+ readonly message?: string | undefined;
1001
+ readonly data?: unknown;
1002
+ } | {
1003
+ readonly _tag: "InvalidParamsError";
1004
+ readonly message?: string | undefined;
1005
+ readonly data?: unknown;
1006
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
1007
+ readonly _tag: "Unauthorized";
1008
+ readonly message?: string | undefined;
1009
+ readonly data?: unknown;
1010
+ } | {
1011
+ readonly _tag: "Forbidden";
1012
+ readonly message?: string | undefined;
1013
+ readonly data?: unknown;
1014
+ } | {
1015
+ readonly _tag: "InvalidParamsError";
1016
+ readonly message?: string | undefined;
1017
+ readonly data?: unknown;
1018
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ConflictError | import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
1019
+ readonly _tag: "Conflict";
1020
+ readonly message?: string | undefined;
1021
+ readonly data?: unknown;
1022
+ } | {
1023
+ readonly _tag: "Unauthorized";
1024
+ readonly message?: string | undefined;
1025
+ readonly data?: unknown;
1026
+ } | {
1027
+ readonly _tag: "Forbidden";
1028
+ readonly message?: string | undefined;
1029
+ readonly data?: unknown;
1030
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").ContactNotFoundError, {
1031
+ readonly _tag: "Unauthorized";
1032
+ readonly message?: string | undefined;
1033
+ readonly data?: unknown;
1034
+ } | {
1035
+ readonly _tag: "Forbidden";
1036
+ readonly message?: string | undefined;
1037
+ readonly data?: unknown;
1038
+ } | {
1039
+ readonly _tag: "ContactNotFound";
1040
+ readonly message?: string | undefined;
1041
+ readonly data?: unknown;
1042
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").AlreadyConnected, {
1043
+ readonly _tag: "Unauthorized";
1044
+ readonly message?: string | undefined;
1045
+ readonly data?: unknown;
1046
+ } | {
1047
+ readonly _tag: "InvalidParamsError";
1048
+ readonly message?: string | undefined;
1049
+ readonly data?: unknown;
1050
+ } | {
1051
+ readonly _tag: "ProtocolMismatchError";
1052
+ readonly data: {
1053
+ readonly reason: "server-above-client-max" | "server-below-client-min";
1054
+ readonly serverVersion: string;
1055
+ readonly clientMinProtocol: string;
1056
+ readonly clientMaxProtocol: string;
1057
+ };
1058
+ readonly message?: string | undefined;
1059
+ } | {
1060
+ readonly _tag: "AlreadyConnected";
1061
+ readonly principal: "agent" | "app";
1062
+ readonly message?: string | undefined;
1063
+ readonly data?: unknown;
1064
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError, {
1065
+ readonly _tag: "Unauthorized";
1066
+ readonly message?: string | undefined;
1067
+ readonly data?: unknown;
1068
+ } | {
1069
+ readonly _tag: "Forbidden";
1070
+ readonly message?: string | undefined;
1071
+ readonly data?: unknown;
1072
+ } | {
1073
+ readonly _tag: "NotInContacts";
1074
+ readonly message?: string | undefined;
1075
+ readonly data?: unknown;
1076
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/task").TaskRejectedError | import("@moltzap/protocol/conversation").ConversationFullError, {
1077
+ readonly _tag: "Unauthorized";
1078
+ readonly message?: string | undefined;
1079
+ readonly data?: unknown;
1080
+ } | {
1081
+ readonly _tag: "Forbidden";
1082
+ readonly message?: string | undefined;
1083
+ readonly data?: unknown;
1084
+ } | {
1085
+ readonly _tag: "NotInContacts";
1086
+ readonly message?: string | undefined;
1087
+ readonly data?: unknown;
1088
+ } | {
1089
+ readonly _tag: "AgentNotFound";
1090
+ readonly message?: string | undefined;
1091
+ readonly data?: unknown;
1092
+ } | {
1093
+ readonly _tag: "TaskRejected";
1094
+ readonly message?: string | undefined;
1095
+ readonly data?: unknown;
1096
+ } | {
1097
+ readonly _tag: "ConversationFull";
1098
+ readonly message?: string | undefined;
1099
+ readonly data?: unknown;
1100
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
1101
+ readonly _tag: "Unauthorized";
1102
+ readonly message?: string | undefined;
1103
+ readonly data?: unknown;
1104
+ } | {
1105
+ readonly _tag: "Forbidden";
1106
+ readonly message?: string | undefined;
1107
+ readonly data?: unknown;
1108
+ } | {
1109
+ readonly _tag: "InvalidParamsError";
1110
+ readonly message?: string | undefined;
1111
+ readonly data?: unknown;
1112
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError, {
1113
+ readonly _tag: "Unauthorized";
1114
+ readonly message?: string | undefined;
1115
+ readonly data?: unknown;
1116
+ } | {
1117
+ readonly _tag: "Forbidden";
1118
+ readonly message?: string | undefined;
1119
+ readonly data?: unknown;
1120
+ } | {
1121
+ readonly _tag: "TaskNotFound";
1122
+ readonly message?: string | undefined;
1123
+ readonly data?: unknown;
1124
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
1125
+ readonly _tag: "Unauthorized";
1126
+ readonly message?: string | undefined;
1127
+ readonly data?: unknown;
1128
+ } | {
1129
+ readonly _tag: "Forbidden";
1130
+ readonly message?: string | undefined;
1131
+ readonly data?: unknown;
1132
+ } | {
1133
+ readonly _tag: "InvalidParamsError";
1134
+ readonly message?: string | undefined;
1135
+ readonly data?: unknown;
1136
+ } | {
1137
+ readonly _tag: "ConversationNotFound";
1138
+ readonly message?: string | undefined;
1139
+ readonly data?: unknown;
1140
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/message").MessageNotFoundError | import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/task").TaskClosedError | import("@moltzap/protocol/conversation").ConversationArchivedError, {
1141
+ readonly _tag: "Unauthorized";
1142
+ readonly message?: string | undefined;
1143
+ readonly data?: unknown;
1144
+ } | {
1145
+ readonly _tag: "Forbidden";
1146
+ readonly message?: string | undefined;
1147
+ readonly data?: unknown;
1148
+ } | {
1149
+ readonly _tag: "ConversationNotFound";
1150
+ readonly message?: string | undefined;
1151
+ readonly data?: unknown;
1152
+ } | {
1153
+ readonly _tag: "HookBlocked";
1154
+ readonly message?: string | undefined;
1155
+ readonly data?: unknown;
1156
+ } | {
1157
+ readonly _tag: "MessageNotFound";
1158
+ readonly message?: string | undefined;
1159
+ readonly data?: unknown;
1160
+ } | {
1161
+ readonly _tag: "DispatchNotFound";
1162
+ readonly message?: string | undefined;
1163
+ readonly data?: unknown;
1164
+ } | {
1165
+ readonly _tag: "TaskClosed";
1166
+ readonly message?: string | undefined;
1167
+ readonly data?: unknown;
1168
+ } | {
1169
+ readonly _tag: "ConversationArchived";
1170
+ readonly message?: string | undefined;
1171
+ readonly data?: unknown;
1172
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
1173
+ readonly _tag: "Unauthorized";
1174
+ readonly message?: string | undefined;
1175
+ readonly data?: unknown;
1176
+ } | {
1177
+ readonly _tag: "Forbidden";
1178
+ readonly message?: string | undefined;
1179
+ readonly data?: unknown;
1180
+ } | {
1181
+ readonly _tag: "TaskNotFound";
1182
+ readonly message?: string | undefined;
1183
+ readonly data?: unknown;
1184
+ } | {
1185
+ readonly _tag: "ConversationNotFound";
1186
+ readonly message?: string | undefined;
1187
+ readonly data?: unknown;
1188
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
1189
+ readonly _tag: "Unauthorized";
1190
+ readonly message?: string | undefined;
1191
+ readonly data?: unknown;
1192
+ } | {
1193
+ readonly _tag: "Forbidden";
1194
+ readonly message?: string | undefined;
1195
+ readonly data?: unknown;
1196
+ }, never>)[]]>, never> | Rpc.Rpc<"cli/send", Schema.Struct<{
187
1197
  target: Schema.transformOrFail<typeof Schema.String, Schema.Struct<{
188
1198
  taskId: Schema.Schema<TaskId, string, never>;
189
1199
  conversationId: Schema.Schema<ConversationId, string, never>;
@@ -192,7 +1202,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
192
1202
  replyToId: Schema.optional<Schema.Schema<MessageId, string, never>>;
193
1203
  }>, Schema.Struct<{
194
1204
  messageId: Schema.Schema<MessageId, string, never>;
195
- }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...Schema.Schema.AnyNoContext[]]>, never> | Rpc.Rpc<"cli/start-task", Schema.Struct<{
1205
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...(Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
1206
+ readonly _tag: "Unauthorized";
1207
+ readonly message?: string | undefined;
1208
+ readonly data?: unknown;
1209
+ } | {
1210
+ readonly _tag: "Forbidden";
1211
+ readonly message?: string | undefined;
1212
+ readonly data?: unknown;
1213
+ } | {
1214
+ readonly _tag: "InvalidParamsError";
1215
+ readonly message?: string | undefined;
1216
+ readonly data?: unknown;
1217
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
1218
+ readonly _tag: "Unauthorized";
1219
+ readonly message?: string | undefined;
1220
+ readonly data?: unknown;
1221
+ } | {
1222
+ readonly _tag: "Forbidden";
1223
+ readonly message?: string | undefined;
1224
+ readonly data?: unknown;
1225
+ } | {
1226
+ readonly _tag: "InvalidParamsError";
1227
+ readonly message?: string | undefined;
1228
+ readonly data?: unknown;
1229
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ConflictError | import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
1230
+ readonly _tag: "Conflict";
1231
+ readonly message?: string | undefined;
1232
+ readonly data?: unknown;
1233
+ } | {
1234
+ readonly _tag: "Unauthorized";
1235
+ readonly message?: string | undefined;
1236
+ readonly data?: unknown;
1237
+ } | {
1238
+ readonly _tag: "Forbidden";
1239
+ readonly message?: string | undefined;
1240
+ readonly data?: unknown;
1241
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").ContactNotFoundError, {
1242
+ readonly _tag: "Unauthorized";
1243
+ readonly message?: string | undefined;
1244
+ readonly data?: unknown;
1245
+ } | {
1246
+ readonly _tag: "Forbidden";
1247
+ readonly message?: string | undefined;
1248
+ readonly data?: unknown;
1249
+ } | {
1250
+ readonly _tag: "ContactNotFound";
1251
+ readonly message?: string | undefined;
1252
+ readonly data?: unknown;
1253
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").AlreadyConnected, {
1254
+ readonly _tag: "Unauthorized";
1255
+ readonly message?: string | undefined;
1256
+ readonly data?: unknown;
1257
+ } | {
1258
+ readonly _tag: "InvalidParamsError";
1259
+ readonly message?: string | undefined;
1260
+ readonly data?: unknown;
1261
+ } | {
1262
+ readonly _tag: "ProtocolMismatchError";
1263
+ readonly data: {
1264
+ readonly reason: "server-above-client-max" | "server-below-client-min";
1265
+ readonly serverVersion: string;
1266
+ readonly clientMinProtocol: string;
1267
+ readonly clientMaxProtocol: string;
1268
+ };
1269
+ readonly message?: string | undefined;
1270
+ } | {
1271
+ readonly _tag: "AlreadyConnected";
1272
+ readonly principal: "agent" | "app";
1273
+ readonly message?: string | undefined;
1274
+ readonly data?: unknown;
1275
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError, {
1276
+ readonly _tag: "Unauthorized";
1277
+ readonly message?: string | undefined;
1278
+ readonly data?: unknown;
1279
+ } | {
1280
+ readonly _tag: "Forbidden";
1281
+ readonly message?: string | undefined;
1282
+ readonly data?: unknown;
1283
+ } | {
1284
+ readonly _tag: "NotInContacts";
1285
+ readonly message?: string | undefined;
1286
+ readonly data?: unknown;
1287
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/task").TaskRejectedError | import("@moltzap/protocol/conversation").ConversationFullError, {
1288
+ readonly _tag: "Unauthorized";
1289
+ readonly message?: string | undefined;
1290
+ readonly data?: unknown;
1291
+ } | {
1292
+ readonly _tag: "Forbidden";
1293
+ readonly message?: string | undefined;
1294
+ readonly data?: unknown;
1295
+ } | {
1296
+ readonly _tag: "NotInContacts";
1297
+ readonly message?: string | undefined;
1298
+ readonly data?: unknown;
1299
+ } | {
1300
+ readonly _tag: "AgentNotFound";
1301
+ readonly message?: string | undefined;
1302
+ readonly data?: unknown;
1303
+ } | {
1304
+ readonly _tag: "TaskRejected";
1305
+ readonly message?: string | undefined;
1306
+ readonly data?: unknown;
1307
+ } | {
1308
+ readonly _tag: "ConversationFull";
1309
+ readonly message?: string | undefined;
1310
+ readonly data?: unknown;
1311
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
1312
+ readonly _tag: "Unauthorized";
1313
+ readonly message?: string | undefined;
1314
+ readonly data?: unknown;
1315
+ } | {
1316
+ readonly _tag: "Forbidden";
1317
+ readonly message?: string | undefined;
1318
+ readonly data?: unknown;
1319
+ } | {
1320
+ readonly _tag: "InvalidParamsError";
1321
+ readonly message?: string | undefined;
1322
+ readonly data?: unknown;
1323
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError, {
1324
+ readonly _tag: "Unauthorized";
1325
+ readonly message?: string | undefined;
1326
+ readonly data?: unknown;
1327
+ } | {
1328
+ readonly _tag: "Forbidden";
1329
+ readonly message?: string | undefined;
1330
+ readonly data?: unknown;
1331
+ } | {
1332
+ readonly _tag: "TaskNotFound";
1333
+ readonly message?: string | undefined;
1334
+ readonly data?: unknown;
1335
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
1336
+ readonly _tag: "Unauthorized";
1337
+ readonly message?: string | undefined;
1338
+ readonly data?: unknown;
1339
+ } | {
1340
+ readonly _tag: "Forbidden";
1341
+ readonly message?: string | undefined;
1342
+ readonly data?: unknown;
1343
+ } | {
1344
+ readonly _tag: "InvalidParamsError";
1345
+ readonly message?: string | undefined;
1346
+ readonly data?: unknown;
1347
+ } | {
1348
+ readonly _tag: "ConversationNotFound";
1349
+ readonly message?: string | undefined;
1350
+ readonly data?: unknown;
1351
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/message").MessageNotFoundError | import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/task").TaskClosedError | import("@moltzap/protocol/conversation").ConversationArchivedError, {
1352
+ readonly _tag: "Unauthorized";
1353
+ readonly message?: string | undefined;
1354
+ readonly data?: unknown;
1355
+ } | {
1356
+ readonly _tag: "Forbidden";
1357
+ readonly message?: string | undefined;
1358
+ readonly data?: unknown;
1359
+ } | {
1360
+ readonly _tag: "ConversationNotFound";
1361
+ readonly message?: string | undefined;
1362
+ readonly data?: unknown;
1363
+ } | {
1364
+ readonly _tag: "HookBlocked";
1365
+ readonly message?: string | undefined;
1366
+ readonly data?: unknown;
1367
+ } | {
1368
+ readonly _tag: "MessageNotFound";
1369
+ readonly message?: string | undefined;
1370
+ readonly data?: unknown;
1371
+ } | {
1372
+ readonly _tag: "DispatchNotFound";
1373
+ readonly message?: string | undefined;
1374
+ readonly data?: unknown;
1375
+ } | {
1376
+ readonly _tag: "TaskClosed";
1377
+ readonly message?: string | undefined;
1378
+ readonly data?: unknown;
1379
+ } | {
1380
+ readonly _tag: "ConversationArchived";
1381
+ readonly message?: string | undefined;
1382
+ readonly data?: unknown;
1383
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
1384
+ readonly _tag: "Unauthorized";
1385
+ readonly message?: string | undefined;
1386
+ readonly data?: unknown;
1387
+ } | {
1388
+ readonly _tag: "Forbidden";
1389
+ readonly message?: string | undefined;
1390
+ readonly data?: unknown;
1391
+ } | {
1392
+ readonly _tag: "TaskNotFound";
1393
+ readonly message?: string | undefined;
1394
+ readonly data?: unknown;
1395
+ } | {
1396
+ readonly _tag: "ConversationNotFound";
1397
+ readonly message?: string | undefined;
1398
+ readonly data?: unknown;
1399
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
1400
+ readonly _tag: "Unauthorized";
1401
+ readonly message?: string | undefined;
1402
+ readonly data?: unknown;
1403
+ } | {
1404
+ readonly _tag: "Forbidden";
1405
+ readonly message?: string | undefined;
1406
+ readonly data?: unknown;
1407
+ }, never>)[]]>, never> | Rpc.Rpc<"cli/start-task", Schema.Struct<{
196
1408
  name: Schema.filter<Schema.filter<typeof Schema.String>>;
197
1409
  participants: Schema.Array$<Schema.transformOrFail<typeof Schema.String, Schema.Union<[Schema.Struct<{
198
1410
  kind: Schema.Literal<["id"]>;
@@ -209,11 +1421,415 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
209
1421
  conversationId: Schema.Schema<ConversationId, string, never>;
210
1422
  reusedConversation: typeof Schema.Boolean;
211
1423
  sentMessageId: Schema.optional<Schema.Schema<MessageId, string, never>>;
212
- }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...Schema.Schema.AnyNoContext[]]>, never> | Rpc.Rpc<"daemon/status", Schema.Struct<{}>, Schema.Struct<{
1424
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...(Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
1425
+ readonly _tag: "Unauthorized";
1426
+ readonly message?: string | undefined;
1427
+ readonly data?: unknown;
1428
+ } | {
1429
+ readonly _tag: "Forbidden";
1430
+ readonly message?: string | undefined;
1431
+ readonly data?: unknown;
1432
+ } | {
1433
+ readonly _tag: "InvalidParamsError";
1434
+ readonly message?: string | undefined;
1435
+ readonly data?: unknown;
1436
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
1437
+ readonly _tag: "Unauthorized";
1438
+ readonly message?: string | undefined;
1439
+ readonly data?: unknown;
1440
+ } | {
1441
+ readonly _tag: "Forbidden";
1442
+ readonly message?: string | undefined;
1443
+ readonly data?: unknown;
1444
+ } | {
1445
+ readonly _tag: "InvalidParamsError";
1446
+ readonly message?: string | undefined;
1447
+ readonly data?: unknown;
1448
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ConflictError | import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
1449
+ readonly _tag: "Conflict";
1450
+ readonly message?: string | undefined;
1451
+ readonly data?: unknown;
1452
+ } | {
1453
+ readonly _tag: "Unauthorized";
1454
+ readonly message?: string | undefined;
1455
+ readonly data?: unknown;
1456
+ } | {
1457
+ readonly _tag: "Forbidden";
1458
+ readonly message?: string | undefined;
1459
+ readonly data?: unknown;
1460
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").ContactNotFoundError, {
1461
+ readonly _tag: "Unauthorized";
1462
+ readonly message?: string | undefined;
1463
+ readonly data?: unknown;
1464
+ } | {
1465
+ readonly _tag: "Forbidden";
1466
+ readonly message?: string | undefined;
1467
+ readonly data?: unknown;
1468
+ } | {
1469
+ readonly _tag: "ContactNotFound";
1470
+ readonly message?: string | undefined;
1471
+ readonly data?: unknown;
1472
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").AlreadyConnected, {
1473
+ readonly _tag: "Unauthorized";
1474
+ readonly message?: string | undefined;
1475
+ readonly data?: unknown;
1476
+ } | {
1477
+ readonly _tag: "InvalidParamsError";
1478
+ readonly message?: string | undefined;
1479
+ readonly data?: unknown;
1480
+ } | {
1481
+ readonly _tag: "ProtocolMismatchError";
1482
+ readonly data: {
1483
+ readonly reason: "server-above-client-max" | "server-below-client-min";
1484
+ readonly serverVersion: string;
1485
+ readonly clientMinProtocol: string;
1486
+ readonly clientMaxProtocol: string;
1487
+ };
1488
+ readonly message?: string | undefined;
1489
+ } | {
1490
+ readonly _tag: "AlreadyConnected";
1491
+ readonly principal: "agent" | "app";
1492
+ readonly message?: string | undefined;
1493
+ readonly data?: unknown;
1494
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError, {
1495
+ readonly _tag: "Unauthorized";
1496
+ readonly message?: string | undefined;
1497
+ readonly data?: unknown;
1498
+ } | {
1499
+ readonly _tag: "Forbidden";
1500
+ readonly message?: string | undefined;
1501
+ readonly data?: unknown;
1502
+ } | {
1503
+ readonly _tag: "NotInContacts";
1504
+ readonly message?: string | undefined;
1505
+ readonly data?: unknown;
1506
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/task").TaskRejectedError | import("@moltzap/protocol/conversation").ConversationFullError, {
1507
+ readonly _tag: "Unauthorized";
1508
+ readonly message?: string | undefined;
1509
+ readonly data?: unknown;
1510
+ } | {
1511
+ readonly _tag: "Forbidden";
1512
+ readonly message?: string | undefined;
1513
+ readonly data?: unknown;
1514
+ } | {
1515
+ readonly _tag: "NotInContacts";
1516
+ readonly message?: string | undefined;
1517
+ readonly data?: unknown;
1518
+ } | {
1519
+ readonly _tag: "AgentNotFound";
1520
+ readonly message?: string | undefined;
1521
+ readonly data?: unknown;
1522
+ } | {
1523
+ readonly _tag: "TaskRejected";
1524
+ readonly message?: string | undefined;
1525
+ readonly data?: unknown;
1526
+ } | {
1527
+ readonly _tag: "ConversationFull";
1528
+ readonly message?: string | undefined;
1529
+ readonly data?: unknown;
1530
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
1531
+ readonly _tag: "Unauthorized";
1532
+ readonly message?: string | undefined;
1533
+ readonly data?: unknown;
1534
+ } | {
1535
+ readonly _tag: "Forbidden";
1536
+ readonly message?: string | undefined;
1537
+ readonly data?: unknown;
1538
+ } | {
1539
+ readonly _tag: "InvalidParamsError";
1540
+ readonly message?: string | undefined;
1541
+ readonly data?: unknown;
1542
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError, {
1543
+ readonly _tag: "Unauthorized";
1544
+ readonly message?: string | undefined;
1545
+ readonly data?: unknown;
1546
+ } | {
1547
+ readonly _tag: "Forbidden";
1548
+ readonly message?: string | undefined;
1549
+ readonly data?: unknown;
1550
+ } | {
1551
+ readonly _tag: "TaskNotFound";
1552
+ readonly message?: string | undefined;
1553
+ readonly data?: unknown;
1554
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
1555
+ readonly _tag: "Unauthorized";
1556
+ readonly message?: string | undefined;
1557
+ readonly data?: unknown;
1558
+ } | {
1559
+ readonly _tag: "Forbidden";
1560
+ readonly message?: string | undefined;
1561
+ readonly data?: unknown;
1562
+ } | {
1563
+ readonly _tag: "InvalidParamsError";
1564
+ readonly message?: string | undefined;
1565
+ readonly data?: unknown;
1566
+ } | {
1567
+ readonly _tag: "ConversationNotFound";
1568
+ readonly message?: string | undefined;
1569
+ readonly data?: unknown;
1570
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/message").MessageNotFoundError | import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/task").TaskClosedError | import("@moltzap/protocol/conversation").ConversationArchivedError, {
1571
+ readonly _tag: "Unauthorized";
1572
+ readonly message?: string | undefined;
1573
+ readonly data?: unknown;
1574
+ } | {
1575
+ readonly _tag: "Forbidden";
1576
+ readonly message?: string | undefined;
1577
+ readonly data?: unknown;
1578
+ } | {
1579
+ readonly _tag: "ConversationNotFound";
1580
+ readonly message?: string | undefined;
1581
+ readonly data?: unknown;
1582
+ } | {
1583
+ readonly _tag: "HookBlocked";
1584
+ readonly message?: string | undefined;
1585
+ readonly data?: unknown;
1586
+ } | {
1587
+ readonly _tag: "MessageNotFound";
1588
+ readonly message?: string | undefined;
1589
+ readonly data?: unknown;
1590
+ } | {
1591
+ readonly _tag: "DispatchNotFound";
1592
+ readonly message?: string | undefined;
1593
+ readonly data?: unknown;
1594
+ } | {
1595
+ readonly _tag: "TaskClosed";
1596
+ readonly message?: string | undefined;
1597
+ readonly data?: unknown;
1598
+ } | {
1599
+ readonly _tag: "ConversationArchived";
1600
+ readonly message?: string | undefined;
1601
+ readonly data?: unknown;
1602
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
1603
+ readonly _tag: "Unauthorized";
1604
+ readonly message?: string | undefined;
1605
+ readonly data?: unknown;
1606
+ } | {
1607
+ readonly _tag: "Forbidden";
1608
+ readonly message?: string | undefined;
1609
+ readonly data?: unknown;
1610
+ } | {
1611
+ readonly _tag: "TaskNotFound";
1612
+ readonly message?: string | undefined;
1613
+ readonly data?: unknown;
1614
+ } | {
1615
+ readonly _tag: "ConversationNotFound";
1616
+ readonly message?: string | undefined;
1617
+ readonly data?: unknown;
1618
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
1619
+ readonly _tag: "Unauthorized";
1620
+ readonly message?: string | undefined;
1621
+ readonly data?: unknown;
1622
+ } | {
1623
+ readonly _tag: "Forbidden";
1624
+ readonly message?: string | undefined;
1625
+ readonly data?: unknown;
1626
+ }, never>)[]]>, never> | Rpc.Rpc<"daemon/status", Schema.Struct<{}>, Schema.Struct<{
213
1627
  agentId: Schema.optional<Schema.Schema<AgentId, string, never>>;
214
1628
  connected: typeof Schema.Boolean;
215
1629
  conversations: Schema.filter<Schema.filter<typeof Schema.Number>>;
216
- }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...Schema.Schema.AnyNoContext[]]>, never> | Rpc.Rpc<"daemon/history", Schema.Struct<{
1630
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...(Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
1631
+ readonly _tag: "Unauthorized";
1632
+ readonly message?: string | undefined;
1633
+ readonly data?: unknown;
1634
+ } | {
1635
+ readonly _tag: "Forbidden";
1636
+ readonly message?: string | undefined;
1637
+ readonly data?: unknown;
1638
+ } | {
1639
+ readonly _tag: "InvalidParamsError";
1640
+ readonly message?: string | undefined;
1641
+ readonly data?: unknown;
1642
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
1643
+ readonly _tag: "Unauthorized";
1644
+ readonly message?: string | undefined;
1645
+ readonly data?: unknown;
1646
+ } | {
1647
+ readonly _tag: "Forbidden";
1648
+ readonly message?: string | undefined;
1649
+ readonly data?: unknown;
1650
+ } | {
1651
+ readonly _tag: "InvalidParamsError";
1652
+ readonly message?: string | undefined;
1653
+ readonly data?: unknown;
1654
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ConflictError | import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
1655
+ readonly _tag: "Conflict";
1656
+ readonly message?: string | undefined;
1657
+ readonly data?: unknown;
1658
+ } | {
1659
+ readonly _tag: "Unauthorized";
1660
+ readonly message?: string | undefined;
1661
+ readonly data?: unknown;
1662
+ } | {
1663
+ readonly _tag: "Forbidden";
1664
+ readonly message?: string | undefined;
1665
+ readonly data?: unknown;
1666
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").ContactNotFoundError, {
1667
+ readonly _tag: "Unauthorized";
1668
+ readonly message?: string | undefined;
1669
+ readonly data?: unknown;
1670
+ } | {
1671
+ readonly _tag: "Forbidden";
1672
+ readonly message?: string | undefined;
1673
+ readonly data?: unknown;
1674
+ } | {
1675
+ readonly _tag: "ContactNotFound";
1676
+ readonly message?: string | undefined;
1677
+ readonly data?: unknown;
1678
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").AlreadyConnected, {
1679
+ readonly _tag: "Unauthorized";
1680
+ readonly message?: string | undefined;
1681
+ readonly data?: unknown;
1682
+ } | {
1683
+ readonly _tag: "InvalidParamsError";
1684
+ readonly message?: string | undefined;
1685
+ readonly data?: unknown;
1686
+ } | {
1687
+ readonly _tag: "ProtocolMismatchError";
1688
+ readonly data: {
1689
+ readonly reason: "server-above-client-max" | "server-below-client-min";
1690
+ readonly serverVersion: string;
1691
+ readonly clientMinProtocol: string;
1692
+ readonly clientMaxProtocol: string;
1693
+ };
1694
+ readonly message?: string | undefined;
1695
+ } | {
1696
+ readonly _tag: "AlreadyConnected";
1697
+ readonly principal: "agent" | "app";
1698
+ readonly message?: string | undefined;
1699
+ readonly data?: unknown;
1700
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError, {
1701
+ readonly _tag: "Unauthorized";
1702
+ readonly message?: string | undefined;
1703
+ readonly data?: unknown;
1704
+ } | {
1705
+ readonly _tag: "Forbidden";
1706
+ readonly message?: string | undefined;
1707
+ readonly data?: unknown;
1708
+ } | {
1709
+ readonly _tag: "NotInContacts";
1710
+ readonly message?: string | undefined;
1711
+ readonly data?: unknown;
1712
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/task").TaskRejectedError | import("@moltzap/protocol/conversation").ConversationFullError, {
1713
+ readonly _tag: "Unauthorized";
1714
+ readonly message?: string | undefined;
1715
+ readonly data?: unknown;
1716
+ } | {
1717
+ readonly _tag: "Forbidden";
1718
+ readonly message?: string | undefined;
1719
+ readonly data?: unknown;
1720
+ } | {
1721
+ readonly _tag: "NotInContacts";
1722
+ readonly message?: string | undefined;
1723
+ readonly data?: unknown;
1724
+ } | {
1725
+ readonly _tag: "AgentNotFound";
1726
+ readonly message?: string | undefined;
1727
+ readonly data?: unknown;
1728
+ } | {
1729
+ readonly _tag: "TaskRejected";
1730
+ readonly message?: string | undefined;
1731
+ readonly data?: unknown;
1732
+ } | {
1733
+ readonly _tag: "ConversationFull";
1734
+ readonly message?: string | undefined;
1735
+ readonly data?: unknown;
1736
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
1737
+ readonly _tag: "Unauthorized";
1738
+ readonly message?: string | undefined;
1739
+ readonly data?: unknown;
1740
+ } | {
1741
+ readonly _tag: "Forbidden";
1742
+ readonly message?: string | undefined;
1743
+ readonly data?: unknown;
1744
+ } | {
1745
+ readonly _tag: "InvalidParamsError";
1746
+ readonly message?: string | undefined;
1747
+ readonly data?: unknown;
1748
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError, {
1749
+ readonly _tag: "Unauthorized";
1750
+ readonly message?: string | undefined;
1751
+ readonly data?: unknown;
1752
+ } | {
1753
+ readonly _tag: "Forbidden";
1754
+ readonly message?: string | undefined;
1755
+ readonly data?: unknown;
1756
+ } | {
1757
+ readonly _tag: "TaskNotFound";
1758
+ readonly message?: string | undefined;
1759
+ readonly data?: unknown;
1760
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
1761
+ readonly _tag: "Unauthorized";
1762
+ readonly message?: string | undefined;
1763
+ readonly data?: unknown;
1764
+ } | {
1765
+ readonly _tag: "Forbidden";
1766
+ readonly message?: string | undefined;
1767
+ readonly data?: unknown;
1768
+ } | {
1769
+ readonly _tag: "InvalidParamsError";
1770
+ readonly message?: string | undefined;
1771
+ readonly data?: unknown;
1772
+ } | {
1773
+ readonly _tag: "ConversationNotFound";
1774
+ readonly message?: string | undefined;
1775
+ readonly data?: unknown;
1776
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/message").MessageNotFoundError | import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/task").TaskClosedError | import("@moltzap/protocol/conversation").ConversationArchivedError, {
1777
+ readonly _tag: "Unauthorized";
1778
+ readonly message?: string | undefined;
1779
+ readonly data?: unknown;
1780
+ } | {
1781
+ readonly _tag: "Forbidden";
1782
+ readonly message?: string | undefined;
1783
+ readonly data?: unknown;
1784
+ } | {
1785
+ readonly _tag: "ConversationNotFound";
1786
+ readonly message?: string | undefined;
1787
+ readonly data?: unknown;
1788
+ } | {
1789
+ readonly _tag: "HookBlocked";
1790
+ readonly message?: string | undefined;
1791
+ readonly data?: unknown;
1792
+ } | {
1793
+ readonly _tag: "MessageNotFound";
1794
+ readonly message?: string | undefined;
1795
+ readonly data?: unknown;
1796
+ } | {
1797
+ readonly _tag: "DispatchNotFound";
1798
+ readonly message?: string | undefined;
1799
+ readonly data?: unknown;
1800
+ } | {
1801
+ readonly _tag: "TaskClosed";
1802
+ readonly message?: string | undefined;
1803
+ readonly data?: unknown;
1804
+ } | {
1805
+ readonly _tag: "ConversationArchived";
1806
+ readonly message?: string | undefined;
1807
+ readonly data?: unknown;
1808
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
1809
+ readonly _tag: "Unauthorized";
1810
+ readonly message?: string | undefined;
1811
+ readonly data?: unknown;
1812
+ } | {
1813
+ readonly _tag: "Forbidden";
1814
+ readonly message?: string | undefined;
1815
+ readonly data?: unknown;
1816
+ } | {
1817
+ readonly _tag: "TaskNotFound";
1818
+ readonly message?: string | undefined;
1819
+ readonly data?: unknown;
1820
+ } | {
1821
+ readonly _tag: "ConversationNotFound";
1822
+ readonly message?: string | undefined;
1823
+ readonly data?: unknown;
1824
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
1825
+ readonly _tag: "Unauthorized";
1826
+ readonly message?: string | undefined;
1827
+ readonly data?: unknown;
1828
+ } | {
1829
+ readonly _tag: "Forbidden";
1830
+ readonly message?: string | undefined;
1831
+ readonly data?: unknown;
1832
+ }, never>)[]]>, never> | Rpc.Rpc<"daemon/history", Schema.Struct<{
217
1833
  taskId: Schema.Schema<TaskId, string, never>;
218
1834
  conversationId: Schema.Schema<ConversationId, string, never>;
219
1835
  limit: Schema.optionalWith<Schema.filter<Schema.filter<typeof Schema.Number>>, {
@@ -243,7 +1859,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
243
1859
  archivedAt: Schema.optional<typeof Schema.String>;
244
1860
  }>>;
245
1861
  newCount: Schema.filter<Schema.filter<typeof Schema.Number>>;
246
- }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...Schema.Schema.AnyNoContext[]]>, never> | Rpc.Rpc<"cli/agents/list", Schema.Struct<{
1862
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...(Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
1863
+ readonly _tag: "Unauthorized";
1864
+ readonly message?: string | undefined;
1865
+ readonly data?: unknown;
1866
+ } | {
1867
+ readonly _tag: "Forbidden";
1868
+ readonly message?: string | undefined;
1869
+ readonly data?: unknown;
1870
+ } | {
1871
+ readonly _tag: "InvalidParamsError";
1872
+ readonly message?: string | undefined;
1873
+ readonly data?: unknown;
1874
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
1875
+ readonly _tag: "Unauthorized";
1876
+ readonly message?: string | undefined;
1877
+ readonly data?: unknown;
1878
+ } | {
1879
+ readonly _tag: "Forbidden";
1880
+ readonly message?: string | undefined;
1881
+ readonly data?: unknown;
1882
+ } | {
1883
+ readonly _tag: "InvalidParamsError";
1884
+ readonly message?: string | undefined;
1885
+ readonly data?: unknown;
1886
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ConflictError | import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
1887
+ readonly _tag: "Conflict";
1888
+ readonly message?: string | undefined;
1889
+ readonly data?: unknown;
1890
+ } | {
1891
+ readonly _tag: "Unauthorized";
1892
+ readonly message?: string | undefined;
1893
+ readonly data?: unknown;
1894
+ } | {
1895
+ readonly _tag: "Forbidden";
1896
+ readonly message?: string | undefined;
1897
+ readonly data?: unknown;
1898
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").ContactNotFoundError, {
1899
+ readonly _tag: "Unauthorized";
1900
+ readonly message?: string | undefined;
1901
+ readonly data?: unknown;
1902
+ } | {
1903
+ readonly _tag: "Forbidden";
1904
+ readonly message?: string | undefined;
1905
+ readonly data?: unknown;
1906
+ } | {
1907
+ readonly _tag: "ContactNotFound";
1908
+ readonly message?: string | undefined;
1909
+ readonly data?: unknown;
1910
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").AlreadyConnected, {
1911
+ readonly _tag: "Unauthorized";
1912
+ readonly message?: string | undefined;
1913
+ readonly data?: unknown;
1914
+ } | {
1915
+ readonly _tag: "InvalidParamsError";
1916
+ readonly message?: string | undefined;
1917
+ readonly data?: unknown;
1918
+ } | {
1919
+ readonly _tag: "ProtocolMismatchError";
1920
+ readonly data: {
1921
+ readonly reason: "server-above-client-max" | "server-below-client-min";
1922
+ readonly serverVersion: string;
1923
+ readonly clientMinProtocol: string;
1924
+ readonly clientMaxProtocol: string;
1925
+ };
1926
+ readonly message?: string | undefined;
1927
+ } | {
1928
+ readonly _tag: "AlreadyConnected";
1929
+ readonly principal: "agent" | "app";
1930
+ readonly message?: string | undefined;
1931
+ readonly data?: unknown;
1932
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError, {
1933
+ readonly _tag: "Unauthorized";
1934
+ readonly message?: string | undefined;
1935
+ readonly data?: unknown;
1936
+ } | {
1937
+ readonly _tag: "Forbidden";
1938
+ readonly message?: string | undefined;
1939
+ readonly data?: unknown;
1940
+ } | {
1941
+ readonly _tag: "NotInContacts";
1942
+ readonly message?: string | undefined;
1943
+ readonly data?: unknown;
1944
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/task").TaskRejectedError | import("@moltzap/protocol/conversation").ConversationFullError, {
1945
+ readonly _tag: "Unauthorized";
1946
+ readonly message?: string | undefined;
1947
+ readonly data?: unknown;
1948
+ } | {
1949
+ readonly _tag: "Forbidden";
1950
+ readonly message?: string | undefined;
1951
+ readonly data?: unknown;
1952
+ } | {
1953
+ readonly _tag: "NotInContacts";
1954
+ readonly message?: string | undefined;
1955
+ readonly data?: unknown;
1956
+ } | {
1957
+ readonly _tag: "AgentNotFound";
1958
+ readonly message?: string | undefined;
1959
+ readonly data?: unknown;
1960
+ } | {
1961
+ readonly _tag: "TaskRejected";
1962
+ readonly message?: string | undefined;
1963
+ readonly data?: unknown;
1964
+ } | {
1965
+ readonly _tag: "ConversationFull";
1966
+ readonly message?: string | undefined;
1967
+ readonly data?: unknown;
1968
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
1969
+ readonly _tag: "Unauthorized";
1970
+ readonly message?: string | undefined;
1971
+ readonly data?: unknown;
1972
+ } | {
1973
+ readonly _tag: "Forbidden";
1974
+ readonly message?: string | undefined;
1975
+ readonly data?: unknown;
1976
+ } | {
1977
+ readonly _tag: "InvalidParamsError";
1978
+ readonly message?: string | undefined;
1979
+ readonly data?: unknown;
1980
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError, {
1981
+ readonly _tag: "Unauthorized";
1982
+ readonly message?: string | undefined;
1983
+ readonly data?: unknown;
1984
+ } | {
1985
+ readonly _tag: "Forbidden";
1986
+ readonly message?: string | undefined;
1987
+ readonly data?: unknown;
1988
+ } | {
1989
+ readonly _tag: "TaskNotFound";
1990
+ readonly message?: string | undefined;
1991
+ readonly data?: unknown;
1992
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
1993
+ readonly _tag: "Unauthorized";
1994
+ readonly message?: string | undefined;
1995
+ readonly data?: unknown;
1996
+ } | {
1997
+ readonly _tag: "Forbidden";
1998
+ readonly message?: string | undefined;
1999
+ readonly data?: unknown;
2000
+ } | {
2001
+ readonly _tag: "InvalidParamsError";
2002
+ readonly message?: string | undefined;
2003
+ readonly data?: unknown;
2004
+ } | {
2005
+ readonly _tag: "ConversationNotFound";
2006
+ readonly message?: string | undefined;
2007
+ readonly data?: unknown;
2008
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/message").MessageNotFoundError | import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/task").TaskClosedError | import("@moltzap/protocol/conversation").ConversationArchivedError, {
2009
+ readonly _tag: "Unauthorized";
2010
+ readonly message?: string | undefined;
2011
+ readonly data?: unknown;
2012
+ } | {
2013
+ readonly _tag: "Forbidden";
2014
+ readonly message?: string | undefined;
2015
+ readonly data?: unknown;
2016
+ } | {
2017
+ readonly _tag: "ConversationNotFound";
2018
+ readonly message?: string | undefined;
2019
+ readonly data?: unknown;
2020
+ } | {
2021
+ readonly _tag: "HookBlocked";
2022
+ readonly message?: string | undefined;
2023
+ readonly data?: unknown;
2024
+ } | {
2025
+ readonly _tag: "MessageNotFound";
2026
+ readonly message?: string | undefined;
2027
+ readonly data?: unknown;
2028
+ } | {
2029
+ readonly _tag: "DispatchNotFound";
2030
+ readonly message?: string | undefined;
2031
+ readonly data?: unknown;
2032
+ } | {
2033
+ readonly _tag: "TaskClosed";
2034
+ readonly message?: string | undefined;
2035
+ readonly data?: unknown;
2036
+ } | {
2037
+ readonly _tag: "ConversationArchived";
2038
+ readonly message?: string | undefined;
2039
+ readonly data?: unknown;
2040
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
2041
+ readonly _tag: "Unauthorized";
2042
+ readonly message?: string | undefined;
2043
+ readonly data?: unknown;
2044
+ } | {
2045
+ readonly _tag: "Forbidden";
2046
+ readonly message?: string | undefined;
2047
+ readonly data?: unknown;
2048
+ } | {
2049
+ readonly _tag: "TaskNotFound";
2050
+ readonly message?: string | undefined;
2051
+ readonly data?: unknown;
2052
+ } | {
2053
+ readonly _tag: "ConversationNotFound";
2054
+ readonly message?: string | undefined;
2055
+ readonly data?: unknown;
2056
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
2057
+ readonly _tag: "Unauthorized";
2058
+ readonly message?: string | undefined;
2059
+ readonly data?: unknown;
2060
+ } | {
2061
+ readonly _tag: "Forbidden";
2062
+ readonly message?: string | undefined;
2063
+ readonly data?: unknown;
2064
+ }, never>)[]]>, never> | Rpc.Rpc<"cli/agents/list", Schema.Struct<{
247
2065
  limit: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>>;
248
2066
  }>, Schema.Struct<{
249
2067
  agents: Schema.Array$<Schema.Struct<{
@@ -261,7 +2079,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
261
2079
  status: Schema.Schema<"active" | "suspended", "active" | "suspended", never>;
262
2080
  }>>;
263
2081
  nextCursor: Schema.optional<Schema.Schema<import("@moltzap/protocol/rpc").ListCursor, string, never>>;
264
- }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...Schema.Schema.AnyNoContext[]]>, never> | Rpc.Rpc<"cli/agents/search", Schema.Struct<{
2082
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...(Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
2083
+ readonly _tag: "Unauthorized";
2084
+ readonly message?: string | undefined;
2085
+ readonly data?: unknown;
2086
+ } | {
2087
+ readonly _tag: "Forbidden";
2088
+ readonly message?: string | undefined;
2089
+ readonly data?: unknown;
2090
+ } | {
2091
+ readonly _tag: "InvalidParamsError";
2092
+ readonly message?: string | undefined;
2093
+ readonly data?: unknown;
2094
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
2095
+ readonly _tag: "Unauthorized";
2096
+ readonly message?: string | undefined;
2097
+ readonly data?: unknown;
2098
+ } | {
2099
+ readonly _tag: "Forbidden";
2100
+ readonly message?: string | undefined;
2101
+ readonly data?: unknown;
2102
+ } | {
2103
+ readonly _tag: "InvalidParamsError";
2104
+ readonly message?: string | undefined;
2105
+ readonly data?: unknown;
2106
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ConflictError | import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
2107
+ readonly _tag: "Conflict";
2108
+ readonly message?: string | undefined;
2109
+ readonly data?: unknown;
2110
+ } | {
2111
+ readonly _tag: "Unauthorized";
2112
+ readonly message?: string | undefined;
2113
+ readonly data?: unknown;
2114
+ } | {
2115
+ readonly _tag: "Forbidden";
2116
+ readonly message?: string | undefined;
2117
+ readonly data?: unknown;
2118
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").ContactNotFoundError, {
2119
+ readonly _tag: "Unauthorized";
2120
+ readonly message?: string | undefined;
2121
+ readonly data?: unknown;
2122
+ } | {
2123
+ readonly _tag: "Forbidden";
2124
+ readonly message?: string | undefined;
2125
+ readonly data?: unknown;
2126
+ } | {
2127
+ readonly _tag: "ContactNotFound";
2128
+ readonly message?: string | undefined;
2129
+ readonly data?: unknown;
2130
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").AlreadyConnected, {
2131
+ readonly _tag: "Unauthorized";
2132
+ readonly message?: string | undefined;
2133
+ readonly data?: unknown;
2134
+ } | {
2135
+ readonly _tag: "InvalidParamsError";
2136
+ readonly message?: string | undefined;
2137
+ readonly data?: unknown;
2138
+ } | {
2139
+ readonly _tag: "ProtocolMismatchError";
2140
+ readonly data: {
2141
+ readonly reason: "server-above-client-max" | "server-below-client-min";
2142
+ readonly serverVersion: string;
2143
+ readonly clientMinProtocol: string;
2144
+ readonly clientMaxProtocol: string;
2145
+ };
2146
+ readonly message?: string | undefined;
2147
+ } | {
2148
+ readonly _tag: "AlreadyConnected";
2149
+ readonly principal: "agent" | "app";
2150
+ readonly message?: string | undefined;
2151
+ readonly data?: unknown;
2152
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError, {
2153
+ readonly _tag: "Unauthorized";
2154
+ readonly message?: string | undefined;
2155
+ readonly data?: unknown;
2156
+ } | {
2157
+ readonly _tag: "Forbidden";
2158
+ readonly message?: string | undefined;
2159
+ readonly data?: unknown;
2160
+ } | {
2161
+ readonly _tag: "NotInContacts";
2162
+ readonly message?: string | undefined;
2163
+ readonly data?: unknown;
2164
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/task").TaskRejectedError | import("@moltzap/protocol/conversation").ConversationFullError, {
2165
+ readonly _tag: "Unauthorized";
2166
+ readonly message?: string | undefined;
2167
+ readonly data?: unknown;
2168
+ } | {
2169
+ readonly _tag: "Forbidden";
2170
+ readonly message?: string | undefined;
2171
+ readonly data?: unknown;
2172
+ } | {
2173
+ readonly _tag: "NotInContacts";
2174
+ readonly message?: string | undefined;
2175
+ readonly data?: unknown;
2176
+ } | {
2177
+ readonly _tag: "AgentNotFound";
2178
+ readonly message?: string | undefined;
2179
+ readonly data?: unknown;
2180
+ } | {
2181
+ readonly _tag: "TaskRejected";
2182
+ readonly message?: string | undefined;
2183
+ readonly data?: unknown;
2184
+ } | {
2185
+ readonly _tag: "ConversationFull";
2186
+ readonly message?: string | undefined;
2187
+ readonly data?: unknown;
2188
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
2189
+ readonly _tag: "Unauthorized";
2190
+ readonly message?: string | undefined;
2191
+ readonly data?: unknown;
2192
+ } | {
2193
+ readonly _tag: "Forbidden";
2194
+ readonly message?: string | undefined;
2195
+ readonly data?: unknown;
2196
+ } | {
2197
+ readonly _tag: "InvalidParamsError";
2198
+ readonly message?: string | undefined;
2199
+ readonly data?: unknown;
2200
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError, {
2201
+ readonly _tag: "Unauthorized";
2202
+ readonly message?: string | undefined;
2203
+ readonly data?: unknown;
2204
+ } | {
2205
+ readonly _tag: "Forbidden";
2206
+ readonly message?: string | undefined;
2207
+ readonly data?: unknown;
2208
+ } | {
2209
+ readonly _tag: "TaskNotFound";
2210
+ readonly message?: string | undefined;
2211
+ readonly data?: unknown;
2212
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
2213
+ readonly _tag: "Unauthorized";
2214
+ readonly message?: string | undefined;
2215
+ readonly data?: unknown;
2216
+ } | {
2217
+ readonly _tag: "Forbidden";
2218
+ readonly message?: string | undefined;
2219
+ readonly data?: unknown;
2220
+ } | {
2221
+ readonly _tag: "InvalidParamsError";
2222
+ readonly message?: string | undefined;
2223
+ readonly data?: unknown;
2224
+ } | {
2225
+ readonly _tag: "ConversationNotFound";
2226
+ readonly message?: string | undefined;
2227
+ readonly data?: unknown;
2228
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/message").MessageNotFoundError | import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/task").TaskClosedError | import("@moltzap/protocol/conversation").ConversationArchivedError, {
2229
+ readonly _tag: "Unauthorized";
2230
+ readonly message?: string | undefined;
2231
+ readonly data?: unknown;
2232
+ } | {
2233
+ readonly _tag: "Forbidden";
2234
+ readonly message?: string | undefined;
2235
+ readonly data?: unknown;
2236
+ } | {
2237
+ readonly _tag: "ConversationNotFound";
2238
+ readonly message?: string | undefined;
2239
+ readonly data?: unknown;
2240
+ } | {
2241
+ readonly _tag: "HookBlocked";
2242
+ readonly message?: string | undefined;
2243
+ readonly data?: unknown;
2244
+ } | {
2245
+ readonly _tag: "MessageNotFound";
2246
+ readonly message?: string | undefined;
2247
+ readonly data?: unknown;
2248
+ } | {
2249
+ readonly _tag: "DispatchNotFound";
2250
+ readonly message?: string | undefined;
2251
+ readonly data?: unknown;
2252
+ } | {
2253
+ readonly _tag: "TaskClosed";
2254
+ readonly message?: string | undefined;
2255
+ readonly data?: unknown;
2256
+ } | {
2257
+ readonly _tag: "ConversationArchived";
2258
+ readonly message?: string | undefined;
2259
+ readonly data?: unknown;
2260
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
2261
+ readonly _tag: "Unauthorized";
2262
+ readonly message?: string | undefined;
2263
+ readonly data?: unknown;
2264
+ } | {
2265
+ readonly _tag: "Forbidden";
2266
+ readonly message?: string | undefined;
2267
+ readonly data?: unknown;
2268
+ } | {
2269
+ readonly _tag: "TaskNotFound";
2270
+ readonly message?: string | undefined;
2271
+ readonly data?: unknown;
2272
+ } | {
2273
+ readonly _tag: "ConversationNotFound";
2274
+ readonly message?: string | undefined;
2275
+ readonly data?: unknown;
2276
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
2277
+ readonly _tag: "Unauthorized";
2278
+ readonly message?: string | undefined;
2279
+ readonly data?: unknown;
2280
+ } | {
2281
+ readonly _tag: "Forbidden";
2282
+ readonly message?: string | undefined;
2283
+ readonly data?: unknown;
2284
+ }, never>)[]]>, never> | Rpc.Rpc<"cli/agents/search", Schema.Struct<{
265
2285
  names: Schema.filter<Schema.filter<Schema.Array$<Schema.filter<Schema.filter<typeof Schema.String>>>>>;
266
2286
  }>, Schema.Struct<{
267
2287
  agents: Schema.Array$<Schema.Struct<{
@@ -279,7 +2299,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
279
2299
  status: Schema.Schema<"active" | "suspended", "active" | "suspended", never>;
280
2300
  }>>;
281
2301
  nextCursor: Schema.optional<Schema.Schema<import("@moltzap/protocol/rpc").ListCursor, string, never>>;
282
- }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...Schema.Schema.AnyNoContext[]]>, never> | Rpc.Rpc<"cli/contacts/list", Schema.Struct<{}>, Schema.Struct<{
2302
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...(Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
2303
+ readonly _tag: "Unauthorized";
2304
+ readonly message?: string | undefined;
2305
+ readonly data?: unknown;
2306
+ } | {
2307
+ readonly _tag: "Forbidden";
2308
+ readonly message?: string | undefined;
2309
+ readonly data?: unknown;
2310
+ } | {
2311
+ readonly _tag: "InvalidParamsError";
2312
+ readonly message?: string | undefined;
2313
+ readonly data?: unknown;
2314
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
2315
+ readonly _tag: "Unauthorized";
2316
+ readonly message?: string | undefined;
2317
+ readonly data?: unknown;
2318
+ } | {
2319
+ readonly _tag: "Forbidden";
2320
+ readonly message?: string | undefined;
2321
+ readonly data?: unknown;
2322
+ } | {
2323
+ readonly _tag: "InvalidParamsError";
2324
+ readonly message?: string | undefined;
2325
+ readonly data?: unknown;
2326
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ConflictError | import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
2327
+ readonly _tag: "Conflict";
2328
+ readonly message?: string | undefined;
2329
+ readonly data?: unknown;
2330
+ } | {
2331
+ readonly _tag: "Unauthorized";
2332
+ readonly message?: string | undefined;
2333
+ readonly data?: unknown;
2334
+ } | {
2335
+ readonly _tag: "Forbidden";
2336
+ readonly message?: string | undefined;
2337
+ readonly data?: unknown;
2338
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").ContactNotFoundError, {
2339
+ readonly _tag: "Unauthorized";
2340
+ readonly message?: string | undefined;
2341
+ readonly data?: unknown;
2342
+ } | {
2343
+ readonly _tag: "Forbidden";
2344
+ readonly message?: string | undefined;
2345
+ readonly data?: unknown;
2346
+ } | {
2347
+ readonly _tag: "ContactNotFound";
2348
+ readonly message?: string | undefined;
2349
+ readonly data?: unknown;
2350
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").AlreadyConnected, {
2351
+ readonly _tag: "Unauthorized";
2352
+ readonly message?: string | undefined;
2353
+ readonly data?: unknown;
2354
+ } | {
2355
+ readonly _tag: "InvalidParamsError";
2356
+ readonly message?: string | undefined;
2357
+ readonly data?: unknown;
2358
+ } | {
2359
+ readonly _tag: "ProtocolMismatchError";
2360
+ readonly data: {
2361
+ readonly reason: "server-above-client-max" | "server-below-client-min";
2362
+ readonly serverVersion: string;
2363
+ readonly clientMinProtocol: string;
2364
+ readonly clientMaxProtocol: string;
2365
+ };
2366
+ readonly message?: string | undefined;
2367
+ } | {
2368
+ readonly _tag: "AlreadyConnected";
2369
+ readonly principal: "agent" | "app";
2370
+ readonly message?: string | undefined;
2371
+ readonly data?: unknown;
2372
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError, {
2373
+ readonly _tag: "Unauthorized";
2374
+ readonly message?: string | undefined;
2375
+ readonly data?: unknown;
2376
+ } | {
2377
+ readonly _tag: "Forbidden";
2378
+ readonly message?: string | undefined;
2379
+ readonly data?: unknown;
2380
+ } | {
2381
+ readonly _tag: "NotInContacts";
2382
+ readonly message?: string | undefined;
2383
+ readonly data?: unknown;
2384
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/task").TaskRejectedError | import("@moltzap/protocol/conversation").ConversationFullError, {
2385
+ readonly _tag: "Unauthorized";
2386
+ readonly message?: string | undefined;
2387
+ readonly data?: unknown;
2388
+ } | {
2389
+ readonly _tag: "Forbidden";
2390
+ readonly message?: string | undefined;
2391
+ readonly data?: unknown;
2392
+ } | {
2393
+ readonly _tag: "NotInContacts";
2394
+ readonly message?: string | undefined;
2395
+ readonly data?: unknown;
2396
+ } | {
2397
+ readonly _tag: "AgentNotFound";
2398
+ readonly message?: string | undefined;
2399
+ readonly data?: unknown;
2400
+ } | {
2401
+ readonly _tag: "TaskRejected";
2402
+ readonly message?: string | undefined;
2403
+ readonly data?: unknown;
2404
+ } | {
2405
+ readonly _tag: "ConversationFull";
2406
+ readonly message?: string | undefined;
2407
+ readonly data?: unknown;
2408
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
2409
+ readonly _tag: "Unauthorized";
2410
+ readonly message?: string | undefined;
2411
+ readonly data?: unknown;
2412
+ } | {
2413
+ readonly _tag: "Forbidden";
2414
+ readonly message?: string | undefined;
2415
+ readonly data?: unknown;
2416
+ } | {
2417
+ readonly _tag: "InvalidParamsError";
2418
+ readonly message?: string | undefined;
2419
+ readonly data?: unknown;
2420
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError, {
2421
+ readonly _tag: "Unauthorized";
2422
+ readonly message?: string | undefined;
2423
+ readonly data?: unknown;
2424
+ } | {
2425
+ readonly _tag: "Forbidden";
2426
+ readonly message?: string | undefined;
2427
+ readonly data?: unknown;
2428
+ } | {
2429
+ readonly _tag: "TaskNotFound";
2430
+ readonly message?: string | undefined;
2431
+ readonly data?: unknown;
2432
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
2433
+ readonly _tag: "Unauthorized";
2434
+ readonly message?: string | undefined;
2435
+ readonly data?: unknown;
2436
+ } | {
2437
+ readonly _tag: "Forbidden";
2438
+ readonly message?: string | undefined;
2439
+ readonly data?: unknown;
2440
+ } | {
2441
+ readonly _tag: "InvalidParamsError";
2442
+ readonly message?: string | undefined;
2443
+ readonly data?: unknown;
2444
+ } | {
2445
+ readonly _tag: "ConversationNotFound";
2446
+ readonly message?: string | undefined;
2447
+ readonly data?: unknown;
2448
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/message").MessageNotFoundError | import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/task").TaskClosedError | import("@moltzap/protocol/conversation").ConversationArchivedError, {
2449
+ readonly _tag: "Unauthorized";
2450
+ readonly message?: string | undefined;
2451
+ readonly data?: unknown;
2452
+ } | {
2453
+ readonly _tag: "Forbidden";
2454
+ readonly message?: string | undefined;
2455
+ readonly data?: unknown;
2456
+ } | {
2457
+ readonly _tag: "ConversationNotFound";
2458
+ readonly message?: string | undefined;
2459
+ readonly data?: unknown;
2460
+ } | {
2461
+ readonly _tag: "HookBlocked";
2462
+ readonly message?: string | undefined;
2463
+ readonly data?: unknown;
2464
+ } | {
2465
+ readonly _tag: "MessageNotFound";
2466
+ readonly message?: string | undefined;
2467
+ readonly data?: unknown;
2468
+ } | {
2469
+ readonly _tag: "DispatchNotFound";
2470
+ readonly message?: string | undefined;
2471
+ readonly data?: unknown;
2472
+ } | {
2473
+ readonly _tag: "TaskClosed";
2474
+ readonly message?: string | undefined;
2475
+ readonly data?: unknown;
2476
+ } | {
2477
+ readonly _tag: "ConversationArchived";
2478
+ readonly message?: string | undefined;
2479
+ readonly data?: unknown;
2480
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
2481
+ readonly _tag: "Unauthorized";
2482
+ readonly message?: string | undefined;
2483
+ readonly data?: unknown;
2484
+ } | {
2485
+ readonly _tag: "Forbidden";
2486
+ readonly message?: string | undefined;
2487
+ readonly data?: unknown;
2488
+ } | {
2489
+ readonly _tag: "TaskNotFound";
2490
+ readonly message?: string | undefined;
2491
+ readonly data?: unknown;
2492
+ } | {
2493
+ readonly _tag: "ConversationNotFound";
2494
+ readonly message?: string | undefined;
2495
+ readonly data?: unknown;
2496
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
2497
+ readonly _tag: "Unauthorized";
2498
+ readonly message?: string | undefined;
2499
+ readonly data?: unknown;
2500
+ } | {
2501
+ readonly _tag: "Forbidden";
2502
+ readonly message?: string | undefined;
2503
+ readonly data?: unknown;
2504
+ }, never>)[]]>, never> | Rpc.Rpc<"cli/contacts/list", Schema.Struct<{}>, Schema.Struct<{
283
2505
  contacts: Schema.Array$<Schema.Struct<{
284
2506
  id: Schema.Schema<ContactId, string, never>;
285
2507
  contactUserId: Schema.Schema<UserId, string, never>;
@@ -289,7 +2511,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
289
2511
  }>>;
290
2512
  }>>;
291
2513
  nextCursor: Schema.optional<Schema.Schema<import("@moltzap/protocol/rpc").ListCursor, string, never>>;
292
- }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...Schema.Schema.AnyNoContext[]]>, never> | Rpc.Rpc<"cli/contacts/add", Schema.Struct<{
2514
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...(Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
2515
+ readonly _tag: "Unauthorized";
2516
+ readonly message?: string | undefined;
2517
+ readonly data?: unknown;
2518
+ } | {
2519
+ readonly _tag: "Forbidden";
2520
+ readonly message?: string | undefined;
2521
+ readonly data?: unknown;
2522
+ } | {
2523
+ readonly _tag: "InvalidParamsError";
2524
+ readonly message?: string | undefined;
2525
+ readonly data?: unknown;
2526
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
2527
+ readonly _tag: "Unauthorized";
2528
+ readonly message?: string | undefined;
2529
+ readonly data?: unknown;
2530
+ } | {
2531
+ readonly _tag: "Forbidden";
2532
+ readonly message?: string | undefined;
2533
+ readonly data?: unknown;
2534
+ } | {
2535
+ readonly _tag: "InvalidParamsError";
2536
+ readonly message?: string | undefined;
2537
+ readonly data?: unknown;
2538
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ConflictError | import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
2539
+ readonly _tag: "Conflict";
2540
+ readonly message?: string | undefined;
2541
+ readonly data?: unknown;
2542
+ } | {
2543
+ readonly _tag: "Unauthorized";
2544
+ readonly message?: string | undefined;
2545
+ readonly data?: unknown;
2546
+ } | {
2547
+ readonly _tag: "Forbidden";
2548
+ readonly message?: string | undefined;
2549
+ readonly data?: unknown;
2550
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").ContactNotFoundError, {
2551
+ readonly _tag: "Unauthorized";
2552
+ readonly message?: string | undefined;
2553
+ readonly data?: unknown;
2554
+ } | {
2555
+ readonly _tag: "Forbidden";
2556
+ readonly message?: string | undefined;
2557
+ readonly data?: unknown;
2558
+ } | {
2559
+ readonly _tag: "ContactNotFound";
2560
+ readonly message?: string | undefined;
2561
+ readonly data?: unknown;
2562
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").AlreadyConnected, {
2563
+ readonly _tag: "Unauthorized";
2564
+ readonly message?: string | undefined;
2565
+ readonly data?: unknown;
2566
+ } | {
2567
+ readonly _tag: "InvalidParamsError";
2568
+ readonly message?: string | undefined;
2569
+ readonly data?: unknown;
2570
+ } | {
2571
+ readonly _tag: "ProtocolMismatchError";
2572
+ readonly data: {
2573
+ readonly reason: "server-above-client-max" | "server-below-client-min";
2574
+ readonly serverVersion: string;
2575
+ readonly clientMinProtocol: string;
2576
+ readonly clientMaxProtocol: string;
2577
+ };
2578
+ readonly message?: string | undefined;
2579
+ } | {
2580
+ readonly _tag: "AlreadyConnected";
2581
+ readonly principal: "agent" | "app";
2582
+ readonly message?: string | undefined;
2583
+ readonly data?: unknown;
2584
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError, {
2585
+ readonly _tag: "Unauthorized";
2586
+ readonly message?: string | undefined;
2587
+ readonly data?: unknown;
2588
+ } | {
2589
+ readonly _tag: "Forbidden";
2590
+ readonly message?: string | undefined;
2591
+ readonly data?: unknown;
2592
+ } | {
2593
+ readonly _tag: "NotInContacts";
2594
+ readonly message?: string | undefined;
2595
+ readonly data?: unknown;
2596
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/task").TaskRejectedError | import("@moltzap/protocol/conversation").ConversationFullError, {
2597
+ readonly _tag: "Unauthorized";
2598
+ readonly message?: string | undefined;
2599
+ readonly data?: unknown;
2600
+ } | {
2601
+ readonly _tag: "Forbidden";
2602
+ readonly message?: string | undefined;
2603
+ readonly data?: unknown;
2604
+ } | {
2605
+ readonly _tag: "NotInContacts";
2606
+ readonly message?: string | undefined;
2607
+ readonly data?: unknown;
2608
+ } | {
2609
+ readonly _tag: "AgentNotFound";
2610
+ readonly message?: string | undefined;
2611
+ readonly data?: unknown;
2612
+ } | {
2613
+ readonly _tag: "TaskRejected";
2614
+ readonly message?: string | undefined;
2615
+ readonly data?: unknown;
2616
+ } | {
2617
+ readonly _tag: "ConversationFull";
2618
+ readonly message?: string | undefined;
2619
+ readonly data?: unknown;
2620
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
2621
+ readonly _tag: "Unauthorized";
2622
+ readonly message?: string | undefined;
2623
+ readonly data?: unknown;
2624
+ } | {
2625
+ readonly _tag: "Forbidden";
2626
+ readonly message?: string | undefined;
2627
+ readonly data?: unknown;
2628
+ } | {
2629
+ readonly _tag: "InvalidParamsError";
2630
+ readonly message?: string | undefined;
2631
+ readonly data?: unknown;
2632
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError, {
2633
+ readonly _tag: "Unauthorized";
2634
+ readonly message?: string | undefined;
2635
+ readonly data?: unknown;
2636
+ } | {
2637
+ readonly _tag: "Forbidden";
2638
+ readonly message?: string | undefined;
2639
+ readonly data?: unknown;
2640
+ } | {
2641
+ readonly _tag: "TaskNotFound";
2642
+ readonly message?: string | undefined;
2643
+ readonly data?: unknown;
2644
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
2645
+ readonly _tag: "Unauthorized";
2646
+ readonly message?: string | undefined;
2647
+ readonly data?: unknown;
2648
+ } | {
2649
+ readonly _tag: "Forbidden";
2650
+ readonly message?: string | undefined;
2651
+ readonly data?: unknown;
2652
+ } | {
2653
+ readonly _tag: "InvalidParamsError";
2654
+ readonly message?: string | undefined;
2655
+ readonly data?: unknown;
2656
+ } | {
2657
+ readonly _tag: "ConversationNotFound";
2658
+ readonly message?: string | undefined;
2659
+ readonly data?: unknown;
2660
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/message").MessageNotFoundError | import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/task").TaskClosedError | import("@moltzap/protocol/conversation").ConversationArchivedError, {
2661
+ readonly _tag: "Unauthorized";
2662
+ readonly message?: string | undefined;
2663
+ readonly data?: unknown;
2664
+ } | {
2665
+ readonly _tag: "Forbidden";
2666
+ readonly message?: string | undefined;
2667
+ readonly data?: unknown;
2668
+ } | {
2669
+ readonly _tag: "ConversationNotFound";
2670
+ readonly message?: string | undefined;
2671
+ readonly data?: unknown;
2672
+ } | {
2673
+ readonly _tag: "HookBlocked";
2674
+ readonly message?: string | undefined;
2675
+ readonly data?: unknown;
2676
+ } | {
2677
+ readonly _tag: "MessageNotFound";
2678
+ readonly message?: string | undefined;
2679
+ readonly data?: unknown;
2680
+ } | {
2681
+ readonly _tag: "DispatchNotFound";
2682
+ readonly message?: string | undefined;
2683
+ readonly data?: unknown;
2684
+ } | {
2685
+ readonly _tag: "TaskClosed";
2686
+ readonly message?: string | undefined;
2687
+ readonly data?: unknown;
2688
+ } | {
2689
+ readonly _tag: "ConversationArchived";
2690
+ readonly message?: string | undefined;
2691
+ readonly data?: unknown;
2692
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
2693
+ readonly _tag: "Unauthorized";
2694
+ readonly message?: string | undefined;
2695
+ readonly data?: unknown;
2696
+ } | {
2697
+ readonly _tag: "Forbidden";
2698
+ readonly message?: string | undefined;
2699
+ readonly data?: unknown;
2700
+ } | {
2701
+ readonly _tag: "TaskNotFound";
2702
+ readonly message?: string | undefined;
2703
+ readonly data?: unknown;
2704
+ } | {
2705
+ readonly _tag: "ConversationNotFound";
2706
+ readonly message?: string | undefined;
2707
+ readonly data?: unknown;
2708
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
2709
+ readonly _tag: "Unauthorized";
2710
+ readonly message?: string | undefined;
2711
+ readonly data?: unknown;
2712
+ } | {
2713
+ readonly _tag: "Forbidden";
2714
+ readonly message?: string | undefined;
2715
+ readonly data?: unknown;
2716
+ }, never>)[]]>, never> | Rpc.Rpc<"cli/contacts/add", Schema.Struct<{
293
2717
  userId: Schema.Schema<UserId, string, never>;
294
2718
  }>, Schema.Struct<{
295
2719
  contact: Schema.Struct<{
@@ -300,7 +2724,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
300
2724
  tags: Schema.optional<Schema.Array$<Schema.Record$<typeof Schema.String, typeof Schema.String>>>;
301
2725
  }>>;
302
2726
  }>;
303
- }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...Schema.Schema.AnyNoContext[]]>, never> | Rpc.Rpc<"cli/contacts/accept", Schema.Struct<{
2727
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...(Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
2728
+ readonly _tag: "Unauthorized";
2729
+ readonly message?: string | undefined;
2730
+ readonly data?: unknown;
2731
+ } | {
2732
+ readonly _tag: "Forbidden";
2733
+ readonly message?: string | undefined;
2734
+ readonly data?: unknown;
2735
+ } | {
2736
+ readonly _tag: "InvalidParamsError";
2737
+ readonly message?: string | undefined;
2738
+ readonly data?: unknown;
2739
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
2740
+ readonly _tag: "Unauthorized";
2741
+ readonly message?: string | undefined;
2742
+ readonly data?: unknown;
2743
+ } | {
2744
+ readonly _tag: "Forbidden";
2745
+ readonly message?: string | undefined;
2746
+ readonly data?: unknown;
2747
+ } | {
2748
+ readonly _tag: "InvalidParamsError";
2749
+ readonly message?: string | undefined;
2750
+ readonly data?: unknown;
2751
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ConflictError | import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
2752
+ readonly _tag: "Conflict";
2753
+ readonly message?: string | undefined;
2754
+ readonly data?: unknown;
2755
+ } | {
2756
+ readonly _tag: "Unauthorized";
2757
+ readonly message?: string | undefined;
2758
+ readonly data?: unknown;
2759
+ } | {
2760
+ readonly _tag: "Forbidden";
2761
+ readonly message?: string | undefined;
2762
+ readonly data?: unknown;
2763
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").ContactNotFoundError, {
2764
+ readonly _tag: "Unauthorized";
2765
+ readonly message?: string | undefined;
2766
+ readonly data?: unknown;
2767
+ } | {
2768
+ readonly _tag: "Forbidden";
2769
+ readonly message?: string | undefined;
2770
+ readonly data?: unknown;
2771
+ } | {
2772
+ readonly _tag: "ContactNotFound";
2773
+ readonly message?: string | undefined;
2774
+ readonly data?: unknown;
2775
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").AlreadyConnected, {
2776
+ readonly _tag: "Unauthorized";
2777
+ readonly message?: string | undefined;
2778
+ readonly data?: unknown;
2779
+ } | {
2780
+ readonly _tag: "InvalidParamsError";
2781
+ readonly message?: string | undefined;
2782
+ readonly data?: unknown;
2783
+ } | {
2784
+ readonly _tag: "ProtocolMismatchError";
2785
+ readonly data: {
2786
+ readonly reason: "server-above-client-max" | "server-below-client-min";
2787
+ readonly serverVersion: string;
2788
+ readonly clientMinProtocol: string;
2789
+ readonly clientMaxProtocol: string;
2790
+ };
2791
+ readonly message?: string | undefined;
2792
+ } | {
2793
+ readonly _tag: "AlreadyConnected";
2794
+ readonly principal: "agent" | "app";
2795
+ readonly message?: string | undefined;
2796
+ readonly data?: unknown;
2797
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError, {
2798
+ readonly _tag: "Unauthorized";
2799
+ readonly message?: string | undefined;
2800
+ readonly data?: unknown;
2801
+ } | {
2802
+ readonly _tag: "Forbidden";
2803
+ readonly message?: string | undefined;
2804
+ readonly data?: unknown;
2805
+ } | {
2806
+ readonly _tag: "NotInContacts";
2807
+ readonly message?: string | undefined;
2808
+ readonly data?: unknown;
2809
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/task").TaskRejectedError | import("@moltzap/protocol/conversation").ConversationFullError, {
2810
+ readonly _tag: "Unauthorized";
2811
+ readonly message?: string | undefined;
2812
+ readonly data?: unknown;
2813
+ } | {
2814
+ readonly _tag: "Forbidden";
2815
+ readonly message?: string | undefined;
2816
+ readonly data?: unknown;
2817
+ } | {
2818
+ readonly _tag: "NotInContacts";
2819
+ readonly message?: string | undefined;
2820
+ readonly data?: unknown;
2821
+ } | {
2822
+ readonly _tag: "AgentNotFound";
2823
+ readonly message?: string | undefined;
2824
+ readonly data?: unknown;
2825
+ } | {
2826
+ readonly _tag: "TaskRejected";
2827
+ readonly message?: string | undefined;
2828
+ readonly data?: unknown;
2829
+ } | {
2830
+ readonly _tag: "ConversationFull";
2831
+ readonly message?: string | undefined;
2832
+ readonly data?: unknown;
2833
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
2834
+ readonly _tag: "Unauthorized";
2835
+ readonly message?: string | undefined;
2836
+ readonly data?: unknown;
2837
+ } | {
2838
+ readonly _tag: "Forbidden";
2839
+ readonly message?: string | undefined;
2840
+ readonly data?: unknown;
2841
+ } | {
2842
+ readonly _tag: "InvalidParamsError";
2843
+ readonly message?: string | undefined;
2844
+ readonly data?: unknown;
2845
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError, {
2846
+ readonly _tag: "Unauthorized";
2847
+ readonly message?: string | undefined;
2848
+ readonly data?: unknown;
2849
+ } | {
2850
+ readonly _tag: "Forbidden";
2851
+ readonly message?: string | undefined;
2852
+ readonly data?: unknown;
2853
+ } | {
2854
+ readonly _tag: "TaskNotFound";
2855
+ readonly message?: string | undefined;
2856
+ readonly data?: unknown;
2857
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
2858
+ readonly _tag: "Unauthorized";
2859
+ readonly message?: string | undefined;
2860
+ readonly data?: unknown;
2861
+ } | {
2862
+ readonly _tag: "Forbidden";
2863
+ readonly message?: string | undefined;
2864
+ readonly data?: unknown;
2865
+ } | {
2866
+ readonly _tag: "InvalidParamsError";
2867
+ readonly message?: string | undefined;
2868
+ readonly data?: unknown;
2869
+ } | {
2870
+ readonly _tag: "ConversationNotFound";
2871
+ readonly message?: string | undefined;
2872
+ readonly data?: unknown;
2873
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/message").MessageNotFoundError | import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/task").TaskClosedError | import("@moltzap/protocol/conversation").ConversationArchivedError, {
2874
+ readonly _tag: "Unauthorized";
2875
+ readonly message?: string | undefined;
2876
+ readonly data?: unknown;
2877
+ } | {
2878
+ readonly _tag: "Forbidden";
2879
+ readonly message?: string | undefined;
2880
+ readonly data?: unknown;
2881
+ } | {
2882
+ readonly _tag: "ConversationNotFound";
2883
+ readonly message?: string | undefined;
2884
+ readonly data?: unknown;
2885
+ } | {
2886
+ readonly _tag: "HookBlocked";
2887
+ readonly message?: string | undefined;
2888
+ readonly data?: unknown;
2889
+ } | {
2890
+ readonly _tag: "MessageNotFound";
2891
+ readonly message?: string | undefined;
2892
+ readonly data?: unknown;
2893
+ } | {
2894
+ readonly _tag: "DispatchNotFound";
2895
+ readonly message?: string | undefined;
2896
+ readonly data?: unknown;
2897
+ } | {
2898
+ readonly _tag: "TaskClosed";
2899
+ readonly message?: string | undefined;
2900
+ readonly data?: unknown;
2901
+ } | {
2902
+ readonly _tag: "ConversationArchived";
2903
+ readonly message?: string | undefined;
2904
+ readonly data?: unknown;
2905
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
2906
+ readonly _tag: "Unauthorized";
2907
+ readonly message?: string | undefined;
2908
+ readonly data?: unknown;
2909
+ } | {
2910
+ readonly _tag: "Forbidden";
2911
+ readonly message?: string | undefined;
2912
+ readonly data?: unknown;
2913
+ } | {
2914
+ readonly _tag: "TaskNotFound";
2915
+ readonly message?: string | undefined;
2916
+ readonly data?: unknown;
2917
+ } | {
2918
+ readonly _tag: "ConversationNotFound";
2919
+ readonly message?: string | undefined;
2920
+ readonly data?: unknown;
2921
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
2922
+ readonly _tag: "Unauthorized";
2923
+ readonly message?: string | undefined;
2924
+ readonly data?: unknown;
2925
+ } | {
2926
+ readonly _tag: "Forbidden";
2927
+ readonly message?: string | undefined;
2928
+ readonly data?: unknown;
2929
+ }, never>)[]]>, never> | Rpc.Rpc<"cli/contacts/accept", Schema.Struct<{
304
2930
  contactId: Schema.Schema<ContactId, string, never>;
305
2931
  }>, Schema.Struct<{
306
2932
  contact: Schema.Struct<{
@@ -311,7 +2937,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
311
2937
  tags: Schema.optional<Schema.Array$<Schema.Record$<typeof Schema.String, typeof Schema.String>>>;
312
2938
  }>>;
313
2939
  }>;
314
- }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...Schema.Schema.AnyNoContext[]]>, never>>;
2940
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartTaskUsageError, typeof StartTaskPartialFailure, typeof ServiceInputError, typeof NotConnectedError, typeof RpcTimeoutError, ...(Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
2941
+ readonly _tag: "Unauthorized";
2942
+ readonly message?: string | undefined;
2943
+ readonly data?: unknown;
2944
+ } | {
2945
+ readonly _tag: "Forbidden";
2946
+ readonly message?: string | undefined;
2947
+ readonly data?: unknown;
2948
+ } | {
2949
+ readonly _tag: "InvalidParamsError";
2950
+ readonly message?: string | undefined;
2951
+ readonly data?: unknown;
2952
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
2953
+ readonly _tag: "Unauthorized";
2954
+ readonly message?: string | undefined;
2955
+ readonly data?: unknown;
2956
+ } | {
2957
+ readonly _tag: "Forbidden";
2958
+ readonly message?: string | undefined;
2959
+ readonly data?: unknown;
2960
+ } | {
2961
+ readonly _tag: "InvalidParamsError";
2962
+ readonly message?: string | undefined;
2963
+ readonly data?: unknown;
2964
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ConflictError | import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
2965
+ readonly _tag: "Conflict";
2966
+ readonly message?: string | undefined;
2967
+ readonly data?: unknown;
2968
+ } | {
2969
+ readonly _tag: "Unauthorized";
2970
+ readonly message?: string | undefined;
2971
+ readonly data?: unknown;
2972
+ } | {
2973
+ readonly _tag: "Forbidden";
2974
+ readonly message?: string | undefined;
2975
+ readonly data?: unknown;
2976
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").ContactNotFoundError, {
2977
+ readonly _tag: "Unauthorized";
2978
+ readonly message?: string | undefined;
2979
+ readonly data?: unknown;
2980
+ } | {
2981
+ readonly _tag: "Forbidden";
2982
+ readonly message?: string | undefined;
2983
+ readonly data?: unknown;
2984
+ } | {
2985
+ readonly _tag: "ContactNotFound";
2986
+ readonly message?: string | undefined;
2987
+ readonly data?: unknown;
2988
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").AlreadyConnected, {
2989
+ readonly _tag: "Unauthorized";
2990
+ readonly message?: string | undefined;
2991
+ readonly data?: unknown;
2992
+ } | {
2993
+ readonly _tag: "InvalidParamsError";
2994
+ readonly message?: string | undefined;
2995
+ readonly data?: unknown;
2996
+ } | {
2997
+ readonly _tag: "ProtocolMismatchError";
2998
+ readonly data: {
2999
+ readonly reason: "server-above-client-max" | "server-below-client-min";
3000
+ readonly serverVersion: string;
3001
+ readonly clientMinProtocol: string;
3002
+ readonly clientMaxProtocol: string;
3003
+ };
3004
+ readonly message?: string | undefined;
3005
+ } | {
3006
+ readonly _tag: "AlreadyConnected";
3007
+ readonly principal: "agent" | "app";
3008
+ readonly message?: string | undefined;
3009
+ readonly data?: unknown;
3010
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError, {
3011
+ readonly _tag: "Unauthorized";
3012
+ readonly message?: string | undefined;
3013
+ readonly data?: unknown;
3014
+ } | {
3015
+ readonly _tag: "Forbidden";
3016
+ readonly message?: string | undefined;
3017
+ readonly data?: unknown;
3018
+ } | {
3019
+ readonly _tag: "NotInContacts";
3020
+ readonly message?: string | undefined;
3021
+ readonly data?: unknown;
3022
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/task").TaskRejectedError | import("@moltzap/protocol/conversation").ConversationFullError, {
3023
+ readonly _tag: "Unauthorized";
3024
+ readonly message?: string | undefined;
3025
+ readonly data?: unknown;
3026
+ } | {
3027
+ readonly _tag: "Forbidden";
3028
+ readonly message?: string | undefined;
3029
+ readonly data?: unknown;
3030
+ } | {
3031
+ readonly _tag: "NotInContacts";
3032
+ readonly message?: string | undefined;
3033
+ readonly data?: unknown;
3034
+ } | {
3035
+ readonly _tag: "AgentNotFound";
3036
+ readonly message?: string | undefined;
3037
+ readonly data?: unknown;
3038
+ } | {
3039
+ readonly _tag: "TaskRejected";
3040
+ readonly message?: string | undefined;
3041
+ readonly data?: unknown;
3042
+ } | {
3043
+ readonly _tag: "ConversationFull";
3044
+ readonly message?: string | undefined;
3045
+ readonly data?: unknown;
3046
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError, {
3047
+ readonly _tag: "Unauthorized";
3048
+ readonly message?: string | undefined;
3049
+ readonly data?: unknown;
3050
+ } | {
3051
+ readonly _tag: "Forbidden";
3052
+ readonly message?: string | undefined;
3053
+ readonly data?: unknown;
3054
+ } | {
3055
+ readonly _tag: "InvalidParamsError";
3056
+ readonly message?: string | undefined;
3057
+ readonly data?: unknown;
3058
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError, {
3059
+ readonly _tag: "Unauthorized";
3060
+ readonly message?: string | undefined;
3061
+ readonly data?: unknown;
3062
+ } | {
3063
+ readonly _tag: "Forbidden";
3064
+ readonly message?: string | undefined;
3065
+ readonly data?: unknown;
3066
+ } | {
3067
+ readonly _tag: "TaskNotFound";
3068
+ readonly message?: string | undefined;
3069
+ readonly data?: unknown;
3070
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
3071
+ readonly _tag: "Unauthorized";
3072
+ readonly message?: string | undefined;
3073
+ readonly data?: unknown;
3074
+ } | {
3075
+ readonly _tag: "Forbidden";
3076
+ readonly message?: string | undefined;
3077
+ readonly data?: unknown;
3078
+ } | {
3079
+ readonly _tag: "InvalidParamsError";
3080
+ readonly message?: string | undefined;
3081
+ readonly data?: unknown;
3082
+ } | {
3083
+ readonly _tag: "ConversationNotFound";
3084
+ readonly message?: string | undefined;
3085
+ readonly data?: unknown;
3086
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/message").MessageNotFoundError | import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/task").TaskClosedError | import("@moltzap/protocol/conversation").ConversationArchivedError, {
3087
+ readonly _tag: "Unauthorized";
3088
+ readonly message?: string | undefined;
3089
+ readonly data?: unknown;
3090
+ } | {
3091
+ readonly _tag: "Forbidden";
3092
+ readonly message?: string | undefined;
3093
+ readonly data?: unknown;
3094
+ } | {
3095
+ readonly _tag: "ConversationNotFound";
3096
+ readonly message?: string | undefined;
3097
+ readonly data?: unknown;
3098
+ } | {
3099
+ readonly _tag: "HookBlocked";
3100
+ readonly message?: string | undefined;
3101
+ readonly data?: unknown;
3102
+ } | {
3103
+ readonly _tag: "MessageNotFound";
3104
+ readonly message?: string | undefined;
3105
+ readonly data?: unknown;
3106
+ } | {
3107
+ readonly _tag: "DispatchNotFound";
3108
+ readonly message?: string | undefined;
3109
+ readonly data?: unknown;
3110
+ } | {
3111
+ readonly _tag: "TaskClosed";
3112
+ readonly message?: string | undefined;
3113
+ readonly data?: unknown;
3114
+ } | {
3115
+ readonly _tag: "ConversationArchived";
3116
+ readonly message?: string | undefined;
3117
+ readonly data?: unknown;
3118
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/conversation").ConversationNotFoundError, {
3119
+ readonly _tag: "Unauthorized";
3120
+ readonly message?: string | undefined;
3121
+ readonly data?: unknown;
3122
+ } | {
3123
+ readonly _tag: "Forbidden";
3124
+ readonly message?: string | undefined;
3125
+ readonly data?: unknown;
3126
+ } | {
3127
+ readonly _tag: "TaskNotFound";
3128
+ readonly message?: string | undefined;
3129
+ readonly data?: unknown;
3130
+ } | {
3131
+ readonly _tag: "ConversationNotFound";
3132
+ readonly message?: string | undefined;
3133
+ readonly data?: unknown;
3134
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").UnauthorizedError | import("@moltzap/protocol/rpc").ForbiddenError, {
3135
+ readonly _tag: "Unauthorized";
3136
+ readonly message?: string | undefined;
3137
+ readonly data?: unknown;
3138
+ } | {
3139
+ readonly _tag: "Forbidden";
3140
+ readonly message?: string | undefined;
3141
+ readonly data?: unknown;
3142
+ }, never>)[]]>, never>>;
315
3143
  export declare class LocalDaemonRpcs extends LocalDaemonRpcs_base {
316
3144
  }
317
3145
  export type LocalDaemonHandlers = RpcGroup.HandlersFrom<RpcGroup.Rpcs<typeof LocalDaemonRpcs>>;