@moltzap/client 2026.731.0 → 2026.731.1

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 (66) hide show
  1. package/dist/channel-core-enrichment.d.ts +5 -2
  2. package/dist/channel-core-enrichment.d.ts.map +1 -1
  3. package/dist/channel-core-enrichment.js +5 -6
  4. package/dist/channel-core-enrichment.js.map +1 -1
  5. package/dist/channel-core.d.ts +28 -18
  6. package/dist/channel-core.d.ts.map +1 -1
  7. package/dist/channel-core.js +24 -61
  8. package/dist/channel-core.js.map +1 -1
  9. package/dist/cli/commands/conversations.d.ts +1 -4
  10. package/dist/cli/commands/conversations.d.ts.map +1 -1
  11. package/dist/cli/commands/conversations.js +4 -8
  12. package/dist/cli/commands/conversations.js.map +1 -1
  13. package/dist/cli/commands/messages.d.ts +0 -3
  14. package/dist/cli/commands/messages.d.ts.map +1 -1
  15. package/dist/cli/commands/messages.js +1 -4
  16. package/dist/cli/commands/messages.js.map +1 -1
  17. package/dist/cli/commands/send.d.ts +10 -21
  18. package/dist/cli/commands/send.d.ts.map +1 -1
  19. package/dist/cli/commands/send.js +16 -25
  20. package/dist/cli/commands/send.js.map +1 -1
  21. package/dist/cli/commands/start.d.ts.map +1 -1
  22. package/dist/cli/commands/start.js +11 -13
  23. package/dist/cli/commands/start.js.map +1 -1
  24. package/dist/cli/index.js +0 -2
  25. package/dist/cli/index.js.map +1 -1
  26. package/dist/local-daemon-rpc.d.ts +338 -2241
  27. package/dist/local-daemon-rpc.d.ts.map +1 -1
  28. package/dist/local-daemon-rpc.js +39 -54
  29. package/dist/local-daemon-rpc.js.map +1 -1
  30. package/dist/local-history.d.ts +0 -2
  31. package/dist/local-history.d.ts.map +1 -1
  32. package/dist/local-history.js +0 -3
  33. package/dist/local-history.js.map +1 -1
  34. package/dist/notification/__tests__/subscribe-signatures.types-check.d.ts +15 -13
  35. package/dist/notification/__tests__/subscribe-signatures.types-check.d.ts.map +1 -1
  36. package/dist/notification/__tests__/subscribe-signatures.types-check.js +5 -5
  37. package/dist/notification/__tests__/subscribe-signatures.types-check.js.map +1 -1
  38. package/dist/service-local-daemon.d.ts.map +1 -1
  39. package/dist/service-local-daemon.js +24 -64
  40. package/dist/service-local-daemon.js.map +1 -1
  41. package/dist/service.d.ts +29 -31
  42. package/dist/service.d.ts.map +1 -1
  43. package/dist/service.js +40 -106
  44. package/dist/service.js.map +1 -1
  45. package/dist/test-utils/channel-service-fixture.d.ts +7 -12
  46. package/dist/test-utils/channel-service-fixture.d.ts.map +1 -1
  47. package/dist/test-utils/channel-service-fixture.js +11 -49
  48. package/dist/test-utils/channel-service-fixture.js.map +1 -1
  49. package/dist/test-utils/ids.d.ts +7 -1
  50. package/dist/test-utils/ids.d.ts.map +1 -1
  51. package/dist/test-utils/ids.js +9 -0
  52. package/dist/test-utils/ids.js.map +1 -1
  53. package/dist/test-utils/index.d.ts +2 -3
  54. package/dist/test-utils/index.d.ts.map +1 -1
  55. package/dist/test-utils/index.js +2 -3
  56. package/dist/test-utils/index.js.map +1 -1
  57. package/dist/tsconfig.tsbuildinfo +1 -1
  58. package/package.json +3 -3
  59. package/dist/cli/commands/contacts.d.ts +0 -10
  60. package/dist/cli/commands/contacts.d.ts.map +0 -1
  61. package/dist/cli/commands/contacts.js +0 -21
  62. package/dist/cli/commands/contacts.js.map +0 -1
  63. package/dist/service-archive-purge.d.ts +0 -36
  64. package/dist/service-archive-purge.d.ts.map +0 -1
  65. package/dist/service-archive-purge.js +0 -50
  66. package/dist/service-archive-purge.js.map +0 -1
package/dist/local-daemon-rpc.d.ts CHANGED
@@ -6,10 +6,15 @@ import { NotConnectedError, RpcTimeoutError } from "@moltzap/protocol/rpc";
6
6
  declare const appIdV4: Schema.filter<Schema.Schema<import("@moltzap/protocol/identity").AppId, string, never>>;
7
7
  /** Represents app id v4 values. */
8
8
  export type AppIdV4 = Schema.Schema.Type<typeof appIdV4>;
9
- /** Validates and decodes send target values. */
9
+ /**
10
+ * A conversation is the whole address. `task:&lt;taskId>:&lt;conversationId>`
11
+ * is also accepted so a caller holding a task label can pass it through; the
12
+ * label rides along to `agent/message/send` untouched and never selects the
13
+ * destination.
14
+ */
10
15
  export declare const sendTarget: Schema.transformOrFail<typeof Schema.String, Schema.Struct<{
11
- taskId: Schema.Schema<import("@moltzap/protocol/task").TaskId, string, never>;
12
16
  conversationId: Schema.Schema<import("@moltzap/protocol/conversation").ConversationId, string, never>;
17
+ taskId: Schema.optional<Schema.Schema<import("@moltzap/protocol/task").TaskId, string, never>>;
13
18
  }>, never>;
14
19
  /** Represents send target values. */
15
20
  export type SendTarget = Schema.Schema.Type<typeof sendTarget>;
@@ -30,24 +35,20 @@ export declare const localDaemonCommands: {
30
35
  readonly history: "daemon/history";
31
36
  readonly agentsList: "cli/agents/list";
32
37
  readonly agentsSearch: "cli/agents/search";
33
- readonly contactsList: "cli/contacts/list";
34
- readonly contactsAdd: "cli/contacts/add";
35
- readonly contactsAccept: "cli/contacts/accept";
36
38
  readonly messagesList: "cli/messages/list";
37
39
  readonly send: "cli/send";
38
- readonly startTask: "cli/start-task";
40
+ readonly start: "cli/start";
39
41
  };
40
42
  declare const sendCommandPayload: Schema.Struct<{
41
43
  target: Schema.transformOrFail<typeof Schema.String, Schema.Struct<{
42
- taskId: Schema.Schema<import("@moltzap/protocol/task").TaskId, string, never>;
43
44
  conversationId: Schema.Schema<import("@moltzap/protocol/conversation").ConversationId, string, never>;
45
+ taskId: Schema.optional<Schema.Schema<import("@moltzap/protocol/task").TaskId, string, never>>;
44
46
  }>, never>;
45
47
  message: Schema.filter<typeof Schema.String>;
46
- replyToId: Schema.optional<Schema.Schema<import("@moltzap/protocol/conversation").MessageId, string, never>>;
47
48
  }>;
48
49
  /** Represents send command payload values. */
49
50
  export type SendCommandPayload = Schema.Schema.Type<typeof sendCommandPayload>;
