@powerhousedao/reactor-mcp 4.1.0-dev.4 → 4.1.0-dev.7

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 (36) hide show
  1. package/dist/src/cli.js +4 -1
  2. package/dist/src/cli.js.map +1 -1
  3. package/dist/src/index.d.ts +6 -1
  4. package/dist/src/index.d.ts.map +1 -1
  5. package/dist/src/index.js +73 -5
  6. package/dist/src/index.js.map +1 -1
  7. package/dist/src/loader.d.ts +18 -0
  8. package/dist/src/loader.d.ts.map +1 -0
  9. package/dist/src/loader.js +86 -0
  10. package/dist/src/loader.js.map +1 -0
  11. package/dist/src/mcp/reactor.d.ts +461 -244
  12. package/dist/src/mcp/reactor.d.ts.map +1 -1
  13. package/dist/src/mcp/reactor.js +198 -146
  14. package/dist/src/mcp/reactor.js.map +1 -1
  15. package/dist/src/mcp/utils.d.ts +8 -21
  16. package/dist/src/mcp/utils.d.ts.map +1 -1
  17. package/dist/src/mcp/utils.js +59 -21
  18. package/dist/src/mcp/utils.js.map +1 -1
  19. package/dist/src/sdk/chat.d.ts +19 -0
  20. package/dist/src/sdk/chat.d.ts.map +1 -0
  21. package/dist/src/sdk/chat.js +59 -0
  22. package/dist/src/sdk/chat.js.map +1 -0
  23. package/dist/src/server.d.ts +3 -2
  24. package/dist/src/server.d.ts.map +1 -1
  25. package/dist/src/server.js +38 -759
  26. package/dist/src/server.js.map +1 -1
  27. package/dist/tsconfig.lib.tsbuildinfo +1 -1
  28. package/package.json +8 -5
  29. package/dist/src/reactor.d.ts +0 -43
  30. package/dist/src/reactor.d.ts.map +0 -1
  31. package/dist/src/reactor.js +0 -142
  32. package/dist/src/reactor.js.map +0 -1
  33. package/dist/src/utils.d.ts +0 -10
  34. package/dist/src/utils.d.ts.map +0 -1
  35. package/dist/src/utils.js +0 -57
  36. package/dist/src/utils.js.map +0 -1
package/dist/src/mcp/reactor.d.ts CHANGED
@@ -1,43 +1,26 @@
1
1
  import type { IDocumentDriveServer } from "document-drive";
2
+ import { type DocumentModelState } from "document-model";
2
3
  import { z } from "zod";
3
4
  import type { ToolSchema, ToolWithCallback } from "./types.js";
