@moltzap/client 2026.721.0 → 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 (18) 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 -18
  6. package/dist/local-daemon-rpc.d.ts.map +1 -1
  7. package/dist/local-history.d.ts +0 -1
  8. package/dist/local-history.d.ts.map +1 -1
  9. package/dist/local-history.js +0 -1
  10. package/dist/local-history.js.map +1 -1
  11. package/dist/service.d.ts.map +1 -1
  12. package/dist/service.js +0 -1
  13. package/dist/service.js.map +1 -1
  14. package/dist/test-utils/fake-service.d.ts.map +1 -1
  15. package/dist/test-utils/fake-service.js +1 -4
  16. package/dist/test-utils/fake-service.js.map +1 -1
  17. package/dist/tsconfig.tsbuildinfo +1 -1
  18. 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,8 +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
- hasMore: typeof Schema.Boolean;
130
- }>, 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>;
131
534
  export declare const SendCommandRpc: Rpc.Rpc<"cli/send", Schema.Struct<{
132
535
  target: Schema.transformOrFail<typeof Schema.String, Schema.Struct<{
133
536
  taskId: Schema.Schema<TaskId, string, never>;
@@ -137,7 +540,209 @@ export declare const SendCommandRpc: Rpc.Rpc<"cli/send", Schema.Struct<{
137
540
  replyToId: Schema.optional<Schema.Schema<MessageId, string, never>>;
138
541
  }>, Schema.Struct<{
139
542
  messageId: Schema.Schema<MessageId, string, never>;
140
- }>, 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>;
141
746
  export declare const StartTaskCommandRpc: Rpc.Rpc<"cli/start-task", Schema.Struct<{
142
747
  name: Schema.filter<Schema.filter<typeof Schema.String>>;
143
748
  participants: Schema.Array$<Schema.transformOrFail<typeof Schema.String, Schema.Union<[Schema.Struct<{
@@ -155,7 +760,209 @@ export declare const StartTaskCommandRpc: Rpc.Rpc<"cli/start-task", Schema.Struc
155
760
  conversationId: Schema.Schema<ConversationId, string, never>;
156
761
  reusedConversation: typeof Schema.Boolean;
157
762
  sentMessageId: Schema.optional<Schema.Schema<MessageId, string, never>>;
158
- }>, 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>;
159
966
  declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list", Schema.Struct<{
160
967
  taskId: Schema.Schema<TaskId, string, never>;
161
968
  conversationId: Schema.Schema<ConversationId, string, never>;
@@ -184,8 +991,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
184
991
  patchedBy: Schema.optional<typeof Schema.String>;
185
992
  createdAt: Schema.Schema<string, string, never>;
186
993
  }>>;
187
- hasMore: typeof Schema.Boolean;
188
- }>, 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<{
189
1197
  target: Schema.transformOrFail<typeof Schema.String, Schema.Struct<{
190
1198
  taskId: Schema.Schema<TaskId, string, never>;
191
1199
  conversationId: Schema.Schema<ConversationId, string, never>;
@@ -194,7 +1202,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
194
1202
  replyToId: Schema.optional<Schema.Schema<MessageId, string, never>>;
195
1203
  }>, Schema.Struct<{
196
1204
  messageId: Schema.Schema<MessageId, string, never>;
197
- }>, 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<{
198
1408
  name: Schema.filter<Schema.filter<typeof Schema.String>>;
199
1409
  participants: Schema.Array$<Schema.transformOrFail<typeof Schema.String, Schema.Union<[Schema.Struct<{
200
1410
  kind: Schema.Literal<["id"]>;
@@ -211,11 +1421,415 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
211
1421
  conversationId: Schema.Schema<ConversationId, string, never>;
212
1422
  reusedConversation: typeof Schema.Boolean;
213
1423
  sentMessageId: Schema.optional<Schema.Schema<MessageId, string, never>>;
214
- }>, 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<{
215
1627
  agentId: Schema.optional<Schema.Schema<AgentId, string, never>>;
216
1628
  connected: typeof Schema.Boolean;
217
1629
  conversations: Schema.filter<Schema.filter<typeof Schema.Number>>;
218
- }>, 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<{
219
1833
  taskId: Schema.Schema<TaskId, string, never>;
220
1834
  conversationId: Schema.Schema<ConversationId, string, never>;
221
1835
  limit: Schema.optionalWith<Schema.filter<Schema.filter<typeof Schema.Number>>, {
@@ -232,7 +1846,6 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
232
1846
  createdAt: typeof Schema.String;
233
1847
  isNew: typeof Schema.Boolean;
234
1848
  }>>;
235
- hasMore: typeof Schema.Boolean;
236
1849
  conversationMeta: Schema.optional<Schema.Struct<{
237
1850
  id: Schema.Schema<ConversationId, string, never>;
238
1851
  name: Schema.optional<typeof Schema.String>;
@@ -246,7 +1859,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
246
1859
  archivedAt: Schema.optional<typeof Schema.String>;
247
1860
  }>>;
248
1861
  newCount: Schema.filter<Schema.filter<typeof Schema.Number>>;
249
- }>, 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<{
250
2065
  limit: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>>;
251
2066
  }>, Schema.Struct<{
252
2067
  agents: Schema.Array$<Schema.Struct<{
@@ -264,7 +2079,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
264
2079
  status: Schema.Schema<"active" | "suspended", "active" | "suspended", never>;
265
2080
  }>>;
266
2081
  nextCursor: Schema.optional<Schema.Schema<import("@moltzap/protocol/rpc").ListCursor, string, never>>;
267
- }>, 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<{
268
2285
  names: Schema.filter<Schema.filter<Schema.Array$<Schema.filter<Schema.filter<typeof Schema.String>>>>>;
269
2286
  }>, Schema.Struct<{
270
2287
  agents: Schema.Array$<Schema.Struct<{
@@ -282,7 +2299,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
282
2299
  status: Schema.Schema<"active" | "suspended", "active" | "suspended", never>;
283
2300
  }>>;
284
2301
  nextCursor: Schema.optional<Schema.Schema<import("@moltzap/protocol/rpc").ListCursor, string, never>>;
285
- }>, 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<{
286
2505
  contacts: Schema.Array$<Schema.Struct<{
287
2506
  id: Schema.Schema<ContactId, string, never>;
288
2507
  contactUserId: Schema.Schema<UserId, string, never>;
@@ -292,7 +2511,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
292
2511
  }>>;
293
2512
  }>>;
294
2513
  nextCursor: Schema.optional<Schema.Schema<import("@moltzap/protocol/rpc").ListCursor, string, never>>;
295
- }>, 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<{
296
2717
  userId: Schema.Schema<UserId, string, never>;
297
2718
  }>, Schema.Struct<{
298
2719
  contact: Schema.Struct<{
@@ -303,7 +2724,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
303
2724
  tags: Schema.optional<Schema.Array$<Schema.Record$<typeof Schema.String, typeof Schema.String>>>;
304
2725
  }>>;
305
2726
  }>;
306
- }>, 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<{
307
2930
  contactId: Schema.Schema<ContactId, string, never>;
308
2931
  }>, Schema.Struct<{
309
2932
  contact: Schema.Struct<{
@@ -314,7 +2937,209 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/messages/list
314
2937
  tags: Schema.optional<Schema.Array$<Schema.Record$<typeof Schema.String, typeof Schema.String>>>;
315
2938
  }>>;
316
2939
  }>;
317
- }>, 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>>;
318
3143
  export declare class LocalDaemonRpcs extends LocalDaemonRpcs_base {
319
3144
  }
320
3145
  export type LocalDaemonHandlers = RpcGroup.HandlersFrom<RpcGroup.Rpcs<typeof LocalDaemonRpcs>>;