50
- declare const startTaskCommandPayload: Schema.Struct<{
51
+ declare const startCommandPayload: Schema.Struct<{
51
52
  name: Schema.filter<Schema.filter<typeof Schema.String>>;
52
53
  participants: Schema.Array$<Schema.transformOrFail<typeof Schema.String, Schema.Union<[Schema.Struct<{
53
54
  kind: Schema.Literal<["id"]>;
@@ -60,16 +61,14 @@ declare const startTaskCommandPayload: Schema.Struct<{
60
61
  message: Schema.optional<typeof Schema.String>;
61
62
  appId: Schema.optional<Schema.filter<Schema.Schema<import("@moltzap/protocol/identity").AppId, string, never>>>;
62
63
  }>;
63
- declare const startTaskCommandResult: Schema.Struct<{
64
- taskId: Schema.Schema<import("@moltzap/protocol/task").TaskId, string, never>;
64
+ declare const startCommandResult: Schema.Struct<{
65
65
  conversationId: Schema.Schema<import("@moltzap/protocol/conversation").ConversationId, string, never>;
66
- reusedConversation: typeof Schema.Boolean;
67
66
  sentMessageId: Schema.optional<Schema.Schema<import("@moltzap/protocol/conversation").MessageId, string, never>>;
68
67
  }>;
69
- /** Represents start task command payload values. */
70
- export type StartTaskCommandPayload = Schema.Schema.Type<typeof startTaskCommandPayload>;
71
- /** Represents the result of start task command. */
72
- export type StartTaskCommandResult = Schema.Schema.Type<typeof startTaskCommandResult>;
68
+ /** Represents start command payload values. */
69
+ export type StartCommandPayload = Schema.Schema.Type<typeof startCommandPayload>;
70
+ /** Represents the result of start command. */
71
+ export type StartCommandResult = Schema.Schema.Type<typeof startCommandResult>;
73
72
  declare const LocalDaemonInputError_base: Schema.TaggedErrorClass<LocalDaemonInputError, "LocalDaemonInputError", {
74
73
  readonly _tag: Schema.tag<"LocalDaemonInputError">;
75
74
  } & {
@@ -78,24 +77,22 @@ declare const LocalDaemonInputError_base: Schema.TaggedErrorClass<LocalDaemonInp
78
77
  /** Reports local daemon input failures. */
79
78
  export declare class LocalDaemonInputError extends LocalDaemonInputError_base {
80
79
  }
81
- declare const StartTaskUsageError_base: Schema.TaggedErrorClass<StartTaskUsageError, "StartTaskUsageError", {
82
- readonly _tag: Schema.tag<"StartTaskUsageError">;
80
+ declare const StartUsageError_base: Schema.TaggedErrorClass<StartUsageError, "StartUsageError", {
81
+ readonly _tag: Schema.tag<"StartUsageError">;
83
82
  } & {
84
83
  message: typeof Schema.String;
85
84
  }>;
86
- /** Reports start task usage failures. */
87
- export declare class StartTaskUsageError extends StartTaskUsageError_base {
85
+ /** Reports start usage failures. */
86
+ export declare class StartUsageError extends StartUsageError_base {
88
87
  }
89
- declare const StartTaskPartialFailure_base: Schema.TaggedErrorClass<StartTaskPartialFailure, "StartTaskPartialFailure", {
90
- readonly _tag: Schema.tag<"StartTaskPartialFailure">;
88
+ declare const StartPartialFailure_base: Schema.TaggedErrorClass<StartPartialFailure, "StartPartialFailure", {
89
+ readonly _tag: Schema.tag<"StartPartialFailure">;
91
90
  } & {
92
- taskId: Schema.Schema<import("@moltzap/protocol/task").TaskId, string, never>;
93
91
  conversationId: Schema.Schema<import("@moltzap/protocol/conversation").ConversationId, string, never>;
94
- reusedConversation: typeof Schema.Boolean;
95
92
  message: typeof Schema.String;
96
93
  }>;
97
- /** Implements start task partial failure. */
98
- export declare class StartTaskPartialFailure extends StartTaskPartialFailure_base {
94
+ /** The conversation exists but its first message did not send. */
95
+ export declare class StartPartialFailure extends StartPartialFailure_base {
99
96
  }
100
97
  declare const ServiceInputError_base: Schema.TaggedErrorClass<ServiceInputError, "ServiceInputError", {
101
98
  readonly _tag: Schema.tag<"ServiceInputError">;
@@ -105,7 +102,7 @@ declare const ServiceInputError_base: Schema.TaggedErrorClass<ServiceInputError,
105
102
  /** Reports service input failures. */
106
103
  export declare class ServiceInputError extends ServiceInputError_base {
107
104
  }
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, {
105
+ declare const localDaemonErrorSchema: Schema.Union<[typeof LocalDaemonInputError, typeof StartUsageError, typeof StartPartialFailure, 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
106
  readonly _tag: "Unauthorized";
110
107
  readonly data?: unknown;
111
108
  readonly message?: string | undefined;
@@ -127,55 +124,7 @@ declare const localDaemonErrorSchema: Schema.Union<[typeof LocalDaemonInputError
127
124
  readonly data?: unknown;
128
125
  readonly message?: string | undefined;
129
126
  readonly principal: "agent" | "app";
130
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
131
- readonly _tag: "Unauthorized";
132
- readonly data?: unknown;
133
- readonly message?: string | undefined;
134
- } | {
135
- readonly _tag: "Forbidden";
136
- readonly data?: unknown;
137
- readonly message?: string | undefined;
138
- } | {
139
- readonly _tag: "InvalidParamsError";
140
- readonly data?: unknown;
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";
144
- readonly data?: unknown;
145
- readonly message?: string | undefined;
146
- } | {
147
- readonly _tag: "Forbidden";
148
- readonly data?: unknown;
149
- readonly message?: string | undefined;
150
- } | {
151
- readonly _tag: "NotInContacts";
152
- readonly data?: unknown;
153
- readonly message?: string | undefined;
154
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
155
- readonly _tag: "Unauthorized";
156
- readonly data?: unknown;
157
- readonly message?: string | undefined;
158
- } | {
159
- readonly _tag: "Forbidden";
160
- readonly data?: unknown;
161
- readonly message?: string | undefined;
162
- } | {
163
- readonly _tag: "InvalidParamsError";
164
- readonly data?: unknown;
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";
168
- readonly data?: unknown;
169
- readonly message?: string | undefined;
170
- } | {
171
- readonly _tag: "Unauthorized";
172
- readonly data?: unknown;
173
- readonly message?: string | undefined;
174
- } | {
175
- readonly _tag: "Forbidden";
176
- readonly data?: unknown;
177
- readonly message?: string | undefined;
178
- }, never> | Schema.Schema<import("@moltzap/protocol/identity").ContactNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
127
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
179
128
  readonly _tag: "Unauthorized";
180
129
  readonly data?: unknown;
181
130
  readonly message?: string | undefined;
@@ -183,10 +132,6 @@ declare const localDaemonErrorSchema: Schema.Union<[typeof LocalDaemonInputError
183
132
  readonly _tag: "Forbidden";
184
133
  readonly data?: unknown;
185
134
  readonly message?: string | undefined;
186
- } | {
187
- readonly _tag: "ContactNotFound";
188
- readonly data?: unknown;
189
- readonly message?: string | undefined;
190
135
  }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
191
136
  readonly _tag: "Unauthorized";
192
137
  readonly data?: unknown;
@@ -207,18 +152,6 @@ declare const localDaemonErrorSchema: Schema.Union<[typeof LocalDaemonInputError
207
152
  readonly _tag: "InvalidParamsError";
208
153
  readonly data?: unknown;
209
154
  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";
212
- readonly data?: unknown;
213
- readonly message?: string | undefined;
214
- } | {
215
- readonly _tag: "Forbidden";
216
- readonly data?: unknown;
217
- readonly message?: string | undefined;
218
- } | {
219
- readonly _tag: "TaskNotFound";
220
- readonly data?: unknown;
221
- readonly message?: string | undefined;
222
155
  }, never> | Schema.Schema<import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
223
156
  readonly _tag: "Unauthorized";
224
157
  readonly data?: unknown;
@@ -235,7 +168,7 @@ declare const localDaemonErrorSchema: Schema.Union<[typeof LocalDaemonInputError
235
168
  readonly _tag: "ConversationNotFound";
236
169
  readonly data?: unknown;
237
170
  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, {
171
+ }, never> | Schema.Schema<import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/conversation").ConversationFullError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
239
172
  readonly _tag: "Unauthorized";
240
173
  readonly data?: unknown;
241
174
  readonly message?: string | undefined;
@@ -243,39 +176,15 @@ declare const localDaemonErrorSchema: Schema.Union<[typeof LocalDaemonInputError
243
176
  readonly _tag: "Forbidden";
244
177
  readonly data?: unknown;
245
178
  readonly message?: string | undefined;
246
- } | {
247
- readonly _tag: "NotInContacts";
248
- readonly data?: unknown;
249
- readonly message?: string | undefined;
250
179
  } | {
251
180
  readonly _tag: "AgentNotFound";
252
181
  readonly data?: unknown;
253
182
  readonly message?: string | undefined;
254
- } | {
255
- readonly _tag: "TaskRejected";
256
- readonly data?: unknown;
257
- readonly message?: string | undefined;
258
183
  } | {
259
184
  readonly _tag: "ConversationFull";
260
185
  readonly data?: unknown;
261
186
  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";
264
- readonly data?: unknown;
265
- readonly message?: string | undefined;
266
- } | {
267
- readonly _tag: "Forbidden";
268
- readonly data?: unknown;
269
- readonly message?: string | undefined;
270
- } | {
271
- readonly _tag: "TaskNotFound";
272
- readonly data?: unknown;
273
- readonly message?: string | undefined;
274
- } | {
275
- readonly _tag: "ConversationNotFound";
276
- readonly data?: unknown;
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, {
187
+ }, never> | Schema.Schema<import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/rpc").UnauthorizedError, {
279
188
  readonly _tag: "Unauthorized";
280
189
  readonly data?: unknown;
281
190
  readonly message?: string | undefined;
@@ -283,35 +192,19 @@ declare const localDaemonErrorSchema: Schema.Union<[typeof LocalDaemonInputError
283
192
  readonly _tag: "Forbidden";
284
193
  readonly data?: unknown;
285
194
  readonly message?: string | undefined;
286
- } | {
287
- readonly _tag: "ConversationNotFound";
288
- readonly data?: unknown;
289
- readonly message?: string | undefined;
290
195
  } | {
291
196
  readonly _tag: "HookBlocked";
292
197
  readonly data?: unknown;
293
198
  readonly message?: string | undefined;
294
- } | {
295
- readonly _tag: "MessageNotFound";
296
- readonly data?: unknown;
297
- readonly message?: string | undefined;
298
199
  } | {
299
200
  readonly _tag: "DispatchNotFound";
300
201
  readonly data?: unknown;
301
202
  readonly message?: string | undefined;
302
- } | {
303
- readonly _tag: "TaskClosed";
304
- readonly data?: unknown;
305
- readonly message?: string | undefined;
306
- } | {
307
- readonly _tag: "ConversationArchived";
308
- readonly data?: unknown;
309
- readonly message?: string | undefined;
310
203
  }, never>)[]]>;
311
204
  /** Represents local daemon error conditions. */
312
205
  export type LocalDaemonError = Schema.Schema.Type<typeof localDaemonErrorSchema>;
313
206
  /** Validates and decodes is local daemon error values. */
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;
207
+ 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/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 | NotConnectedError | import("@moltzap/protocol/network").ProtocolMismatchError | RpcTimeoutError | ServiceInputError | StartPartialFailure | StartUsageError | import("@moltzap/protocol/rpc").UnauthorizedError;
315
208
  /**
316
209
  * Provides the to local daemon error runtime value.
317
210
  * @param error Error to inspect.
@@ -320,15 +213,14 @@ export declare const isLocalDaemonError: (u: unknown, overrideOptions?: SchemaAS
320
213
  export declare const toLocalDaemonError: (error: unknown) => LocalDaemonError;
321
214
  /** Provides the messages list command rpc runtime value. */
322
215
  export declare const messagesListCommandRpc: Rpc.Rpc<"cli/messages/list", Schema.Struct<{
323
- taskId: Schema.Schema<import("@moltzap/protocol/task").TaskId, string, never>;
324
216
  conversationId: Schema.Schema<import("@moltzap/protocol/conversation").ConversationId, string, never>;
325
217
  limit: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>>;
326
218
  }>, Schema.Struct<{
327
219
  messages: Schema.Array$<Schema.Struct<{
328
220
  id: Schema.Schema<import("@moltzap/protocol/conversation").MessageId, string, never>;
329
221
  conversationId: Schema.Schema<import("@moltzap/protocol/conversation").ConversationId, string, never>;
222
+ taskId: Schema.optional<Schema.Schema<import("@moltzap/protocol/task").TaskId, string, never>>;
330
223
  senderId: Schema.Schema<import("@moltzap/protocol/identity").AgentId, string, never>;
331
- replyToId: Schema.optional<Schema.Schema<import("@moltzap/protocol/conversation").MessageId, string, never>>;
332
224
  parts: Schema.filter<Schema.NonEmptyArray<Schema.Union<[Schema.Struct<{
333
225
  type: Schema.Literal<["text"]>;
334
226
  text: Schema.filter<Schema.filter<typeof Schema.String>>;
@@ -347,7 +239,7 @@ export declare const messagesListCommandRpc: Rpc.Rpc<"cli/messages/list", Schema
347
239
  patchedBy: Schema.optional<typeof Schema.String>;
348
240
  createdAt: Schema.Schema<string, string, never>;
349
241
  }>>;
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, {
242
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartUsageError, typeof StartPartialFailure, 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
243
  readonly _tag: "Unauthorized";
352
244
  readonly data?: unknown;
353
245
  readonly message?: string | undefined;
@@ -369,7 +261,7 @@ export declare const messagesListCommandRpc: Rpc.Rpc<"cli/messages/list", Schema
369
261
  readonly data?: unknown;
370
262
  readonly message?: string | undefined;
371
263
  readonly principal: "agent" | "app";
372
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
264
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
373
265
  readonly _tag: "Unauthorized";
374
266
  readonly data?: unknown;
375
267
  readonly message?: string | undefined;
@@ -377,11 +269,7 @@ export declare const messagesListCommandRpc: Rpc.Rpc<"cli/messages/list", Schema
377
269
  readonly _tag: "Forbidden";
378
270
  readonly data?: unknown;
379
271
  readonly message?: string | undefined;
380
- } | {
381
- readonly _tag: "InvalidParamsError";
382
- readonly data?: unknown;
383
- readonly message?: string | undefined;
384
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
272
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
385
273
  readonly _tag: "Unauthorized";
386
274
  readonly data?: unknown;
387
275
  readonly message?: string | undefined;
@@ -389,10 +277,6 @@ export declare const messagesListCommandRpc: Rpc.Rpc<"cli/messages/list", Schema
389
277
  readonly _tag: "Forbidden";
390
278
  readonly data?: unknown;
391
279
  readonly message?: string | undefined;
392
- } | {
393
- readonly _tag: "NotInContacts";
394
- readonly data?: unknown;
395
- readonly message?: string | undefined;
396
280
  }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
397
281
  readonly _tag: "Unauthorized";
398
282
  readonly data?: unknown;
@@ -405,11 +289,7 @@ export declare const messagesListCommandRpc: Rpc.Rpc<"cli/messages/list", Schema
405
289
  readonly _tag: "InvalidParamsError";
406
290
  readonly data?: unknown;
407
291
  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";
410
- readonly data?: unknown;
411
- readonly message?: string | undefined;
412
- } | {
292
+ }, never> | Schema.Schema<import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
413
293
  readonly _tag: "Unauthorized";
414
294
  readonly data?: unknown;
415
295
  readonly message?: string | undefined;
@@ -417,19 +297,15 @@ export declare const messagesListCommandRpc: Rpc.Rpc<"cli/messages/list", Schema
417
297
  readonly _tag: "Forbidden";
418
298
  readonly data?: unknown;
419
299
  readonly message?: string | undefined;
420
- }, never> | Schema.Schema<import("@moltzap/protocol/identity").ContactNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
421
- readonly _tag: "Unauthorized";
422
- readonly data?: unknown;
423
- readonly message?: string | undefined;
424
300
  } | {
425
- readonly _tag: "Forbidden";
301
+ readonly _tag: "InvalidParamsError";
426
302
  readonly data?: unknown;
427
303
  readonly message?: string | undefined;
428
304
  } | {
429
- readonly _tag: "ContactNotFound";
305
+ readonly _tag: "ConversationNotFound";
430
306
  readonly data?: unknown;
431
307
  readonly message?: string | undefined;
432
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
308
+ }, never> | Schema.Schema<import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/conversation").ConversationFullError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
433
309
  readonly _tag: "Unauthorized";
434
310
  readonly data?: unknown;
435
311
  readonly message?: string | undefined;
@@ -437,19 +313,15 @@ export declare const messagesListCommandRpc: Rpc.Rpc<"cli/messages/list", Schema
437
313
  readonly _tag: "Forbidden";
438
314
  readonly data?: unknown;
439
315
  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";
442
- readonly data?: unknown;
443
- readonly message?: string | undefined;
444
316
  } | {
445
- readonly _tag: "Forbidden";
317
+ readonly _tag: "AgentNotFound";
446
318
  readonly data?: unknown;
447
319
  readonly message?: string | undefined;
448
320
  } | {
449
- readonly _tag: "InvalidParamsError";
321
+ readonly _tag: "ConversationFull";
450
322
  readonly data?: unknown;
451
323
  readonly message?: string | undefined;
452
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/rpc").UnauthorizedError, {
324
+ }, never> | Schema.Schema<import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/rpc").UnauthorizedError, {
453
325
  readonly _tag: "Unauthorized";
454
326
  readonly data?: unknown;
455
327
  readonly message?: string | undefined;
@@ -458,15 +330,32 @@ export declare const messagesListCommandRpc: Rpc.Rpc<"cli/messages/list", Schema
458
330
  readonly data?: unknown;
459
331
  readonly message?: string | undefined;
460
332
  } | {
461
- readonly _tag: "TaskNotFound";
333
+ readonly _tag: "HookBlocked";
462
334
  readonly data?: unknown;
463
335
  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";
336
+ } | {
337
+ readonly _tag: "DispatchNotFound";
466
338
  readonly data?: unknown;
467
339
  readonly message?: string | undefined;
468
- } | {
469
- readonly _tag: "Forbidden";
340
+ }, never>)[]]>, never>;
341
+ /** Provides the start command rpc runtime value. */
342
+ export declare const startCommandRpc: Rpc.Rpc<"cli/start", Schema.Struct<{
343
+ name: Schema.filter<Schema.filter<typeof Schema.String>>;
344
+ participants: Schema.Array$<Schema.transformOrFail<typeof Schema.String, Schema.Union<[Schema.Struct<{
345
+ kind: Schema.Literal<["id"]>;
346
+ id: Schema.Schema<import("@moltzap/protocol/identity").AgentId, string, never>;
347
+ }>, Schema.Struct<{
348
+ kind: Schema.Literal<["name"]>;
349
+ token: typeof Schema.String;
350
+ name: Schema.filter<Schema.filter<typeof Schema.String>>;
351
+ }>]>, never>>;
352
+ message: Schema.optional<typeof Schema.String>;
353
+ appId: Schema.optional<Schema.filter<Schema.Schema<import("@moltzap/protocol/identity").AppId, string, never>>>;
354
+ }>, Schema.Struct<{
355
+ conversationId: Schema.Schema<import("@moltzap/protocol/conversation").ConversationId, string, never>;
356
+ sentMessageId: Schema.optional<Schema.Schema<import("@moltzap/protocol/conversation").MessageId, string, never>>;
357
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartUsageError, typeof StartPartialFailure, 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, {
358
+ readonly _tag: "Unauthorized";
470
359
  readonly data?: unknown;
471
360
  readonly message?: string | undefined;
472
361
  } | {
@@ -474,10 +363,20 @@ export declare const messagesListCommandRpc: Rpc.Rpc<"cli/messages/list", Schema
474
363
  readonly data?: unknown;
475
364
  readonly message?: string | undefined;
476
365
  } | {
477
- readonly _tag: "ConversationNotFound";
366
+ readonly _tag: "ProtocolMismatchError";
367
+ readonly data: {
368
+ readonly clientMaxProtocol: string;
369
+ readonly clientMinProtocol: string;
370
+ readonly reason: "server-above-client-max" | "server-below-client-min";
371
+ readonly serverVersion: string;
372
+ };
373
+ readonly message?: string | undefined;
374
+ } | {
375
+ readonly _tag: "AlreadyConnected";
478
376
  readonly data?: unknown;
479
377
  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, {
378
+ readonly principal: "agent" | "app";
379
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
481
380
  readonly _tag: "Unauthorized";
482
381
  readonly data?: unknown;
483
382
  readonly message?: string | undefined;
@@ -485,23 +384,27 @@ export declare const messagesListCommandRpc: Rpc.Rpc<"cli/messages/list", Schema
485
384
  readonly _tag: "Forbidden";
486
385
  readonly data?: unknown;
487
386
  readonly message?: string | undefined;
488
- } | {
489
- readonly _tag: "NotInContacts";
387
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
388
+ readonly _tag: "Unauthorized";
490
389
  readonly data?: unknown;
491
390
  readonly message?: string | undefined;
492
391
  } | {
493
- readonly _tag: "AgentNotFound";
392
+ readonly _tag: "Forbidden";
393
+ readonly data?: unknown;
394
+ readonly message?: string | undefined;
395
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
396
+ readonly _tag: "Unauthorized";
494
397
  readonly data?: unknown;
495
398
  readonly message?: string | undefined;
496
399
  } | {
497
- readonly _tag: "TaskRejected";
400
+ readonly _tag: "Forbidden";
498
401
  readonly data?: unknown;
499
402
  readonly message?: string | undefined;
500
403
  } | {
501
- readonly _tag: "ConversationFull";
404
+ readonly _tag: "InvalidParamsError";
502
405
  readonly data?: unknown;
503
406
  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, {
407
+ }, never> | Schema.Schema<import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
505
408
  readonly _tag: "Unauthorized";
506
409
  readonly data?: unknown;
507
410
  readonly message?: string | undefined;
@@ -510,14 +413,14 @@ export declare const messagesListCommandRpc: Rpc.Rpc<"cli/messages/list", Schema
510
413
  readonly data?: unknown;
511
414
  readonly message?: string | undefined;
512
415
  } | {
513
- readonly _tag: "TaskNotFound";
416
+ readonly _tag: "InvalidParamsError";
514
417
  readonly data?: unknown;
515
418
  readonly message?: string | undefined;
516
419
  } | {
517
420
  readonly _tag: "ConversationNotFound";
518
421
  readonly data?: unknown;
519
422
  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, {
423
+ }, never> | Schema.Schema<import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/conversation").ConversationFullError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
521
424
  readonly _tag: "Unauthorized";
522
425
  readonly data?: unknown;
523
426
  readonly message?: string | undefined;
@@ -526,41 +429,49 @@ export declare const messagesListCommandRpc: Rpc.Rpc<"cli/messages/list", Schema
526
429
  readonly data?: unknown;
527
430
  readonly message?: string | undefined;
528
431
  } | {
529
- readonly _tag: "ConversationNotFound";
432
+ readonly _tag: "AgentNotFound";
530
433
  readonly data?: unknown;
531
434
  readonly message?: string | undefined;
532
435
  } | {
533
- readonly _tag: "HookBlocked";
436
+ readonly _tag: "ConversationFull";
534
437
  readonly data?: unknown;
535
438
  readonly message?: string | undefined;
536
- } | {
537
- readonly _tag: "MessageNotFound";
439
+ }, never> | Schema.Schema<import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/rpc").UnauthorizedError, {
440
+ readonly _tag: "Unauthorized";
538
441
  readonly data?: unknown;
539
442
  readonly message?: string | undefined;
540
443
  } | {
541
- readonly _tag: "DispatchNotFound";
444
+ readonly _tag: "Forbidden";
542
445
  readonly data?: unknown;
543
446
  readonly message?: string | undefined;
544
447
  } | {
545
- readonly _tag: "TaskClosed";
448
+ readonly _tag: "HookBlocked";
546
449
  readonly data?: unknown;
547
450
  readonly message?: string | undefined;
548
451
  } | {
549
- readonly _tag: "ConversationArchived";
452
+ readonly _tag: "DispatchNotFound";
550
453
  readonly data?: unknown;
551
454
  readonly message?: string | undefined;
552
455
  }, never>)[]]>, never>;
553
- /** Provides the send command rpc runtime value. */
554
- export declare const sendCommandRpc: Rpc.Rpc<"cli/send", Schema.Struct<{
555
- target: Schema.transformOrFail<typeof Schema.String, Schema.Struct<{
556
- taskId: Schema.Schema<import("@moltzap/protocol/task").TaskId, string, never>;
557
- conversationId: Schema.Schema<import("@moltzap/protocol/conversation").ConversationId, string, never>;
558
- }>, never>;
559
- message: Schema.filter<typeof Schema.String>;
560
- replyToId: Schema.optional<Schema.Schema<import("@moltzap/protocol/conversation").MessageId, string, never>>;
456
+ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list", Schema.Struct<{
457
+ limit: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>>;
561
458
  }>, Schema.Struct<{
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").AlreadyConnected | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").UnauthorizedError, {
459
+ agents: Schema.Array$<Schema.Struct<{
460
+ id: Schema.Schema<import("@moltzap/protocol/identity").AgentId, string, never>;
461
+ ownerUserId: Schema.optional<Schema.Schema<import("@moltzap/protocol/identity").UserId, string, never>>;
462
+ name: Schema.Schema<import("@moltzap/protocol/identity").AgentName, string, never>;
463
+ displayName: Schema.optional<typeof Schema.String>;
464
+ description: Schema.optional<typeof Schema.String>;
465
+ agentType: Schema.optional<Schema.Schema<"NanoClaw" | "OpenClaw", "NanoClaw" | "OpenClaw", never>>;
466
+ metadata: Schema.optional<Schema.Struct<{
467
+ purpose: Schema.optional<Schema.Array$<typeof Schema.String>>;
468
+ description: Schema.optional<typeof Schema.String>;
469
+ tags: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
470
+ }>>;
471
+ status: Schema.Schema<"active" | "suspended", "active" | "suspended", never>;
472
+ }>>;
473
+ nextCursor: Schema.optional<Schema.Schema<import("@moltzap/protocol/rpc").ListCursor, string, never>>;
474
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartUsageError, typeof StartPartialFailure, 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
475
  readonly _tag: "Unauthorized";
565
476
  readonly data?: unknown;
566
477
  readonly message?: string | undefined;
@@ -582,7 +493,7 @@ export declare const sendCommandRpc: Rpc.Rpc<"cli/send", Schema.Struct<{
582
493
  readonly data?: unknown;
583
494
  readonly message?: string | undefined;
584
495
  readonly principal: "agent" | "app";
585
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
496
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
586
497
  readonly _tag: "Unauthorized";
587
498
  readonly data?: unknown;
588
499
  readonly message?: string | undefined;
@@ -590,11 +501,15 @@ export declare const sendCommandRpc: Rpc.Rpc<"cli/send", Schema.Struct<{
590
501
  readonly _tag: "Forbidden";
591
502
  readonly data?: unknown;
592
503
  readonly message?: string | undefined;
504
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
505
+ readonly _tag: "Unauthorized";
506
+ readonly data?: unknown;
507
+ readonly message?: string | undefined;
593
508
  } | {
594
- readonly _tag: "InvalidParamsError";
509
+ readonly _tag: "Forbidden";
595
510
  readonly data?: unknown;
596
511
  readonly message?: string | undefined;
597
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
512
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
598
513
  readonly _tag: "Unauthorized";
599
514
  readonly data?: unknown;
600
515
  readonly message?: string | undefined;
@@ -603,10 +518,10 @@ export declare const sendCommandRpc: Rpc.Rpc<"cli/send", Schema.Struct<{
603
518
  readonly data?: unknown;
604
519
  readonly message?: string | undefined;
605
520
  } | {
606
- readonly _tag: "NotInContacts";
521
+ readonly _tag: "InvalidParamsError";
607
522
  readonly data?: unknown;
608
523
  readonly message?: string | undefined;
609
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
524
+ }, never> | Schema.Schema<import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
610
525
  readonly _tag: "Unauthorized";
611
526
  readonly data?: unknown;
612
527
  readonly message?: string | undefined;
@@ -618,11 +533,11 @@ export declare const sendCommandRpc: Rpc.Rpc<"cli/send", Schema.Struct<{
618
533
  readonly _tag: "InvalidParamsError";
619
534
  readonly data?: unknown;
620
535
  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";
536
+ } | {
537
+ readonly _tag: "ConversationNotFound";
623
538
  readonly data?: unknown;
624
539
  readonly message?: string | undefined;
625
- } | {
540
+ }, never> | Schema.Schema<import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/conversation").ConversationFullError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
626
541
  readonly _tag: "Unauthorized";
627
542
  readonly data?: unknown;
628
543
  readonly message?: string | undefined;
@@ -630,19 +545,15 @@ export declare const sendCommandRpc: Rpc.Rpc<"cli/send", Schema.Struct<{
630
545
  readonly _tag: "Forbidden";
631
546
  readonly data?: unknown;
632
547
  readonly message?: string | undefined;
633
- }, never> | Schema.Schema<import("@moltzap/protocol/identity").ContactNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
634
- readonly _tag: "Unauthorized";
635
- readonly data?: unknown;
636
- readonly message?: string | undefined;
637
548
  } | {
638
- readonly _tag: "Forbidden";
549
+ readonly _tag: "AgentNotFound";
639
550
  readonly data?: unknown;
640
551
  readonly message?: string | undefined;
641
552
  } | {
642
- readonly _tag: "ContactNotFound";
553
+ readonly _tag: "ConversationFull";
643
554
  readonly data?: unknown;
644
555
  readonly message?: string | undefined;
645
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
556
+ }, never> | Schema.Schema<import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/rpc").UnauthorizedError, {
646
557
  readonly _tag: "Unauthorized";
647
558
  readonly data?: unknown;
648
559
  readonly message?: string | undefined;
@@ -650,143 +561,38 @@ export declare const sendCommandRpc: Rpc.Rpc<"cli/send", Schema.Struct<{
650
561
  readonly _tag: "Forbidden";
651
562
  readonly data?: unknown;
652
563
  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";
655
- readonly data?: unknown;
656
- readonly message?: string | undefined;
657
564
  } | {
658
- readonly _tag: "Forbidden";
565
+ readonly _tag: "HookBlocked";
659
566
  readonly data?: unknown;
660
567
  readonly message?: string | undefined;
661
568
  } | {
662
- readonly _tag: "InvalidParamsError";
569
+ readonly _tag: "DispatchNotFound";
663
570
  readonly data?: unknown;
664
571
  readonly message?: string | undefined;
665
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/rpc").UnauthorizedError, {
572
+ }, never>)[]]>, never> | Rpc.Rpc<"cli/agents/search", Schema.Struct<{
573
+ names: Schema.filter<Schema.filter<Schema.Array$<Schema.filter<Schema.filter<typeof Schema.String>>>>>;
574
+ }>, Schema.Struct<{
575
+ agents: Schema.Array$<Schema.Struct<{
576
+ id: Schema.Schema<import("@moltzap/protocol/identity").AgentId, string, never>;
577
+ ownerUserId: Schema.optional<Schema.Schema<import("@moltzap/protocol/identity").UserId, string, never>>;
578
+ name: Schema.Schema<import("@moltzap/protocol/identity").AgentName, string, never>;
579
+ displayName: Schema.optional<typeof Schema.String>;
580
+ description: Schema.optional<typeof Schema.String>;
581
+ agentType: Schema.optional<Schema.Schema<"NanoClaw" | "OpenClaw", "NanoClaw" | "OpenClaw", never>>;
582
+ metadata: Schema.optional<Schema.Struct<{
583
+ purpose: Schema.optional<Schema.Array$<typeof Schema.String>>;
584
+ description: Schema.optional<typeof Schema.String>;
585
+ tags: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
586
+ }>>;
587
+ status: Schema.Schema<"active" | "suspended", "active" | "suspended", never>;
588
+ }>>;
589
+ nextCursor: Schema.optional<Schema.Schema<import("@moltzap/protocol/rpc").ListCursor, string, never>>;
590
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartUsageError, typeof StartPartialFailure, 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, {
666
591
  readonly _tag: "Unauthorized";
667
592
  readonly data?: unknown;
668
593
  readonly message?: string | undefined;
669
594
  } | {
670
- readonly _tag: "Forbidden";
671
- readonly data?: unknown;
672
- readonly message?: string | undefined;
673
- } | {
674
- readonly _tag: "TaskNotFound";
675
- readonly data?: unknown;
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";
679
- readonly data?: unknown;
680
- readonly message?: string | undefined;
681
- } | {
682
- readonly _tag: "Forbidden";
683
- readonly data?: unknown;
684
- readonly message?: string | undefined;
685
- } | {
686
- readonly _tag: "InvalidParamsError";
687
- readonly data?: unknown;
688
- readonly message?: string | undefined;
689
- } | {
690
- readonly _tag: "ConversationNotFound";
691
- readonly data?: unknown;
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";
695
- readonly data?: unknown;
696
- readonly message?: string | undefined;
697
- } | {
698
- readonly _tag: "Forbidden";
699
- readonly data?: unknown;
700
- readonly message?: string | undefined;
701
- } | {
702
- readonly _tag: "NotInContacts";
703
- readonly data?: unknown;
704
- readonly message?: string | undefined;
705
- } | {
706
- readonly _tag: "AgentNotFound";
707
- readonly data?: unknown;
708
- readonly message?: string | undefined;
709
- } | {
710
- readonly _tag: "TaskRejected";
711
- readonly data?: unknown;
712
- readonly message?: string | undefined;
713
- } | {
714
- readonly _tag: "ConversationFull";
715
- readonly data?: unknown;
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";
719
- readonly data?: unknown;
720
- readonly message?: string | undefined;
721
- } | {
722
- readonly _tag: "Forbidden";
723
- readonly data?: unknown;
724
- readonly message?: string | undefined;
725
- } | {
726
- readonly _tag: "TaskNotFound";
727
- readonly data?: unknown;
728
- readonly message?: string | undefined;
729
- } | {
730
- readonly _tag: "ConversationNotFound";
731
- readonly data?: unknown;
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";
735
- readonly data?: unknown;
736
- readonly message?: string | undefined;
737
- } | {
738
- readonly _tag: "Forbidden";
739
- readonly data?: unknown;
740
- readonly message?: string | undefined;
741
- } | {
742
- readonly _tag: "ConversationNotFound";
743
- readonly data?: unknown;
744
- readonly message?: string | undefined;
745
- } | {
746
- readonly _tag: "HookBlocked";
747
- readonly data?: unknown;
748
- readonly message?: string | undefined;
749
- } | {
750
- readonly _tag: "MessageNotFound";
751
- readonly data?: unknown;
752
- readonly message?: string | undefined;
753
- } | {
754
- readonly _tag: "DispatchNotFound";
755
- readonly data?: unknown;
756
- readonly message?: string | undefined;
757
- } | {
758
- readonly _tag: "TaskClosed";
759
- readonly data?: unknown;
760
- readonly message?: string | undefined;
761
- } | {
762
- readonly _tag: "ConversationArchived";
763
- readonly data?: unknown;
764
- readonly message?: string | undefined;
765
- }, never>)[]]>, never>;
766
- /** Provides the start task command rpc runtime value. */
767
- export declare const startTaskCommandRpc: Rpc.Rpc<"cli/start-task", Schema.Struct<{
768
- name: Schema.filter<Schema.filter<typeof Schema.String>>;
769
- participants: Schema.Array$<Schema.transformOrFail<typeof Schema.String, Schema.Union<[Schema.Struct<{
770
- kind: Schema.Literal<["id"]>;
771
- id: Schema.Schema<import("@moltzap/protocol/identity").AgentId, string, never>;
772
- }>, Schema.Struct<{
773
- kind: Schema.Literal<["name"]>;
774
- token: typeof Schema.String;
775
- name: Schema.filter<Schema.filter<typeof Schema.String>>;
776
- }>]>, never>>;
777
- message: Schema.optional<typeof Schema.String>;
778
- appId: Schema.optional<Schema.filter<Schema.Schema<import("@moltzap/protocol/identity").AppId, string, never>>>;
779
- }>, Schema.Struct<{
780
- taskId: Schema.Schema<import("@moltzap/protocol/task").TaskId, string, never>;
781
- conversationId: Schema.Schema<import("@moltzap/protocol/conversation").ConversationId, string, never>;
782
- reusedConversation: typeof Schema.Boolean;
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").AlreadyConnected | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/network").ProtocolMismatchError | import("@moltzap/protocol/rpc").UnauthorizedError, {
785
- readonly _tag: "Unauthorized";
786
- readonly data?: unknown;
787
- readonly message?: string | undefined;
788
- } | {
789
- readonly _tag: "InvalidParamsError";
595
+ readonly _tag: "InvalidParamsError";
790
596
  readonly data?: unknown;
791
597
  readonly message?: string | undefined;
792
598
  } | {
@@ -803,55 +609,7 @@ export declare const startTaskCommandRpc: Rpc.Rpc<"cli/start-task", Schema.Struc
803
609
  readonly data?: unknown;
804
610
  readonly message?: string | undefined;
805
611
  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";
808
- readonly data?: unknown;
809
- readonly message?: string | undefined;
810
- } | {
811
- readonly _tag: "Forbidden";
812
- readonly data?: unknown;
813
- readonly message?: string | undefined;
814
- } | {
815
- readonly _tag: "InvalidParamsError";
816
- readonly data?: unknown;
817
- readonly message?: string | undefined;
818
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
819
- readonly _tag: "Unauthorized";
820
- readonly data?: unknown;
821
- readonly message?: string | undefined;
822
- } | {
823
- readonly _tag: "Forbidden";
824
- readonly data?: unknown;
825
- readonly message?: string | undefined;
826
- } | {
827
- readonly _tag: "NotInContacts";
828
- readonly data?: unknown;
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";
832
- readonly data?: unknown;
833
- readonly message?: string | undefined;
834
- } | {
835
- readonly _tag: "Forbidden";
836
- readonly data?: unknown;
837
- readonly message?: string | undefined;
838
- } | {
839
- readonly _tag: "InvalidParamsError";
840
- readonly data?: unknown;
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";
844
- readonly data?: unknown;
845
- readonly message?: string | undefined;
846
- } | {
847
- readonly _tag: "Unauthorized";
848
- readonly data?: unknown;
849
- readonly message?: string | undefined;
850
- } | {
851
- readonly _tag: "Forbidden";
852
- readonly data?: unknown;
853
- readonly message?: string | undefined;
854
- }, never> | Schema.Schema<import("@moltzap/protocol/identity").ContactNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
612
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
855
613
  readonly _tag: "Unauthorized";
856
614
  readonly data?: unknown;
857
615
  readonly message?: string | undefined;
@@ -859,10 +617,6 @@ export declare const startTaskCommandRpc: Rpc.Rpc<"cli/start-task", Schema.Struc
859
617
  readonly _tag: "Forbidden";
860
618
  readonly data?: unknown;
861
619
  readonly message?: string | undefined;
862
- } | {
863
- readonly _tag: "ContactNotFound";
864
- readonly data?: unknown;
865
- readonly message?: string | undefined;
866
620
  }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
867
621
  readonly _tag: "Unauthorized";
868
622
  readonly data?: unknown;
@@ -883,18 +637,6 @@ export declare const startTaskCommandRpc: Rpc.Rpc<"cli/start-task", Schema.Struc
883
637
  readonly _tag: "InvalidParamsError";
884
638
  readonly data?: unknown;
885
639
  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";
888
- readonly data?: unknown;
889
- readonly message?: string | undefined;
890
- } | {
891
- readonly _tag: "Forbidden";
892
- readonly data?: unknown;
893
- readonly message?: string | undefined;
894
- } | {
895
- readonly _tag: "TaskNotFound";
896
- readonly data?: unknown;
897
- readonly message?: string | undefined;
898
640
  }, never> | Schema.Schema<import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
899
641
  readonly _tag: "Unauthorized";
900
642
  readonly data?: unknown;
@@ -911,7 +653,7 @@ export declare const startTaskCommandRpc: Rpc.Rpc<"cli/start-task", Schema.Struc
911
653
  readonly _tag: "ConversationNotFound";
912
654
  readonly data?: unknown;
913
655
  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, {
656
+ }, never> | Schema.Schema<import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/conversation").ConversationFullError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
915
657
  readonly _tag: "Unauthorized";
916
658
  readonly data?: unknown;
917
659
  readonly message?: string | undefined;
@@ -919,39 +661,15 @@ export declare const startTaskCommandRpc: Rpc.Rpc<"cli/start-task", Schema.Struc
919
661
  readonly _tag: "Forbidden";
920
662
  readonly data?: unknown;
921
663
  readonly message?: string | undefined;
922
- } | {
923
- readonly _tag: "NotInContacts";
924
- readonly data?: unknown;
925
- readonly message?: string | undefined;
926
664
  } | {
927
665
  readonly _tag: "AgentNotFound";
928
666
  readonly data?: unknown;
929
667
  readonly message?: string | undefined;
930
- } | {
931
- readonly _tag: "TaskRejected";
932
- readonly data?: unknown;
933
- readonly message?: string | undefined;
934
668
  } | {
935
669
  readonly _tag: "ConversationFull";
936
670
  readonly data?: unknown;
937
671
  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";
940
- readonly data?: unknown;
941
- readonly message?: string | undefined;
942
- } | {
943
- readonly _tag: "Forbidden";
944
- readonly data?: unknown;
945
- readonly message?: string | undefined;
946
- } | {
947
- readonly _tag: "TaskNotFound";
948
- readonly data?: unknown;
949
- readonly message?: string | undefined;
950
- } | {
951
- readonly _tag: "ConversationNotFound";
952
- readonly data?: unknown;
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, {
672
+ }, never> | Schema.Schema<import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/rpc").UnauthorizedError, {
955
673
  readonly _tag: "Unauthorized";
956
674
  readonly data?: unknown;
957
675
  readonly message?: string | undefined;
@@ -959,50 +677,42 @@ export declare const startTaskCommandRpc: Rpc.Rpc<"cli/start-task", Schema.Struc
959
677
  readonly _tag: "Forbidden";
960
678
  readonly data?: unknown;
961
679
  readonly message?: string | undefined;
962
- } | {
963
- readonly _tag: "ConversationNotFound";
964
- readonly data?: unknown;
965
- readonly message?: string | undefined;
966
680
  } | {
967
681
  readonly _tag: "HookBlocked";
968
682
  readonly data?: unknown;
969
683
  readonly message?: string | undefined;
970
- } | {
971
- readonly _tag: "MessageNotFound";
972
- readonly data?: unknown;
973
- readonly message?: string | undefined;
974
684
  } | {
975
685
  readonly _tag: "DispatchNotFound";
976
686
  readonly data?: unknown;
977
687
  readonly message?: string | undefined;
978
- } | {
979
- readonly _tag: "TaskClosed";
980
- readonly data?: unknown;
981
- readonly message?: string | undefined;
982
- } | {
983
- readonly _tag: "ConversationArchived";
984
- readonly data?: unknown;
985
- readonly message?: string | undefined;
986
- }, never>)[]]>, never>;
987
- declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list", Schema.Struct<{
688
+ }, never>)[]]>, never> | Rpc.Rpc<"cli/messages/list", Schema.Struct<{
689
+ conversationId: Schema.Schema<import("@moltzap/protocol/conversation").ConversationId, string, never>;
988
690
  limit: Schema.optional<Schema.filter<Schema.filter<Schema.filter<typeof Schema.Number>>>>;
989
691
  }>, 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>;