4
- export declare const getDocumentTool: {
5
- readonly name: "getDocument";
6
- readonly description: "Retrieve a document by its ID";
5
+ export declare const createDocumentTool: {
6
+ readonly name: "createDocument";
7
+ readonly description: "Create a new document.\n Unless the user specifies otherwise, and a drive named \"vetra\" is available, add the document after creating it to that drive using \"addActions\" tool with a \"ADD_FILE\" action to the drive document.";
7
8
  readonly inputSchema: {
8
- readonly id: z.ZodString;
9
+ readonly documentType: z.ZodString;
10
+ readonly documentId: z.ZodOptional<z.ZodString>;
9
11
  };
10
12
  readonly outputSchema: {
11
- readonly document: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
13
+ readonly documentId: z.ZodString;
12
14
  };
13
15
  };
14
- export declare const createDocumentTool: {
15
- readonly name: "createDocument";
16
- readonly description: "Create a new document";
16
+ export declare const getDocumentTool: {
17
+ readonly name: "getDocument";
18
+ readonly description: "Retrieve a document by its ID";
17
19
  readonly inputSchema: {
18
- readonly documentType: z.ZodString;
19
- readonly documentId: z.ZodOptional<z.ZodString>;
20
+ readonly id: z.ZodString;
20
21
  };
21
22
  readonly outputSchema: {
22
- readonly result: z.ZodObject<{
23
- status: z.ZodEnum<["SUCCESS", "CONFLICT", "MISSING", "ERROR"]>;
24
- error: z.ZodOptional<z.ZodString>;
25
- operations: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
26
- document: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
27
- signals: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
28
- }, "strip", z.ZodTypeAny, {
29
- status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
30
- operations: {}[];
31
- signals: {}[];
32
- document?: {} | undefined;
33
- error?: string | undefined;
34
- }, {
35
- status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
36
- operations: {}[];
37
- signals: {}[];
38
- document?: {} | undefined;
39
- error?: string | undefined;
40
- }>;
23
+ readonly document: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
41
24
  };
42
25
  };
43
26
  export declare const getDocumentsTool: {
@@ -60,110 +43,30 @@ export declare const deleteDocumentTool: {
60
43
  readonly success: z.ZodBoolean;
61
44
  };
62
45
  };
63
- export declare const addActionTool: {
64
- readonly name: "addAction";
65
- readonly description: "Add an action to a document";
46
+ export declare const addActionsTool: {
47
+ readonly name: "addActions";
48
+ readonly description: "Adds actions to a document. Prefer adding multiples actions at once to reduce the number of steps.";
66
49
  readonly inputSchema: {
67
50
  readonly documentId: z.ZodString;
68
- readonly action: z.ZodObject<{
51
+ readonly actions: z.ZodArray<z.ZodObject<{
69
52
  type: z.ZodString;
70
- input: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>;
53
+ input: z.ZodUnknown;
71
54
  scope: z.ZodString;
72
55
  context: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
73
56
  }, "strict", z.ZodTypeAny, {
74
- scope: string;
75
- input: string | number | boolean | any[] | {} | null;
76
57
  type: string;
77
- context?: {} | undefined;
78
- }, {
79
58
  scope: string;
80
- input: string | number | boolean | any[] | {} | null;
81
- type: string;
59
+ input?: unknown;
82
60
  context?: {} | undefined;
83
- }>;
84
- };
85
- readonly outputSchema: {
86
- readonly result: z.ZodObject<{
87
- status: z.ZodEnum<["SUCCESS", "CONFLICT", "MISSING", "ERROR"]>;
88
- error: z.ZodOptional<z.ZodString>;
89
- operations: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
90
- document: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
91
- signals: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
92
- }, "strip", z.ZodTypeAny, {
93
- status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
94
- operations: {}[];
95
- signals: {}[];
96
- document?: {} | undefined;
97
- error?: string | undefined;
98
61
  }, {
99
- status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
100
- operations: {}[];
101
- signals: {}[];
102
- document?: {} | undefined;
103
- error?: string | undefined;
104
- }>;
105
- };
106
- };
107
- export declare const addOperationTool: {
108
- readonly name: "addOperation";
109
- readonly description: "Add an operation to a document";
110
- readonly inputSchema: {
111
- readonly documentId: z.ZodString;
112
- readonly operation: z.ZodObject<{
113
- type: z.ZodString;
114
- input: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>;
115
- scope: z.ZodString;
116
- index: z.ZodNumber;
117
- timestamp: z.ZodString;
118
- hash: z.ZodString;
119
- skip: z.ZodNumber;
120
- error: z.ZodOptional<z.ZodString>;
121
- id: z.ZodOptional<z.ZodString>;
122
- context: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
123
- }, "strict", z.ZodTypeAny, {
124
- scope: string;
125
- input: string | number | boolean | any[] | {} | null;
126
62
  type: string;
127
- index: number;
128
- timestamp: string;
129
- hash: string;
130
- skip: number;
131
- id?: string | undefined;
132
- error?: string | undefined;
133
- context?: {} | undefined;
134
- }, {
135
63
  scope: string;
136
- input: string | number | boolean | any[] | {} | null;
137
- type: string;
138
- index: number;
139
- timestamp: string;
140
- hash: string;
141
- skip: number;
142
- id?: string | undefined;
143
- error?: string | undefined;
64
+ input?: unknown;
144
65
  context?: {} | undefined;
145
- }>;
66
+ }>, "many">;
146
67
  };
147
68
  readonly outputSchema: {
148
- readonly result: z.ZodObject<{
149
- status: z.ZodEnum<["SUCCESS", "CONFLICT", "MISSING", "ERROR"]>;
150
- error: z.ZodOptional<z.ZodString>;
151
- operations: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
152
- document: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
153
- signals: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
154
- }, "strip", z.ZodTypeAny, {
155
- status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
156
- operations: {}[];
157
- signals: {}[];
158
- document?: {} | undefined;
159
- error?: string | undefined;
160
- }, {
161
- status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
162
- operations: {}[];
163
- signals: {}[];
164
- document?: {} | undefined;
165
- error?: string | undefined;
166
- }>;
69
+ readonly success: z.ZodBoolean;
167
70
  };
168
71
  };
169
72
  export declare const getDrivesTool: {
@@ -207,29 +110,29 @@ export declare const addDriveTool: {
207
110
  name: string;
208
111
  icon?: string | null | undefined;
209
112
  };
113
+ id?: string | undefined;
114
+ slug?: string | undefined;
115
+ preferredEditor?: string | undefined;
210
116
  local?: {
211
117
  availableOffline?: boolean | undefined;
212
118
  sharingType?: string | null | undefined;
213
119
  } | undefined;
214
- id?: string | undefined;
215
- slug?: string | undefined;
216
- preferredEditor?: string | undefined;
217
120
  }, {
218
121
  global: {
219
122
  name: string;
220
123
  icon?: string | null | undefined;
221
124
  };
125
+ id?: string | undefined;
126
+ slug?: string | undefined;
127
+ preferredEditor?: string | undefined;
222
128
  local?: {
223
129
  availableOffline?: boolean | undefined;
224
130
  sharingType?: string | null | undefined;
225
131
  } | undefined;
226
- id?: string | undefined;
227
- slug?: string | undefined;
228
- preferredEditor?: string | undefined;
229
132
  }>;
230
133
  };
231
134
  readonly outputSchema: {
232
- readonly drive: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
135
+ readonly driveId: z.ZodString;
233
136
  };
234
137
  };
235
138
  export declare const getDriveTool: {
@@ -310,7 +213,49 @@ export declare const addRemoteDriveTool: {
310
213
  }>;
311
214
  };
312
215
  readonly outputSchema: {
313
- readonly drive: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
216
+ readonly driveId: z.ZodString;
217
+ };
218
+ };
219
+ type Properties<T> = Required<{
220
+ [K in keyof T]: z.ZodType<T[K], any, T[K]>;
221
+ }>;
222
+ export declare const getDocumentModelSchemaTool: {
223
+ readonly name: "getDocumentModelSchema";
224
+ readonly description: "Get the schema of a document model";
225
+ readonly inputSchema: {
226
+ readonly type: z.ZodString;
227
+ };
228
+ readonly outputSchema: {
229
+ readonly schema: z.ZodObject<Properties<DocumentModelState>>;
230
+ };
231
+ };
232
+ export declare const getDocumentModelsTool: {
233
+ readonly name: "getDocumentModels";
234
+ readonly description: "Get the list of document models";
235
+ readonly inputSchema: {};
236
+ readonly outputSchema: {
237
+ readonly documentModels: z.ZodArray<z.ZodObject<{
238
+ name: z.ZodString;
239
+ type: z.ZodString;
240
+ description: z.ZodString;
241
+ extension: z.ZodString;
242
+ authorName: z.ZodString;
243
+ authorWebsite: z.ZodString;
244
+ }, "strip", z.ZodTypeAny, {
245
+ type: string;
246
+ name: string;
247
+ description: string;
248
+ extension: string;
249
+ authorName: string;
250
+ authorWebsite: string;
251
+ }, {
252
+ type: string;
253
+ name: string;
254
+ description: string;
255
+ extension: string;
256
+ authorName: string;
257
+ authorWebsite: string;
258
+ }>, "many">;
314
259
  };
315
260
  };
