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