@moltzap/client 2026.730.1 → 2026.731.0

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