692
+ messages: Schema.Array$<Schema.Struct<{
693
+ id: Schema.Schema<import("@moltzap/protocol/conversation").MessageId, string, never>;
694
+ conversationId: Schema.Schema<import("@moltzap/protocol/conversation").ConversationId, string, never>;
695
+ taskId: Schema.optional<Schema.Schema<import("@moltzap/protocol/task").TaskId, string, never>>;
696
+ senderId: Schema.Schema<import("@moltzap/protocol/identity").AgentId, string, never>;
697
+ parts: Schema.filter<Schema.NonEmptyArray<Schema.Union<[Schema.Struct<{
698
+ type: Schema.Literal<["text"]>;
699
+ text: Schema.filter<Schema.filter<typeof Schema.String>>;
700
+ }>, Schema.Struct<{
701
+ type: Schema.Literal<["image"]>;
702
+ url: Schema.filter<Schema.Schema<string, string, never>>;
703
+ altText: Schema.optional<Schema.filter<typeof Schema.String>>;
704
+ }>, Schema.Struct<{
705
+ type: Schema.Literal<["file"]>;
706
+ url: Schema.filter<Schema.Schema<string, string, never>>;
707
+ name: Schema.filter<Schema.filter<typeof Schema.String>>;
708
+ mimeType: Schema.optional<Schema.filter<Schema.filter<typeof Schema.String>>>;
709
+ size: Schema.optional<Schema.filter<Schema.filter<typeof Schema.Number>>>;
710
+ }>]>>>;
711
+ taggedEntities: Schema.optional<Schema.Array$<Schema.Schema<import("@moltzap/protocol/identity").AgentId, string, never>>>;
712
+ patchedBy: Schema.optional<typeof Schema.String>;
713
+ createdAt: Schema.Schema<string, string, never>;
1003
714
  }>>;
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, {
715
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartUsageError, typeof StartPartialFailure, 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
716
  readonly _tag: "Unauthorized";
1007
717
  readonly data?: unknown;
1008
718
  readonly message?: string | undefined;
@@ -1024,1633 +734,15 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
1024
734
  readonly data?: unknown;
1025
735
  readonly message?: string | undefined;
1026
736
  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";
1029
- readonly data?: unknown;
1030
- readonly message?: string | undefined;
1031
- } | {
1032
- readonly _tag: "Forbidden";
1033
- readonly data?: unknown;
1034
- readonly message?: string | undefined;
1035
- } | {
1036
- readonly _tag: "InvalidParamsError";
1037
- readonly data?: unknown;
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";
1041
- readonly data?: unknown;
1042
- readonly message?: string | undefined;
1043
- } | {
1044
- readonly _tag: "Forbidden";
1045
- readonly data?: unknown;
1046
- readonly message?: string | undefined;
1047
- } | {
1048
- readonly _tag: "NotInContacts";
1049
- readonly data?: unknown;
1050
- readonly message?: string | undefined;
1051
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
737
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
1052
738
  readonly _tag: "Unauthorized";
1053
739
  readonly data?: unknown;
1054
740
  readonly message?: string | undefined;
1055
741
  } | {
1056
- readonly _tag: "Forbidden";
1057
- readonly data?: unknown;
1058
- readonly message?: string | undefined;
1059
- } | {
1060
- readonly _tag: "InvalidParamsError";
1061
- readonly data?: unknown;
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";
1065
- readonly data?: unknown;
1066
- readonly message?: string | undefined;
1067
- } | {
1068
- readonly _tag: "Unauthorized";
1069
- readonly data?: unknown;
1070
- readonly message?: string | undefined;
1071
- } | {
1072
- readonly _tag: "Forbidden";
1073
- readonly data?: unknown;
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";
1077
- readonly data?: unknown;
1078
- readonly message?: string | undefined;
1079
- } | {
1080
- readonly _tag: "Forbidden";
1081
- readonly data?: unknown;
1082
- readonly message?: string | undefined;
1083
- } | {
1084
- readonly _tag: "ContactNotFound";
1085
- readonly data?: unknown;
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";
1093
- readonly data?: unknown;
1094
- readonly message?: string | undefined;
1095
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
1096
- readonly _tag: "Unauthorized";
1097
- readonly data?: unknown;
1098
- readonly message?: string | undefined;
1099
- } | {
1100
- readonly _tag: "Forbidden";
1101
- readonly data?: unknown;
1102
- readonly message?: string | undefined;
1103
- } | {
1104
- readonly _tag: "InvalidParamsError";
1105
- readonly data?: unknown;
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";
1109
- readonly data?: unknown;
1110
- readonly message?: string | undefined;
1111
- } | {
1112
- readonly _tag: "Forbidden";
1113
- readonly data?: unknown;
1114
- readonly message?: string | undefined;
1115
- } | {
1116
- readonly _tag: "TaskNotFound";
1117
- readonly data?: unknown;
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";
1121
- readonly data?: unknown;
1122
- readonly message?: string | undefined;
1123
- } | {
1124
- readonly _tag: "Forbidden";
1125
- readonly data?: unknown;
1126
- readonly message?: string | undefined;
1127
- } | {
1128
- readonly _tag: "InvalidParamsError";
1129
- readonly data?: unknown;
1130
- readonly message?: string | undefined;
1131
- } | {
1132
- readonly _tag: "ConversationNotFound";
1133
- readonly data?: unknown;
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";
1137
- readonly data?: unknown;
1138
- readonly message?: string | undefined;
1139
- } | {
1140
- readonly _tag: "Forbidden";
1141
- readonly data?: unknown;
1142
- readonly message?: string | undefined;
1143
- } | {
1144
- readonly _tag: "NotInContacts";
1145
- readonly data?: unknown;
1146
- readonly message?: string | undefined;
1147
- } | {
1148
- readonly _tag: "AgentNotFound";
1149
- readonly data?: unknown;
1150
- readonly message?: string | undefined;
1151
- } | {
1152
- readonly _tag: "TaskRejected";
1153
- readonly data?: unknown;
1154
- readonly message?: string | undefined;
1155
- } | {
1156
- readonly _tag: "ConversationFull";
1157
- readonly data?: unknown;
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";
1161
- readonly data?: unknown;
1162
- readonly message?: string | undefined;
1163
- } | {
1164
- readonly _tag: "Forbidden";
1165
- readonly data?: unknown;
1166
- readonly message?: string | undefined;
1167
- } | {
1168
- readonly _tag: "TaskNotFound";
1169
- readonly data?: unknown;
1170
- readonly message?: string | undefined;
1171
- } | {
1172
- readonly _tag: "ConversationNotFound";
1173
- readonly data?: unknown;
1174
- readonly message?: string | undefined;
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, {
1176
- readonly _tag: "Unauthorized";
1177
- readonly data?: unknown;
1178
- readonly message?: string | undefined;
1179
- } | {
1180
- readonly _tag: "Forbidden";
1181
- readonly data?: unknown;
1182
- readonly message?: string | undefined;
1183
- } | {
1184
- readonly _tag: "ConversationNotFound";
1185
- readonly data?: unknown;
1186
- readonly message?: string | undefined;
1187
- } | {
1188
- readonly _tag: "HookBlocked";
1189
- readonly data?: unknown;
1190
- readonly message?: string | undefined;
1191
- } | {
1192
- readonly _tag: "MessageNotFound";
1193
- readonly data?: unknown;
1194
- readonly message?: string | undefined;
1195
- } | {
1196
- readonly _tag: "DispatchNotFound";
1197
- readonly data?: unknown;
1198
- readonly message?: string | undefined;
1199
- } | {
1200
- readonly _tag: "TaskClosed";
1201
- readonly data?: unknown;
1202
- readonly message?: string | undefined;
1203
- } | {
1204
- readonly _tag: "ConversationArchived";
1205
- readonly data?: unknown;
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";
1227
- readonly data?: unknown;
1228
- readonly message?: string | undefined;
1229
- } | {
1230
- readonly _tag: "InvalidParamsError";
1231
- readonly data?: unknown;
1232
- readonly message?: string | undefined;
1233
- } | {
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
- };
1241
- readonly message?: string | undefined;
1242
- } | {
1243
- readonly _tag: "AlreadyConnected";
1244
- readonly data?: unknown;
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";
1249
- readonly data?: unknown;
1250
- readonly message?: string | undefined;
1251
- } | {
1252
- readonly _tag: "Forbidden";
1253
- readonly data?: unknown;
1254
- readonly message?: string | undefined;
1255
- } | {
1256
- readonly _tag: "InvalidParamsError";
1257
- readonly data?: unknown;
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";
1261
- readonly data?: unknown;
1262
- readonly message?: string | undefined;
1263
- } | {
1264
- readonly _tag: "Forbidden";
1265
- readonly data?: unknown;
1266
- readonly message?: string | undefined;
1267
- } | {
1268
- readonly _tag: "NotInContacts";
1269
- readonly data?: unknown;
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";
1273
- readonly data?: unknown;
1274
- readonly message?: string | undefined;
1275
- } | {
1276
- readonly _tag: "Forbidden";
1277
- readonly data?: unknown;
1278
- readonly message?: string | undefined;
1279
- } | {
1280
- readonly _tag: "InvalidParamsError";
1281
- readonly data?: unknown;
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";
1285
- readonly data?: unknown;
1286
- readonly message?: string | undefined;
1287
- } | {
1288
- readonly _tag: "Unauthorized";
1289
- readonly data?: unknown;
1290
- readonly message?: string | undefined;
1291
- } | {
1292
- readonly _tag: "Forbidden";
1293
- readonly data?: unknown;
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";
1297
- readonly data?: unknown;
1298
- readonly message?: string | undefined;
1299
- } | {
1300
- readonly _tag: "Forbidden";
1301
- readonly data?: unknown;
1302
- readonly message?: string | undefined;
1303
- } | {
1304
- readonly _tag: "ContactNotFound";
1305
- readonly data?: unknown;
1306
- readonly message?: string | undefined;
1307
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
1308
- readonly _tag: "Unauthorized";
1309
- readonly data?: unknown;
1310
- readonly message?: string | undefined;
1311
- } | {
1312
- readonly _tag: "Forbidden";
1313
- readonly data?: unknown;
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";
1317
- readonly data?: unknown;
1318
- readonly message?: string | undefined;
1319
- } | {
1320
- readonly _tag: "Forbidden";
1321
- readonly data?: unknown;
1322
- readonly message?: string | undefined;
1323
- } | {
1324
- readonly _tag: "InvalidParamsError";
1325
- readonly data?: unknown;
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";
1329
- readonly data?: unknown;
1330
- readonly message?: string | undefined;
1331
- } | {
1332
- readonly _tag: "Forbidden";
1333
- readonly data?: unknown;
1334
- readonly message?: string | undefined;
1335
- } | {
1336
- readonly _tag: "TaskNotFound";
1337
- readonly data?: unknown;
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";
1341
- readonly data?: unknown;
1342
- readonly message?: string | undefined;
1343
- } | {
1344
- readonly _tag: "Forbidden";
1345
- readonly data?: unknown;
1346
- readonly message?: string | undefined;
1347
- } | {
1348
- readonly _tag: "InvalidParamsError";
1349
- readonly data?: unknown;
1350
- readonly message?: string | undefined;
1351
- } | {
1352
- readonly _tag: "ConversationNotFound";
1353
- readonly data?: unknown;
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";
1357
- readonly data?: unknown;
1358
- readonly message?: string | undefined;
1359
- } | {
1360
- readonly _tag: "Forbidden";
1361
- readonly data?: unknown;
1362
- readonly message?: string | undefined;
1363
- } | {
1364
- readonly _tag: "NotInContacts";
1365
- readonly data?: unknown;
1366
- readonly message?: string | undefined;
1367
- } | {
1368
- readonly _tag: "AgentNotFound";
1369
- readonly data?: unknown;
1370
- readonly message?: string | undefined;
1371
- } | {
1372
- readonly _tag: "TaskRejected";
1373
- readonly data?: unknown;
1374
- readonly message?: string | undefined;
1375
- } | {
1376
- readonly _tag: "ConversationFull";
1377
- readonly data?: unknown;
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";
1381
- readonly data?: unknown;
1382
- readonly message?: string | undefined;
1383
- } | {
1384
- readonly _tag: "Forbidden";
1385
- readonly data?: unknown;
1386
- readonly message?: string | undefined;
1387
- } | {
1388
- readonly _tag: "TaskNotFound";
1389
- readonly data?: unknown;
1390
- readonly message?: string | undefined;
1391
- } | {
1392
- readonly _tag: "ConversationNotFound";
1393
- readonly data?: unknown;
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";
1397
- readonly data?: unknown;
1398
- readonly message?: string | undefined;
1399
- } | {
1400
- readonly _tag: "Forbidden";
1401
- readonly data?: unknown;
1402
- readonly message?: string | undefined;
1403
- } | {
1404
- readonly _tag: "ConversationNotFound";
1405
- readonly data?: unknown;
1406
- readonly message?: string | undefined;
1407
- } | {
1408
- readonly _tag: "HookBlocked";
1409
- readonly data?: unknown;
1410
- readonly message?: string | undefined;
1411
- } | {
1412
- readonly _tag: "MessageNotFound";
1413
- readonly data?: unknown;
1414
- readonly message?: string | undefined;
1415
- } | {
1416
- readonly _tag: "DispatchNotFound";
1417
- readonly data?: unknown;
1418
- readonly message?: string | undefined;
1419
- } | {
1420
- readonly _tag: "TaskClosed";
1421
- readonly data?: unknown;
1422
- readonly message?: string | undefined;
1423
- } | {
1424
- readonly _tag: "ConversationArchived";
1425
- readonly data?: unknown;
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";
1440
- readonly data?: unknown;
1441
- readonly message?: string | undefined;
1442
- } | {
1443
- readonly _tag: "InvalidParamsError";
1444
- readonly data?: unknown;
1445
- readonly message?: string | undefined;
1446
- } | {
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
- };
1454
- readonly message?: string | undefined;
1455
- } | {
1456
- readonly _tag: "AlreadyConnected";
1457
- readonly data?: unknown;
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";
1462
- readonly data?: unknown;
1463
- readonly message?: string | undefined;
1464
- } | {
1465
- readonly _tag: "Forbidden";
1466
- readonly data?: unknown;
1467
- readonly message?: string | undefined;
1468
- } | {
1469
- readonly _tag: "InvalidParamsError";
1470
- readonly data?: unknown;
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";
1474
- readonly data?: unknown;
1475
- readonly message?: string | undefined;
1476
- } | {
1477
- readonly _tag: "Forbidden";
1478
- readonly data?: unknown;
1479
- readonly message?: string | undefined;
1480
- } | {
1481
- readonly _tag: "NotInContacts";
1482
- readonly data?: unknown;
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";
1486
- readonly data?: unknown;
1487
- readonly message?: string | undefined;
1488
- } | {
1489
- readonly _tag: "Forbidden";
1490
- readonly data?: unknown;
1491
- readonly message?: string | undefined;
1492
- } | {
1493
- readonly _tag: "InvalidParamsError";
1494
- readonly data?: unknown;
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";
1498
- readonly data?: unknown;
1499
- readonly message?: string | undefined;
1500
- } | {
1501
- readonly _tag: "Unauthorized";
1502
- readonly data?: unknown;
1503
- readonly message?: string | undefined;
1504
- } | {
1505
- readonly _tag: "Forbidden";
1506
- readonly data?: unknown;
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";
1510
- readonly data?: unknown;
1511
- readonly message?: string | undefined;
1512
- } | {
1513
- readonly _tag: "Forbidden";
1514
- readonly data?: unknown;
1515
- readonly message?: string | undefined;
1516
- } | {
1517
- readonly _tag: "ContactNotFound";
1518
- readonly data?: unknown;
1519
- readonly message?: string | undefined;
1520
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
1521
- readonly _tag: "Unauthorized";
1522
- readonly data?: unknown;
1523
- readonly message?: string | undefined;
1524
- } | {
1525
- readonly _tag: "Forbidden";
1526
- readonly data?: unknown;
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";
1530
- readonly data?: unknown;
1531
- readonly message?: string | undefined;
1532
- } | {
1533
- readonly _tag: "Forbidden";
1534
- readonly data?: unknown;
1535
- readonly message?: string | undefined;
1536
- } | {
1537
- readonly _tag: "InvalidParamsError";
1538
- readonly data?: unknown;
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";
1542
- readonly data?: unknown;
1543
- readonly message?: string | undefined;
1544
- } | {
1545
- readonly _tag: "Forbidden";
1546
- readonly data?: unknown;
1547
- readonly message?: string | undefined;
1548
- } | {
1549
- readonly _tag: "TaskNotFound";
1550
- readonly data?: unknown;
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";
1554
- readonly data?: unknown;
1555
- readonly message?: string | undefined;
1556
- } | {
1557
- readonly _tag: "Forbidden";
1558
- readonly data?: unknown;
1559
- readonly message?: string | undefined;
1560
- } | {
1561
- readonly _tag: "InvalidParamsError";
1562
- readonly data?: unknown;
1563
- readonly message?: string | undefined;
1564
- } | {
1565
- readonly _tag: "ConversationNotFound";
1566
- readonly data?: unknown;
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";
1570
- readonly data?: unknown;
1571
- readonly message?: string | undefined;
1572
- } | {
1573
- readonly _tag: "Forbidden";
1574
- readonly data?: unknown;
1575
- readonly message?: string | undefined;
1576
- } | {
1577
- readonly _tag: "NotInContacts";
1578
- readonly data?: unknown;
1579
- readonly message?: string | undefined;
1580
- } | {
1581
- readonly _tag: "AgentNotFound";
1582
- readonly data?: unknown;
1583
- readonly message?: string | undefined;
1584
- } | {
1585
- readonly _tag: "TaskRejected";
1586
- readonly data?: unknown;
1587
- readonly message?: string | undefined;
1588
- } | {
1589
- readonly _tag: "ConversationFull";
1590
- readonly data?: unknown;
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";
1594
- readonly data?: unknown;
1595
- readonly message?: string | undefined;
1596
- } | {
1597
- readonly _tag: "Forbidden";
1598
- readonly data?: unknown;
1599
- readonly message?: string | undefined;
1600
- } | {
1601
- readonly _tag: "TaskNotFound";
1602
- readonly data?: unknown;
1603
- readonly message?: string | undefined;
1604
- } | {
1605
- readonly _tag: "ConversationNotFound";
1606
- readonly data?: unknown;
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";
1610
- readonly data?: unknown;
1611
- readonly message?: string | undefined;
1612
- } | {
1613
- readonly _tag: "Forbidden";
1614
- readonly data?: unknown;
1615
- readonly message?: string | undefined;
1616
- } | {
1617
- readonly _tag: "ConversationNotFound";
1618
- readonly data?: unknown;
1619
- readonly message?: string | undefined;
1620
- } | {
1621
- readonly _tag: "HookBlocked";
1622
- readonly data?: unknown;
1623
- readonly message?: string | undefined;
1624
- } | {
1625
- readonly _tag: "MessageNotFound";
1626
- readonly data?: unknown;
1627
- readonly message?: string | undefined;
1628
- } | {
1629
- readonly _tag: "DispatchNotFound";
1630
- readonly data?: unknown;
1631
- readonly message?: string | undefined;
1632
- } | {
1633
- readonly _tag: "TaskClosed";
1634
- readonly data?: unknown;
1635
- readonly message?: string | undefined;
1636
- } | {
1637
- readonly _tag: "ConversationArchived";
1638
- readonly data?: unknown;
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";
1653
- readonly data?: unknown;
1654
- readonly message?: string | undefined;
1655
- } | {
1656
- readonly _tag: "InvalidParamsError";
1657
- readonly data?: unknown;
1658
- readonly message?: string | undefined;
1659
- } | {
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
- };
1667
- readonly message?: string | undefined;
1668
- } | {
1669
- readonly _tag: "AlreadyConnected";
1670
- readonly data?: unknown;
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";
1675
- readonly data?: unknown;
1676
- readonly message?: string | undefined;
1677
- } | {
1678
- readonly _tag: "Forbidden";
1679
- readonly data?: unknown;
1680
- readonly message?: string | undefined;
1681
- } | {
1682
- readonly _tag: "InvalidParamsError";
1683
- readonly data?: unknown;
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";
1687
- readonly data?: unknown;
1688
- readonly message?: string | undefined;
1689
- } | {
1690
- readonly _tag: "Forbidden";
1691
- readonly data?: unknown;
1692
- readonly message?: string | undefined;
1693
- } | {
1694
- readonly _tag: "NotInContacts";
1695
- readonly data?: unknown;
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";
1699
- readonly data?: unknown;
1700
- readonly message?: string | undefined;
1701
- } | {
1702
- readonly _tag: "Forbidden";
1703
- readonly data?: unknown;
1704
- readonly message?: string | undefined;
1705
- } | {
1706
- readonly _tag: "InvalidParamsError";
1707
- readonly data?: unknown;
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";
1711
- readonly data?: unknown;
1712
- readonly message?: string | undefined;
1713
- } | {
1714
- readonly _tag: "Unauthorized";
1715
- readonly data?: unknown;
1716
- readonly message?: string | undefined;
1717
- } | {
1718
- readonly _tag: "Forbidden";
1719
- readonly data?: unknown;
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";
1723
- readonly data?: unknown;
1724
- readonly message?: string | undefined;
1725
- } | {
1726
- readonly _tag: "Forbidden";
1727
- readonly data?: unknown;
1728
- readonly message?: string | undefined;
1729
- } | {
1730
- readonly _tag: "ContactNotFound";
1731
- readonly data?: unknown;
1732
- readonly message?: string | undefined;
1733
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
1734
- readonly _tag: "Unauthorized";
1735
- readonly data?: unknown;
1736
- readonly message?: string | undefined;
1737
- } | {
1738
- readonly _tag: "Forbidden";
1739
- readonly data?: unknown;
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";
1743
- readonly data?: unknown;
1744
- readonly message?: string | undefined;
1745
- } | {
1746
- readonly _tag: "Forbidden";
1747
- readonly data?: unknown;
1748
- readonly message?: string | undefined;
1749
- } | {
1750
- readonly _tag: "InvalidParamsError";
1751
- readonly data?: unknown;
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";
1755
- readonly data?: unknown;
1756
- readonly message?: string | undefined;
1757
- } | {
1758
- readonly _tag: "Forbidden";
1759
- readonly data?: unknown;
1760
- readonly message?: string | undefined;
1761
- } | {
1762
- readonly _tag: "TaskNotFound";
1763
- readonly data?: unknown;
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";
1767
- readonly data?: unknown;
1768
- readonly message?: string | undefined;
1769
- } | {
1770
- readonly _tag: "Forbidden";
1771
- readonly data?: unknown;
1772
- readonly message?: string | undefined;
1773
- } | {
1774
- readonly _tag: "InvalidParamsError";
1775
- readonly data?: unknown;
1776
- readonly message?: string | undefined;
1777
- } | {
1778
- readonly _tag: "ConversationNotFound";
1779
- readonly data?: unknown;
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";
1783
- readonly data?: unknown;
1784
- readonly message?: string | undefined;
1785
- } | {
1786
- readonly _tag: "Forbidden";
1787
- readonly data?: unknown;
1788
- readonly message?: string | undefined;
1789
- } | {
1790
- readonly _tag: "NotInContacts";
1791
- readonly data?: unknown;
1792
- readonly message?: string | undefined;
1793
- } | {
1794
- readonly _tag: "AgentNotFound";
1795
- readonly data?: unknown;
1796
- readonly message?: string | undefined;
1797
- } | {
1798
- readonly _tag: "TaskRejected";
1799
- readonly data?: unknown;
1800
- readonly message?: string | undefined;
1801
- } | {
1802
- readonly _tag: "ConversationFull";
1803
- readonly data?: unknown;
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";
1807
- readonly data?: unknown;
1808
- readonly message?: string | undefined;
1809
- } | {
1810
- readonly _tag: "Forbidden";
1811
- readonly data?: unknown;
1812
- readonly message?: string | undefined;
1813
- } | {
1814
- readonly _tag: "TaskNotFound";
1815
- readonly data?: unknown;
1816
- readonly message?: string | undefined;
1817
- } | {
1818
- readonly _tag: "ConversationNotFound";
1819
- readonly data?: unknown;
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";
1823
- readonly data?: unknown;
1824
- readonly message?: string | undefined;
1825
- } | {
1826
- readonly _tag: "Forbidden";
1827
- readonly data?: unknown;
1828
- readonly message?: string | undefined;
1829
- } | {
1830
- readonly _tag: "ConversationNotFound";
1831
- readonly data?: unknown;
1832
- readonly message?: string | undefined;
1833
- } | {
1834
- readonly _tag: "HookBlocked";
1835
- readonly data?: unknown;
1836
- readonly message?: string | undefined;
1837
- } | {
1838
- readonly _tag: "MessageNotFound";
1839
- readonly data?: unknown;
1840
- readonly message?: string | undefined;
1841
- } | {
1842
- readonly _tag: "DispatchNotFound";
1843
- readonly data?: unknown;
1844
- readonly message?: string | undefined;
1845
- } | {
1846
- readonly _tag: "TaskClosed";
1847
- readonly data?: unknown;
1848
- readonly message?: string | undefined;
1849
- } | {
1850
- readonly _tag: "ConversationArchived";
1851
- readonly data?: unknown;
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";
1865
- readonly data?: unknown;
1866
- readonly message?: string | undefined;
1867
- } | {
1868
- readonly _tag: "InvalidParamsError";
1869
- readonly data?: unknown;
1870
- readonly message?: string | undefined;
1871
- } | {
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
- };
1879
- readonly message?: string | undefined;
1880
- } | {
1881
- readonly _tag: "AlreadyConnected";
1882
- readonly data?: unknown;
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";
1887
- readonly data?: unknown;
1888
- readonly message?: string | undefined;
1889
- } | {
1890
- readonly _tag: "Forbidden";
1891
- readonly data?: unknown;
1892
- readonly message?: string | undefined;
1893
- } | {
1894
- readonly _tag: "InvalidParamsError";
1895
- readonly data?: unknown;
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";
1899
- readonly data?: unknown;
1900
- readonly message?: string | undefined;
1901
- } | {
1902
- readonly _tag: "Forbidden";
1903
- readonly data?: unknown;
1904
- readonly message?: string | undefined;
1905
- } | {
1906
- readonly _tag: "NotInContacts";
1907
- readonly data?: unknown;
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";
1911
- readonly data?: unknown;
1912
- readonly message?: string | undefined;
1913
- } | {
1914
- readonly _tag: "Forbidden";
1915
- readonly data?: unknown;
1916
- readonly message?: string | undefined;
1917
- } | {
1918
- readonly _tag: "InvalidParamsError";
1919
- readonly data?: unknown;
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";
1923
- readonly data?: unknown;
1924
- readonly message?: string | undefined;
1925
- } | {
1926
- readonly _tag: "Unauthorized";
1927
- readonly data?: unknown;
1928
- readonly message?: string | undefined;
1929
- } | {
1930
- readonly _tag: "Forbidden";
1931
- readonly data?: unknown;
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";
1935
- readonly data?: unknown;
1936
- readonly message?: string | undefined;
1937
- } | {
1938
- readonly _tag: "Forbidden";
1939
- readonly data?: unknown;
1940
- readonly message?: string | undefined;
1941
- } | {
1942
- readonly _tag: "ContactNotFound";
1943
- readonly data?: unknown;
1944
- readonly message?: string | undefined;
1945
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
1946
- readonly _tag: "Unauthorized";
1947
- readonly data?: unknown;
1948
- readonly message?: string | undefined;
1949
- } | {
1950
- readonly _tag: "Forbidden";
1951
- readonly data?: unknown;
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";
1955
- readonly data?: unknown;
1956
- readonly message?: string | undefined;
1957
- } | {
1958
- readonly _tag: "Forbidden";
1959
- readonly data?: unknown;
1960
- readonly message?: string | undefined;
1961
- } | {
1962
- readonly _tag: "InvalidParamsError";
1963
- readonly data?: unknown;
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";
1967
- readonly data?: unknown;
1968
- readonly message?: string | undefined;
1969
- } | {
1970
- readonly _tag: "Forbidden";
1971
- readonly data?: unknown;
1972
- readonly message?: string | undefined;
1973
- } | {
1974
- readonly _tag: "TaskNotFound";
1975
- readonly data?: unknown;
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";
1979
- readonly data?: unknown;
1980
- readonly message?: string | undefined;
1981
- } | {
1982
- readonly _tag: "Forbidden";
1983
- readonly data?: unknown;
1984
- readonly message?: string | undefined;
1985
- } | {
1986
- readonly _tag: "InvalidParamsError";
1987
- readonly data?: unknown;
1988
- readonly message?: string | undefined;
1989
- } | {
1990
- readonly _tag: "ConversationNotFound";
1991
- readonly data?: unknown;
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";
1995
- readonly data?: unknown;
1996
- readonly message?: string | undefined;
1997
- } | {
1998
- readonly _tag: "Forbidden";
1999
- readonly data?: unknown;
2000
- readonly message?: string | undefined;
2001
- } | {
2002
- readonly _tag: "NotInContacts";
2003
- readonly data?: unknown;
2004
- readonly message?: string | undefined;
2005
- } | {
2006
- readonly _tag: "AgentNotFound";
2007
- readonly data?: unknown;
2008
- readonly message?: string | undefined;
2009
- } | {
2010
- readonly _tag: "TaskRejected";
2011
- readonly data?: unknown;
2012
- readonly message?: string | undefined;
2013
- } | {
2014
- readonly _tag: "ConversationFull";
2015
- readonly data?: unknown;
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";
2019
- readonly data?: unknown;
2020
- readonly message?: string | undefined;
2021
- } | {
2022
- readonly _tag: "Forbidden";
2023
- readonly data?: unknown;
2024
- readonly message?: string | undefined;
2025
- } | {
2026
- readonly _tag: "TaskNotFound";
2027
- readonly data?: unknown;
2028
- readonly message?: string | undefined;
2029
- } | {
2030
- readonly _tag: "ConversationNotFound";
2031
- readonly data?: unknown;
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";
2035
- readonly data?: unknown;
2036
- readonly message?: string | undefined;
2037
- } | {
2038
- readonly _tag: "Forbidden";
2039
- readonly data?: unknown;
2040
- readonly message?: string | undefined;
2041
- } | {
2042
- readonly _tag: "ConversationNotFound";
2043
- readonly data?: unknown;
2044
- readonly message?: string | undefined;
2045
- } | {
2046
- readonly _tag: "HookBlocked";
2047
- readonly data?: unknown;
2048
- readonly message?: string | undefined;
2049
- } | {
2050
- readonly _tag: "MessageNotFound";
2051
- readonly data?: unknown;
2052
- readonly message?: string | undefined;
2053
- } | {
2054
- readonly _tag: "DispatchNotFound";
2055
- readonly data?: unknown;
2056
- readonly message?: string | undefined;
2057
- } | {
2058
- readonly _tag: "TaskClosed";
2059
- readonly data?: unknown;
2060
- readonly message?: string | undefined;
2061
- } | {
2062
- readonly _tag: "ConversationArchived";
2063
- readonly data?: unknown;
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";
2095
- readonly data?: unknown;
2096
- readonly message?: string | undefined;
2097
- } | {
2098
- readonly _tag: "InvalidParamsError";
2099
- readonly data?: unknown;
2100
- readonly message?: string | undefined;
2101
- } | {
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
- };
2109
- readonly message?: string | undefined;
2110
- } | {
2111
- readonly _tag: "AlreadyConnected";
2112
- readonly data?: unknown;
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";
2117
- readonly data?: unknown;
2118
- readonly message?: string | undefined;
2119
- } | {
2120
- readonly _tag: "Forbidden";
2121
- readonly data?: unknown;
2122
- readonly message?: string | undefined;
2123
- } | {
2124
- readonly _tag: "InvalidParamsError";
2125
- readonly data?: unknown;
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";
2129
- readonly data?: unknown;
2130
- readonly message?: string | undefined;
2131
- } | {
2132
- readonly _tag: "Forbidden";
2133
- readonly data?: unknown;
2134
- readonly message?: string | undefined;
2135
- } | {
2136
- readonly _tag: "NotInContacts";
2137
- readonly data?: unknown;
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";
2141
- readonly data?: unknown;
2142
- readonly message?: string | undefined;
2143
- } | {
2144
- readonly _tag: "Forbidden";
2145
- readonly data?: unknown;
2146
- readonly message?: string | undefined;
2147
- } | {
2148
- readonly _tag: "InvalidParamsError";
2149
- readonly data?: unknown;
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";
2153
- readonly data?: unknown;
2154
- readonly message?: string | undefined;
2155
- } | {
2156
- readonly _tag: "Unauthorized";
2157
- readonly data?: unknown;
2158
- readonly message?: string | undefined;
2159
- } | {
2160
- readonly _tag: "Forbidden";
2161
- readonly data?: unknown;
2162
- readonly message?: string | undefined;
2163
- }, never> | Schema.Schema<import("@moltzap/protocol/identity").ContactNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2164
- readonly _tag: "Unauthorized";
2165
- readonly data?: unknown;
2166
- readonly message?: string | undefined;
2167
- } | {
2168
- readonly _tag: "Forbidden";
2169
- readonly data?: unknown;
2170
- readonly message?: string | undefined;
2171
- } | {
2172
- readonly _tag: "ContactNotFound";
2173
- readonly data?: unknown;
2174
- readonly message?: string | undefined;
2175
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2176
- readonly _tag: "Unauthorized";
2177
- readonly data?: unknown;
2178
- readonly message?: string | undefined;
2179
- } | {
2180
- readonly _tag: "Forbidden";
2181
- readonly data?: unknown;
2182
- readonly message?: string | undefined;
2183
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2184
- readonly _tag: "Unauthorized";
2185
- readonly data?: unknown;
2186
- readonly message?: string | undefined;
2187
- } | {
2188
- readonly _tag: "Forbidden";
2189
- readonly data?: unknown;
2190
- readonly message?: string | undefined;
2191
- } | {
2192
- readonly _tag: "InvalidParamsError";
2193
- readonly data?: unknown;
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";
2197
- readonly data?: unknown;
2198
- readonly message?: string | undefined;
2199
- } | {
2200
- readonly _tag: "Forbidden";
2201
- readonly data?: unknown;
2202
- readonly message?: string | undefined;
2203
- } | {
2204
- readonly _tag: "TaskNotFound";
2205
- readonly data?: unknown;
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";
2209
- readonly data?: unknown;
2210
- readonly message?: string | undefined;
2211
- } | {
2212
- readonly _tag: "Forbidden";
2213
- readonly data?: unknown;
2214
- readonly message?: string | undefined;
2215
- } | {
2216
- readonly _tag: "InvalidParamsError";
2217
- readonly data?: unknown;
2218
- readonly message?: string | undefined;
2219
- } | {
2220
- readonly _tag: "ConversationNotFound";
2221
- readonly data?: unknown;
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";
2225
- readonly data?: unknown;
2226
- readonly message?: string | undefined;
2227
- } | {
2228
- readonly _tag: "Forbidden";
2229
- readonly data?: unknown;
2230
- readonly message?: string | undefined;
2231
- } | {
2232
- readonly _tag: "NotInContacts";
2233
- readonly data?: unknown;
2234
- readonly message?: string | undefined;
2235
- } | {
2236
- readonly _tag: "AgentNotFound";
2237
- readonly data?: unknown;
2238
- readonly message?: string | undefined;
2239
- } | {
2240
- readonly _tag: "TaskRejected";
2241
- readonly data?: unknown;
2242
- readonly message?: string | undefined;
2243
- } | {
2244
- readonly _tag: "ConversationFull";
2245
- readonly data?: unknown;
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";
2249
- readonly data?: unknown;
2250
- readonly message?: string | undefined;
2251
- } | {
2252
- readonly _tag: "Forbidden";
2253
- readonly data?: unknown;
2254
- readonly message?: string | undefined;
2255
- } | {
2256
- readonly _tag: "TaskNotFound";
2257
- readonly data?: unknown;
2258
- readonly message?: string | undefined;
2259
- } | {
2260
- readonly _tag: "ConversationNotFound";
2261
- readonly data?: unknown;
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";
2265
- readonly data?: unknown;
2266
- readonly message?: string | undefined;
2267
- } | {
2268
- readonly _tag: "Forbidden";
2269
- readonly data?: unknown;
2270
- readonly message?: string | undefined;
2271
- } | {
2272
- readonly _tag: "ConversationNotFound";
2273
- readonly data?: unknown;
2274
- readonly message?: string | undefined;
2275
- } | {
2276
- readonly _tag: "HookBlocked";
2277
- readonly data?: unknown;
2278
- readonly message?: string | undefined;
2279
- } | {
2280
- readonly _tag: "MessageNotFound";
2281
- readonly data?: unknown;
2282
- readonly message?: string | undefined;
2283
- } | {
2284
- readonly _tag: "DispatchNotFound";
2285
- readonly data?: unknown;
2286
- readonly message?: string | undefined;
2287
- } | {
2288
- readonly _tag: "TaskClosed";
2289
- readonly data?: unknown;
2290
- readonly message?: string | undefined;
2291
- } | {
2292
- readonly _tag: "ConversationArchived";
2293
- readonly data?: unknown;
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";
2306
- readonly data?: unknown;
2307
- readonly message?: string | undefined;
2308
- } | {
2309
- readonly _tag: "InvalidParamsError";
2310
- readonly data?: unknown;
2311
- readonly message?: string | undefined;
2312
- } | {
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
- };
2320
- readonly message?: string | undefined;
2321
- } | {
2322
- readonly _tag: "AlreadyConnected";
2323
- readonly data?: unknown;
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";
2328
- readonly data?: unknown;
2329
- readonly message?: string | undefined;
2330
- } | {
2331
- readonly _tag: "Forbidden";
2332
- readonly data?: unknown;
2333
- readonly message?: string | undefined;
2334
- } | {
2335
- readonly _tag: "InvalidParamsError";
2336
- readonly data?: unknown;
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";
2340
- readonly data?: unknown;
2341
- readonly message?: string | undefined;
2342
- } | {
2343
- readonly _tag: "Forbidden";
2344
- readonly data?: unknown;
2345
- readonly message?: string | undefined;
2346
- } | {
2347
- readonly _tag: "NotInContacts";
2348
- readonly data?: unknown;
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";
2352
- readonly data?: unknown;
2353
- readonly message?: string | undefined;
2354
- } | {
2355
- readonly _tag: "Forbidden";
2356
- readonly data?: unknown;
2357
- readonly message?: string | undefined;
2358
- } | {
2359
- readonly _tag: "InvalidParamsError";
2360
- readonly data?: unknown;
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";
2364
- readonly data?: unknown;
2365
- readonly message?: string | undefined;
2366
- } | {
2367
- readonly _tag: "Unauthorized";
2368
- readonly data?: unknown;
2369
- readonly message?: string | undefined;
2370
- } | {
2371
- readonly _tag: "Forbidden";
2372
- readonly data?: unknown;
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";
2376
- readonly data?: unknown;
2377
- readonly message?: string | undefined;
2378
- } | {
2379
- readonly _tag: "Forbidden";
2380
- readonly data?: unknown;
2381
- readonly message?: string | undefined;
2382
- } | {
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;
2389
- readonly message?: string | undefined;
2390
- } | {
2391
- readonly _tag: "Forbidden";
2392
- readonly data?: unknown;
2393
- readonly message?: string | undefined;
2394
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2395
- readonly _tag: "Unauthorized";
2396
- readonly data?: unknown;
2397
- readonly message?: string | undefined;
2398
- } | {
2399
- readonly _tag: "Forbidden";
2400
- readonly data?: unknown;
2401
- readonly message?: string | undefined;
2402
- } | {
2403
- readonly _tag: "InvalidParamsError";
2404
- readonly data?: unknown;
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";
2408
- readonly data?: unknown;
2409
- readonly message?: string | undefined;
2410
- } | {
2411
- readonly _tag: "Forbidden";
2412
- readonly data?: unknown;
2413
- readonly message?: string | undefined;
2414
- } | {
2415
- readonly _tag: "TaskNotFound";
2416
- readonly data?: unknown;
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";
2420
- readonly data?: unknown;
2421
- readonly message?: string | undefined;
2422
- } | {
2423
- readonly _tag: "Forbidden";
2424
- readonly data?: unknown;
2425
- readonly message?: string | undefined;
2426
- } | {
2427
- readonly _tag: "InvalidParamsError";
2428
- readonly data?: unknown;
2429
- readonly message?: string | undefined;
2430
- } | {
2431
- readonly _tag: "ConversationNotFound";
2432
- readonly data?: unknown;
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";
2436
- readonly data?: unknown;
2437
- readonly message?: string | undefined;
2438
- } | {
2439
- readonly _tag: "Forbidden";
2440
- readonly data?: unknown;
2441
- readonly message?: string | undefined;
2442
- } | {
2443
- readonly _tag: "NotInContacts";
2444
- readonly data?: unknown;
2445
- readonly message?: string | undefined;
2446
- } | {
2447
- readonly _tag: "AgentNotFound";
2448
- readonly data?: unknown;
2449
- readonly message?: string | undefined;
2450
- } | {
2451
- readonly _tag: "TaskRejected";
2452
- readonly data?: unknown;
2453
- readonly message?: string | undefined;
2454
- } | {
2455
- readonly _tag: "ConversationFull";
2456
- readonly data?: unknown;
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";
2460
- readonly data?: unknown;
2461
- readonly message?: string | undefined;
2462
- } | {
2463
- readonly _tag: "Forbidden";
2464
- readonly data?: unknown;
2465
- readonly message?: string | undefined;
2466
- } | {
2467
- readonly _tag: "TaskNotFound";
2468
- readonly data?: unknown;
2469
- readonly message?: string | undefined;
2470
- } | {
2471
- readonly _tag: "ConversationNotFound";
2472
- readonly data?: unknown;
2473
- readonly message?: string | undefined;
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, {
2475
- readonly _tag: "Unauthorized";
2476
- readonly data?: unknown;
2477
- readonly message?: string | undefined;
2478
- } | {
2479
- readonly _tag: "Forbidden";
2480
- readonly data?: unknown;
2481
- readonly message?: string | undefined;
2482
- } | {
2483
- readonly _tag: "ConversationNotFound";
2484
- readonly data?: unknown;
2485
- readonly message?: string | undefined;
2486
- } | {
2487
- readonly _tag: "HookBlocked";
2488
- readonly data?: unknown;
2489
- readonly message?: string | undefined;
2490
- } | {
2491
- readonly _tag: "MessageNotFound";
2492
- readonly data?: unknown;
2493
- readonly message?: string | undefined;
2494
- } | {
2495
- readonly _tag: "DispatchNotFound";
2496
- readonly data?: unknown;
2497
- readonly message?: string | undefined;
2498
- } | {
2499
- readonly _tag: "TaskClosed";
2500
- readonly data?: unknown;
2501
- readonly message?: string | undefined;
2502
- } | {
2503
- readonly _tag: "ConversationArchived";
2504
- readonly data?: unknown;
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";
2525
- readonly data?: unknown;
2526
- readonly message?: string | undefined;
2527
- } | {
2528
- readonly _tag: "InvalidParamsError";
2529
- readonly data?: unknown;
2530
- readonly message?: string | undefined;
2531
- } | {
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
- };
2539
- readonly message?: string | undefined;
2540
- } | {
2541
- readonly _tag: "AlreadyConnected";
2542
- readonly data?: unknown;
2543
- readonly message?: string | undefined;
2544
- readonly principal: "agent" | "app";
2545
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2546
- readonly _tag: "Unauthorized";
2547
- readonly data?: unknown;
2548
- readonly message?: string | undefined;
2549
- } | {
2550
- readonly _tag: "Forbidden";
2551
- readonly data?: unknown;
2552
- readonly message?: string | undefined;
2553
- } | {
2554
- readonly _tag: "InvalidParamsError";
2555
- readonly data?: unknown;
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";
2559
- readonly data?: unknown;
2560
- readonly message?: string | undefined;
2561
- } | {
2562
- readonly _tag: "Forbidden";
2563
- readonly data?: unknown;
2564
- readonly message?: string | undefined;
2565
- } | {
2566
- readonly _tag: "NotInContacts";
2567
- readonly data?: unknown;
2568
- readonly message?: string | undefined;
2569
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2570
- readonly _tag: "Unauthorized";
2571
- readonly data?: unknown;
2572
- readonly message?: string | undefined;
2573
- } | {
2574
- readonly _tag: "Forbidden";
2575
- readonly data?: unknown;
2576
- readonly message?: string | undefined;
2577
- } | {
2578
- readonly _tag: "InvalidParamsError";
2579
- readonly data?: unknown;
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";
2583
- readonly data?: unknown;
2584
- readonly message?: string | undefined;
2585
- } | {
2586
- readonly _tag: "Unauthorized";
2587
- readonly data?: unknown;
2588
- readonly message?: string | undefined;
2589
- } | {
2590
- readonly _tag: "Forbidden";
2591
- readonly data?: unknown;
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";
2595
- readonly data?: unknown;
2596
- readonly message?: string | undefined;
2597
- } | {
2598
- readonly _tag: "Forbidden";
2599
- readonly data?: unknown;
2600
- readonly message?: string | undefined;
2601
- } | {
2602
- readonly _tag: "ContactNotFound";
2603
- readonly data?: unknown;
2604
- readonly message?: string | undefined;
2605
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2606
- readonly _tag: "Unauthorized";
2607
- readonly data?: unknown;
2608
- readonly message?: string | undefined;
2609
- } | {
2610
- readonly _tag: "Forbidden";
2611
- readonly data?: unknown;
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";
2615
- readonly data?: unknown;
2616
- readonly message?: string | undefined;
2617
- } | {
2618
- readonly _tag: "Forbidden";
2619
- readonly data?: unknown;
2620
- readonly message?: string | undefined;
2621
- } | {
2622
- readonly _tag: "InvalidParamsError";
2623
- readonly data?: unknown;
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";
2627
- readonly data?: unknown;
2628
- readonly message?: string | undefined;
2629
- } | {
2630
- readonly _tag: "Forbidden";
2631
- readonly data?: unknown;
2632
- readonly message?: string | undefined;
2633
- } | {
2634
- readonly _tag: "TaskNotFound";
2635
- readonly data?: unknown;
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";
2639
- readonly data?: unknown;
2640
- readonly message?: string | undefined;
2641
- } | {
2642
- readonly _tag: "Forbidden";
2643
- readonly data?: unknown;
2644
- readonly message?: string | undefined;
2645
- } | {
2646
- readonly _tag: "InvalidParamsError";
2647
- readonly data?: unknown;
2648
- readonly message?: string | undefined;
2649
- } | {
2650
- readonly _tag: "ConversationNotFound";
742
+ readonly _tag: "Forbidden";
2651
743
  readonly data?: unknown;
2652
744
  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, {
745
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2654
746
  readonly _tag: "Unauthorized";
2655
747
  readonly data?: unknown;
2656
748
  readonly message?: string | undefined;
@@ -2658,23 +750,19 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2658
750
  readonly _tag: "Forbidden";
2659
751
  readonly data?: unknown;
2660
752
  readonly message?: string | undefined;
2661
- } | {
2662
- readonly _tag: "NotInContacts";
2663
- readonly data?: unknown;
2664
- readonly message?: string | undefined;
2665
- } | {
2666
- readonly _tag: "AgentNotFound";
753
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
754
+ readonly _tag: "Unauthorized";
2667
755
  readonly data?: unknown;
2668
756
  readonly message?: string | undefined;
2669
757
  } | {
2670
- readonly _tag: "TaskRejected";
758
+ readonly _tag: "Forbidden";
2671
759
  readonly data?: unknown;
2672
760
  readonly message?: string | undefined;
2673
761
  } | {
2674
- readonly _tag: "ConversationFull";
762
+ readonly _tag: "InvalidParamsError";
2675
763
  readonly data?: unknown;
2676
764
  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, {
765
+ }, never> | Schema.Schema<import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2678
766
  readonly _tag: "Unauthorized";
2679
767
  readonly data?: unknown;
2680
768
  readonly message?: string | undefined;
@@ -2683,14 +771,14 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2683
771
  readonly data?: unknown;
2684
772
  readonly message?: string | undefined;
2685
773
  } | {
2686
- readonly _tag: "TaskNotFound";
774
+ readonly _tag: "InvalidParamsError";
2687
775
  readonly data?: unknown;
2688
776
  readonly message?: string | undefined;
2689
777
  } | {
2690
778
  readonly _tag: "ConversationNotFound";
2691
779
  readonly data?: unknown;
2692
780
  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, {
781
+ }, never> | Schema.Schema<import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/conversation").ConversationFullError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2694
782
  readonly _tag: "Unauthorized";
2695
783
  readonly data?: unknown;
2696
784
  readonly message?: string | undefined;
@@ -2699,60 +787,38 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2699
787
  readonly data?: unknown;
2700
788
  readonly message?: string | undefined;
2701
789
  } | {
2702
- readonly _tag: "ConversationNotFound";
790
+ readonly _tag: "AgentNotFound";
2703
791
  readonly data?: unknown;
2704
792
  readonly message?: string | undefined;
2705
793
  } | {
2706
- readonly _tag: "HookBlocked";
794
+ readonly _tag: "ConversationFull";
2707
795
  readonly data?: unknown;
2708
796
  readonly message?: string | undefined;
2709
- } | {
2710
- readonly _tag: "MessageNotFound";
797
+ }, never> | Schema.Schema<import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/rpc").UnauthorizedError, {
798
+ readonly _tag: "Unauthorized";
2711
799
  readonly data?: unknown;
2712
800
  readonly message?: string | undefined;
2713
801
  } | {
2714
- readonly _tag: "DispatchNotFound";
802
+ readonly _tag: "Forbidden";
2715
803
  readonly data?: unknown;
2716
804
  readonly message?: string | undefined;
2717
805
  } | {
2718
- readonly _tag: "TaskClosed";
806
+ readonly _tag: "HookBlocked";
2719
807
  readonly data?: unknown;
2720
808
  readonly message?: string | undefined;
2721
809
  } | {
2722
- readonly _tag: "ConversationArchived";
810
+ readonly _tag: "DispatchNotFound";
2723
811
  readonly data?: unknown;
2724
812
  readonly message?: string | undefined;
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>;
813
+ }, never>)[]]>, never> | Rpc.Rpc<"cli/send", Schema.Struct<{
814
+ target: Schema.transformOrFail<typeof Schema.String, Schema.Struct<{
815
+ conversationId: Schema.Schema<import("@moltzap/protocol/conversation").ConversationId, string, never>;
816
+ taskId: Schema.optional<Schema.Schema<import("@moltzap/protocol/task").TaskId, string, never>>;
817
+ }>, never>;
818
+ message: Schema.filter<typeof Schema.String>;
2732
819
  }>, Schema.Struct<{
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>;
2746
- metadata: Schema.optional<Schema.Struct<{
2747
- tags: Schema.optional<Schema.Array$<Schema.Record$<typeof Schema.String, typeof Schema.String>>>;
2748
- }>>;
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, {
820
+ messageId: Schema.Schema<import("@moltzap/protocol/conversation").MessageId, string, never>;
821
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartUsageError, typeof StartPartialFailure, 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, {
2756
822
  readonly _tag: "Unauthorized";
2757
823
  readonly data?: unknown;
2758
824
  readonly message?: string | undefined;
@@ -2774,7 +840,7 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2774
840
  readonly data?: unknown;
2775
841
  readonly message?: string | undefined;
2776
842
  readonly principal: "agent" | "app";
2777
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
843
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2778
844
  readonly _tag: "Unauthorized";
2779
845
  readonly data?: unknown;
2780
846
  readonly message?: string | undefined;
@@ -2782,11 +848,7 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2782
848
  readonly _tag: "Forbidden";
2783
849
  readonly data?: unknown;
2784
850
  readonly message?: string | undefined;
2785
- } | {
2786
- readonly _tag: "InvalidParamsError";
2787
- readonly data?: unknown;
2788
- readonly message?: string | undefined;
2789
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
851
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2790
852
  readonly _tag: "Unauthorized";
2791
853
  readonly data?: unknown;
2792
854
  readonly message?: string | undefined;
@@ -2794,10 +856,6 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2794
856
  readonly _tag: "Forbidden";
2795
857
  readonly data?: unknown;
2796
858
  readonly message?: string | undefined;
2797
- } | {
2798
- readonly _tag: "NotInContacts";
2799
- readonly data?: unknown;
2800
- readonly message?: string | undefined;
2801
859
  }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2802
860
  readonly _tag: "Unauthorized";
2803
861
  readonly data?: unknown;
@@ -2810,11 +868,7 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2810
868
  readonly _tag: "InvalidParamsError";
2811
869
  readonly data?: unknown;
2812
870
  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";
2815
- readonly data?: unknown;
2816
- readonly message?: string | undefined;
2817
- } | {
871
+ }, never> | Schema.Schema<import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2818
872
  readonly _tag: "Unauthorized";
2819
873
  readonly data?: unknown;
2820
874
  readonly message?: string | undefined;
@@ -2822,19 +876,15 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2822
876
  readonly _tag: "Forbidden";
2823
877
  readonly data?: unknown;
2824
878
  readonly message?: string | undefined;
2825
- }, never> | Schema.Schema<import("@moltzap/protocol/identity").ContactNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2826
- readonly _tag: "Unauthorized";
2827
- readonly data?: unknown;
2828
- readonly message?: string | undefined;
2829
879
  } | {
2830
- readonly _tag: "Forbidden";
880
+ readonly _tag: "InvalidParamsError";
2831
881
  readonly data?: unknown;
2832
882
  readonly message?: string | undefined;
2833
883
  } | {
2834
- readonly _tag: "ContactNotFound";
884
+ readonly _tag: "ConversationNotFound";
2835
885
  readonly data?: unknown;
2836
886
  readonly message?: string | undefined;
2837
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
887
+ }, never> | Schema.Schema<import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/conversation").ConversationFullError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2838
888
  readonly _tag: "Unauthorized";