316
261
  type ToolRecord<T extends readonly ToolSchema[]> = {
@@ -329,31 +274,13 @@ declare const allTools: readonly [{
329
274
  };
330
275
  }, {
331
276
  readonly name: "createDocument";
332
- readonly description: "Create a new document";
277
+ readonly description: "Create a new document.\n Unless the user specifies otherwise, and a drive named \"vetra\" is available, add the document after creating it to that drive using \"addActions\" tool with a \"ADD_FILE\" action to the drive document.";
333
278
  readonly inputSchema: {
334
279
  readonly documentType: z.ZodString;
335
280
  readonly documentId: z.ZodOptional<z.ZodString>;
336
281
  };
337
282
  readonly outputSchema: {
338
- readonly result: z.ZodObject<{
339
- status: z.ZodEnum<["SUCCESS", "CONFLICT", "MISSING", "ERROR"]>;
340
- error: z.ZodOptional<z.ZodString>;
341
- operations: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
342
- document: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
343
- signals: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
344
- }, "strip", z.ZodTypeAny, {
345
- status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
346
- operations: {}[];
347
- signals: {}[];
348
- document?: {} | undefined;
349
- error?: string | undefined;
350
- }, {
351
- status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
352
- operations: {}[];
353
- signals: {}[];
354
- document?: {} | undefined;
355
- error?: string | undefined;
356
- }>;
283
+ readonly documentId: z.ZodString;
357
284
  };
358
285
  }, {
359
286
  readonly name: "getDocuments";
@@ -374,108 +301,29 @@ declare const allTools: readonly [{
374
301
  readonly success: z.ZodBoolean;
375
302
  };
376
303
  }, {
377
- readonly name: "addAction";
378
- readonly description: "Add an action to a document";
304
+ readonly name: "addActions";
305
+ readonly description: "Adds actions to a document. Prefer adding multiples actions at once to reduce the number of steps.";
379
306
  readonly inputSchema: {
380
307
  readonly documentId: z.ZodString;
381
- readonly action: z.ZodObject<{
308
+ readonly actions: z.ZodArray<z.ZodObject<{
382
309
  type: z.ZodString;
383
- input: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>;
310
+ input: z.ZodUnknown;
384
311
  scope: z.ZodString;
385
312
  context: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
386
313
  }, "strict", z.ZodTypeAny, {
387
- scope: string;
388
- input: string | number | boolean | any[] | {} | null;
389
314
  type: string;
390
- context?: {} | undefined;
391
- }, {
392
315
  scope: string;
393
- input: string | number | boolean | any[] | {} | null;
394
- type: string;
316
+ input?: unknown;
395
317
  context?: {} | undefined;
396
- }>;
397
- };
398
- readonly outputSchema: {
399
- readonly result: z.ZodObject<{
400
- status: z.ZodEnum<["SUCCESS", "CONFLICT", "MISSING", "ERROR"]>;
401
- error: z.ZodOptional<z.ZodString>;
402
- operations: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
403
- document: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
404
- signals: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
405
- }, "strip", z.ZodTypeAny, {
406
- status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
407
- operations: {}[];
408
- signals: {}[];
409
- document?: {} | undefined;
410
- error?: string | undefined;
411
318
  }, {
412
- status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
413
- operations: {}[];
414
- signals: {}[];
415
- document?: {} | undefined;
416
- error?: string | undefined;
417
- }>;
418
- };
419
- }, {
420
- readonly name: "addOperation";
421
- readonly description: "Add an operation to a document";
422
- readonly inputSchema: {
423
- readonly documentId: z.ZodString;
424
- readonly operation: z.ZodObject<{
425
- type: z.ZodString;
426
- input: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, z.ZodArray<z.ZodAny, "many">, z.ZodNull]>;
427
- scope: z.ZodString;
428
- index: z.ZodNumber;
429
- timestamp: z.ZodString;
430
- hash: z.ZodString;
431
- skip: z.ZodNumber;
432
- error: z.ZodOptional<z.ZodString>;
433
- id: z.ZodOptional<z.ZodString>;
434
- context: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
435
- }, "strict", z.ZodTypeAny, {
436
- scope: string;
437
- input: string | number | boolean | any[] | {} | null;
438
319
  type: string;
439
- index: number;
440
- timestamp: string;
441
- hash: string;
442
- skip: number;
443
- id?: string | undefined;
444
- error?: string | undefined;
445
- context?: {} | undefined;
446
- }, {
447
320
  scope: string;
448
- input: string | number | boolean | any[] | {} | null;
449
- type: string;
450
- index: number;
451
- timestamp: string;
452
- hash: string;
453
- skip: number;
454
- id?: string | undefined;
455
- error?: string | undefined;
321
+ input?: unknown;
456
322
  context?: {} | undefined;
457
- }>;
323
+ }>, "many">;
458
324
  };
459
325
  readonly outputSchema: {
460
- readonly result: z.ZodObject<{
461
- status: z.ZodEnum<["SUCCESS", "CONFLICT", "MISSING", "ERROR"]>;
462
- error: z.ZodOptional<z.ZodString>;
463
- operations: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
464
- document: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
465
- signals: z.ZodArray<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>, "many">;
466
- }, "strip", z.ZodTypeAny, {
467
- status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
468
- operations: {}[];
469
- signals: {}[];
470
- document?: {} | undefined;
471
- error?: string | undefined;
472
- }, {
473
- status: "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
474
- operations: {}[];
475
- signals: {}[];
476
- document?: {} | undefined;
477
- error?: string | undefined;
478
- }>;
326
+ readonly success: z.ZodBoolean;
479
327
  };
480
328
  }, {
481
329
  readonly name: "getDrives";
@@ -517,29 +365,29 @@ declare const allTools: readonly [{
517
365
  name: string;
518
366
  icon?: string | null | undefined;
519
367
  };
368
+ id?: string | undefined;
369
+ slug?: string | undefined;
370
+ preferredEditor?: string | undefined;
520
371
  local?: {
521
372
  availableOffline?: boolean | undefined;
522
373
  sharingType?: string | null | undefined;
523
374
  } | undefined;
524
- id?: string | undefined;
525
- slug?: string | undefined;
526
- preferredEditor?: string | undefined;
527
375
  }, {
528
376
  global: {
529
377
  name: string;
530
378
  icon?: string | null | undefined;
531
379
  };
380
+ id?: string | undefined;
381
+ slug?: string | undefined;
382
+ preferredEditor?: string | undefined;
532
383
  local?: {
533
384
  availableOffline?: boolean | undefined;
534
385
  sharingType?: string | null | undefined;
535
386
  } | undefined;
536
- id?: string | undefined;
537
- slug?: string | undefined;
538
- preferredEditor?: string | undefined;
539
387
  }>;
540
388
  };
541
389
  readonly outputSchema: {
542
- readonly drive: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
390
+ readonly driveId: z.ZodString;
543
391
  };
544
392
  }, {
545
393
  readonly name: "getDrive";
@@ -617,14 +465,383 @@ declare const allTools: readonly [{
617
465
  }>;
618
466
  };
619
467
  readonly outputSchema: {
620
- readonly drive: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
468
+ readonly driveId: z.ZodString;
469
+ };
470
+ }, {
471
+ readonly name: "getDocumentModelSchema";
472
+ readonly description: "Get the schema of a document model";
473
+ readonly inputSchema: {
474
+ readonly type: z.ZodString;
475
+ };
476
+ readonly outputSchema: {
477
+ readonly schema: z.ZodObject<Properties<DocumentModelState>>;
478
+ };
479
+ }, {
480
+ readonly name: "getDocumentModels";
481
+ readonly description: "Get the list of document models";
482
+ readonly inputSchema: {};
483
+ readonly outputSchema: {
484
+ readonly documentModels: z.ZodArray<z.ZodObject<{
485
+ name: z.ZodString;
486
+ type: z.ZodString;
487
+ description: z.ZodString;
488
+ extension: z.ZodString;
489
+ authorName: z.ZodString;
490
+ authorWebsite: z.ZodString;
491
+ }, "strip", z.ZodTypeAny, {
492
+ type: string;
493
+ name: string;
494
+ description: string;
495
+ extension: string;
496
+ authorName: string;
497
+ authorWebsite: string;
498
+ }, {
499
+ type: string;
500
+ name: string;
501
+ description: string;
502
+ extension: string;
503
+ authorName: string;
504
+ authorWebsite: string;
505
+ }>, "many">;
621
506
  };
622
507
  }];