2839
889
  readonly data?: unknown;
2840
890
  readonly message?: string | undefined;
@@ -2842,19 +892,15 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2842
892
  readonly _tag: "Forbidden";
2843
893
  readonly data?: unknown;
2844
894
  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";
2847
- readonly data?: unknown;
2848
- readonly message?: string | undefined;
2849
895
  } | {
2850
- readonly _tag: "Forbidden";
896
+ readonly _tag: "AgentNotFound";
2851
897
  readonly data?: unknown;
2852
898
  readonly message?: string | undefined;
2853
899
  } | {
2854
- readonly _tag: "InvalidParamsError";
900
+ readonly _tag: "ConversationFull";
2855
901
  readonly data?: unknown;
2856
902
  readonly message?: string | undefined;
2857
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/rpc").UnauthorizedError, {
903
+ }, never> | Schema.Schema<import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2858
904
  readonly _tag: "Unauthorized";
2859
905
  readonly data?: unknown;
2860
906
  readonly message?: string | undefined;
@@ -2863,15 +909,30 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2863
909
  readonly data?: unknown;
2864
910
  readonly message?: string | undefined;
2865
911
  } | {
2866
- readonly _tag: "TaskNotFound";
912
+ readonly _tag: "HookBlocked";
2867
913
  readonly data?: unknown;
2868
914
  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";
915
+ } | {
916
+ readonly _tag: "DispatchNotFound";
2871
917
  readonly data?: unknown;
2872
918
  readonly message?: string | undefined;
2873
- } | {
2874
- readonly _tag: "Forbidden";
919
+ }, never>)[]]>, never> | Rpc.Rpc<"cli/start", Schema.Struct<{
920
+ name: Schema.filter<Schema.filter<typeof Schema.String>>;
921
+ participants: Schema.Array$<Schema.transformOrFail<typeof Schema.String, Schema.Union<[Schema.Struct<{
922
+ kind: Schema.Literal<["id"]>;
923
+ id: Schema.Schema<import("@moltzap/protocol/identity").AgentId, string, never>;
924
+ }>, Schema.Struct<{
925
+ kind: Schema.Literal<["name"]>;
926
+ token: typeof Schema.String;
927
+ name: Schema.filter<Schema.filter<typeof Schema.String>>;
928
+ }>]>, never>>;
929
+ message: Schema.optional<typeof Schema.String>;
930
+ appId: Schema.optional<Schema.filter<Schema.Schema<import("@moltzap/protocol/identity").AppId, string, never>>>;
931
+ }>, Schema.Struct<{
932
+ conversationId: Schema.Schema<import("@moltzap/protocol/conversation").ConversationId, string, never>;
933
+ sentMessageId: Schema.optional<Schema.Schema<import("@moltzap/protocol/conversation").MessageId, string, never>>;
934
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartUsageError, typeof StartPartialFailure, 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, {
935
+ readonly _tag: "Unauthorized";
2875
936
  readonly data?: unknown;
2876
937
  readonly message?: string | undefined;
2877
938
  } | {
@@ -2879,10 +940,20 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2879
940
  readonly data?: unknown;
2880
941
  readonly message?: string | undefined;
2881
942
  } | {
2882
- readonly _tag: "ConversationNotFound";
943
+ readonly _tag: "ProtocolMismatchError";
944
+ readonly data: {
945
+ readonly clientMaxProtocol: string;
946
+ readonly clientMinProtocol: string;
947
+ readonly reason: "server-above-client-max" | "server-below-client-min";
948
+ readonly serverVersion: string;
949
+ };
950
+ readonly message?: string | undefined;
951
+ } | {
952
+ readonly _tag: "AlreadyConnected";
2883
953
  readonly data?: unknown;
2884
954
  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, {
955
+ readonly principal: "agent" | "app";
956
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2886
957
  readonly _tag: "Unauthorized";
2887
958
  readonly data?: unknown;
2888
959
  readonly message?: string | undefined;
@@ -2890,23 +961,27 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2890
961
  readonly _tag: "Forbidden";
2891
962
  readonly data?: unknown;
2892
963
  readonly message?: string | undefined;
2893
- } | {
2894
- readonly _tag: "NotInContacts";
964
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
965
+ readonly _tag: "Unauthorized";
2895
966
  readonly data?: unknown;
2896
967
  readonly message?: string | undefined;
2897
968
  } | {
2898
- readonly _tag: "AgentNotFound";
969
+ readonly _tag: "Forbidden";
970
+ readonly data?: unknown;
971
+ readonly message?: string | undefined;
972
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
973
+ readonly _tag: "Unauthorized";
2899
974
  readonly data?: unknown;
2900
975
  readonly message?: string | undefined;
2901
976
  } | {
2902
- readonly _tag: "TaskRejected";
977
+ readonly _tag: "Forbidden";
2903
978
  readonly data?: unknown;
2904
979
  readonly message?: string | undefined;
2905
980
  } | {
2906
- readonly _tag: "ConversationFull";
981
+ readonly _tag: "InvalidParamsError";
2907
982
  readonly data?: unknown;
2908
983
  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, {
984
+ }, never> | Schema.Schema<import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2910
985
  readonly _tag: "Unauthorized";
2911
986
  readonly data?: unknown;
2912
987
  readonly message?: string | undefined;
@@ -2915,14 +990,14 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2915
990
  readonly data?: unknown;
2916
991
  readonly message?: string | undefined;
2917
992
  } | {
2918
- readonly _tag: "TaskNotFound";
993
+ readonly _tag: "InvalidParamsError";
2919
994
  readonly data?: unknown;
2920
995
  readonly message?: string | undefined;
2921
996
  } | {
2922
997
  readonly _tag: "ConversationNotFound";
2923
998
  readonly data?: unknown;
2924
999
  readonly message?: string | undefined;
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, {
1000
+ }, never> | Schema.Schema<import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/conversation").ConversationFullError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2926
1001
  readonly _tag: "Unauthorized";
2927
1002
  readonly data?: unknown;
2928
1003
  readonly message?: string | undefined;
@@ -2931,34 +1006,58 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2931
1006
  readonly data?: unknown;
2932
1007
  readonly message?: string | undefined;
2933
1008
  } | {
2934
- readonly _tag: "ConversationNotFound";
1009
+ readonly _tag: "AgentNotFound";
2935
1010
  readonly data?: unknown;
2936
1011
  readonly message?: string | undefined;
2937
1012
  } | {
2938
- readonly _tag: "HookBlocked";
1013
+ readonly _tag: "ConversationFull";
2939
1014
  readonly data?: unknown;
2940
1015
  readonly message?: string | undefined;
2941
- } | {
2942
- readonly _tag: "MessageNotFound";
1016
+ }, never> | Schema.Schema<import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/rpc").UnauthorizedError, {
1017
+ readonly _tag: "Unauthorized";
2943
1018
  readonly data?: unknown;
2944
1019
  readonly message?: string | undefined;
2945
1020
  } | {
2946
- readonly _tag: "DispatchNotFound";
1021
+ readonly _tag: "Forbidden";
2947
1022
  readonly data?: unknown;
2948
1023
  readonly message?: string | undefined;
2949
1024
  } | {
2950
- readonly _tag: "TaskClosed";
1025
+ readonly _tag: "HookBlocked";
2951
1026
  readonly data?: unknown;
2952
1027
  readonly message?: string | undefined;
2953
1028
  } | {
2954
- readonly _tag: "ConversationArchived";
1029
+ readonly _tag: "DispatchNotFound";
2955
1030
  readonly data?: unknown;
2956
1031
  readonly message?: string | undefined;
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, {
1032
+ }, never>)[]]>, never> | Rpc.Rpc<"daemon/history", Schema.Struct<{
1033
+ conversationId: Schema.Schema<import("@moltzap/protocol/conversation").ConversationId, string, never>;
1034
+ limit: Schema.optionalWith<Schema.filter<Schema.filter<typeof Schema.Number>>, {
1035
+ default: () => number;
1036
+ }>;
1037
+ sessionKey: Schema.optional<typeof Schema.String>;
1038
+ }>, Schema.Struct<{
1039
+ messages: Schema.Array$<Schema.Struct<{
1040
+ id: Schema.Schema<import("@moltzap/protocol/conversation").MessageId, string, never>;
1041
+ senderId: Schema.Schema<import("@moltzap/protocol/identity").AgentId, string, never>;
1042
+ senderName: typeof Schema.String;
1043
+ isOwn: typeof Schema.Boolean;
1044
+ text: typeof Schema.String;
1045
+ createdAt: typeof Schema.String;
1046
+ isNew: typeof Schema.Boolean;
1047
+ }>>;
1048
+ conversationMeta: Schema.optional<Schema.Struct<{
1049
+ id: Schema.Schema<import("@moltzap/protocol/conversation").ConversationId, string, never>;
1050
+ name: Schema.optional<typeof Schema.String>;
1051
+ createdBy: Schema.Schema<import("@moltzap/protocol/identity").AgentId, string, never>;
1052
+ metadata: Schema.optional<Schema.Struct<{
1053
+ tags: Schema.optional<Schema.Array$<Schema.Record$<typeof Schema.String, typeof Schema.String>>>;
1054
+ }>>;
1055
+ lastMessageTimestamp: Schema.optional<typeof Schema.String>;
1056
+ createdAt: typeof Schema.String;
1057
+ updatedAt: typeof Schema.String;
1058
+ }>>;
1059
+ newCount: Schema.filter<Schema.filter<typeof Schema.Number>>;
1060
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartUsageError, typeof StartPartialFailure, 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, {
2962
1061
  readonly _tag: "Unauthorized";
2963
1062
  readonly data?: unknown;
2964
1063
  readonly message?: string | undefined;
@@ -2980,7 +1079,7 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2980
1079
  readonly data?: unknown;
2981
1080
  readonly message?: string | undefined;
2982
1081
  readonly principal: "agent" | "app";
2983
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
1082
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2984
1083
  readonly _tag: "Unauthorized";
2985
1084
  readonly data?: unknown;
2986
1085
  readonly message?: string | undefined;
@@ -2988,11 +1087,7 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
2988
1087
  readonly _tag: "Forbidden";
2989
1088
  readonly data?: unknown;
2990
1089
  readonly message?: string | undefined;
2991
- } | {
2992
- readonly _tag: "InvalidParamsError";
2993
- readonly data?: unknown;
2994
- readonly message?: string | undefined;
2995
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/identity").NotInContactsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
1090
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
2996
1091
  readonly _tag: "Unauthorized";
2997
1092
  readonly data?: unknown;
2998
1093
  readonly message?: string | undefined;
@@ -3000,10 +1095,6 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
3000
1095
  readonly _tag: "Forbidden";
3001
1096
  readonly data?: unknown;
3002
1097
  readonly message?: string | undefined;
3003
- } | {
3004
- readonly _tag: "NotInContacts";
3005
- readonly data?: unknown;
3006
- readonly message?: string | undefined;
3007
1098
  }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
3008
1099
  readonly _tag: "Unauthorized";
3009
1100
  readonly data?: unknown;
@@ -3016,11 +1107,7 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
3016
1107
  readonly _tag: "InvalidParamsError";
3017
1108
  readonly data?: unknown;
3018
1109
  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";
3021
- readonly data?: unknown;
3022
- readonly message?: string | undefined;
3023
- } | {
1110
+ }, never> | Schema.Schema<import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
3024
1111
  readonly _tag: "Unauthorized";
3025
1112
  readonly data?: unknown;
3026
1113
  readonly message?: string | undefined;
@@ -3028,19 +1115,15 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
3028
1115
  readonly _tag: "Forbidden";
3029
1116
  readonly data?: unknown;
3030
1117
  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";
3033
- readonly data?: unknown;
3034
- readonly message?: string | undefined;
3035
1118
  } | {
3036
- readonly _tag: "Forbidden";
1119
+ readonly _tag: "InvalidParamsError";
3037
1120
  readonly data?: unknown;
3038
1121
  readonly message?: string | undefined;
3039
1122
  } | {
3040
- readonly _tag: "ContactNotFound";
1123
+ readonly _tag: "ConversationNotFound";
3041
1124
  readonly data?: unknown;
3042
1125
  readonly message?: string | undefined;
3043
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
1126
+ }, never> | Schema.Schema<import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/conversation").ConversationFullError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
3044
1127
  readonly _tag: "Unauthorized";
3045
1128
  readonly data?: unknown;
3046
1129
  readonly message?: string | undefined;
@@ -3048,19 +1131,15 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
3048
1131
  readonly _tag: "Forbidden";
3049
1132
  readonly data?: unknown;
3050
1133
  readonly message?: string | undefined;
3051
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
3052
- readonly _tag: "Unauthorized";
3053
- readonly data?: unknown;
3054
- readonly message?: string | undefined;
3055
1134
  } | {
3056
- readonly _tag: "Forbidden";
1135
+ readonly _tag: "AgentNotFound";
3057
1136
  readonly data?: unknown;
3058
1137
  readonly message?: string | undefined;
3059
1138
  } | {
3060
- readonly _tag: "InvalidParamsError";
1139
+ readonly _tag: "ConversationFull";
3061
1140
  readonly data?: unknown;
3062
1141
  readonly message?: string | undefined;
3063
- }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").TaskNotFoundError | import("@moltzap/protocol/rpc").UnauthorizedError, {
1142
+ }, never> | Schema.Schema<import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/rpc").UnauthorizedError, {
3064
1143
  readonly _tag: "Unauthorized";