623
508
  export type ReactorMcpTools = ToolRecord<typeof allTools>;
624
509
  export declare function createReactorMcpProvider(reactor: IDocumentDriveServer): Promise<{
625
- tools: ReactorMcpTools;
626
- resources: {};
627
- prompts: {};
510
+ readonly tools: {
511
+ readonly getDocument: {
512
+ readonly name: "getDocument";
513
+ readonly description: "Retrieve a document by its ID";
514
+ readonly inputSchema: {
515
+ readonly id: z.ZodString;
516
+ };
517
+ readonly outputSchema: {
518
+ readonly document: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
519
+ };
520
+ } & {
521
+ callback: (args: {
522
+ id: string;
523
+ }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
524
+ };
525
+ readonly createDocument: {
526
+ readonly name: "createDocument";
527
+ readonly description: "Create a new document.\n Unless the user specifies otherwise, and a drive named \"vetra\" is available, add the document after creating it to that drive using \"addActions\" tool with a \"ADD_FILE\" action to the drive document.";
528
+ readonly inputSchema: {
529
+ readonly documentType: z.ZodString;
530
+ readonly documentId: z.ZodOptional<z.ZodString>;
531
+ };
532
+ readonly outputSchema: {
533
+ readonly documentId: z.ZodString;
534
+ };
535
+ } & {
536
+ callback: (args: {
537
+ documentType: string;
538
+ documentId?: string | undefined;
539
+ }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
540
+ };
541
+ readonly getDocuments: {
542
+ readonly name: "getDocuments";
543
+ readonly description: "List documents in a drive";
544
+ readonly inputSchema: {
545
+ readonly parentId: z.ZodString;
546
+ };
547
+ readonly outputSchema: {
548
+ readonly documentIds: z.ZodArray<z.ZodString, "many">;
549
+ };
550
+ } & {
551
+ callback: (args: {
552
+ parentId: string;
553
+ }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
554
+ };
555
+ readonly deleteDocument: {
556
+ readonly name: "deleteDocument";
557
+ readonly description: "Delete a document";
558
+ readonly inputSchema: {
559
+ readonly documentId: z.ZodString;
560
+ };
561
+ readonly outputSchema: {
562
+ readonly success: z.ZodBoolean;
563
+ };
564
+ } & {
565
+ callback: (args: {
566
+ documentId: string;
567
+ }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
568
+ };
569
+ readonly addActions: {
570
+ readonly name: "addActions";
571
+ readonly description: "Adds actions to a document. Prefer adding multiples actions at once to reduce the number of steps.";
572
+ readonly inputSchema: {
573
+ readonly documentId: z.ZodString;
574
+ readonly actions: z.ZodArray<z.ZodObject<{
575
+ type: z.ZodString;
576
+ input: z.ZodUnknown;
577
+ scope: z.ZodString;
578
+ context: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>>;
579
+ }, "strict", z.ZodTypeAny, {
580
+ type: string;
581
+ scope: string;
582
+ input?: unknown;
583
+ context?: {} | undefined;
584
+ }, {
585
+ type: string;
586
+ scope: string;
587
+ input?: unknown;
588
+ context?: {} | undefined;
589
+ }>, "many">;
590
+ };
591
+ readonly outputSchema: {
592
+ readonly success: z.ZodBoolean;
593
+ };
594
+ } & {
595
+ callback: (args: {
596
+ documentId: string;
597
+ actions: {
598
+ type: string;
599
+ scope: string;
600
+ input?: unknown;
601
+ context?: {} | undefined;
602
+ }[];
603
+ }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
604
+ };
605
+ readonly getDrives: {
606
+ readonly name: "getDrives";
607
+ readonly description: "List all drives";
608
+ readonly inputSchema: {};
609
+ readonly outputSchema: {
610
+ readonly driveIds: z.ZodArray<z.ZodString, "many">;
611
+ };
612
+ } & {
613
+ callback: (args: {}) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
614
+ };
615
+ readonly addDrive: {
616
+ readonly name: "addDrive";
617
+ readonly description: "Create a new drive";
618
+ readonly inputSchema: {
619
+ readonly driveInput: z.ZodObject<{
620
+ global: z.ZodObject<{
621
+ name: z.ZodString;
622
+ icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
623
+ }, "strip", z.ZodTypeAny, {
624
+ name: string;
625
+ icon?: string | null | undefined;
626
+ }, {
627
+ name: string;
628
+ icon?: string | null | undefined;
629
+ }>;
630
+ id: z.ZodOptional<z.ZodString>;
631
+ slug: z.ZodOptional<z.ZodString>;
632
+ preferredEditor: z.ZodOptional<z.ZodString>;
633
+ local: z.ZodOptional<z.ZodObject<{
634
+ availableOffline: z.ZodOptional<z.ZodBoolean>;
635
+ sharingType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
636
+ }, "strip", z.ZodTypeAny, {
637
+ availableOffline?: boolean | undefined;
638
+ sharingType?: string | null | undefined;
639
+ }, {
640
+ availableOffline?: boolean | undefined;
641
+ sharingType?: string | null | undefined;
642
+ }>>;
643
+ }, "strip", z.ZodTypeAny, {
644
+ global: {
645
+ name: string;
646
+ icon?: string | null | undefined;
647
+ };
648
+ id?: string | undefined;
649
+ slug?: string | undefined;
650
+ preferredEditor?: string | undefined;
651
+ local?: {
652
+ availableOffline?: boolean | undefined;
653
+ sharingType?: string | null | undefined;
654
+ } | undefined;
655
+ }, {
656
+ global: {
657
+ name: string;
658
+ icon?: string | null | undefined;
659
+ };
660
+ id?: string | undefined;
661
+ slug?: string | undefined;
662
+ preferredEditor?: string | undefined;
663
+ local?: {
664
+ availableOffline?: boolean | undefined;
665
+ sharingType?: string | null | undefined;
666
+ } | undefined;
667
+ }>;
668
+ };
669
+ readonly outputSchema: {
670
+ readonly driveId: z.ZodString;
671
+ };
672
+ } & {
673
+ callback: (args: {
674
+ driveInput: {
675
+ global: {
676
+ name: string;
677
+ icon?: string | null | undefined;
678
+ };
679
+ id?: string | undefined;
680
+ slug?: string | undefined;
681
+ preferredEditor?: string | undefined;
682
+ local?: {
683
+ availableOffline?: boolean | undefined;
684
+ sharingType?: string | null | undefined;
685
+ } | undefined;
686
+ };
687
+ }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
688
+ };
689
+ readonly getDrive: {
690
+ readonly name: "getDrive";
691
+ readonly description: "Get a specific drive";
692
+ readonly inputSchema: {
693
+ readonly driveId: z.ZodString;
694
+ readonly options: z.ZodOptional<z.ZodObject<{
695
+ revisions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
696
+ checkHashes: z.ZodOptional<z.ZodBoolean>;
697
+ }, "strip", z.ZodTypeAny, {
698
+ revisions?: Record<string, number> | undefined;
699
+ checkHashes?: boolean | undefined;
700
+ }, {
701
+ revisions?: Record<string, number> | undefined;
702
+ checkHashes?: boolean | undefined;
703
+ }>>;
704
+ };
705
+ readonly outputSchema: {
706
+ readonly drive: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
707
+ };
708
+ } & {
709
+ callback: (args: {
710
+ driveId: string;
711
+ options?: {
712
+ revisions?: Record<string, number> | undefined;
713
+ checkHashes?: boolean | undefined;
714
+ } | undefined;
715
+ }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
716
+ };
717
+ readonly deleteDrive: {
718
+ readonly name: "deleteDrive";
719
+ readonly description: "Delete a drive";
720
+ readonly inputSchema: {
721
+ readonly driveId: z.ZodString;
722
+ };
723
+ readonly outputSchema: {
724
+ readonly success: z.ZodBoolean;
725
+ };
726
+ } & {
727
+ callback: (args: {
728
+ driveId: string;
729
+ }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
730
+ };
731
+ readonly addRemoteDrive: {
732
+ readonly name: "addRemoteDrive";
733
+ readonly description: "Connect to a remote drive";
734
+ readonly inputSchema: {
735
+ readonly url: z.ZodString;
736
+ readonly options: z.ZodObject<{
737
+ availableOffline: z.ZodBoolean;
738
+ sharingType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
739
+ pullFilter: z.ZodOptional<z.ZodObject<{
740
+ branch: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
741
+ documentId: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
742
+ documentType: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
743
+ scope: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
744
+ }, "strip", z.ZodTypeAny, {
745
+ scope?: string[] | null | undefined;
746
+ documentType?: string[] | null | undefined;
747
+ documentId?: string[] | null | undefined;
748
+ branch?: string[] | null | undefined;
749
+ }, {
750
+ scope?: string[] | null | undefined;
751
+ documentType?: string[] | null | undefined;
752
+ documentId?: string[] | null | undefined;
753
+ branch?: string[] | null | undefined;
754
+ }>>;
755
+ pullInterval: z.ZodOptional<z.ZodNumber>;
756
+ }, "strip", z.ZodTypeAny, {
757
+ availableOffline: boolean;
758
+ sharingType?: string | null | undefined;
759
+ pullFilter?: {
760
+ scope?: string[] | null | undefined;
761
+ documentType?: string[] | null | undefined;
762
+ documentId?: string[] | null | undefined;
763
+ branch?: string[] | null | undefined;
764
+ } | undefined;
765
+ pullInterval?: number | undefined;
766
+ }, {
767
+ availableOffline: boolean;
768
+ sharingType?: string | null | undefined;
769
+ pullFilter?: {
770
+ scope?: string[] | null | undefined;
771
+ documentType?: string[] | null | undefined;
772
+ documentId?: string[] | null | undefined;
773
+ branch?: string[] | null | undefined;
774
+ } | undefined;
775
+ pullInterval?: number | undefined;
776
+ }>;
777
+ };
778
+ readonly outputSchema: {
779
+ readonly driveId: z.ZodString;
780
+ };
781
+ } & {
782
+ callback: (args: {
783
+ options: {
784
+ availableOffline: boolean;
785
+ sharingType?: string | null | undefined;
786
+ pullFilter?: {
787
+ scope?: string[] | null | undefined;
788
+ documentType?: string[] | null | undefined;
789
+ documentId?: string[] | null | undefined;
790
+ branch?: string[] | null | undefined;
791
+ } | undefined;
792
+ pullInterval?: number | undefined;
793
+ };
794
+ url: string;
795
+ }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
796
+ };
797
+ readonly getDocumentModels: {
798
+ readonly name: "getDocumentModels";
799
+ readonly description: "Get the list of document models";
800
+ readonly inputSchema: {};
801
+ readonly outputSchema: {
802
+ readonly documentModels: z.ZodArray<z.ZodObject<{
803
+ name: z.ZodString;
804
+ type: z.ZodString;
805
+ description: z.ZodString;
806
+ extension: z.ZodString;
807
+ authorName: z.ZodString;
808
+ authorWebsite: z.ZodString;
809
+ }, "strip", z.ZodTypeAny, {
810
+ type: string;
811
+ name: string;
812
+ description: string;
813
+ extension: string;
814
+ authorName: string;
815
+ authorWebsite: string;
816
+ }, {
817
+ type: string;
818
+ name: string;
819
+ description: string;
820
+ extension: string;
821
+ authorName: string;
822
+ authorWebsite: string;
823
+ }>, "many">;
824
+ };
825
+ } & {
826
+ callback: (args: {}) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
827
+ };
828
+ readonly getDocumentModelSchema: {
829
+ readonly name: "getDocumentModelSchema";
830
+ readonly description: "Get the schema of a document model";
831
+ readonly inputSchema: {
832
+ readonly type: z.ZodString;
833
+ };
834
+ readonly outputSchema: {
835
+ readonly schema: z.ZodObject<Properties<DocumentModelState>>;
836
+ };
837
+ } & {
838
+ callback: (args: {
839
+ type: string;
840
+ }) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>;
841
+ };
842
+ };
843
+ readonly resources: {};
844
+ readonly prompts: {};
628
845
  }>;
629
846
  export {};
630
847
  //# sourceMappingURL=reactor.d.ts.map