3065
1144
  readonly data?: unknown;
3066
1145
  readonly message?: string | undefined;
@@ -3069,15 +1148,19 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
3069
1148
  readonly data?: unknown;
3070
1149
  readonly message?: string | undefined;
3071
1150
  } | {
3072
- readonly _tag: "TaskNotFound";
1151
+ readonly _tag: "HookBlocked";
3073
1152
  readonly data?: unknown;
3074
1153
  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";
1154
+ } | {
1155
+ readonly _tag: "DispatchNotFound";
3077
1156
  readonly data?: unknown;
3078
1157
  readonly message?: string | undefined;
3079
- } | {
3080
- readonly _tag: "Forbidden";
1158
+ }, never>)[]]>, never> | Rpc.Rpc<"daemon/status", Schema.Struct<{}>, Schema.Struct<{
1159
+ agentId: Schema.optional<Schema.Schema<import("@moltzap/protocol/identity").AgentId, string, never>>;
1160
+ connected: typeof Schema.Boolean;
1161
+ conversations: Schema.filter<Schema.filter<typeof Schema.Number>>;
1162
+ }>, Schema.Union<[typeof LocalDaemonInputError, typeof StartUsageError, typeof StartPartialFailure, 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, {
1163
+ readonly _tag: "Unauthorized";
3081
1164
  readonly data?: unknown;
3082
1165
  readonly message?: string | undefined;
3083
1166
  } | {
@@ -3085,10 +1168,20 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
3085
1168
  readonly data?: unknown;
3086
1169
  readonly message?: string | undefined;
3087
1170
  } | {
3088
- readonly _tag: "ConversationNotFound";
1171
+ readonly _tag: "ProtocolMismatchError";
1172
+ readonly data: {
1173
+ readonly clientMaxProtocol: string;
1174
+ readonly clientMinProtocol: string;
1175
+ readonly reason: "server-above-client-max" | "server-below-client-min";
1176
+ readonly serverVersion: string;
1177
+ };
1178
+ readonly message?: string | undefined;
1179
+ } | {
1180
+ readonly _tag: "AlreadyConnected";
3089
1181
  readonly data?: unknown;
3090
1182
  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, {
1183
+ readonly principal: "agent" | "app";
1184
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
3092
1185
  readonly _tag: "Unauthorized";
3093
1186
  readonly data?: unknown;
3094
1187
  readonly message?: string | undefined;
@@ -3096,23 +1189,27 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
3096
1189
  readonly _tag: "Forbidden";
3097
1190
  readonly data?: unknown;
3098
1191
  readonly message?: string | undefined;
3099
- } | {
3100
- readonly _tag: "NotInContacts";
1192
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
1193
+ readonly _tag: "Unauthorized";
3101
1194
  readonly data?: unknown;
3102
1195
  readonly message?: string | undefined;
3103
1196
  } | {
3104
- readonly _tag: "AgentNotFound";
1197
+ readonly _tag: "Forbidden";
1198
+ readonly data?: unknown;
1199
+ readonly message?: string | undefined;
1200
+ }, never> | Schema.Schema<import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
1201
+ readonly _tag: "Unauthorized";
3105
1202
  readonly data?: unknown;
3106
1203
  readonly message?: string | undefined;
3107
1204
  } | {
3108
- readonly _tag: "TaskRejected";
1205
+ readonly _tag: "Forbidden";
3109
1206
  readonly data?: unknown;
3110
1207
  readonly message?: string | undefined;
3111
1208
  } | {
3112
- readonly _tag: "ConversationFull";
1209
+ readonly _tag: "InvalidParamsError";
3113
1210
  readonly data?: unknown;
3114
1211
  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, {
1212
+ }, never> | Schema.Schema<import("@moltzap/protocol/conversation").ConversationNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").InvalidParamsError | import("@moltzap/protocol/rpc").UnauthorizedError, {
3116
1213
  readonly _tag: "Unauthorized";
3117
1214
  readonly data?: unknown;
3118
1215
  readonly message?: string | undefined;
@@ -3121,14 +1218,14 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
3121
1218
  readonly data?: unknown;
3122
1219
  readonly message?: string | undefined;
3123
1220
  } | {
3124
- readonly _tag: "TaskNotFound";
1221
+ readonly _tag: "InvalidParamsError";
3125
1222
  readonly data?: unknown;
3126
1223
  readonly message?: string | undefined;
3127
1224
  } | {
3128
1225
  readonly _tag: "ConversationNotFound";
3129
1226
  readonly data?: unknown;
3130
1227
  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, {
1228
+ }, never> | Schema.Schema<import("@moltzap/protocol/identity").AgentNotFoundError | import("@moltzap/protocol/conversation").ConversationFullError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/rpc").UnauthorizedError, {
3132
1229
  readonly _tag: "Unauthorized";
3133
1230
  readonly data?: unknown;
3134
1231
  readonly message?: string | undefined;
@@ -3137,27 +1234,27 @@ declare const LocalDaemonRpcs_base: RpcGroup.RpcGroup<Rpc.Rpc<"cli/agents/list",
3137
1234
  readonly data?: unknown;
3138
1235
  readonly message?: string | undefined;
3139
1236
  } | {
3140
- readonly _tag: "ConversationNotFound";
1237
+ readonly _tag: "AgentNotFound";
3141
1238
  readonly data?: unknown;
3142
1239
  readonly message?: string | undefined;
3143
1240
  } | {
3144
- readonly _tag: "HookBlocked";
1241
+ readonly _tag: "ConversationFull";
3145
1242
  readonly data?: unknown;
3146
1243
  readonly message?: string | undefined;
3147
- } | {
3148
- readonly _tag: "MessageNotFound";
1244
+ }, never> | Schema.Schema<import("@moltzap/protocol/message/dispatch").DispatchNotFoundError | import("@moltzap/protocol/rpc").ForbiddenError | import("@moltzap/protocol/task").HookBlockedError | import("@moltzap/protocol/rpc").UnauthorizedError, {
1245
+ readonly _tag: "Unauthorized";
3149
1246
  readonly data?: unknown;
3150
1247
  readonly message?: string | undefined;
3151
1248
  } | {
3152
- readonly _tag: "DispatchNotFound";
1249
+ readonly _tag: "Forbidden";
3153
1250
  readonly data?: unknown;
3154
1251
  readonly message?: string | undefined;
3155
1252
  } | {
3156
- readonly _tag: "TaskClosed";
1253
+ readonly _tag: "HookBlocked";
3157
1254
  readonly data?: unknown;
3158
1255
  readonly message?: string | undefined;
3159
1256
  } | {
3160
- readonly _tag: "ConversationArchived";
1257
+ readonly _tag: "DispatchNotFound";
3161
1258
  readonly data?: unknown;
3162
1259
  readonly message?: string | undefined;
3163
1260
  }, never>)[]]>, never>>;