@agentknight/client 0.9.48 → 0.9.50

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.
@@ -0,0 +1,2902 @@
1
+ #!/usr/bin/env node
2
+
3
+ // ../../shared/protocol/dist/auth/authentication.js
4
+ import { z as z4 } from "zod";
5
+
6
+ // ../../shared/protocol/dist/common/primitives.js
7
+ import { z } from "zod";
8
+ var IdSchema = z.string().trim().min(1).max(256);
9
+ var IsoDateSchema = z.iso.datetime({ offset: true });
10
+ var Base64UrlKeyIdSchema = z.string().regex(/^[A-Za-z0-9_-]{22}$/u, "Expected a 16-byte base64url key ID");
11
+ var UsernameSchema = z.string().trim().min(1).max(120);
12
+
13
+ // ../../shared/protocol/dist/common/errors.js
14
+ import { z as z2 } from "zod";
15
+ var ProtocolFailureSchema = z2.object({
16
+ code: IdSchema,
17
+ message: z2.string().min(1).max(1024)
18
+ });
19
+ var OperationAckSchema = z2.discriminatedUnion("ok", [
20
+ z2.object({ ok: z2.literal(true), capabilities: z2.array(IdSchema).max(64).optional() }),
21
+ z2.object({
22
+ ok: z2.literal(false),
23
+ code: IdSchema,
24
+ message: z2.string().min(1).max(1024)
25
+ })
26
+ ]);
27
+ var ProtocolErrorSchema = z2.object({
28
+ event: z2.string().min(1).max(128),
29
+ code: IdSchema,
30
+ message: z2.string().min(1).max(1024)
31
+ });
32
+
33
+ // ../../shared/protocol/dist/auth/mobile-identity.js
34
+ import { z as z3 } from "zod";
35
+ var MobileAuthorizationIdSchema = z3.string().regex(/^[A-Za-z0-9_-]{43}$/u);
36
+ var MobileIdentityProofSchema = z3.object({
37
+ timestamp: z3.number().int().positive(),
38
+ nonce: MobileAuthorizationIdSchema,
39
+ signature: z3.string().regex(/^[A-Za-z0-9_-]+$/u).min(340).max(700)
40
+ }).strict();
41
+
42
+ // ../../shared/protocol/dist/auth/authentication.js
43
+ var UserRoleSchema = z4.enum(["admin", "user"]);
44
+ var PasswordSchema = z4.string().min(1).max(4096);
45
+ var PcTokenLabelSchema = z4.string().trim().min(1).max(120);
46
+ var AuthUserSchema = z4.object({
47
+ userId: IdSchema,
48
+ username: UsernameSchema,
49
+ role: UserRoleSchema
50
+ }).strict();
51
+ var AadAccountResultSchema = z4.object({
52
+ authMode: z4.literal("aad"),
53
+ user: AuthUserSchema
54
+ }).strict();
55
+ var RELAY_AUTH_DISCOVERY_PATH = "/.well-known/agentknight-auth";
56
+ var RelayAuthenticationSchema = z4.discriminatedUnion("mode", [
57
+ z4.object({ mode: z4.literal("microsoft") }).strict(),
58
+ z4.object({
59
+ mode: z4.literal("aad"),
60
+ tenantId: z4.uuid(),
61
+ clientId: z4.uuid(),
62
+ apiClientId: z4.uuid()
63
+ }).strict()
64
+ ]);
65
+ var RelayAuthDiscoverySchema = z4.object({
66
+ version: z4.literal(1),
67
+ authentication: z4.discriminatedUnion("mode", [...RelayAuthenticationSchema.options, z4.object({ mode: z4.literal("token") }).strict()])
68
+ }).strict();
69
+ var LoginRequestSchema = z4.object({
70
+ username: UsernameSchema,
71
+ password: PasswordSchema
72
+ });
73
+ var LoginResultSchema = z4.discriminatedUnion("ok", [
74
+ z4.object({
75
+ ok: z4.literal(true),
76
+ accessToken: z4.string().min(32),
77
+ expiresAt: z4.number().int().positive(),
78
+ user: AuthUserSchema
79
+ }),
80
+ z4.object({
81
+ ok: z4.literal(false),
82
+ error: ProtocolFailureSchema
83
+ })
84
+ ]);
85
+ var MobileLoginRequestSchema = z4.object({
86
+ mobileCredential: z4.string().min(64).max(4096),
87
+ clientId: IdSchema,
88
+ proof: MobileIdentityProofSchema.optional()
89
+ });
90
+ var PcAccountRequestSchema = z4.object({
91
+ userId: IdSchema,
92
+ machineId: IdSchema
93
+ }).strict();
94
+ var PcAccountResultSchema = z4.discriminatedUnion("ok", [
95
+ z4.object({
96
+ ok: z4.literal(true),
97
+ user: AuthUserSchema,
98
+ method: z4.enum(["microsoft", "token"])
99
+ }).strict(),
100
+ z4.object({
101
+ ok: z4.literal(false),
102
+ error: ProtocolFailureSchema
103
+ }).strict()
104
+ ]);
105
+ var AdminUserSummarySchema = z4.object({
106
+ userId: IdSchema,
107
+ username: UsernameSchema,
108
+ role: UserRoleSchema,
109
+ createdAt: z4.number().int().nonnegative(),
110
+ updatedAt: z4.number().int().nonnegative(),
111
+ disabledAt: z4.number().int().nonnegative().nullable()
112
+ }).strict();
113
+ var AdminFailureResultSchema = z4.object({
114
+ ok: z4.literal(false),
115
+ error: ProtocolFailureSchema
116
+ }).strict();
117
+ var AdminUserListResultSchema = z4.discriminatedUnion("ok", [
118
+ z4.object({
119
+ ok: z4.literal(true),
120
+ users: z4.array(AdminUserSummarySchema)
121
+ }).strict(),
122
+ AdminFailureResultSchema
123
+ ]);
124
+ var AdminUserCreateRequestSchema = z4.object({
125
+ username: UsernameSchema,
126
+ password: PasswordSchema
127
+ }).strict();
128
+ var AdminUserCreateResultSchema = z4.discriminatedUnion("ok", [
129
+ z4.object({
130
+ ok: z4.literal(true),
131
+ user: AdminUserSummarySchema
132
+ }).strict(),
133
+ AdminFailureResultSchema
134
+ ]);
135
+ var AdminUserStatusRequestSchema = z4.object({
136
+ userId: IdSchema,
137
+ disabled: z4.boolean()
138
+ }).strict();
139
+ var AdminUserStatusResultSchema = z4.discriminatedUnion("ok", [
140
+ z4.object({
141
+ ok: z4.literal(true),
142
+ user: AdminUserSummarySchema
143
+ }).strict(),
144
+ AdminFailureResultSchema
145
+ ]);
146
+ var AdminUserPasswordRequestSchema = z4.object({
147
+ userId: IdSchema,
148
+ password: PasswordSchema
149
+ }).strict();
150
+ var AdminUserPasswordResultSchema = z4.discriminatedUnion("ok", [
151
+ z4.object({
152
+ ok: z4.literal(true),
153
+ user: AdminUserSummarySchema
154
+ }).strict(),
155
+ AdminFailureResultSchema
156
+ ]);
157
+ var PcServiceTokenSummarySchema = z4.object({
158
+ tokenId: IdSchema,
159
+ userId: IdSchema,
160
+ label: PcTokenLabelSchema,
161
+ createdAt: z4.number().int().nonnegative(),
162
+ lastUsedAt: z4.number().int().nonnegative().nullable(),
163
+ revokedAt: z4.number().int().nonnegative().nullable()
164
+ }).strict();
165
+ var AdminPcTokenListRequestSchema = z4.object({
166
+ userId: IdSchema
167
+ }).strict();
168
+ var AdminPcTokenListResultSchema = z4.discriminatedUnion("ok", [
169
+ z4.object({
170
+ ok: z4.literal(true),
171
+ tokens: z4.array(PcServiceTokenSummarySchema)
172
+ }).strict(),
173
+ AdminFailureResultSchema
174
+ ]);
175
+ var AdminPcTokenIssueRequestSchema = z4.object({
176
+ userId: IdSchema,
177
+ label: PcTokenLabelSchema
178
+ }).strict();
179
+ var AdminPcTokenIssueResultSchema = z4.discriminatedUnion("ok", [
180
+ z4.object({
181
+ ok: z4.literal(true),
182
+ token: z4.string().min(32).max(256),
183
+ pcToken: PcServiceTokenSummarySchema
184
+ }).strict(),
185
+ AdminFailureResultSchema
186
+ ]);
187
+ var AdminPcTokenRevokeRequestSchema = z4.object({
188
+ tokenId: IdSchema
189
+ }).strict();
190
+ var AdminPcTokenRevokeResultSchema = z4.discriminatedUnion("ok", [
191
+ z4.object({
192
+ ok: z4.literal(true),
193
+ pcToken: PcServiceTokenSummarySchema
194
+ }).strict(),
195
+ AdminFailureResultSchema
196
+ ]);
197
+
198
+ // ../../shared/protocol/dist/conversation/timeline.js
199
+ import { z as z7 } from "zod";
200
+
201
+ // ../../shared/protocol/dist/conversation/conversation.js
202
+ import { z as z6 } from "zod";
203
+
204
+ // ../../shared/protocol/dist/conversation/attachments.js
205
+ import { z as z5 } from "zod";
206
+ var MAX_INLINE_IMAGE_BYTES = 3 * 1024 * 1024;
207
+ var MAX_INLINE_HTML_BYTES = 512 * 1024;
208
+ var MAX_PROMPT_FILE_BYTES = 1024 * 1024;
209
+ var InlineImageMimeTypeSchema = z5.enum([
210
+ "image/gif",
211
+ "image/jpeg",
212
+ "image/png",
213
+ "image/webp"
214
+ ]);
215
+ var Base64DataSchema = z5.string().min(4).max(Math.ceil(MAX_INLINE_IMAGE_BYTES / 3) * 4).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/, "Expected canonical base64 data");
216
+ var Sha256Schema = z5.string().regex(/^[a-f0-9]{64}$/);
217
+ function decodedBase64ByteLength(value) {
218
+ const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
219
+ return value.length / 4 * 3 - padding;
220
+ }
221
+ var PromptImageAttachmentSchema = z5.object({
222
+ name: z5.string().trim().min(1).max(255),
223
+ mimeType: z5.enum(["image/jpeg", "image/png", "image/webp"]),
224
+ data: Base64DataSchema,
225
+ byteLength: z5.number().int().positive().max(MAX_INLINE_IMAGE_BYTES),
226
+ sha256: Sha256Schema
227
+ }).strict().superRefine((attachment, context) => {
228
+ if (decodedBase64ByteLength(attachment.data) !== attachment.byteLength) {
229
+ context.addIssue({
230
+ code: "custom",
231
+ path: ["byteLength"],
232
+ message: "byteLength does not match the base64 payload"
233
+ });
234
+ }
235
+ });
236
+ var PromptFileAttachmentSchema = z5.object({
237
+ name: z5.string().trim().min(1).max(255).regex(/^[^\\/\x00-\x1f\x7f]+$/).refine((name) => name !== "." && name !== "..", "Expected a filename"),
238
+ mimeType: z5.string().max(256).regex(/^[a-zA-Z0-9!#$&^_.+-]+\/[a-zA-Z0-9!#$&^_.+-]+$/),
239
+ data: Base64DataSchema.max(Math.ceil(MAX_PROMPT_FILE_BYTES / 3) * 4),
240
+ byteLength: z5.number().int().positive().max(MAX_PROMPT_FILE_BYTES),
241
+ sha256: Sha256Schema
242
+ }).strict().superRefine((attachment, context) => {
243
+ if (decodedBase64ByteLength(attachment.data) !== attachment.byteLength) {
244
+ context.addIssue({
245
+ code: "custom",
246
+ path: ["byteLength"],
247
+ message: "byteLength does not match the base64 payload"
248
+ });
249
+ }
250
+ });
251
+ var ConversationAttachmentSchema = z5.object({
252
+ kind: z5.enum([
253
+ "file",
254
+ "image",
255
+ "html",
256
+ "selection",
257
+ "github-reference",
258
+ "unknown"
259
+ ]),
260
+ name: z5.string().trim().min(1).max(1024),
261
+ mimeType: z5.string().trim().min(1).max(256).optional(),
262
+ uri: z5.string().trim().min(1).max(32768).optional(),
263
+ data: Base64DataSchema.optional(),
264
+ byteLength: z5.number().int().positive().max(MAX_INLINE_IMAGE_BYTES).optional(),
265
+ sha256: Sha256Schema.optional(),
266
+ imageRef: z5.literal("sha256").optional()
267
+ }).strict().superRefine((attachment, context) => {
268
+ if (attachment.imageRef !== void 0) {
269
+ if (attachment.kind !== "image" || attachment.data !== void 0 || attachment.sha256 === void 0 || attachment.byteLength === void 0 || !InlineImageMimeTypeSchema.safeParse(attachment.mimeType).success) {
270
+ context.addIssue({
271
+ code: "custom",
272
+ message: "Image references require image metadata and must not carry inline data"
273
+ });
274
+ }
275
+ return;
276
+ }
277
+ const contentFields = [
278
+ attachment.data,
279
+ attachment.byteLength,
280
+ attachment.sha256
281
+ ];
282
+ const contentFieldCount = contentFields.filter((field) => field !== void 0).length;
283
+ if (contentFieldCount !== 0 && contentFieldCount !== contentFields.length) {
284
+ context.addIssue({
285
+ code: "custom",
286
+ message: "Inline attachment content requires data, byteLength, and sha256"
287
+ });
288
+ return;
289
+ }
290
+ if (attachment.data === void 0 || attachment.byteLength === void 0) {
291
+ return;
292
+ }
293
+ if (attachment.kind !== "image" && attachment.kind !== "html") {
294
+ context.addIssue({
295
+ code: "custom",
296
+ path: ["data"],
297
+ message: "Only image and html attachments may carry inline content"
298
+ });
299
+ }
300
+ if (attachment.kind === "image" && !InlineImageMimeTypeSchema.safeParse(attachment.mimeType).success) {
301
+ context.addIssue({
302
+ code: "custom",
303
+ path: ["mimeType"],
304
+ message: "Inline images must be GIF, JPEG, PNG, or WebP"
305
+ });
306
+ }
307
+ if (attachment.kind === "html" && (attachment.mimeType !== "text/html" || attachment.byteLength > MAX_INLINE_HTML_BYTES)) {
308
+ context.addIssue({
309
+ code: "custom",
310
+ path: ["mimeType"],
311
+ message: "HTML content must be text/html and at most 512 KiB"
312
+ });
313
+ }
314
+ if (decodedBase64ByteLength(attachment.data) !== attachment.byteLength) {
315
+ context.addIssue({
316
+ code: "custom",
317
+ path: ["byteLength"],
318
+ message: "byteLength does not match the base64 payload"
319
+ });
320
+ }
321
+ });
322
+
323
+ // ../../shared/protocol/dist/conversation/conversation.js
324
+ var CONVERSATION_ACTIVITY_STEP_LIMIT = 1e3;
325
+ var CONVERSATION_SOURCE_ID_LIMIT = 1e3;
326
+ var ConversationItemBaseShape = {
327
+ id: IdSchema,
328
+ revision: z6.number().int().positive(),
329
+ turnId: IdSchema,
330
+ timestamp: IsoDateSchema,
331
+ sourceEventIds: z6.array(IdSchema).min(1).max(CONVERSATION_SOURCE_ID_LIMIT),
332
+ sourceMessageIds: z6.array(IdSchema).min(1).max(CONVERSATION_SOURCE_ID_LIMIT).optional(),
333
+ sourceInteractionIds: z6.array(IdSchema).min(1).max(CONVERSATION_SOURCE_ID_LIMIT).optional()
334
+ };
335
+ var MAX_INLINE_IMAGE_MESSAGE_BYTES = 3 * 1024 * 1024;
336
+ var MAX_INLINE_IMAGES_PER_MESSAGE = 4;
337
+ var ActivityStepTimeShape = {
338
+ // First observed event time; completion updates must not move an existing call.
339
+ timestamp: IsoDateSchema.optional()
340
+ };
341
+ var ConversationToolStepSchema = z6.object({
342
+ id: IdSchema,
343
+ kind: z6.literal("tool"),
344
+ name: z6.string().trim().min(1).max(256),
345
+ status: z6.enum(["running", "completed", "failed"]),
346
+ ...ActivityStepTimeShape
347
+ }).strict();
348
+ var ConversationSkillStepSchema = z6.object({
349
+ id: IdSchema,
350
+ kind: z6.literal("skill"),
351
+ name: z6.string().trim().min(1).max(256),
352
+ status: z6.literal("completed"),
353
+ description: z6.string().trim().min(1).max(2048).optional(),
354
+ source: z6.string().trim().min(1).max(256).optional(),
355
+ ...ActivityStepTimeShape
356
+ }).strict();
357
+ var ConversationSubagentStepSchema = z6.object({
358
+ id: IdSchema,
359
+ kind: z6.literal("subagent"),
360
+ name: z6.string().trim().min(1).max(256),
361
+ status: z6.enum(["running", "completed", "failed"]),
362
+ description: z6.string().trim().min(1).max(2048).optional(),
363
+ model: z6.string().trim().min(1).max(256).optional(),
364
+ durationMs: z6.number().int().nonnegative().optional(),
365
+ resultSummary: z6.string().max(4096).optional(),
366
+ error: z6.string().max(4096).optional(),
367
+ ...ActivityStepTimeShape
368
+ }).strict();
369
+ var ConversationPermissionStepSchema = z6.object({
370
+ id: IdSchema,
371
+ kind: z6.literal("permission"),
372
+ name: z6.string().trim().min(1).max(256),
373
+ status: z6.enum(["running", "completed", "failed"]),
374
+ description: z6.string().trim().min(1).max(2048).optional(),
375
+ resultSummary: z6.string().max(4096).optional(),
376
+ error: z6.string().max(4096).optional(),
377
+ ...ActivityStepTimeShape
378
+ }).strict();
379
+ var ConversationActivityStepSchema = z6.discriminatedUnion("kind", [
380
+ ConversationToolStepSchema,
381
+ ConversationSkillStepSchema,
382
+ ConversationSubagentStepSchema,
383
+ ConversationPermissionStepSchema
384
+ ]);
385
+ var ConversationHumanMessageSchema = z6.object({
386
+ ...ConversationItemBaseShape,
387
+ kind: z6.literal("human-message"),
388
+ actor: z6.literal("human"),
389
+ content: z6.string().max(1e5),
390
+ attachments: z6.array(ConversationAttachmentSchema).max(100),
391
+ operationId: IdSchema.optional()
392
+ }).strict();
393
+ var ConversationAssistantMessageSchema = z6.object({
394
+ ...ConversationItemBaseShape,
395
+ kind: z6.literal("assistant-message"),
396
+ actor: z6.enum(["assistant", "subagent"]),
397
+ content: z6.string().max(5e5),
398
+ attachments: z6.array(ConversationAttachmentSchema).max(100).optional(),
399
+ model: z6.string().trim().min(1).max(256).optional(),
400
+ agentId: IdSchema.optional(),
401
+ final: z6.boolean()
402
+ }).strict().superRefine((message, context) => {
403
+ const inlineImages = message.attachments?.filter((attachment) => attachment.kind === "image" && attachment.data !== void 0) ?? [];
404
+ if (inlineImages.length > MAX_INLINE_IMAGES_PER_MESSAGE) {
405
+ context.addIssue({
406
+ code: "custom",
407
+ path: ["attachments"],
408
+ message: "Assistant messages may contain at most 4 inline images"
409
+ });
410
+ }
411
+ const inlineImageBytes = inlineImages.reduce((total, attachment) => total + (attachment.byteLength ?? 0), 0);
412
+ if (inlineImageBytes > MAX_INLINE_IMAGE_MESSAGE_BYTES) {
413
+ context.addIssue({
414
+ code: "custom",
415
+ path: ["attachments"],
416
+ message: "Assistant message images exceed the 3 MiB total limit"
417
+ });
418
+ }
419
+ });
420
+ var ConversationActivityGroupSchema = z6.object({
421
+ ...ConversationItemBaseShape,
422
+ kind: z6.literal("activity-group"),
423
+ actor: z6.enum(["assistant", "subagent"]),
424
+ status: z6.enum(["running", "completed", "failed"]),
425
+ steps: z6.array(ConversationActivityStepSchema).max(CONVERSATION_ACTIVITY_STEP_LIMIT)
426
+ }).strict();
427
+ var ConversationNoticeSchema = z6.object({
428
+ ...ConversationItemBaseShape,
429
+ kind: z6.literal("notice"),
430
+ actor: z6.enum(["system", "assistant", "subagent"]),
431
+ severity: z6.enum(["info", "success", "warning", "error"]),
432
+ title: z6.string().trim().min(1).max(256),
433
+ content: z6.string().max(4096),
434
+ presentation: z6.literal("compact").optional()
435
+ }).strict();
436
+ var ConversationPlanTodoSchema = z6.object({
437
+ id: IdSchema,
438
+ title: z6.string().trim().min(1).max(1024),
439
+ description: z6.string().max(4096).optional(),
440
+ status: z6.string().trim().min(1).max(64),
441
+ dependsOn: z6.array(IdSchema).max(100)
442
+ }).strict();
443
+ var ConversationPlanUpdateSchema = z6.object({
444
+ ...ConversationItemBaseShape,
445
+ kind: z6.literal("plan-update"),
446
+ actor: z6.enum(["assistant", "subagent"]),
447
+ operation: z6.enum(["created", "updated", "deleted"]),
448
+ content: z6.string().max(1e5),
449
+ todos: z6.array(ConversationPlanTodoSchema).max(1e3)
450
+ }).strict();
451
+ var ConversationItemSchema = z6.discriminatedUnion("kind", [
452
+ ConversationHumanMessageSchema,
453
+ ConversationAssistantMessageSchema,
454
+ ConversationActivityGroupSchema,
455
+ ConversationNoticeSchema,
456
+ ConversationPlanUpdateSchema
457
+ ]);
458
+ var ConversationItemUpsertSchema = z6.object({
459
+ userId: IdSchema,
460
+ machineId: IdSchema,
461
+ sessionId: IdSchema,
462
+ item: ConversationItemSchema
463
+ });
464
+ var ConversationActivityStepUpsertSchema = z6.object({
465
+ userId: IdSchema,
466
+ machineId: IdSchema,
467
+ sessionId: IdSchema,
468
+ activityId: IdSchema,
469
+ revision: z6.number().int().positive(),
470
+ turnId: IdSchema,
471
+ timestamp: IsoDateSchema,
472
+ actor: z6.enum(["assistant", "subagent"]),
473
+ status: z6.enum(["running", "completed", "failed"]),
474
+ sourceEventId: IdSchema,
475
+ step: ConversationActivityStepSchema
476
+ }).strict();
477
+
478
+ // ../../shared/protocol/dist/conversation/timeline.js
479
+ var SessionUserPreviewSchema = z7.object({
480
+ id: IdSchema,
481
+ revision: z7.number().int().positive(),
482
+ timestamp: IsoDateSchema,
483
+ text: z7.string().max(4096)
484
+ });
485
+ var SessionAssistantPreviewSchema = z7.object({
486
+ id: IdSchema,
487
+ revision: z7.number().int().positive(),
488
+ timestamp: IsoDateSchema,
489
+ sourceEventIds: z7.array(IdSchema).min(1).max(1e3),
490
+ text: z7.string().max(4096),
491
+ final: z7.boolean(),
492
+ attachments: z7.array(ConversationAttachmentSchema.refine((attachment) => attachment.kind === "image" && attachment.imageRef === "sha256", "Assistant previews contain image references only")).max(4),
493
+ kind: z7.enum(["assistant-message", "task-completion"]).optional()
494
+ });
495
+ var SESSION_TIMELINE_PAGE_SIZE = 100;
496
+ var SessionTimelinePageRequestSchema = z7.object({
497
+ requestId: IdSchema,
498
+ machineId: IdSchema,
499
+ sessionId: IdSchema,
500
+ cursor: z7.string().max(32768).optional(),
501
+ metadataOnly: z7.boolean().optional(),
502
+ acceptContentEncodings: z7.array(z7.string().min(1).max(32)).max(8).optional(),
503
+ imageReferences: z7.boolean().optional(),
504
+ pageSize: z7.number().int().min(1).max(SESSION_TIMELINE_PAGE_SIZE).default(SESSION_TIMELINE_PAGE_SIZE),
505
+ assistantPreview: z7.boolean().optional()
506
+ });
507
+ var SessionWatchRequestSchema = z7.object({
508
+ requestId: IdSchema,
509
+ machineId: IdSchema,
510
+ sessionId: IdSchema,
511
+ watching: z7.boolean()
512
+ }).strict();
513
+ var SessionWatchResultSchema = z7.discriminatedUnion("ok", [
514
+ z7.object({
515
+ ok: z7.literal(true),
516
+ requestId: IdSchema,
517
+ machineId: IdSchema,
518
+ sessionId: IdSchema,
519
+ watching: z7.boolean()
520
+ }).strict(),
521
+ z7.object({
522
+ ok: z7.literal(false),
523
+ requestId: IdSchema,
524
+ machineId: IdSchema,
525
+ sessionId: IdSchema,
526
+ watching: z7.boolean(),
527
+ error: ProtocolFailureSchema
528
+ }).strict()
529
+ ]);
530
+ var SessionTimelinePageSchema = z7.object({
531
+ items: z7.array(ConversationItemSchema).max(SESSION_TIMELINE_PAGE_SIZE),
532
+ cursor: z7.string().max(32768),
533
+ hasMore: z7.boolean(),
534
+ cursorStatus: z7.enum(["ok", "expired"]),
535
+ assistantPreview: SessionAssistantPreviewSchema.optional(),
536
+ userPreview: SessionUserPreviewSchema.optional(),
537
+ previewsComplete: z7.boolean().optional()
538
+ });
539
+ var SessionTimelinePageResultSchema = z7.discriminatedUnion("ok", [
540
+ z7.object({
541
+ ok: z7.literal(true),
542
+ requestId: IdSchema,
543
+ machineId: IdSchema,
544
+ sessionId: IdSchema,
545
+ page: SessionTimelinePageSchema
546
+ }),
547
+ z7.object({
548
+ ok: z7.literal(false),
549
+ requestId: IdSchema,
550
+ machineId: IdSchema,
551
+ sessionId: IdSchema,
552
+ error: ProtocolFailureSchema
553
+ })
554
+ ]);
555
+ var SessionTimelineInvalidatedSchema = z7.object({
556
+ userId: IdSchema,
557
+ machineId: IdSchema,
558
+ sessionId: IdSchema,
559
+ reason: z7.enum(["clear", "rewind"]),
560
+ sourceEventId: IdSchema,
561
+ timestamp: IsoDateSchema
562
+ }).strict();
563
+
564
+ // ../../shared/protocol/dist/common/version.js
565
+ import { z as z8 } from "zod";
566
+ var LEGACY_PROTOCOL_VERSION = 10;
567
+ var PROTOCOL_VERSION = 11;
568
+ var OLDEST_SUPPORTED_PROTOCOL_VERSION = 9;
569
+ var SupportedProtocolVersionSchema = z8.union([
570
+ z8.literal(OLDEST_SUPPORTED_PROTOCOL_VERSION),
571
+ z8.literal(LEGACY_PROTOCOL_VERSION),
572
+ z8.literal(PROTOCOL_VERSION)
573
+ ]);
574
+ var TRANSPORT_V2 = 2;
575
+
576
+ // ../../shared/protocol/dist/auth/pairing.js
577
+ import { z as z9 } from "zod";
578
+ var MOBILE_TRANSFER_MAX_PARTS = 64;
579
+ var MOBILE_TRANSFER_PART_DATA_MAX_LENGTH = 2600;
580
+ var MOBILE_TRANSFER_RELAY_TTL_MS = 10 * 60 * 1e3;
581
+ var MOBILE_TRANSFER_RELAY_MAX_CIPHERTEXT_LENGTH = 128 * 1024;
582
+ var PairingCreateRequestSchema = z9.object({
583
+ userId: IdSchema,
584
+ machineId: IdSchema,
585
+ stableDeviceId: IdSchema.optional(),
586
+ machineName: z9.string().trim().min(1).max(120),
587
+ keyId: Base64UrlKeyIdSchema.optional()
588
+ });
589
+ var PairingCreateResultSchema = z9.discriminatedUnion("ok", [
590
+ z9.object({
591
+ ok: z9.literal(true),
592
+ code: z9.string().min(32).max(256),
593
+ expiresAt: z9.number().int().positive(),
594
+ // Presence advertises the PC-only status endpoint; older Relays omit it.
595
+ statusId: z9.string().regex(/^[A-Za-z0-9_-]{43}$/u).optional()
596
+ }),
597
+ z9.object({
598
+ ok: z9.literal(false),
599
+ error: ProtocolFailureSchema
600
+ })
601
+ ]);
602
+ var PairingStatusRequestSchema = z9.object({
603
+ userId: IdSchema,
604
+ machineId: IdSchema,
605
+ statusId: z9.string().regex(/^[A-Za-z0-9_-]{43}$/u)
606
+ });
607
+ var PairingStatusSchema = z9.enum(["pending", "paired", "unavailable"]);
608
+ var PairingStatusResultSchema = z9.discriminatedUnion("ok", [
609
+ z9.object({ ok: z9.literal(true), state: PairingStatusSchema }),
610
+ z9.object({ ok: z9.literal(false), error: ProtocolFailureSchema })
611
+ ]);
612
+ var PairingExchangeRequestSchema = z9.object({
613
+ code: z9.string().min(32).max(256),
614
+ clientId: IdSchema
615
+ });
616
+ var PairingExchangeResultSchema = z9.discriminatedUnion("ok", [
617
+ z9.object({
618
+ ok: z9.literal(true),
619
+ accessToken: z9.string().min(32),
620
+ expiresAt: z9.number().int().positive(),
621
+ mobileCredential: z9.string().min(64).max(4096),
622
+ mobileCredentialExpiresAt: z9.number().int().positive(),
623
+ stableDeviceId: IdSchema.optional(),
624
+ user: AuthUserSchema
625
+ }),
626
+ z9.object({
627
+ ok: z9.literal(false),
628
+ error: ProtocolFailureSchema
629
+ })
630
+ ]);
631
+ var MobileTransferMachineSchema = z9.object({
632
+ machineId: IdSchema,
633
+ mobileCredential: z9.string().min(64).max(4096),
634
+ contentKey: z9.string().regex(/^[A-Za-z0-9_-]{43}$/u, "Expected a 32-byte base64url key"),
635
+ relayUrl: z9.url().max(2048).optional(),
636
+ relayUsername: UsernameSchema.optional(),
637
+ stableDeviceId: IdSchema.optional(),
638
+ pairedAt: z9.number().int().nonnegative().optional(),
639
+ lastSeenAt: z9.number().int().nonnegative().optional(),
640
+ sleeping: z9.boolean().optional(),
641
+ selected: z9.boolean().optional()
642
+ }).strict();
643
+ var MobileTransferPayloadSchema = z9.object({
644
+ relayUrl: z9.url().max(2048),
645
+ username: UsernameSchema,
646
+ machines: z9.array(MobileTransferMachineSchema).min(1).max(32)
647
+ }).strict().superRefine((payload, context) => {
648
+ const normalizeEndpoint = (value) => value.trim().replace(/\/+$/u, "").replace(/^(https?):\/\/(\[[^\]]+\]|[^:/?#]+)(?::([0-9]+))?(?=\/|$)/iu, (_match, scheme, host, rawPort) => {
649
+ const protocol = scheme.toLowerCase();
650
+ const port = rawPort === void 0 ? void 0 : Number(rawPort);
651
+ const isDefaultPort = protocol === "http" && port === 80 || protocol === "https" && port === 443;
652
+ const authorityPort = port === void 0 || isDefaultPort ? "" : `:${port}`;
653
+ return `${protocol}://${host.toLowerCase()}${authorityPort}`;
654
+ });
655
+ const defaultEndpoint = normalizeEndpoint(payload.relayUrl);
656
+ const identities = /* @__PURE__ */ new Set();
657
+ const devices = /* @__PURE__ */ new Map();
658
+ payload.machines.forEach((machine, index) => {
659
+ const endpoint = normalizeEndpoint(machine.relayUrl ?? payload.relayUrl);
660
+ const account = machine.relayUsername ?? (endpoint === defaultEndpoint ? payload.username : null);
661
+ const identity2 = JSON.stringify([machine.machineId, endpoint, account]);
662
+ if (identities.has(identity2)) {
663
+ context.addIssue({
664
+ code: "custom",
665
+ message: "Transfer contains duplicate PC authorizations",
666
+ path: ["machines", index]
667
+ });
668
+ }
669
+ identities.add(identity2);
670
+ const deviceId = machine.stableDeviceId ?? machine.machineId;
671
+ const connections = devices.get(deviceId) ?? [];
672
+ connections.push(machine);
673
+ devices.set(deviceId, connections);
674
+ });
675
+ for (const connections of devices.values()) {
676
+ if (connections.some((machine) => machine.selected !== void 0) && connections.filter((machine) => machine.selected !== false).length > 1) {
677
+ context.addIssue({
678
+ code: "custom",
679
+ message: "Transfer selects multiple connections for one PC",
680
+ path: ["machines"]
681
+ });
682
+ }
683
+ }
684
+ });
685
+ var MobileTransferPartSchema = z9.object({
686
+ transferId: z9.string().regex(/^[A-Za-z0-9_-]{43}$/u, "Expected a SHA-256 base64url digest"),
687
+ part: z9.number().int().min(1).max(MOBILE_TRANSFER_MAX_PARTS),
688
+ total: z9.number().int().min(2).max(MOBILE_TRANSFER_MAX_PARTS),
689
+ data: z9.string().min(1).max(MOBILE_TRANSFER_PART_DATA_MAX_LENGTH).regex(/^[A-Za-z0-9_-]+$/u, "Expected base64url data")
690
+ }).strict().refine(({ part, total }) => part <= total, {
691
+ message: "Part number must not exceed total parts",
692
+ path: ["part"]
693
+ });
694
+ var MobileTransferUploadRequestSchema = z9.object({
695
+ ciphertext: z9.string().min(1).max(MOBILE_TRANSFER_RELAY_MAX_CIPHERTEXT_LENGTH).regex(/^[A-Za-z0-9_-]+$/u, "Expected base64url ciphertext")
696
+ }).strict();
697
+ var MobileTransferUploadResultSchema = z9.object({
698
+ token: z9.string().regex(/^[A-Za-z0-9_-]{43}$/u, "Expected a 32-byte base64url token"),
699
+ expiresAt: z9.number().int().positive()
700
+ }).strict();
701
+ var MobileTransferDownloadResultSchema = z9.object({
702
+ ciphertext: z9.string().min(1).max(MOBILE_TRANSFER_RELAY_MAX_CIPHERTEXT_LENGTH).regex(/^[A-Za-z0-9_-]+$/u, "Expected base64url ciphertext")
703
+ }).strict();
704
+
705
+ // ../../shared/protocol/dist/auth/mobile-authorization.js
706
+ import { z as z10 } from "zod";
707
+ var MobileIdentityPublicKeySchema = z10.string().regex(/^[A-Za-z0-9_-]+$/u).min(350).max(800);
708
+ var MobileAuthorizationScopeSchema = z10.object({
709
+ userId: IdSchema,
710
+ machineId: IdSchema
711
+ }).strict();
712
+ var MobileAuthorizationCreateSchema = MobileAuthorizationScopeSchema.extend({
713
+ keyId: Base64UrlKeyIdSchema,
714
+ machineName: z10.string().trim().min(1).max(120),
715
+ stableDeviceId: IdSchema.optional()
716
+ });
717
+ var MobileAuthorizationClaimSchema = z10.object({
718
+ requestId: MobileAuthorizationIdSchema,
719
+ code: MobileAuthorizationIdSchema,
720
+ publicKey: MobileIdentityPublicKeySchema,
721
+ deviceName: z10.string().trim().min(1).max(120),
722
+ proof: MobileIdentityProofSchema
723
+ }).strict();
724
+ var MobileAuthorizationPollSchema = z10.object({
725
+ requestId: MobileAuthorizationIdSchema,
726
+ proof: MobileIdentityProofSchema
727
+ }).strict();
728
+ var MobileAuthorizationDecisionSchema = MobileAuthorizationScopeSchema.extend({
729
+ requestId: MobileAuthorizationIdSchema,
730
+ action: z10.enum(["approve", "reject", "revoke"]),
731
+ encryptedKey: z10.string().regex(/^[A-Za-z0-9_-]+$/u).min(340).max(700).optional()
732
+ }).strict().superRefine((value, context) => {
733
+ if (value.action === "approve" !== (value.encryptedKey !== void 0)) {
734
+ context.addIssue({ code: "custom", message: "Only approval requires an encrypted content key." });
735
+ }
736
+ });
737
+ var MobileAuthorizationStateSchema = z10.enum(["open", "pending", "active", "rejected", "cancelled", "expired", "revoked"]);
738
+ var MobileAuthorizationViewSchema = z10.object({
739
+ requestId: MobileAuthorizationIdSchema,
740
+ state: MobileAuthorizationStateSchema,
741
+ deviceName: z10.string(),
742
+ clientId: z10.string(),
743
+ publicKey: z10.string(),
744
+ confirmationCode: z10.string(),
745
+ createdAt: z10.number().int(),
746
+ expiresAt: z10.number().int(),
747
+ decidedAt: z10.number().int().nullable(),
748
+ lastSeenAt: z10.number().int().nullable(),
749
+ online: z10.boolean()
750
+ });
751
+ var MobileAuthorizationCreateResultSchema = z10.object({
752
+ requestId: MobileAuthorizationIdSchema,
753
+ code: MobileAuthorizationIdSchema,
754
+ expiresAt: z10.number().int()
755
+ });
756
+ var MobileAuthorizationListResultSchema = z10.object({
757
+ clients: z10.array(MobileAuthorizationViewSchema)
758
+ });
759
+ var MobileAuthorizationResultSchema = z10.object({
760
+ ok: z10.boolean(),
761
+ state: MobileAuthorizationStateSchema.optional(),
762
+ encryptedKey: z10.string().optional(),
763
+ mobileCredential: z10.string().optional(),
764
+ mobileCredentialExpiresAt: z10.number().int().optional(),
765
+ stableDeviceId: IdSchema.optional(),
766
+ user: AuthUserSchema.optional(),
767
+ error: ProtocolFailureSchema.optional()
768
+ });
769
+
770
+ // ../../shared/protocol/dist/auth/microsoft-enrollment.js
771
+ import { z as z11 } from "zod";
772
+ var MicrosoftIdentityReferenceSchema = z11.object({
773
+ issuer: z11.literal("https://login.microsoftonline.com/9188040d-6c67-4c5b-b112-36a304b66dad/v2.0"),
774
+ clientId: z11.uuid(),
775
+ subject: z11.string().min(1).max(255).regex(/^[\x21-\x7e]+$/)
776
+ }).strict();
777
+ var PcEnrollmentIdSchema = z11.uuid();
778
+ var PcEnrollmentStateSchema = z11.enum([
779
+ "pending",
780
+ "approved",
781
+ "issued",
782
+ "confirmed",
783
+ "cancelled",
784
+ "expired"
785
+ ]);
786
+ var PcEnrollmentStartRequestSchema = z11.object({
787
+ machineId: z11.string().min(1).max(128).regex(/^[A-Za-z0-9._:-]+$/),
788
+ deviceName: z11.string().trim().min(1).max(120).regex(/^[^\x00-\x1f\x7f]+$/),
789
+ codeChallenge: z11.string().regex(/^[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/)
790
+ }).strict();
791
+ var PcEnrollmentVerifierRequestSchema = z11.object({
792
+ verifier: z11.string().regex(/^[A-Za-z0-9._~-]{43,128}$/)
793
+ }).strict();
794
+ var MicrosoftCsrfRequestSchema = z11.object({
795
+ csrfToken: z11.string().min(1).max(256)
796
+ }).strict();
797
+ var PcEnrollmentApproveRequestSchema = MicrosoftCsrfRequestSchema.extend({
798
+ confirmationCode: z11.string().regex(/^[A-F0-9]{8}$/),
799
+ localCredentials: z11.object({
800
+ username: z11.string().trim().min(1).max(120),
801
+ password: z11.string().min(1).max(4096)
802
+ }).strict().optional()
803
+ }).strict();
804
+ var MicrosoftEnrollmentFailureSchema = z11.object({
805
+ ok: z11.literal(false),
806
+ error: z11.object({
807
+ code: z11.string().min(1).max(128),
808
+ message: z11.string().min(1).max(1024)
809
+ }).strict()
810
+ }).strict();
811
+ var MicrosoftMutationResultSchema = z11.discriminatedUnion("ok", [
812
+ z11.object({ ok: z11.literal(true) }).strict(),
813
+ MicrosoftEnrollmentFailureSchema
814
+ ]);
815
+ var PcEnrollmentStartResultSchema = z11.discriminatedUnion("ok", [
816
+ z11.object({
817
+ ok: z11.literal(true),
818
+ enrollmentId: PcEnrollmentIdSchema,
819
+ confirmationCode: z11.string().regex(/^[A-F0-9]{8}$/),
820
+ verificationUri: z11.url(),
821
+ expiresAt: z11.number().int().positive(),
822
+ intervalSeconds: z11.number().int().positive()
823
+ }).strict(),
824
+ MicrosoftEnrollmentFailureSchema
825
+ ]);
826
+ var PcEnrollmentStatusResultSchema = z11.discriminatedUnion("ok", [
827
+ z11.object({
828
+ ok: z11.literal(true),
829
+ state: PcEnrollmentStateSchema,
830
+ expiresAt: z11.number().int().positive()
831
+ }).strict(),
832
+ MicrosoftEnrollmentFailureSchema
833
+ ]);
834
+ var PcEnrollmentExchangeResultSchema = z11.discriminatedUnion("ok", [
835
+ z11.object({
836
+ ok: z11.literal(true),
837
+ token: z11.string().min(32).max(4096),
838
+ tokenId: z11.string().min(1).max(256),
839
+ grantId: z11.uuid(),
840
+ machineId: PcEnrollmentStartRequestSchema.shape.machineId,
841
+ user: AuthUserSchema,
842
+ confirmBy: z11.number().int().positive()
843
+ }).strict(),
844
+ MicrosoftEnrollmentFailureSchema
845
+ ]);
846
+ var PcBrowserRedirectUriSchema = z11.string().regex(/^http:\/\/127\.0\.0\.1:(?:[1-9]\d{0,3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5])\/relay-login\/callback$/);
847
+ var PcBrowserStateSchema = PcEnrollmentStartRequestSchema.shape.codeChallenge;
848
+ var PcBrowserAuthorizationCodeSchema = PcEnrollmentStartRequestSchema.shape.codeChallenge;
849
+ var PcBrowserAuthorizationStartRequestSchema = PcEnrollmentStartRequestSchema.extend({
850
+ redirectUri: PcBrowserRedirectUriSchema,
851
+ state: PcBrowserStateSchema
852
+ }).strict();
853
+ var PcBrowserAuthorizationStartResultSchema = z11.discriminatedUnion("ok", [
854
+ z11.object({
855
+ ok: z11.literal(true),
856
+ enrollmentId: PcEnrollmentIdSchema,
857
+ verificationUri: z11.url(),
858
+ expiresAt: z11.number().int().positive()
859
+ }).strict(),
860
+ MicrosoftEnrollmentFailureSchema
861
+ ]);
862
+ var PcBrowserAuthorizationExchangeRequestSchema = PcEnrollmentVerifierRequestSchema.extend({
863
+ code: PcBrowserAuthorizationCodeSchema,
864
+ redirectUri: PcBrowserRedirectUriSchema
865
+ }).strict();
866
+ var PcBrowserAuthorizationCallbackSchema = z11.union([
867
+ z11.object({ state: PcBrowserStateSchema, code: PcBrowserAuthorizationCodeSchema }).strict(),
868
+ z11.object({
869
+ state: PcBrowserStateSchema,
870
+ error: z11.enum(["access_denied", "expired", "cancelled"])
871
+ }).strict()
872
+ ]);
873
+ var MicrosoftDeviceSchema = z11.object({
874
+ grantId: z11.uuid(),
875
+ tokenId: z11.string().min(1).max(256),
876
+ machineId: PcEnrollmentStartRequestSchema.shape.machineId,
877
+ deviceName: PcEnrollmentStartRequestSchema.shape.deviceName,
878
+ createdAt: z11.number().int().nonnegative(),
879
+ revokedAt: z11.number().int().nonnegative().nullable()
880
+ }).strict();
881
+ var MicrosoftDevicesResultSchema = z11.discriminatedUnion("ok", [
882
+ z11.object({
883
+ ok: z11.literal(true),
884
+ identity: MicrosoftIdentityReferenceSchema,
885
+ devices: z11.array(MicrosoftDeviceSchema)
886
+ }).strict(),
887
+ MicrosoftEnrollmentFailureSchema
888
+ ]);
889
+ var MicrosoftIdentitySummarySchema = MicrosoftIdentityReferenceSchema.extend({
890
+ identityId: z11.uuid(),
891
+ userId: z11.string().min(1).max(256).nullable(),
892
+ allowed: z11.boolean(),
893
+ decidedBy: z11.string().min(1).max(256),
894
+ decidedAt: z11.number().int().nonnegative(),
895
+ createdAt: z11.number().int().nonnegative(),
896
+ lastLoginAt: z11.number().int().nonnegative().nullable()
897
+ }).strict();
898
+ var MicrosoftIdentityAllowRequestSchema = z11.object({
899
+ identity: MicrosoftIdentityReferenceSchema,
900
+ allowed: z11.boolean()
901
+ }).strict();
902
+ var MicrosoftIdentityAllowResultSchema = z11.discriminatedUnion("ok", [
903
+ z11.object({ ok: z11.literal(true), identity: MicrosoftIdentitySummarySchema }).strict(),
904
+ MicrosoftEnrollmentFailureSchema
905
+ ]);
906
+ var MicrosoftIdentitiesResultSchema = z11.discriminatedUnion("ok", [
907
+ z11.object({ ok: z11.literal(true), identities: z11.array(MicrosoftIdentitySummarySchema) }).strict(),
908
+ MicrosoftEnrollmentFailureSchema
909
+ ]);
910
+ var MicrosoftInvitationEmailSchema = z11.email().max(254).regex(/^[\x21-\x7e]+$/);
911
+ var MicrosoftInvitationCodeSchema = z11.string().length(24).regex(/^[A-F0-9]{24}$/);
912
+ var MicrosoftInvitationCreateRequestSchema = z11.object({
913
+ email: MicrosoftInvitationEmailSchema
914
+ }).strict();
915
+ var MicrosoftInvitationCreateResultSchema = z11.discriminatedUnion("ok", [
916
+ z11.object({
917
+ ok: z11.literal(true),
918
+ invitationId: z11.uuid(),
919
+ email: MicrosoftInvitationEmailSchema,
920
+ code: MicrosoftInvitationCodeSchema,
921
+ expiresAt: z11.number().int().nonnegative(),
922
+ invitationUri: z11.url()
923
+ }).strict(),
924
+ MicrosoftEnrollmentFailureSchema
925
+ ]);
926
+ var MicrosoftInvitationAcceptRequestSchema = MicrosoftCsrfRequestSchema.extend({
927
+ code: MicrosoftInvitationCodeSchema
928
+ }).strict();
929
+
930
+ // ../../shared/protocol/dist/transport/event-names.js
931
+ import { z as z12 } from "zod";
932
+ var PcSecureEventNameSchema = z12.enum([
933
+ "session.communication",
934
+ "session.list.result",
935
+ "session.options.result",
936
+ "session.create.result",
937
+ "session.delete.result",
938
+ "session.configure.result",
939
+ "session.remote.result",
940
+ "session.timeline.page.result",
941
+ "session.watch.result",
942
+ "session.prompt.result",
943
+ "session.activity",
944
+ "session.abort.result",
945
+ "conversation.item.upsert",
946
+ "conversation.activity.step.upsert",
947
+ "session.timeline.invalidated",
948
+ "interaction.request",
949
+ "interaction.respond.result",
950
+ "permission.request",
951
+ "permission.respond.result",
952
+ "sessions.snapshot"
953
+ ]);
954
+ var MobileSecureEventNameSchema = z12.enum([
955
+ "session.communication",
956
+ "session.list",
957
+ "session.options",
958
+ "session.create",
959
+ "session.delete",
960
+ "session.configure",
961
+ "session.remote",
962
+ "session.timeline.page",
963
+ "session.watch",
964
+ "session.prompt",
965
+ "session.abort",
966
+ "interaction.respond",
967
+ "permission.respond"
968
+ ]);
969
+ var SecureEventNameSchema = z12.enum([
970
+ "session.communication",
971
+ "session.list.result",
972
+ "session.options.result",
973
+ "session.create.result",
974
+ "session.delete.result",
975
+ "session.configure.result",
976
+ "session.remote.result",
977
+ "session.timeline.page.result",
978
+ "session.watch.result",
979
+ "session.prompt.result",
980
+ "session.activity",
981
+ "session.abort.result",
982
+ "conversation.item.upsert",
983
+ "conversation.activity.step.upsert",
984
+ "session.timeline.invalidated",
985
+ "interaction.request",
986
+ "interaction.respond.result",
987
+ "permission.request",
988
+ "permission.respond.result",
989
+ "sessions.snapshot",
990
+ "session.list",
991
+ "session.options",
992
+ "session.create",
993
+ "session.delete",
994
+ "session.configure",
995
+ "session.remote",
996
+ "session.timeline.page",
997
+ "session.watch",
998
+ "session.prompt",
999
+ "session.abort",
1000
+ "interaction.respond",
1001
+ "permission.respond"
1002
+ ]);
1003
+
1004
+ // ../../shared/protocol/dist/transport/transport.js
1005
+ import { z as z13 } from "zod";
1006
+ var RoleSchema = z13.enum(["pc", "mobile"]);
1007
+ var V2SocketAuthBaseShape = {
1008
+ transportVersion: z13.coerce.number().pipe(z13.literal(TRANSPORT_V2)),
1009
+ protocolVersion: z13.coerce.number().pipe(SupportedProtocolVersionSchema),
1010
+ token: z13.string().min(1),
1011
+ clientId: IdSchema,
1012
+ machineId: IdSchema,
1013
+ keyId: Base64UrlKeyIdSchema
1014
+ };
1015
+ var V2PcSocketAuthSchema = z13.object({
1016
+ ...V2SocketAuthBaseShape,
1017
+ role: z13.literal("pc"),
1018
+ userId: IdSchema
1019
+ }).strict();
1020
+ var V2MobileSocketAuthSchema = z13.object({
1021
+ ...V2SocketAuthBaseShape,
1022
+ role: z13.literal("mobile"),
1023
+ mobileCredential: z13.string().min(64).max(4096),
1024
+ proof: z13.preprocess((value) => {
1025
+ if (typeof value !== "string" || value.length > 2048)
1026
+ return value;
1027
+ try {
1028
+ return JSON.parse(value);
1029
+ } catch {
1030
+ return value;
1031
+ }
1032
+ }, MobileIdentityProofSchema).optional()
1033
+ }).strict();
1034
+ var V2SocketAuthSchema = z13.discriminatedUnion("role", [
1035
+ V2PcSocketAuthSchema,
1036
+ V2MobileSocketAuthSchema
1037
+ ]);
1038
+ var SECURE_MESSAGE_MAX_CIPHERTEXT_LENGTH = 16e6;
1039
+ var SecureMessageBaseShape = {
1040
+ version: z13.literal(1),
1041
+ algorithm: z13.literal("A256GCM"),
1042
+ messageId: IdSchema,
1043
+ machineId: IdSchema,
1044
+ clientId: IdSchema,
1045
+ recipientClientId: IdSchema.optional(),
1046
+ keyId: Base64UrlKeyIdSchema,
1047
+ sentAt: z13.number().int().nonnegative(),
1048
+ nonce: z13.string().regex(/^[A-Za-z0-9_-]{16}$/u, "Expected a 12-byte base64url nonce"),
1049
+ ciphertext: z13.string().min(22).max(SECURE_MESSAGE_MAX_CIPHERTEXT_LENGTH).regex(/^[A-Za-z0-9_-]+$/u, "Expected base64url ciphertext")
1050
+ };
1051
+ var SecureMessageSchema = z13.discriminatedUnion("sender", [
1052
+ z13.object({
1053
+ ...SecureMessageBaseShape,
1054
+ sender: z13.literal("pc"),
1055
+ event: PcSecureEventNameSchema
1056
+ }).strict(),
1057
+ z13.object({
1058
+ ...SecureMessageBaseShape,
1059
+ sender: z13.literal("mobile"),
1060
+ event: MobileSecureEventNameSchema
1061
+ }).strict()
1062
+ ]);
1063
+ var SecureDeliveryErrorSchema = z13.object({
1064
+ messageId: IdSchema,
1065
+ event: SecureEventNameSchema,
1066
+ machineId: IdSchema,
1067
+ code: z13.enum([
1068
+ "MACHINE_OFFLINE",
1069
+ "IDENTITY_MISMATCH",
1070
+ "KEY_ID_MISMATCH",
1071
+ "INVALID_PAYLOAD",
1072
+ "SESSION_DELETE_UNSUPPORTED",
1073
+ "SESSION_COMMUNICATION_UNSUPPORTED"
1074
+ ]),
1075
+ message: z13.string().min(1).max(1024)
1076
+ }).strict();
1077
+
1078
+ // ../../shared/protocol/dist/transport/machines.js
1079
+ import { z as z14 } from "zod";
1080
+ var MACHINE_HELLO_SDK_COMPAT_VERSION = "1.0.9";
1081
+ var MachineHelloBaseShape = {
1082
+ userId: IdSchema,
1083
+ machineId: IdSchema,
1084
+ machineName: z14.string().trim().min(1).max(120),
1085
+ platform: z14.string().trim().min(1).max(64),
1086
+ agentRunId: IdSchema,
1087
+ sdkVersion: z14.literal(MACHINE_HELLO_SDK_COMPAT_VERSION),
1088
+ clientVersion: z14.string().trim().min(1).max(64).optional(),
1089
+ capabilities: z14.array(IdSchema).max(64).optional()
1090
+ };
1091
+ var OldestSupportedMachineHelloSchema = z14.object({
1092
+ ...MachineHelloBaseShape,
1093
+ protocolVersion: z14.literal(OLDEST_SUPPORTED_PROTOCOL_VERSION)
1094
+ });
1095
+ var LegacyMachineHelloSchema = z14.object({
1096
+ ...MachineHelloBaseShape,
1097
+ protocolVersion: z14.literal(LEGACY_PROTOCOL_VERSION)
1098
+ });
1099
+ var MachineHelloSchema = z14.object({
1100
+ ...MachineHelloBaseShape,
1101
+ protocolVersion: z14.literal(PROTOCOL_VERSION)
1102
+ });
1103
+ var CompatibleMachineHelloSchema = z14.union([
1104
+ OldestSupportedMachineHelloSchema,
1105
+ LegacyMachineHelloSchema,
1106
+ MachineHelloSchema
1107
+ ]);
1108
+ var V2MachineHelloSchema = z14.union([
1109
+ OldestSupportedMachineHelloSchema.strict(),
1110
+ LegacyMachineHelloSchema.strict(),
1111
+ MachineHelloSchema.strict()
1112
+ ]);
1113
+ var MachineHeartbeatSchema = z14.object({
1114
+ userId: IdSchema,
1115
+ machineId: IdSchema,
1116
+ agentRunId: IdSchema,
1117
+ sentAt: z14.number().int().nonnegative()
1118
+ });
1119
+ var MachinePresenceStateShape = {
1120
+ online: z14.literal(true),
1121
+ connectedAt: z14.number().int().nonnegative(),
1122
+ lastSeen: z14.number().int().nonnegative()
1123
+ };
1124
+ var MachinePresenceSchema = z14.union([
1125
+ OldestSupportedMachineHelloSchema.extend(MachinePresenceStateShape),
1126
+ LegacyMachineHelloSchema.extend(MachinePresenceStateShape),
1127
+ MachineHelloSchema.extend(MachinePresenceStateShape)
1128
+ ]);
1129
+ var MachineOfflineSchema = z14.object({
1130
+ userId: IdSchema,
1131
+ machineId: IdSchema,
1132
+ agentRunId: IdSchema,
1133
+ disconnectedAt: z14.number().int().nonnegative()
1134
+ });
1135
+ var MobileDisconnectedSchema = z14.object({
1136
+ clientId: IdSchema,
1137
+ machineId: IdSchema,
1138
+ disconnectedAt: z14.number().int().nonnegative()
1139
+ });
1140
+ var MobileConnectedSchema = z14.object({
1141
+ clientId: IdSchema,
1142
+ machineId: IdSchema,
1143
+ connectedAt: z14.number().int().nonnegative(),
1144
+ capabilities: z14.array(IdSchema).max(64).optional()
1145
+ });
1146
+ var MachineListRequestSchema = z14.object({
1147
+ requestId: IdSchema
1148
+ });
1149
+ var MachineListResultSchema = z14.object({
1150
+ requestId: IdSchema,
1151
+ machines: z14.array(MachinePresenceSchema),
1152
+ // Absent on older relays; PC presence capabilities alone do not negotiate routing.
1153
+ relayCapabilities: z14.array(IdSchema).max(64).optional()
1154
+ });
1155
+
1156
+ // ../../shared/protocol/dist/transport/peer-message.js
1157
+ import { z as z15 } from "zod";
1158
+ var PeerTextSchema = z15.string().max(16e3).refine((value) => value.trim().length > 0);
1159
+ var PeerMessageBaseShape = {
1160
+ version: z15.literal(1),
1161
+ messageId: IdSchema,
1162
+ sourceSessionId: IdSchema,
1163
+ targetMachineId: IdSchema,
1164
+ targetSessionId: IdSchema
1165
+ };
1166
+ var PeerMessageSchema = z15.discriminatedUnion("kind", [
1167
+ z15.object({
1168
+ ...PeerMessageBaseShape,
1169
+ kind: z15.literal("request"),
1170
+ content: PeerTextSchema,
1171
+ timeoutMs: z15.number().int().min(1e3).max(12e4)
1172
+ }).strict(),
1173
+ z15.object({
1174
+ ...PeerMessageBaseShape,
1175
+ kind: z15.literal("response"),
1176
+ requestId: IdSchema,
1177
+ content: PeerTextSchema
1178
+ }).strict(),
1179
+ z15.object({
1180
+ ...PeerMessageBaseShape,
1181
+ kind: z15.literal("error"),
1182
+ requestId: IdSchema,
1183
+ code: z15.string().trim().min(1).max(80),
1184
+ message: z15.string().trim().min(1).max(1024)
1185
+ }).strict(),
1186
+ z15.object({
1187
+ ...PeerMessageBaseShape,
1188
+ kind: z15.literal("cancel"),
1189
+ requestId: IdSchema
1190
+ }).strict()
1191
+ ]);
1192
+ var PeerDeliverySchema = z15.object({
1193
+ sourceMachineId: IdSchema,
1194
+ message: PeerMessageSchema
1195
+ }).strict();
1196
+
1197
+ // ../../shared/protocol/dist/transport/a2a.js
1198
+ import { z as z16 } from "zod";
1199
+ var A2A_BODY_MAX_LENGTH = 65536;
1200
+ var A2aRelayRequestSchema = z16.object({
1201
+ userId: IdSchema,
1202
+ sourceMachineId: IdSchema,
1203
+ targetSessionId: IdSchema,
1204
+ endpointUrl: z16.url().max(2048),
1205
+ kind: z16.enum(["card", "rpc"]),
1206
+ body: z16.string().max(A2A_BODY_MAX_LENGTH),
1207
+ protocolVersion: z16.string().max(32).optional()
1208
+ }).strict().refine((request) => request.kind !== "card" || request.body === "", {
1209
+ path: ["body"],
1210
+ message: "Agent card requests must have an empty body"
1211
+ });
1212
+ var A2aRelayResponseSchema = z16.object({
1213
+ status: z16.number().int().min(200).max(599),
1214
+ body: z16.string().max(A2A_BODY_MAX_LENGTH)
1215
+ }).strict();
1216
+
1217
+ // ../../shared/protocol/dist/transport/browser-open-url.js
1218
+ import { z as z17 } from "zod";
1219
+ var BROWSER_OPEN_URL_MAX_LENGTH = 8192;
1220
+ var BrowserOpenUrlParamsSchema = z17.strictObject({
1221
+ url: z17.string().min(1).max(BROWSER_OPEN_URL_MAX_LENGTH).refine((value) => {
1222
+ if (!/^https?:\/\//i.test(value) || /[\s\p{Cc}\\]/u.test(value) || /%(?![0-9a-f]{2})/i.test(value))
1223
+ return false;
1224
+ const authority = value.split(/[/?#]/)[2];
1225
+ if (!authority || /[@%]|[^\x21-\x7e]/.test(authority))
1226
+ return false;
1227
+ try {
1228
+ return new URL(value).hostname.length > 0;
1229
+ } catch {
1230
+ return false;
1231
+ }
1232
+ }, "Expected an absolute HTTP(S) URL without credentials or whitespace")
1233
+ });
1234
+ var BrowserOpenUrlResultSchema = z17.strictObject({ opened: z17.literal(true) });
1235
+
1236
+ // ../../shared/protocol/dist/sessions/session-communication.js
1237
+ import { z as z18 } from "zod";
1238
+ var SessionCommunicationIdSchema = z18.string().min(1).max(256).refine((value) => value === value.trim(), "Expected an unpadded identity");
1239
+ var SessionCommunicationIdentityShape = {
1240
+ requestId: SessionCommunicationIdSchema,
1241
+ machineId: SessionCommunicationIdSchema,
1242
+ sessionId: SessionCommunicationIdSchema,
1243
+ operation: z18.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/u),
1244
+ version: z18.number().int().positive().max(2147483647)
1245
+ };
1246
+ var SessionCommunicationDataSchema = z18.record(z18.string(), z18.json());
1247
+ var SessionCommunicationRequestSchema = z18.object({
1248
+ ...SessionCommunicationIdentityShape,
1249
+ kind: z18.literal("request"),
1250
+ data: SessionCommunicationDataSchema
1251
+ }).strict();
1252
+ var SessionCommunicationResponseSchema = z18.object({
1253
+ ...SessionCommunicationIdentityShape,
1254
+ kind: z18.literal("response"),
1255
+ data: SessionCommunicationDataSchema
1256
+ }).strict();
1257
+ var SessionCommunicationErrorSchema = z18.object({
1258
+ ...SessionCommunicationIdentityShape,
1259
+ kind: z18.literal("error"),
1260
+ error: ProtocolFailureSchema
1261
+ }).strict();
1262
+ var SessionCommunicationSchema = z18.discriminatedUnion("kind", [
1263
+ SessionCommunicationRequestSchema,
1264
+ SessionCommunicationResponseSchema,
1265
+ SessionCommunicationErrorSchema
1266
+ ]);
1267
+ function sessionCommunicationOperationCapability(operation, version) {
1268
+ return `${operation}.v${version}`;
1269
+ }
1270
+
1271
+ // ../../shared/protocol/dist/sessions/session-workspace.js
1272
+ import { z as z19 } from "zod";
1273
+ var SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH = 32768;
1274
+ var SESSION_PROJECT_IDENTITY_MAX_RESPONSE_BYTES = 640 * 1024;
1275
+ var SESSION_DIRECTORY_MAX_PATH_LENGTH = 1024;
1276
+ var SESSION_DIRECTORY_MAX_DEPTH = 32;
1277
+ var SESSION_DIRECTORY_MAX_ENTRIES = 500;
1278
+ var SESSION_DIRECTORY_MAX_RESPONSE_BYTES = 128 * 1024;
1279
+ var SESSION_FILE_MAX_ORIGINAL_BYTES = 500 * 1024;
1280
+ var SESSION_FILE_V2_MAX_ORIGINAL_BYTES = 1024 * 1024;
1281
+ var SESSION_FILE_GZIP_THRESHOLD_BYTES = 20 * 1024;
1282
+ var SESSION_FILE_MAX_IMAGE_BYTES = 100 * 1024;
1283
+ var SESSION_FILE_MAX_IMAGE_PIXELS = 16 * 1024 * 1024;
1284
+ var SESSION_FILE_MAX_TRANSFER_BYTES = SESSION_FILE_MAX_ORIGINAL_BYTES + 1024;
1285
+ var SESSION_FILE_MAX_BASE64_LENGTH = Math.ceil(SESSION_FILE_MAX_TRANSFER_BYTES / 3) * 4;
1286
+ var SESSION_FILE_MAX_RESPONSE_BYTES = SESSION_FILE_MAX_BASE64_LENGTH + 8192;
1287
+ var SESSION_FILE_V2_MAX_TRANSFER_BYTES = SESSION_FILE_V2_MAX_ORIGINAL_BYTES + 1024;
1288
+ var SESSION_FILE_V2_MAX_BASE64_LENGTH = Math.ceil(SESSION_FILE_V2_MAX_TRANSFER_BYTES / 3) * 4;
1289
+ var SESSION_FILE_V2_MAX_RESPONSE_BYTES = SESSION_FILE_V2_MAX_BASE64_LENGTH + 8192;
1290
+ var SESSION_FILE_MEDIA_TYPES = [
1291
+ "text/plain",
1292
+ "text/html",
1293
+ "text/markdown",
1294
+ "text/css",
1295
+ "text/javascript",
1296
+ "application/json",
1297
+ "application/xml",
1298
+ "text/xml",
1299
+ "application/yaml",
1300
+ "image/webp"
1301
+ ];
1302
+ var SESSION_FILE_VIDEO_MEDIA_TYPES = ["video/mp4", "video/webm"];
1303
+ var SESSION_FILE_V2_MEDIA_TYPES = [...SESSION_FILE_MEDIA_TYPES, ...SESSION_FILE_VIDEO_MEDIA_TYPES];
1304
+ var SESSION_FILE_MAX_VIDEO_PIXELS = 16 * 1024 * 1024;
1305
+ function isSafeSessionDirectoryPath(path) {
1306
+ if (path === "")
1307
+ return true;
1308
+ if (path.length > SESSION_DIRECTORY_MAX_PATH_LENGTH)
1309
+ return false;
1310
+ const segments = path.split("/");
1311
+ return segments.length <= SESSION_DIRECTORY_MAX_DEPTH && segments.every((segment) => segment.length > 0 && segment.length <= 255 && segment !== "." && segment !== ".." && !/[\\:<>"|?*\u0000-\u001f\u007f]/u.test(segment) && !/[. ]$/u.test(segment) && !/~[0-9]/u.test(segment) && !/^(?:con|prn|aux|nul|com[0-9¹²³]|lpt[0-9¹²³])(?:[ .]|$)/iu.test(segment) && !/^(?:conin\$|conout\$)$/iu.test(segment));
1312
+ }
1313
+ var SessionDirectoryListRequestSchema = z19.object({
1314
+ requestId: IdSchema,
1315
+ machineId: IdSchema,
1316
+ sessionId: IdSchema,
1317
+ path: z19.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH)
1318
+ }).strict();
1319
+ var SessionDirectoryEntrySchema = z19.object({
1320
+ name: z19.string().min(1).max(255),
1321
+ kind: z19.enum(["directory", "file", "blocked"])
1322
+ }).strict();
1323
+ var SessionDirectoryListDataSchema = SessionDirectoryListRequestSchema.pick({ path: true });
1324
+ var SessionDirectoryListResultDataSchema = z19.object({
1325
+ path: z19.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH),
1326
+ rootRevision: z19.string().min(1).max(128),
1327
+ entries: z19.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES)
1328
+ }).strict();
1329
+ var SessionDirectoryListResponseSchema = SessionDirectoryListRequestSchema.extend({
1330
+ rootRevision: z19.string().min(1).max(128).optional(),
1331
+ entries: z19.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES).optional(),
1332
+ error: ProtocolFailureSchema.optional()
1333
+ }).superRefine((response, context) => {
1334
+ if (response.error === void 0 ? response.entries === void 0 || response.rootRevision === void 0 : response.entries !== void 0 || response.rootRevision !== void 0) {
1335
+ context.addIssue({ code: "custom", message: "Expected directory success or failure" });
1336
+ }
1337
+ });
1338
+ var SessionFileReadDataSchema = z19.object({
1339
+ path: z19.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
1340
+ rootRevision: z19.string().regex(/^[A-Za-z0-9_-]{43}$/u)
1341
+ }).strict();
1342
+ function fileResultSchema(mediaTypes, extended) {
1343
+ const maxOriginal = extended ? SESSION_FILE_V2_MAX_ORIGINAL_BYTES : SESSION_FILE_MAX_ORIGINAL_BYTES;
1344
+ const maxTransfer = extended ? SESSION_FILE_V2_MAX_TRANSFER_BYTES : SESSION_FILE_MAX_TRANSFER_BYTES;
1345
+ return z19.object({
1346
+ path: SessionFileReadDataSchema.shape.path,
1347
+ rootRevision: SessionFileReadDataSchema.shape.rootRevision,
1348
+ mediaType: z19.enum(mediaTypes),
1349
+ originalByteLength: z19.number().int().min(0).max(maxOriginal),
1350
+ // Canonical length after decompression, not the length of the transport bytes.
1351
+ byteLength: z19.number().int().min(0).max(maxOriginal),
1352
+ encoding: z19.enum(["identity", "gzip"]),
1353
+ data: z19.string().max(extended ? SESSION_FILE_V2_MAX_BASE64_LENGTH : SESSION_FILE_MAX_BASE64_LENGTH)
1354
+ }).strict().superRefine((result, context) => {
1355
+ const invalid = () => context.addIssue({ code: "custom", message: "Invalid file content" });
1356
+ if (result.encoding === "gzip" !== result.originalByteLength >= SESSION_FILE_GZIP_THRESHOLD_BYTES)
1357
+ invalid();
1358
+ if (result.mediaType === "image/webp" ? result.byteLength === 0 || result.byteLength > SESSION_FILE_MAX_IMAGE_BYTES || result.originalByteLength === 0 : result.byteLength !== result.originalByteLength)
1359
+ invalid();
1360
+ if (result.mediaType.startsWith("video/") && (result.byteLength === 0 || !result.path.toLowerCase().endsWith(result.mediaType === "video/mp4" ? ".mp4" : ".webm")))
1361
+ invalid();
1362
+ const base64 = result.data;
1363
+ const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
1364
+ const length = base64.length / 4 * 3 - padding;
1365
+ if (base64.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(base64) || length > maxTransfer || padding === 2 && !/[AQgw]==$/u.test(base64) || padding === 1 && !/[AEIMQUYcgkosw048]=$/u.test(base64) || (result.encoding === "identity" ? length !== result.byteLength : length < 20))
1366
+ invalid();
1367
+ });
1368
+ }
1369
+ var SessionFileReadResultDataSchema = fileResultSchema(SESSION_FILE_MEDIA_TYPES, false);
1370
+ var SessionFileReadV2ResultDataSchema = fileResultSchema(SESSION_FILE_V2_MEDIA_TYPES, true);
1371
+ var SessionFileDownloadDataSchema = SessionFileReadDataSchema;
1372
+ var SessionFileDownloadResultDataSchema = fileResultSchema(["application/octet-stream"], true);
1373
+ var SessionGitProjectSchema = z19.object({
1374
+ localRepositoryKey: z19.string().length(43).regex(/^[A-Za-z0-9_-]{43}$/),
1375
+ worktreeRoot: z19.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH),
1376
+ mainWorktreeRoot: z19.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional(),
1377
+ gitRemoteUrl: z19.string().max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional()
1378
+ }).strict();
1379
+ var SessionProjectIdentityRequestDataSchema = z19.object({}).strict();
1380
+ var SessionProjectIdentityResultDataSchema = z19.object({
1381
+ project: SessionGitProjectSchema.optional()
1382
+ }).strict();
1383
+
1384
+ // ../../shared/protocol/dist/sessions/session-git-diff.js
1385
+ import { z as z20 } from "zod";
1386
+ var SESSION_GIT_DIFF_GZIP_MIN_BYTES = 2 * 1024;
1387
+ var SESSION_GIT_DIFF_MAX_FILES = 500;
1388
+ var SESSION_GIT_DIFF_MAX_PATCH_BYTES = 128 * 1024;
1389
+ var SESSION_GIT_DIFF_MAX_RESPONSE_BYTES = 512 * 1024;
1390
+ var SESSION_GIT_DIFF_MAX_TRANSFER_BYTES = SESSION_GIT_DIFF_MAX_RESPONSE_BYTES + 1024;
1391
+ var SESSION_GIT_DIFF_MAX_BASE64_LENGTH = Math.ceil(SESSION_GIT_DIFF_MAX_TRANSFER_BYTES / 3) * 4;
1392
+ var SESSION_GIT_DIFF_MAX_GZIP_RESPONSE_BYTES = SESSION_GIT_DIFF_MAX_BASE64_LENGTH + 1024;
1393
+ var commitSchema = z20.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u);
1394
+ var SessionGitDiffDataSchema = z20.object({
1395
+ rootRevision: SessionFileReadDataSchema.shape.rootRevision,
1396
+ path: SessionFileReadDataSchema.shape.path.optional(),
1397
+ baseCommit: commitSchema.optional()
1398
+ }).strict().refine((value) => value.path === void 0 === (value.baseCommit === void 0), "A file diff must identify its listed base commit");
1399
+ var SessionGitDiffEntrySchema = z20.object({
1400
+ path: SessionFileReadDataSchema.shape.path,
1401
+ status: z20.enum(["added", "modified", "deleted", "untracked"])
1402
+ }).strict();
1403
+ var SessionGitDiffResultDataSchema = z20.object({
1404
+ rootRevision: SessionFileReadDataSchema.shape.rootRevision,
1405
+ baseRef: z20.enum(["origin/main", "main"]),
1406
+ baseCommit: commitSchema,
1407
+ files: z20.array(SessionGitDiffEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional(),
1408
+ path: SessionFileReadDataSchema.shape.path.optional(),
1409
+ patch: z20.string().max(SESSION_GIT_DIFF_MAX_PATCH_BYTES).optional(),
1410
+ binary: z20.boolean().optional()
1411
+ }).strict().superRefine((value, context) => {
1412
+ const encoder = new TextEncoder();
1413
+ if (value.patch !== void 0 && encoder.encode(value.patch).length > SESSION_GIT_DIFF_MAX_PATCH_BYTES || encoder.encode(JSON.stringify(value)).length > SESSION_GIT_DIFF_MAX_RESPONSE_BYTES) {
1414
+ context.addIssue({ code: "custom", message: "Git diff exceeds its transfer limit" });
1415
+ }
1416
+ if (value.path === void 0) {
1417
+ if (value.files === void 0 || value.patch !== void 0 || value.binary !== void 0 || new Set(value.files?.map((entry) => entry.path)).size !== value.files?.length) {
1418
+ context.addIssue({ code: "custom", message: "Expected a unique changed-file list" });
1419
+ }
1420
+ } else if (value.files !== void 0 || value.patch === void 0 || value.binary === void 0 || value.binary && value.patch !== "") {
1421
+ context.addIssue({ code: "custom", message: "Expected a text patch or an explicit binary change" });
1422
+ }
1423
+ });
1424
+ var SessionGitDiffFileErrorSchema = z20.object({
1425
+ code: z20.enum(["DIFF_BLOCKED", "DIFF_FILE_UNAVAILABLE"]),
1426
+ message: z20.string().min(1).max(512)
1427
+ }).strict();
1428
+ var SessionGitDiffPartialEntrySchema = SessionGitDiffEntrySchema.extend({
1429
+ // Error paths are display-only: they must never be used for file requests.
1430
+ path: z20.string().min(1).max(32768).refine((value) => !value.includes("\0")),
1431
+ error: SessionGitDiffFileErrorSchema.optional()
1432
+ }).superRefine((value, context) => {
1433
+ if (value.error === void 0 && !SessionGitDiffEntrySchema.shape.path.safeParse(value.path).success) {
1434
+ context.addIssue({ code: "custom", message: "A readable diff entry must have a safe path" });
1435
+ }
1436
+ });
1437
+ var SessionGitDiffPartialResultDataSchema = SessionGitDiffResultDataSchema.safeExtend({
1438
+ files: z20.array(SessionGitDiffPartialEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional()
1439
+ });
1440
+ var SessionGitDiffGzipResultDataSchema = z20.object({
1441
+ encoding: z20.literal("gzip"),
1442
+ byteLength: z20.number().int().min(1).max(SESSION_GIT_DIFF_MAX_RESPONSE_BYTES),
1443
+ data: z20.string().max(SESSION_GIT_DIFF_MAX_BASE64_LENGTH).regex(/^[A-Za-z0-9+/]*={0,2}$/u)
1444
+ }).strict().superRefine((value, context) => {
1445
+ const padding = value.data.endsWith("==") ? 2 : value.data.endsWith("=") ? 1 : 0;
1446
+ const bytes = value.data.length / 4 * 3 - padding;
1447
+ const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
1448
+ const tail = alphabet.indexOf(value.data[value.data.length - padding - 1] ?? "");
1449
+ if (value.data.length % 4 !== 0 || bytes < 20 || bytes > SESSION_GIT_DIFF_MAX_TRANSFER_BYTES || padding === 2 && (tail & 15) !== 0 || padding === 1 && (tail & 3) !== 0) {
1450
+ context.addIssue({ code: "custom", message: "Invalid gzip transfer" });
1451
+ }
1452
+ });
1453
+ var SessionGitDiffV2ResultDataSchema = z20.union([
1454
+ SessionGitDiffResultDataSchema,
1455
+ SessionGitDiffGzipResultDataSchema
1456
+ ]);
1457
+
1458
+ // ../../shared/protocol/dist/sessions/session-resource.js
1459
+ import { z as z21 } from "zod";
1460
+ var SESSION_RESOURCE_MAX_ORIGINAL_BYTES = 499999;
1461
+ var SESSION_RESOURCE_GZIP_THRESHOLD_BYTES = 20 * 1024;
1462
+ var SESSION_RESOURCE_MAX_IMAGE_PIXELS = 16 * 1024 * 1024;
1463
+ var SESSION_RESOURCE_MAX_TRANSFER_BYTES = SESSION_RESOURCE_MAX_ORIGINAL_BYTES + 1024;
1464
+ var SESSION_RESOURCE_MAX_BASE64_LENGTH = Math.ceil(SESSION_RESOURCE_MAX_TRANSFER_BYTES / 3) * 4;
1465
+ var SESSION_RESOURCE_MAX_RESPONSE_BYTES = SESSION_RESOURCE_MAX_BASE64_LENGTH + 8192;
1466
+ var SESSION_RESOURCE_MEDIA_TYPES = [
1467
+ "image/jpeg",
1468
+ "image/png",
1469
+ "image/webp",
1470
+ "text/css",
1471
+ "text/javascript"
1472
+ ];
1473
+ var SessionResourceReadDataSchema = z21.object({
1474
+ path: z21.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
1475
+ rootRevision: z21.string().regex(/^[A-Za-z0-9_-]{43}$/u)
1476
+ }).strict();
1477
+ var SessionResourceReadResultDataSchema = z21.object({
1478
+ path: SessionResourceReadDataSchema.shape.path,
1479
+ rootRevision: SessionResourceReadDataSchema.shape.rootRevision,
1480
+ mediaType: z21.enum(SESSION_RESOURCE_MEDIA_TYPES),
1481
+ originalByteLength: z21.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
1482
+ byteLength: z21.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
1483
+ encoding: z21.enum(["identity", "gzip"]),
1484
+ data: z21.string().max(SESSION_RESOURCE_MAX_BASE64_LENGTH)
1485
+ }).strict().superRefine((result, context) => {
1486
+ const invalid = () => context.addIssue({ code: "custom", message: "Invalid resource content" });
1487
+ if (result.encoding === "gzip" !== result.originalByteLength >= SESSION_RESOURCE_GZIP_THRESHOLD_BYTES || result.byteLength !== result.originalByteLength || result.mediaType.startsWith("image/") && result.byteLength === 0)
1488
+ invalid();
1489
+ const base64 = result.data;
1490
+ const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
1491
+ const length = base64.length / 4 * 3 - padding;
1492
+ if (base64.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(base64) || length > SESSION_RESOURCE_MAX_TRANSFER_BYTES || padding === 2 && !/[AQgw]==$/u.test(base64) || padding === 1 && !/[AEIMQUYcgkosw048]=$/u.test(base64) || (result.encoding === "identity" ? length !== result.byteLength : length < 20))
1493
+ invalid();
1494
+ });
1495
+
1496
+ // ../../shared/protocol/dist/sessions/session-images.js
1497
+ import { z as z22 } from "zod";
1498
+ var SESSION_IMAGE_MAX_BYTES = 3 * 1024 * 1024;
1499
+ var SESSION_IMAGE_MAX_PIXELS = 16 * 1024 * 1024;
1500
+ var SessionImageIdSchema = z22.uuid();
1501
+ var SessionImageTransferModeSchema = z22.enum(["direct", "proxy"]);
1502
+ var DirectUrlSchema = z22.string().regex(/^https:\/\/[^/?#@\\\s\x00-\x1f\x7f]+(?:[/?][^#\\\s\x00-\x1f\x7f]*)?$/u).refine((raw) => {
1503
+ if (!URL.canParse(raw))
1504
+ return false;
1505
+ const url = new URL(raw);
1506
+ return url.protocol === "https:" && url.username === "" && url.password === "" && url.hash === "";
1507
+ }, "Direct transfers require HTTPS without userinfo, fragments or unsafe characters");
1508
+ var ProxyUrlSchema = z22.string().regex(/^\/api\/v3\/session-images\/[0-9a-f-]+\/content\?[^#\\\s\x00-\x1f\x7f]+$/u);
1509
+ var SessionImageTransferHeadersSchema = z22.record(z22.string().regex(/^(?:content-type|if-none-match|x-ms-blob-type)$/u), z22.string().min(1).max(256).regex(/^[\x20-\x7e]+$/u));
1510
+ var SessionImageUploadRequestSchema = z22.object({
1511
+ machineId: IdSchema,
1512
+ sessionId: IdSchema,
1513
+ sizeBytes: z22.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES)
1514
+ }).strict();
1515
+ var SessionImageScopeSchema = z22.object({
1516
+ machineId: IdSchema,
1517
+ sessionId: IdSchema
1518
+ }).strict();
1519
+ var UploadResultFields = {
1520
+ imageId: SessionImageIdSchema,
1521
+ uploadExpiresAt: z22.number().int().positive(),
1522
+ method: z22.literal("PUT"),
1523
+ contentType: z22.literal("image/webp"),
1524
+ headers: SessionImageTransferHeadersSchema.refine((headers) => headers["content-type"] === "image/webp")
1525
+ };
1526
+ var SessionImageUploadResultSchema = z22.discriminatedUnion("mode", [
1527
+ z22.object({ ...UploadResultFields, mode: z22.literal("direct"), uploadUrl: DirectUrlSchema }).strict(),
1528
+ z22.object({ ...UploadResultFields, mode: z22.literal("proxy"), uploadUrl: ProxyUrlSchema }).strict()
1529
+ ]);
1530
+ var SessionImageCommitResultSchema = z22.object({
1531
+ imageId: SessionImageIdSchema,
1532
+ machineId: IdSchema,
1533
+ sessionId: IdSchema,
1534
+ sizeBytes: z22.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES),
1535
+ width: z22.number().int().positive(),
1536
+ height: z22.number().int().positive(),
1537
+ sha256: z22.string().regex(/^[a-f0-9]{64}$/u),
1538
+ expiresAt: z22.number().int().positive()
1539
+ }).strict();
1540
+ var DownloadResultFields = {
1541
+ image: SessionImageCommitResultSchema,
1542
+ downloadExpiresAt: z22.number().int().positive(),
1543
+ method: z22.literal("GET"),
1544
+ headers: SessionImageTransferHeadersSchema
1545
+ };
1546
+ var SessionImageDownloadResultSchema = z22.discriminatedUnion("mode", [
1547
+ z22.object({ ...DownloadResultFields, mode: z22.literal("direct"), downloadUrl: DirectUrlSchema }).strict(),
1548
+ z22.object({ ...DownloadResultFields, mode: z22.literal("proxy"), downloadUrl: ProxyUrlSchema }).strict()
1549
+ ]);
1550
+ var TimelineImageBlobRequestSchema = z22.object({
1551
+ sha256: z22.string().regex(/^[a-f0-9]{64}$/u)
1552
+ }).strict();
1553
+ var TimelineImageBlobResultSchema = z22.object({
1554
+ sha256: TimelineImageBlobRequestSchema.shape.sha256,
1555
+ image: SessionImageCommitResultSchema
1556
+ }).strict();
1557
+
1558
+ // ../../shared/protocol/dist/sessions/session-rename.js
1559
+ import { z as z23 } from "zod";
1560
+ var SESSION_RENAME_OPERATION = "session.rename";
1561
+ var SESSION_RENAME_VERSION = 1;
1562
+ var SESSION_RENAME_CAPABILITY = sessionCommunicationOperationCapability(SESSION_RENAME_OPERATION, SESSION_RENAME_VERSION);
1563
+ var SESSION_NAME_MAX_LENGTH = 100;
1564
+ var SessionNameSchema = z23.string().regex(/^[^\u0000-\u001f\u007f]*$/u).trim().min(1).max(SESSION_NAME_MAX_LENGTH);
1565
+ var SessionRenameDataSchema = z23.object({ name: SessionNameSchema }).strict();
1566
+ var SessionRenameResultDataSchema = z23.object({ name: SessionNameSchema }).strict();
1567
+
1568
+ // ../../shared/protocol/dist/sessions/sessions.js
1569
+ import { z as z24 } from "zod";
1570
+ var GroupChatParticipantSchema = z24.object({
1571
+ sessionId: IdSchema,
1572
+ title: z24.string().trim().min(1).max(260)
1573
+ }).strict();
1574
+ var GroupChatInfoSchema = z24.object({
1575
+ participants: z24.array(GroupChatParticipantSchema).length(2).refine((participants) => new Set(participants.map((participant) => participant.sessionId)).size === 2, "A group requires two different sessions"),
1576
+ state: z24.enum(["ready", "running", "paused", "blocked"])
1577
+ }).strict();
1578
+ var SessionSummarySchema = z24.object({
1579
+ userId: IdSchema,
1580
+ sessionId: IdSchema,
1581
+ machineId: IdSchema,
1582
+ summary: z24.string().max(4096).optional(),
1583
+ renameSupported: z24.boolean().optional(),
1584
+ workingDirectory: z24.string().max(32768).optional(),
1585
+ gitRoot: z24.string().max(32768).optional(),
1586
+ repository: z24.string().max(1024).optional(),
1587
+ gitRemoteUrl: z24.string().max(32768).optional(),
1588
+ branch: z24.string().max(1024).optional(),
1589
+ isRemote: z24.boolean(),
1590
+ createdAt: IsoDateSchema,
1591
+ modifiedAt: IsoDateSchema,
1592
+ groupChat: GroupChatInfoSchema.optional()
1593
+ });
1594
+ var SessionsSnapshotSchema = z24.object({
1595
+ userId: IdSchema,
1596
+ machineId: IdSchema,
1597
+ machineName: z24.string().trim().min(1).max(120),
1598
+ platform: z24.string().trim().min(1).max(64),
1599
+ agentRunId: IdSchema,
1600
+ sequence: z24.number().int().positive(),
1601
+ generatedAt: IsoDateSchema,
1602
+ complete: z24.boolean(),
1603
+ totalCount: z24.number().int().nonnegative(),
1604
+ nextCursor: z24.string().min(1).max(1024).optional(),
1605
+ sessions: z24.array(SessionSummarySchema)
1606
+ }).superRefine((snapshot, context) => {
1607
+ if (snapshot.totalCount < snapshot.sessions.length) {
1608
+ context.addIssue({
1609
+ code: "custom",
1610
+ message: "Snapshot totalCount cannot be smaller than its session page",
1611
+ path: ["totalCount"]
1612
+ });
1613
+ }
1614
+ if (snapshot.complete === (snapshot.nextCursor !== void 0)) {
1615
+ context.addIssue({
1616
+ code: "custom",
1617
+ message: "Incomplete snapshots require a nextCursor",
1618
+ path: ["nextCursor"]
1619
+ });
1620
+ }
1621
+ const sessionIds = /* @__PURE__ */ new Set();
1622
+ for (const [index, session] of snapshot.sessions.entries()) {
1623
+ if (session.machineId !== snapshot.machineId) {
1624
+ context.addIssue({
1625
+ code: "custom",
1626
+ message: "Session machineId must match snapshot machineId",
1627
+ path: ["sessions", index, "machineId"]
1628
+ });
1629
+ }
1630
+ if (session.userId !== snapshot.userId) {
1631
+ context.addIssue({
1632
+ code: "custom",
1633
+ message: "Session userId must match snapshot userId",
1634
+ path: ["sessions", index, "userId"]
1635
+ });
1636
+ }
1637
+ if (sessionIds.has(session.sessionId)) {
1638
+ context.addIssue({
1639
+ code: "custom",
1640
+ message: "Session IDs must be unique within a snapshot",
1641
+ path: ["sessions", index, "sessionId"]
1642
+ });
1643
+ }
1644
+ sessionIds.add(session.sessionId);
1645
+ }
1646
+ });
1647
+ var SessionListRequestSchema = z24.object({
1648
+ requestId: IdSchema,
1649
+ machineId: IdSchema,
1650
+ cursor: z24.string().min(1).max(1024).optional()
1651
+ });
1652
+ var SessionListResultSchema = z24.discriminatedUnion("ok", [
1653
+ z24.object({
1654
+ ok: z24.literal(true),
1655
+ requestId: IdSchema,
1656
+ machineId: IdSchema,
1657
+ snapshot: SessionsSnapshotSchema
1658
+ }),
1659
+ z24.object({
1660
+ ok: z24.literal(false),
1661
+ requestId: IdSchema,
1662
+ machineId: IdSchema,
1663
+ error: ProtocolFailureSchema
1664
+ })
1665
+ ]);
1666
+ var SessionAgentModeSchema = z24.enum([
1667
+ "interactive",
1668
+ "plan",
1669
+ "autopilot"
1670
+ ]);
1671
+ var AgentConfigurationOptionSchema = z24.object({
1672
+ id: IdSchema,
1673
+ name: z24.string().trim().min(1).max(260),
1674
+ value: z24.string().min(1).max(256),
1675
+ options: z24.array(z24.object({
1676
+ value: z24.string().min(1).max(256),
1677
+ name: z24.string().trim().min(1).max(260)
1678
+ }).strict()).min(1).max(100)
1679
+ }).strict();
1680
+ var AgentConfigurationChangeSchema = z24.object({
1681
+ id: IdSchema,
1682
+ value: z24.string().min(1).max(256)
1683
+ }).strict();
1684
+ var WorkspaceOptionSchema = z24.object({
1685
+ id: IdSchema,
1686
+ name: z24.string().trim().min(1).max(260),
1687
+ path: z24.string().trim().min(1).max(32768)
1688
+ });
1689
+ var REASONING_EFFORTS = [
1690
+ "low",
1691
+ "medium",
1692
+ "high",
1693
+ "xhigh",
1694
+ "max"
1695
+ ];
1696
+ var ReasoningEffortSchema = z24.enum(REASONING_EFFORTS);
1697
+ var CopilotModelOptionSchema = z24.object({
1698
+ id: IdSchema,
1699
+ name: z24.string().trim().min(1).max(260),
1700
+ isDefault: z24.boolean(),
1701
+ supportedReasoningEfforts: z24.array(ReasoningEffortSchema).optional(),
1702
+ defaultReasoningEffort: ReasoningEffortSchema.optional(),
1703
+ creation: z24.object({
1704
+ agentId: IdSchema,
1705
+ agentName: z24.string().trim().min(1).max(260),
1706
+ modelName: z24.string().trim().min(1).max(260),
1707
+ agentModes: z24.array(SessionAgentModeSchema).min(1),
1708
+ reasoningEffortConfigurationSupported: z24.boolean(),
1709
+ isDefault: z24.boolean()
1710
+ }).strict().optional()
1711
+ });
1712
+ var SessionReasoningEffortSchema = z24.enum([
1713
+ "default",
1714
+ ...REASONING_EFFORTS
1715
+ ]);
1716
+ var CurrentReasoningEffortSchema = z24.string().trim().min(1).max(64);
1717
+ var SessionToolInfoSchema = z24.object({
1718
+ name: z24.string().trim().min(1).max(260),
1719
+ description: z24.string().trim().min(1).max(4096).optional(),
1720
+ deferred: z24.boolean().optional()
1721
+ });
1722
+ var SessionSlashCommandInfoSchema = z24.object({
1723
+ name: z24.string().trim().min(1).max(260),
1724
+ description: z24.string().trim().min(1).max(4096).optional(),
1725
+ kind: z24.enum(["builtin", "skill", "client"])
1726
+ });
1727
+ var SessionSkillInfoSchema = z24.object({
1728
+ name: z24.string().trim().min(1).max(260),
1729
+ description: z24.string().trim().min(1).max(4096).optional(),
1730
+ source: z24.string().trim().min(1).max(260),
1731
+ enabled: z24.boolean(),
1732
+ userInvocable: z24.boolean(),
1733
+ commandName: z24.string().trim().min(1).max(260).optional()
1734
+ });
1735
+ var SessionEnvironmentInfoSchema = z24.object({
1736
+ tools: z24.array(SessionToolInfoSchema).max(512),
1737
+ slashCommands: z24.array(SessionSlashCommandInfoSchema).max(512),
1738
+ skills: z24.array(SessionSkillInfoSchema).max(512)
1739
+ });
1740
+ var SessionOptionsRequestSchema = z24.object({
1741
+ requestId: IdSchema,
1742
+ machineId: IdSchema,
1743
+ sessionId: IdSchema.optional(),
1744
+ workspaceId: IdSchema.optional(),
1745
+ capabilities: z24.array(IdSchema).max(64).optional()
1746
+ });
1747
+ var SessionOptionsResultSchema = z24.discriminatedUnion("ok", [
1748
+ z24.object({
1749
+ ok: z24.literal(true),
1750
+ requestId: IdSchema,
1751
+ machineId: IdSchema,
1752
+ sessionId: IdSchema.optional(),
1753
+ workspaces: z24.array(WorkspaceOptionSchema),
1754
+ models: z24.array(CopilotModelOptionSchema).min(1),
1755
+ modelRefreshError: z24.string().min(1).max(4096).optional(),
1756
+ agentModes: z24.array(SessionAgentModeSchema).min(1),
1757
+ reasoningEffortConfigurationSupported: z24.literal(true).optional(),
1758
+ fileAttachmentsSupported: z24.boolean().optional(),
1759
+ worktreeCreationSupported: z24.literal(true).optional(),
1760
+ worktreeBranches: z24.array(z24.string().min(1).max(1024)).optional(),
1761
+ worktreeCurrentBranch: z24.string().min(1).max(1024).optional(),
1762
+ currentModelId: IdSchema.optional(),
1763
+ currentAgentMode: SessionAgentModeSchema.optional(),
1764
+ currentReasoningEffort: CurrentReasoningEffortSchema.optional(),
1765
+ environment: SessionEnvironmentInfoSchema.optional(),
1766
+ environmentPending: z24.literal(true).optional(),
1767
+ agentName: z24.string().trim().min(1).max(260).optional(),
1768
+ configOptions: z24.array(AgentConfigurationOptionSchema).max(32).optional()
1769
+ }),
1770
+ z24.object({
1771
+ ok: z24.literal(false),
1772
+ requestId: IdSchema,
1773
+ machineId: IdSchema,
1774
+ sessionId: IdSchema.optional(),
1775
+ error: ProtocolFailureSchema,
1776
+ failureStage: z24.enum(["models", "configuration", "workspaces"]).optional(),
1777
+ models: z24.array(CopilotModelOptionSchema).min(1).optional(),
1778
+ agentModes: z24.array(SessionAgentModeSchema).min(1).optional(),
1779
+ reasoningEffortConfigurationSupported: z24.literal(true).optional(),
1780
+ fileAttachmentsSupported: z24.boolean().optional(),
1781
+ currentModelId: IdSchema.optional(),
1782
+ currentAgentMode: SessionAgentModeSchema.optional(),
1783
+ currentReasoningEffort: CurrentReasoningEffortSchema.optional(),
1784
+ agentName: z24.string().trim().min(1).max(260).optional(),
1785
+ configOptions: z24.array(AgentConfigurationOptionSchema).max(32).optional()
1786
+ })
1787
+ ]);
1788
+ var SessionCreateRequestSchema = z24.object({
1789
+ requestId: IdSchema,
1790
+ machineId: IdSchema,
1791
+ workspaceId: IdSchema,
1792
+ modelId: IdSchema,
1793
+ agentMode: SessionAgentModeSchema,
1794
+ reasoningEffort: SessionReasoningEffortSchema.optional(),
1795
+ worktree: z24.object({
1796
+ branchName: z24.string().trim().min(1).max(120).optional(),
1797
+ baseBranch: z24.string().trim().min(1).max(1024).optional()
1798
+ }).strict().optional()
1799
+ });
1800
+ var SessionCreateResultSchema = z24.discriminatedUnion("ok", [
1801
+ z24.object({
1802
+ ok: z24.literal(true),
1803
+ requestId: IdSchema,
1804
+ machineId: IdSchema,
1805
+ session: SessionSummarySchema,
1806
+ modelId: IdSchema,
1807
+ agentMode: SessionAgentModeSchema,
1808
+ reasoningEffort: SessionReasoningEffortSchema.optional()
1809
+ }),
1810
+ z24.object({
1811
+ ok: z24.literal(false),
1812
+ requestId: IdSchema,
1813
+ machineId: IdSchema,
1814
+ error: ProtocolFailureSchema
1815
+ })
1816
+ ]);
1817
+ var SessionDeleteRequestSchema = z24.object({
1818
+ requestId: IdSchema,
1819
+ machineId: IdSchema,
1820
+ sessionId: IdSchema
1821
+ }).strict();
1822
+ var SessionDeleteResultSchema = z24.discriminatedUnion("ok", [
1823
+ z24.object({
1824
+ ok: z24.literal(true),
1825
+ requestId: IdSchema,
1826
+ machineId: IdSchema,
1827
+ sessionId: IdSchema
1828
+ }).strict(),
1829
+ z24.object({
1830
+ ok: z24.literal(false),
1831
+ requestId: IdSchema,
1832
+ machineId: IdSchema,
1833
+ sessionId: IdSchema,
1834
+ error: ProtocolFailureSchema
1835
+ }).strict()
1836
+ ]);
1837
+ var SessionConfigureRequestSchema = z24.object({
1838
+ requestId: IdSchema,
1839
+ machineId: IdSchema,
1840
+ sessionId: IdSchema,
1841
+ modelId: IdSchema.optional(),
1842
+ agentMode: SessionAgentModeSchema.optional(),
1843
+ reasoningEffort: SessionReasoningEffortSchema.optional(),
1844
+ configOption: AgentConfigurationChangeSchema.optional()
1845
+ }).refine((request) => request.modelId !== void 0 || request.agentMode !== void 0 || request.reasoningEffort !== void 0 || request.configOption !== void 0, { message: "A modelId, agentMode, reasoningEffort, or configOption change is required" });
1846
+ var SessionConfigureResultSchema = z24.discriminatedUnion("ok", [
1847
+ z24.object({
1848
+ ok: z24.literal(true),
1849
+ requestId: IdSchema,
1850
+ machineId: IdSchema,
1851
+ sessionId: IdSchema,
1852
+ modelId: IdSchema.optional(),
1853
+ agentMode: SessionAgentModeSchema,
1854
+ reasoningEffort: CurrentReasoningEffortSchema.optional(),
1855
+ configOptions: z24.array(AgentConfigurationOptionSchema).max(32).optional()
1856
+ }),
1857
+ z24.object({
1858
+ ok: z24.literal(false),
1859
+ requestId: IdSchema,
1860
+ machineId: IdSchema,
1861
+ sessionId: IdSchema,
1862
+ error: ProtocolFailureSchema
1863
+ })
1864
+ ]);
1865
+ var SessionRemoteActionSchema = z24.enum([
1866
+ "status",
1867
+ "enable",
1868
+ "disable"
1869
+ ]);
1870
+ var SessionRemoteStateSchema = z24.enum([
1871
+ "off",
1872
+ "connecting",
1873
+ "active",
1874
+ "error"
1875
+ ]);
1876
+ var SessionRemoteRequestSchema = z24.object({
1877
+ requestId: IdSchema,
1878
+ machineId: IdSchema,
1879
+ sessionId: IdSchema,
1880
+ action: SessionRemoteActionSchema
1881
+ });
1882
+ var SessionRemoteStatusSchema = z24.object({
1883
+ state: SessionRemoteStateSchema,
1884
+ attachedSessionId: IdSchema.optional(),
1885
+ url: z24.url().max(32768).optional(),
1886
+ steerable: z24.boolean(),
1887
+ error: ProtocolFailureSchema.optional()
1888
+ });
1889
+ var SessionRemoteResultSchema = z24.discriminatedUnion("ok", [
1890
+ z24.object({
1891
+ ok: z24.literal(true),
1892
+ requestId: IdSchema,
1893
+ machineId: IdSchema,
1894
+ sessionId: IdSchema,
1895
+ status: SessionRemoteStatusSchema
1896
+ }),
1897
+ z24.object({
1898
+ ok: z24.literal(false),
1899
+ requestId: IdSchema,
1900
+ machineId: IdSchema,
1901
+ sessionId: IdSchema,
1902
+ error: ProtocolFailureSchema
1903
+ })
1904
+ ]);
1905
+
1906
+ // ../../shared/protocol/dist/sessions/group-chat.js
1907
+ import { z as z25 } from "zod";
1908
+ var GROUP_CHAT_CREATE_OPERATION = "group-chat.create";
1909
+ var GROUP_CHAT_CREATE_VERSION = 1;
1910
+ var GROUP_CHAT_CREATE_CAPABILITY = sessionCommunicationOperationCapability(GROUP_CHAT_CREATE_OPERATION, GROUP_CHAT_CREATE_VERSION);
1911
+ var GroupChatCreateDataSchema = z25.object({
1912
+ peerSessionId: IdSchema
1913
+ }).strict();
1914
+ var GroupChatCreateResultDataSchema = z25.object({
1915
+ session: SessionSummarySchema.refine((session) => session.groupChat !== void 0, "Group creation must return a virtual group session")
1916
+ }).strict();
1917
+
1918
+ // ../../shared/protocol/dist/sessions/prompts.js
1919
+ import { z as z26 } from "zod";
1920
+ var SessionAvatarPersonaSchema = z26.object({
1921
+ role: z26.enum(["designer", "filmmaker", "developer", "secretary", "default"]),
1922
+ displayName: z26.string().trim().min(1).max(40).regex(/^[^\u0000-\u001f\u007f-\u009f]*$/).optional()
1923
+ }).strict().refine((value) => value.role === "default" ? value.displayName === void 0 : value.displayName !== void 0, { message: "A role requires a display name; default must not include one" });
1924
+ var MAX_PROMPT_IMAGE_BYTES = 3 * 1024 * 1024;
1925
+ var SessionPromptRequestSchema = z26.object({
1926
+ requestId: IdSchema,
1927
+ operationId: IdSchema,
1928
+ machineId: IdSchema,
1929
+ sessionId: IdSchema,
1930
+ prompt: z26.string().trim().max(1e5),
1931
+ attachments: z26.array(PromptImageAttachmentSchema).max(4).optional(),
1932
+ fileAttachments: z26.array(PromptFileAttachmentSchema).max(4).optional(),
1933
+ avatarPersona: SessionAvatarPersonaSchema.optional(),
1934
+ mode: z26.enum(["enqueue", "immediate"]).default("enqueue")
1935
+ }).strict().superRefine((request, context) => {
1936
+ if (request.prompt.length === 0 && (request.attachments?.length ?? 0) === 0 && (request.fileAttachments?.length ?? 0) === 0) {
1937
+ context.addIssue({
1938
+ code: "custom",
1939
+ path: ["prompt"],
1940
+ message: "A prompt or attachment is required"
1941
+ });
1942
+ }
1943
+ const attachments = [...request.attachments ?? [], ...request.fileAttachments ?? []];
1944
+ if (attachments.length > 4) {
1945
+ context.addIssue({
1946
+ code: "custom",
1947
+ path: ["fileAttachments"],
1948
+ message: "A prompt supports at most 4 attachments"
1949
+ });
1950
+ }
1951
+ const attachmentBytes = attachments.reduce((total, attachment) => total + attachment.byteLength, 0) ?? 0;
1952
+ if (attachmentBytes > MAX_PROMPT_IMAGE_BYTES) {
1953
+ context.addIssue({
1954
+ code: "custom",
1955
+ path: ["attachments"],
1956
+ message: "Prompt attachments exceed the 3 MiB total limit"
1957
+ });
1958
+ }
1959
+ });
1960
+ var SessionPromptResultSchema = z26.discriminatedUnion("ok", [
1961
+ z26.object({
1962
+ ok: z26.literal(true),
1963
+ requestId: IdSchema,
1964
+ operationId: IdSchema,
1965
+ machineId: IdSchema,
1966
+ sessionId: IdSchema,
1967
+ messageId: IdSchema,
1968
+ mode: z26.enum(["enqueue", "immediate"]),
1969
+ deliveryState: z26.enum(["queued", "processing"]),
1970
+ // Negotiated lower bound from the native event clock. Exact text and history
1971
+ // ownership checks still apply; this is not an identity or proof of persistence.
1972
+ submittedAt: IsoDateSchema.optional()
1973
+ }),
1974
+ z26.object({
1975
+ ok: z26.literal(false),
1976
+ requestId: IdSchema,
1977
+ operationId: IdSchema,
1978
+ machineId: IdSchema,
1979
+ sessionId: IdSchema,
1980
+ error: ProtocolFailureSchema
1981
+ })
1982
+ ]);
1983
+ var SessionActivityUpdateSchema = z26.object({
1984
+ userId: IdSchema,
1985
+ machineId: IdSchema,
1986
+ sessionId: IdSchema,
1987
+ state: z26.enum(["working", "idle"]),
1988
+ occurredAt: IsoDateSchema,
1989
+ assistantPreview: SessionAssistantPreviewSchema.optional(),
1990
+ userPreview: SessionUserPreviewSchema.optional()
1991
+ });
1992
+ var SessionAbortRequestSchema = z26.object({
1993
+ requestId: IdSchema,
1994
+ machineId: IdSchema,
1995
+ sessionId: IdSchema
1996
+ });
1997
+ var SessionAbortResultSchema = z26.discriminatedUnion("ok", [
1998
+ z26.object({
1999
+ ok: z26.literal(true),
2000
+ requestId: IdSchema,
2001
+ machineId: IdSchema,
2002
+ sessionId: IdSchema
2003
+ }),
2004
+ z26.object({
2005
+ ok: z26.literal(false),
2006
+ requestId: IdSchema,
2007
+ machineId: IdSchema,
2008
+ sessionId: IdSchema,
2009
+ error: ProtocolFailureSchema
2010
+ })
2011
+ ]);
2012
+
2013
+ // ../../shared/protocol/dist/sessions/interactions.js
2014
+ import { z as z27 } from "zod";
2015
+ var InteractionFormFieldSchema = z27.object({
2016
+ id: IdSchema,
2017
+ label: z27.string().trim().min(1).max(1024),
2018
+ description: z27.string().max(2048).optional(),
2019
+ inputType: z27.enum([
2020
+ "text",
2021
+ "number",
2022
+ "integer",
2023
+ "boolean",
2024
+ "select",
2025
+ "multi-select"
2026
+ ]),
2027
+ required: z27.boolean(),
2028
+ options: z27.array(z27.string().max(1024)).max(100),
2029
+ defaultValue: z27.union([
2030
+ z27.string().max(4096),
2031
+ z27.number().finite(),
2032
+ z27.boolean(),
2033
+ z27.array(z27.string().max(1024)).max(100)
2034
+ ]).optional(),
2035
+ minimum: z27.number().finite().optional(),
2036
+ maximum: z27.number().finite().optional(),
2037
+ minLength: z27.number().int().nonnegative().max(1e6).optional(),
2038
+ maxLength: z27.number().int().nonnegative().max(1e6).optional(),
2039
+ minItems: z27.number().int().nonnegative().max(100).optional(),
2040
+ maxItems: z27.number().int().nonnegative().max(100).optional(),
2041
+ format: z27.enum(["email", "uri", "date", "date-time"]).optional()
2042
+ }).strict();
2043
+ var InteractionPermissionRequestSchema = z27.object({
2044
+ kind: z27.literal("permission"),
2045
+ permissionKind: IdSchema,
2046
+ title: z27.string().trim().min(1).max(256),
2047
+ description: z27.string().max(4096),
2048
+ canApproveSession: z27.boolean(),
2049
+ canApproveAlways: z27.boolean().optional(),
2050
+ approvalScope: z27.string().trim().min(1).max(4096).optional()
2051
+ }).strict();
2052
+ var InteractionUserInputRequestSchema = z27.object({
2053
+ kind: z27.literal("user_input"),
2054
+ question: z27.string().trim().min(1).max(4096),
2055
+ choices: z27.array(z27.string().max(1024)).max(100),
2056
+ allowFreeform: z27.boolean()
2057
+ }).strict();
2058
+ var InteractionElicitationRequestSchema = z27.object({
2059
+ kind: z27.literal("elicitation"),
2060
+ message: z27.string().trim().min(1).max(4096),
2061
+ mode: z27.enum(["form", "url"]),
2062
+ source: z27.string().trim().min(1).max(256).optional(),
2063
+ url: z27.url().max(32768).optional(),
2064
+ fields: z27.array(InteractionFormFieldSchema).max(100)
2065
+ }).strict();
2066
+ var InteractionMcpOauthRequestSchema = z27.object({
2067
+ kind: z27.literal("mcp_oauth"),
2068
+ serverName: z27.string().trim().min(1).max(256),
2069
+ serverUrl: z27.url().max(32768),
2070
+ reason: z27.enum(["initial", "refresh", "reauth", "upscope"]),
2071
+ responseMode: z27.literal("cancel-only")
2072
+ }).strict();
2073
+ var InteractionMcpHeadersRequestSchema = z27.object({
2074
+ kind: z27.literal("mcp_headers"),
2075
+ serverName: z27.string().trim().min(1).max(256),
2076
+ serverUrl: z27.url().max(32768),
2077
+ reason: z27.string().trim().min(1).max(256),
2078
+ responseMode: z27.literal("none-only")
2079
+ }).strict();
2080
+ var InteractionAutoModeSwitchRequestSchema = z27.object({
2081
+ kind: z27.literal("auto_mode_switch"),
2082
+ errorCode: IdSchema.optional(),
2083
+ retryAfterSeconds: z27.number().int().nonnegative().optional()
2084
+ }).strict();
2085
+ var InteractionSessionLimitsRequestSchema = z27.object({
2086
+ kind: z27.literal("session_limits"),
2087
+ maxAiCredits: z27.number().finite().nonnegative(),
2088
+ usedAiCredits: z27.number().finite().nonnegative()
2089
+ }).strict();
2090
+ var InteractionExitPlanRequestSchema = z27.object({
2091
+ kind: z27.literal("exit_plan"),
2092
+ summary: z27.string().max(4096),
2093
+ planContent: z27.string().max(1e5).optional(),
2094
+ actions: z27.array(IdSchema).min(1).max(20),
2095
+ recommendedAction: IdSchema
2096
+ }).strict();
2097
+ var InteractionRequestSchema = z27.discriminatedUnion("kind", [
2098
+ InteractionPermissionRequestSchema,
2099
+ InteractionUserInputRequestSchema,
2100
+ InteractionElicitationRequestSchema,
2101
+ InteractionMcpOauthRequestSchema,
2102
+ InteractionMcpHeadersRequestSchema,
2103
+ InteractionAutoModeSwitchRequestSchema,
2104
+ InteractionSessionLimitsRequestSchema,
2105
+ InteractionExitPlanRequestSchema
2106
+ ]);
2107
+ var InteractionPermissionResponseSchema = z27.object({
2108
+ kind: z27.literal("permission"),
2109
+ decision: z27.enum(["approve-once", "approve-for-session", "approve-always", "reject"]),
2110
+ feedback: z27.string().trim().min(1).max(2048).optional()
2111
+ }).strict();
2112
+ var InteractionUserInputResponseSchema = z27.object({
2113
+ kind: z27.literal("user_input"),
2114
+ answer: z27.string().max(1e5),
2115
+ wasFreeform: z27.boolean()
2116
+ }).strict();
2117
+ var InteractionFieldValueSchema = z27.union([
2118
+ z27.string().max(4096),
2119
+ z27.number(),
2120
+ z27.boolean(),
2121
+ z27.array(z27.string().max(1024)).max(100)
2122
+ ]);
2123
+ var InteractionElicitationResponseSchema = z27.object({
2124
+ kind: z27.literal("elicitation"),
2125
+ action: z27.enum(["accept", "decline", "cancel"]),
2126
+ values: z27.record(z27.string().max(256), InteractionFieldValueSchema)
2127
+ }).strict();
2128
+ var InteractionMcpOauthResponseSchema = z27.object({
2129
+ kind: z27.literal("mcp_oauth"),
2130
+ action: z27.literal("cancel")
2131
+ }).strict();
2132
+ var InteractionMcpHeadersResponseSchema = z27.object({
2133
+ kind: z27.literal("mcp_headers"),
2134
+ action: z27.literal("none")
2135
+ }).strict();
2136
+ var InteractionAutoModeSwitchResponseSchema = z27.object({
2137
+ kind: z27.literal("auto_mode_switch"),
2138
+ action: z27.enum(["yes", "yes_always", "no"])
2139
+ }).strict();
2140
+ var InteractionSessionLimitsResponseSchema = z27.object({
2141
+ kind: z27.literal("session_limits"),
2142
+ action: z27.enum(["add", "set", "unset", "cancel"]),
2143
+ additionalAiCredits: z27.number().positive().optional(),
2144
+ maxAiCredits: z27.number().positive().optional()
2145
+ }).strict().superRefine((response, context) => {
2146
+ if (response.action === "add" && response.additionalAiCredits === void 0) {
2147
+ context.addIssue({
2148
+ code: z27.ZodIssueCode.custom,
2149
+ path: ["additionalAiCredits"],
2150
+ message: "additionalAiCredits is required for add"
2151
+ });
2152
+ }
2153
+ if (response.action === "set" && response.maxAiCredits === void 0) {
2154
+ context.addIssue({
2155
+ code: z27.ZodIssueCode.custom,
2156
+ path: ["maxAiCredits"],
2157
+ message: "maxAiCredits is required for set"
2158
+ });
2159
+ }
2160
+ if (response.action !== "add" && response.additionalAiCredits !== void 0) {
2161
+ context.addIssue({
2162
+ code: z27.ZodIssueCode.custom,
2163
+ path: ["additionalAiCredits"],
2164
+ message: "additionalAiCredits is only valid for add"
2165
+ });
2166
+ }
2167
+ if (response.action !== "set" && response.maxAiCredits !== void 0) {
2168
+ context.addIssue({
2169
+ code: z27.ZodIssueCode.custom,
2170
+ path: ["maxAiCredits"],
2171
+ message: "maxAiCredits is only valid for set"
2172
+ });
2173
+ }
2174
+ });
2175
+ var InteractionExitPlanResponseSchema = z27.object({
2176
+ kind: z27.literal("exit_plan"),
2177
+ approved: z27.boolean(),
2178
+ selectedAction: IdSchema.optional(),
2179
+ feedback: z27.string().trim().min(1).max(4096).optional()
2180
+ }).strict();
2181
+ var InteractionResponseSchema = z27.discriminatedUnion("kind", [
2182
+ InteractionPermissionResponseSchema,
2183
+ InteractionUserInputResponseSchema,
2184
+ InteractionElicitationResponseSchema,
2185
+ InteractionMcpOauthResponseSchema,
2186
+ InteractionMcpHeadersResponseSchema,
2187
+ InteractionAutoModeSwitchResponseSchema,
2188
+ InteractionSessionLimitsResponseSchema,
2189
+ InteractionExitPlanResponseSchema
2190
+ ]);
2191
+ var InteractionRequestPayloadSchema = z27.object({
2192
+ interactionRequestId: IdSchema,
2193
+ userId: IdSchema,
2194
+ machineId: IdSchema,
2195
+ sessionId: IdSchema,
2196
+ request: InteractionRequestSchema
2197
+ }).strict();
2198
+ var InteractionRespondRequestSchema = z27.object({
2199
+ requestId: IdSchema,
2200
+ interactionRequestId: IdSchema,
2201
+ machineId: IdSchema,
2202
+ sessionId: IdSchema,
2203
+ response: InteractionResponseSchema
2204
+ }).strict();
2205
+ var InteractionRespondResultSchema = z27.discriminatedUnion("ok", [
2206
+ z27.object({
2207
+ ok: z27.literal(true),
2208
+ requestId: IdSchema,
2209
+ interactionRequestId: IdSchema,
2210
+ machineId: IdSchema,
2211
+ sessionId: IdSchema
2212
+ }).strict(),
2213
+ z27.object({
2214
+ ok: z27.literal(false),
2215
+ requestId: IdSchema,
2216
+ interactionRequestId: IdSchema,
2217
+ machineId: IdSchema,
2218
+ sessionId: IdSchema,
2219
+ error: ProtocolFailureSchema
2220
+ }).strict()
2221
+ ]);
2222
+ var PermissionRequestPayloadSchema = z27.object({
2223
+ permissionRequestId: IdSchema,
2224
+ userId: IdSchema,
2225
+ machineId: IdSchema,
2226
+ sessionId: IdSchema,
2227
+ request: z27.record(z27.string(), z27.unknown())
2228
+ });
2229
+ var PermissionRespondRequestSchema = z27.object({
2230
+ requestId: IdSchema,
2231
+ permissionRequestId: IdSchema,
2232
+ machineId: IdSchema,
2233
+ sessionId: IdSchema,
2234
+ decision: z27.enum(["approve-once", "reject"]),
2235
+ feedback: z27.string().trim().min(1).max(2048).optional()
2236
+ });
2237
+ var PermissionRespondResultSchema = z27.discriminatedUnion("ok", [
2238
+ z27.object({
2239
+ ok: z27.literal(true),
2240
+ requestId: IdSchema,
2241
+ permissionRequestId: IdSchema,
2242
+ machineId: IdSchema,
2243
+ sessionId: IdSchema
2244
+ }),
2245
+ z27.object({
2246
+ ok: z27.literal(false),
2247
+ requestId: IdSchema,
2248
+ permissionRequestId: IdSchema,
2249
+ machineId: IdSchema,
2250
+ sessionId: IdSchema,
2251
+ error: ProtocolFailureSchema
2252
+ })
2253
+ ]);
2254
+
2255
+ // ../../shared/protocol/dist/conversation/timeline-sync.js
2256
+ import { z as z28 } from "zod";
2257
+ var TIMELINE_SYNC_MAX_EVENTS = 128;
2258
+ var TIMELINE_SYNC_MAX_BYTES = 6 * 1024 * 1024;
2259
+ var TIMELINE_IMAGE_CHUNK_BYTES = 48 * 1024;
2260
+ var TIMELINE_IMAGE_MAX_BYTES = 3 * 1024 * 1024;
2261
+ var identity = z28.string().min(1).max(256);
2262
+ var sequence = z28.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
2263
+ var hash = z28.string().regex(/^[a-f0-9]{64}$/u);
2264
+ var TimelineWatermarkSchema = z28.object({
2265
+ epoch: identity,
2266
+ sequence
2267
+ }).strict();
2268
+ var TimelineSyncRequestSchema = z28.object({
2269
+ watermark: TimelineWatermarkSchema.optional(),
2270
+ waitMs: z28.number().int().min(0).max(2e4).optional(),
2271
+ resume: z28.boolean().optional()
2272
+ }).strict();
2273
+ var TimelineTextAppendSchema = z28.object({
2274
+ itemId: identity,
2275
+ baseRevision: z28.number().int().positive(),
2276
+ revision: z28.number().int().positive(),
2277
+ appendText: z28.string().min(1).max(5e5),
2278
+ sourceEventIds: z28.array(identity).min(1).max(1e3).optional(),
2279
+ sourceMessageIds: z28.array(identity).min(1).max(1e3).optional(),
2280
+ sourceInteractionIds: z28.array(identity).min(1).max(1e3).optional()
2281
+ }).strict();
2282
+ var TimelineSyncEventSchema = z28.discriminatedUnion("kind", [
2283
+ z28.object({ kind: z28.literal("upsert"), sequence, item: ConversationItemSchema }).strict(),
2284
+ z28.object({ kind: z28.literal("append"), sequence, append: TimelineTextAppendSchema }).strict(),
2285
+ z28.object({
2286
+ kind: z28.literal("step"),
2287
+ sequence,
2288
+ upsert: ConversationActivityStepUpsertSchema
2289
+ }).strict()
2290
+ ]);
2291
+ var TimelineResyncReasonSchema = z28.enum([
2292
+ "initial",
2293
+ "epoch-changed",
2294
+ "evicted",
2295
+ "gap",
2296
+ "clear",
2297
+ "rewind",
2298
+ "oversized"
2299
+ ]);
2300
+ var TimelineSyncResponseSchema = z28.discriminatedUnion("status", [
2301
+ z28.object({
2302
+ status: z28.literal("snapshot"),
2303
+ watermark: TimelineWatermarkSchema,
2304
+ page: SessionTimelinePageSchema
2305
+ }).strict(),
2306
+ z28.object({
2307
+ status: z28.literal("replay"),
2308
+ watermark: TimelineWatermarkSchema,
2309
+ afterSequence: sequence,
2310
+ events: z28.array(TimelineSyncEventSchema).max(TIMELINE_SYNC_MAX_EVENTS),
2311
+ hasMore: z28.boolean()
2312
+ }).strict(),
2313
+ z28.object({
2314
+ status: z28.literal("resync"),
2315
+ epoch: identity,
2316
+ reason: TimelineResyncReasonSchema
2317
+ }).strict()
2318
+ ]);
2319
+ var TimelineImageRequestSchema = z28.object({
2320
+ sha256: hash,
2321
+ offset: z28.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1)
2322
+ }).strict();
2323
+ var TimelineImageChunkSchema = z28.object({
2324
+ sha256: hash,
2325
+ offset: z28.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1),
2326
+ totalBytes: z28.number().int().positive().max(TIMELINE_IMAGE_MAX_BYTES),
2327
+ mimeType: z28.enum(["image/gif", "image/jpeg", "image/png", "image/webp"]),
2328
+ data: z28.string().min(4).max(Math.ceil(TIMELINE_IMAGE_CHUNK_BYTES / 3) * 4).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u),
2329
+ eof: z28.boolean()
2330
+ }).strict().superRefine((chunk, context) => {
2331
+ const padding = chunk.data.endsWith("==") ? 2 : chunk.data.endsWith("=") ? 1 : 0;
2332
+ const length = chunk.data.length / 4 * 3 - padding;
2333
+ const end = chunk.offset + length;
2334
+ if (end > chunk.totalBytes || chunk.eof !== (end === chunk.totalBytes) || !chunk.eof && length !== TIMELINE_IMAGE_CHUNK_BYTES) {
2335
+ context.addIssue({ code: "custom", message: "Image chunk length or completion does not match its total" });
2336
+ }
2337
+ });
2338
+
2339
+ // ../../shared/protocol/dist/workbench.js
2340
+ import { z as z30 } from "zod";
2341
+
2342
+ // ../../shared/protocol/dist/schedules.js
2343
+ import { z as z29 } from "zod";
2344
+ var SCHEDULE_OPERATIONS = [
2345
+ "schedule.snapshot",
2346
+ "schedule.create",
2347
+ "schedule.delete",
2348
+ "schedule.draft.dismiss",
2349
+ "schedule.resume"
2350
+ ];
2351
+ var Id = z29.string().min(1).max(256);
2352
+ var NativeId = z29.number().int().positive().max(Number.MAX_SAFE_INTEGER);
2353
+ var Time = z29.iso.datetime({ offset: true });
2354
+ var WorkbenchScheduleRuleSchema = z29.discriminatedUnion("kind", [
2355
+ z29.object({ kind: z29.literal("once"), at: Time }).strict(),
2356
+ z29.object({
2357
+ kind: z29.literal("interval"),
2358
+ seconds: z29.number().int().min(10).max(86400),
2359
+ recurring: z29.boolean().optional()
2360
+ }).strict(),
2361
+ z29.object({
2362
+ kind: z29.literal("cron"),
2363
+ expression: z29.string().trim().min(9).max(256).regex(/^\S+(?: +\S+){4}$/),
2364
+ timezone: z29.string().min(1).max(128).regex(/^[A-Za-z0-9_+./-]+$/)
2365
+ }).strict()
2366
+ ]);
2367
+ var Content = {
2368
+ rule: WorkbenchScheduleRuleSchema,
2369
+ prompt: z29.string().max(16e3).describe("The execution prompt, or ONLY the user's exact arguments when skill is set. Do not include the skill name, slash prefix, scheduling instructions, or extra explanation in skill arguments."),
2370
+ skill: z29.string().min(1).max(256).regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/).optional().describe("A genuine callable skill name from this session, without the leading slash. Set this field when the user requests a skill; put only its exact arguments in prompt.")
2371
+ };
2372
+ var WorkbenchScheduleProposalSchema = z29.object(Content).strict().refine((value) => value.prompt.trim().length > 0 || value.skill !== void 0, { message: "A prompt or skill is required" });
2373
+ var WorkbenchScheduleDraftSchema = z29.object({
2374
+ id: z29.uuid(),
2375
+ createdAt: Time,
2376
+ ...Content
2377
+ }).strict();
2378
+ var WorkbenchScheduleEntrySchema = z29.object({
2379
+ id: NativeId,
2380
+ prompt: z29.string().max(1e5),
2381
+ displayPrompt: z29.string().max(1e5).optional(),
2382
+ recurring: z29.boolean(),
2383
+ nextRunAt: Time,
2384
+ intervalMs: z29.number().int().positive().optional(),
2385
+ cron: z29.string().max(256).optional(),
2386
+ timezone: z29.string().max(128).optional(),
2387
+ at: Time.optional()
2388
+ }).strict();
2389
+ var WorkbenchScheduleResultSchema = z29.object({
2390
+ id: Id,
2391
+ scheduleId: NativeId,
2392
+ triggerEventId: Id,
2393
+ time: Time,
2394
+ prompt: z29.string().max(16e3),
2395
+ status: z29.enum(["reply", "error", "merged", "pending", "unknown"]),
2396
+ reply: z29.string().max(16e3).optional(),
2397
+ replyEventId: Id.optional(),
2398
+ error: z29.string().max(1024).optional()
2399
+ }).strict();
2400
+ var WorkbenchScheduleSnapshotSchema = z29.object({
2401
+ state: z29.enum(["active", "needs-resume"]),
2402
+ workingDirectory: z29.string().max(32768).optional(),
2403
+ timezone: z29.string().max(128).optional(),
2404
+ entries: z29.array(WorkbenchScheduleEntrySchema).max(256),
2405
+ drafts: z29.array(WorkbenchScheduleDraftSchema).max(100),
2406
+ results: z29.array(WorkbenchScheduleResultSchema).max(100),
2407
+ historyTruncated: z29.boolean(),
2408
+ sampledAt: Time
2409
+ }).strict();
2410
+ var Submission = {
2411
+ operationId: z29.uuid(),
2412
+ operationCreatedAt: z29.iso.datetime(),
2413
+ expectedAgentRunId: Id
2414
+ };
2415
+ var WorkbenchScheduleCreateRequestSchema = z29.object({
2416
+ ...Submission,
2417
+ ...Content,
2418
+ draftId: z29.uuid().optional()
2419
+ }).strict().refine((value) => value.prompt.trim().length > 0 || value.skill !== void 0, { message: "A prompt or skill is required" });
2420
+ var WorkbenchScheduleCreateResultSchema = z29.object({
2421
+ snapshot: WorkbenchScheduleSnapshotSchema,
2422
+ verified: z29.boolean()
2423
+ }).strict();
2424
+ var WorkbenchScheduleDeleteRequestSchema = z29.object({
2425
+ ...Submission,
2426
+ id: NativeId
2427
+ }).strict();
2428
+ var WorkbenchScheduleDeleteResultSchema = z29.object({
2429
+ snapshot: WorkbenchScheduleSnapshotSchema,
2430
+ removed: z29.boolean()
2431
+ }).strict();
2432
+ var WorkbenchScheduleDraftDismissRequestSchema = z29.object({
2433
+ ...Submission,
2434
+ draftId: z29.uuid()
2435
+ }).strict();
2436
+ var ScheduleAndroidSchemas = {
2437
+ WorkbenchScheduleRule: WorkbenchScheduleRuleSchema,
2438
+ WorkbenchScheduleProposal: WorkbenchScheduleProposalSchema,
2439
+ WorkbenchScheduleDraft: WorkbenchScheduleDraftSchema,
2440
+ WorkbenchScheduleEntry: WorkbenchScheduleEntrySchema,
2441
+ WorkbenchScheduleResult: WorkbenchScheduleResultSchema,
2442
+ WorkbenchScheduleSnapshot: WorkbenchScheduleSnapshotSchema,
2443
+ WorkbenchScheduleCreateRequest: WorkbenchScheduleCreateRequestSchema,
2444
+ WorkbenchScheduleCreateResult: WorkbenchScheduleCreateResultSchema,
2445
+ WorkbenchScheduleDeleteRequest: WorkbenchScheduleDeleteRequestSchema,
2446
+ WorkbenchScheduleDeleteResult: WorkbenchScheduleDeleteResultSchema,
2447
+ WorkbenchScheduleDraftDismissRequest: WorkbenchScheduleDraftDismissRequestSchema
2448
+ };
2449
+
2450
+ // ../../shared/protocol/dist/workbench.js
2451
+ var Id2 = z30.string().trim().min(1).max(256);
2452
+ var Text = z30.string().max(1e5);
2453
+ var Count = z30.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
2454
+ var Failure = z30.object({ code: Id2, message: z30.string().min(1).max(1024) }).strict();
2455
+ var WORKBENCH_OPERATIONS = [
2456
+ "operation.get",
2457
+ "question.ask",
2458
+ "research.create",
2459
+ "research.list",
2460
+ "research.timeline",
2461
+ "research.send",
2462
+ "research.abort",
2463
+ "research.delete",
2464
+ "command.list",
2465
+ "command.invoke",
2466
+ "queue.snapshot",
2467
+ "queue.mutate",
2468
+ "insights.read",
2469
+ "context.compact",
2470
+ ...SCHEDULE_OPERATIONS
2471
+ ];
2472
+ var Submission2 = {
2473
+ operationId: z30.uuid(),
2474
+ operationCreatedAt: z30.iso.datetime(),
2475
+ expectedAgentRunId: Id2
2476
+ };
2477
+ var WorkbenchOperationGetSchema = z30.object({ operationId: z30.uuid() }).strict();
2478
+ var WorkbenchOperationStatusSchema = z30.object({
2479
+ operationId: z30.uuid(),
2480
+ operation: z30.enum(WORKBENCH_OPERATIONS),
2481
+ agentRunId: Id2,
2482
+ state: z30.enum(["running", "succeeded", "failed", "uncertain", "result-expired"]),
2483
+ result: z30.record(z30.string(), z30.json()).optional(),
2484
+ error: Failure.optional()
2485
+ }).strict().superRefine((value, context) => {
2486
+ if (value.state === "succeeded" !== (value.result !== void 0) || (value.state === "failed" || value.state === "uncertain") !== (value.error !== void 0)) {
2487
+ context.addIssue({ code: "custom", message: "Invalid operation state payload" });
2488
+ }
2489
+ });
2490
+ var WorkbenchAskRequestSchema = z30.object({
2491
+ ...Submission2,
2492
+ question: z30.string().trim().min(1).max(16e3)
2493
+ }).strict();
2494
+ var WorkbenchAskResultSchema = z30.object({ answer: Text }).strict();
2495
+ var WorkbenchEmptyRequestSchema = z30.object({}).strict();
2496
+ var WorkbenchSubmitRequestSchema = z30.object(Submission2).strict();
2497
+ var WorkbenchResearchCreateRequestSchema = z30.object({
2498
+ ...Submission2,
2499
+ title: z30.string().trim().min(1).max(120),
2500
+ question: z30.string().trim().min(1).max(16e3),
2501
+ sourceItemId: Id2.optional(),
2502
+ deferInitialPrompt: z30.literal(true).optional()
2503
+ }).strict();
2504
+ var WorkbenchResearchThreadSchema = z30.object({
2505
+ sessionId: Id2,
2506
+ parentSessionId: Id2,
2507
+ title: z30.string().min(1).max(120),
2508
+ createdAt: z30.iso.datetime(),
2509
+ contextAnchor: Id2.optional(),
2510
+ contextTruncated: z30.boolean(),
2511
+ detached: z30.boolean(),
2512
+ state: z30.enum(["creating", "ready", "failed"])
2513
+ }).strict();
2514
+ var WorkbenchResearchCreateResultSchema = z30.object({
2515
+ thread: WorkbenchResearchThreadSchema
2516
+ }).strict();
2517
+ var WorkbenchResearchListResultSchema = z30.object({
2518
+ threads: z30.array(WorkbenchResearchThreadSchema).max(100)
2519
+ }).strict();
2520
+ var WorkbenchResearchTimelineRequestSchema = z30.object({
2521
+ cursor: Id2.optional()
2522
+ }).strict();
2523
+ var WorkbenchResearchSendRequestSchema = z30.object({
2524
+ ...Submission2,
2525
+ prompt: z30.string().trim().min(1).max(16e3)
2526
+ }).strict();
2527
+ var WorkbenchResearchSendResultSchema = z30.object({ messageId: Id2 }).strict();
2528
+ var WorkbenchCompletedResultSchema = z30.object({ completed: z30.boolean() }).strict();
2529
+ var WorkbenchCommandSchema = z30.object({
2530
+ name: z30.string().min(1).max(260),
2531
+ description: z30.string().max(4096),
2532
+ argumentHint: z30.string().max(1024).optional(),
2533
+ kind: z30.enum(["builtin", "skill", "client"]),
2534
+ allowDuringExecution: z30.boolean(),
2535
+ supported: z30.boolean(),
2536
+ reason: z30.string().max(1024).optional()
2537
+ }).strict();
2538
+ var WorkbenchCommandListResultSchema = z30.object({
2539
+ commands: z30.array(WorkbenchCommandSchema).max(512)
2540
+ }).strict();
2541
+ var WorkbenchCommandInvokeRequestSchema = z30.object({
2542
+ ...Submission2,
2543
+ name: z30.string().trim().min(1).max(260),
2544
+ input: z30.string().max(16e3)
2545
+ }).strict();
2546
+ var WorkbenchCommandChoiceSchema = z30.object({
2547
+ name: z30.string().min(1).max(260),
2548
+ label: z30.string().min(1).max(1024),
2549
+ input: z30.string().max(16e3)
2550
+ }).strict();
2551
+ var WorkbenchCommandResultSchema = z30.discriminatedUnion("kind", [
2552
+ z30.object({ kind: z30.literal("text"), text: Text }).strict(),
2553
+ z30.object({ kind: z30.literal("completed") }).strict(),
2554
+ z30.object({ kind: z30.literal("sent"), messageId: Id2 }).strict(),
2555
+ z30.object({
2556
+ kind: z30.literal("select-subcommand"),
2557
+ choices: z30.array(WorkbenchCommandChoiceSchema).min(1).max(100)
2558
+ }).strict()
2559
+ ]);
2560
+ var WorkbenchQueueItemSchema = z30.object({
2561
+ id: Id2,
2562
+ kind: z30.string().min(1).max(64),
2563
+ texts: z30.array(z30.string().max(1e5)).min(1).max(100),
2564
+ actions: z30.array(z30.enum(["edit", "remove", "move", "send-now"])).max(4)
2565
+ }).strict();
2566
+ var WorkbenchQueueSnapshotSchema = z30.object({
2567
+ generation: Id2,
2568
+ revision: Id2,
2569
+ items: z30.array(WorkbenchQueueItemSchema).max(512),
2570
+ steeringMessages: z30.array(z30.string().max(1e5)).max(512)
2571
+ }).strict();
2572
+ var QueueMutation = {
2573
+ ...Submission2,
2574
+ generation: Id2,
2575
+ revision: Id2,
2576
+ id: Id2
2577
+ };
2578
+ var WorkbenchQueueMutationRequestSchema = z30.discriminatedUnion("action", [
2579
+ z30.object({ ...QueueMutation, action: z30.literal("edit"), prompt: z30.string().trim().min(1).max(1e5) }).strict(),
2580
+ z30.object({ ...QueueMutation, action: z30.literal("remove") }).strict(),
2581
+ z30.object({ ...QueueMutation, action: z30.literal("move"), toPosition: z30.number().int().min(0).max(511) }).strict(),
2582
+ z30.object({ ...QueueMutation, action: z30.literal("send-now") }).strict()
2583
+ ]);
2584
+ var WorkbenchQueueMutationResultSchema = z30.object({
2585
+ changed: z30.boolean(),
2586
+ snapshot: WorkbenchQueueSnapshotSchema
2587
+ }).strict();
2588
+ var WorkbenchTokenMetricSchema = z30.object({
2589
+ kind: z30.string().min(1).max(128),
2590
+ count: Count
2591
+ }).strict();
2592
+ var WorkbenchModelUsageSchema = z30.object({
2593
+ model: Id2,
2594
+ requests: Count,
2595
+ premiumRequestCost: z30.number().finite().nonnegative(),
2596
+ tokens: z30.array(WorkbenchTokenMetricSchema).max(32)
2597
+ }).strict();
2598
+ var WorkbenchContextSchema = z30.object({
2599
+ currentTokens: Count,
2600
+ tokenLimit: Count,
2601
+ systemTokens: Count.optional(),
2602
+ conversationTokens: Count.optional(),
2603
+ toolTokens: Count.optional()
2604
+ }).strict();
2605
+ var WorkbenchInsightsSchema = z30.object({
2606
+ sampledAt: z30.iso.datetime(),
2607
+ generation: Id2,
2608
+ model: Id2.optional(),
2609
+ totalUserRequests: Count,
2610
+ premiumRequestCost: z30.number().finite().nonnegative(),
2611
+ nanoAiu: z30.string().regex(/^\d+$/).max(40).optional(),
2612
+ tokens: z30.array(WorkbenchTokenMetricSchema).max(32),
2613
+ models: z30.array(WorkbenchModelUsageSchema).max(100),
2614
+ context: WorkbenchContextSchema.optional(),
2615
+ canCompact: z30.boolean(),
2616
+ compactUnavailableReason: z30.string().max(1024).optional()
2617
+ }).strict();
2618
+ var WorkbenchCompactResultSchema = z30.object({
2619
+ success: z30.boolean(),
2620
+ tokensRemoved: Count,
2621
+ messagesRemoved: Count
2622
+ }).strict();
2623
+ var WorkbenchAndroidSchemas = {
2624
+ WorkbenchOperationGet: WorkbenchOperationGetSchema,
2625
+ WorkbenchOperationStatus: WorkbenchOperationStatusSchema,
2626
+ WorkbenchAskRequest: WorkbenchAskRequestSchema,
2627
+ WorkbenchAskResult: WorkbenchAskResultSchema,
2628
+ WorkbenchSubmitRequest: WorkbenchSubmitRequestSchema,
2629
+ WorkbenchResearchCreateRequest: WorkbenchResearchCreateRequestSchema,
2630
+ WorkbenchResearchThread: WorkbenchResearchThreadSchema,
2631
+ WorkbenchResearchCreateResult: WorkbenchResearchCreateResultSchema,
2632
+ WorkbenchResearchListResult: WorkbenchResearchListResultSchema,
2633
+ WorkbenchResearchTimelineRequest: WorkbenchResearchTimelineRequestSchema,
2634
+ WorkbenchResearchSendRequest: WorkbenchResearchSendRequestSchema,
2635
+ WorkbenchResearchSendResult: WorkbenchResearchSendResultSchema,
2636
+ WorkbenchCompletedResult: WorkbenchCompletedResultSchema,
2637
+ WorkbenchCommand: WorkbenchCommandSchema,
2638
+ WorkbenchCommandListResult: WorkbenchCommandListResultSchema,
2639
+ WorkbenchCommandInvokeRequest: WorkbenchCommandInvokeRequestSchema,
2640
+ WorkbenchCommandChoice: WorkbenchCommandChoiceSchema,
2641
+ WorkbenchCommandResult: WorkbenchCommandResultSchema,
2642
+ WorkbenchQueueItem: WorkbenchQueueItemSchema,
2643
+ WorkbenchQueueSnapshot: WorkbenchQueueSnapshotSchema,
2644
+ WorkbenchQueueMutationRequest: WorkbenchQueueMutationRequestSchema,
2645
+ WorkbenchQueueMutationResult: WorkbenchQueueMutationResultSchema,
2646
+ WorkbenchTokenMetric: WorkbenchTokenMetricSchema,
2647
+ WorkbenchModelUsage: WorkbenchModelUsageSchema,
2648
+ WorkbenchContext: WorkbenchContextSchema,
2649
+ WorkbenchInsights: WorkbenchInsightsSchema,
2650
+ WorkbenchCompactResult: WorkbenchCompactResultSchema
2651
+ };
2652
+
2653
+ // ../../shared/protocol/dist/microsoft-todo.js
2654
+ import { z as z31 } from "zod";
2655
+ var MicrosoftTodoOperationSchema = z31.enum([
2656
+ "status",
2657
+ "connect",
2658
+ "disconnect",
2659
+ "list_lists",
2660
+ "get_list",
2661
+ "create_list",
2662
+ "update_list",
2663
+ "delete_list",
2664
+ "list_tasks",
2665
+ "get_task",
2666
+ "create_task",
2667
+ "update_task",
2668
+ "delete_task"
2669
+ ]);
2670
+ var MicrosoftTodoIdSchema = z31.string().min(1).max(1024).regex(/^[A-Za-z0-9_/=+-]+$/);
2671
+ var MicrosoftTodoDateTimeSchema = z31.object({
2672
+ dateTime: z31.string().min(1).max(64).regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,7})?$/),
2673
+ timeZone: z31.string().min(1).max(128)
2674
+ }).strict();
2675
+ var MicrosoftTodoTaskInputSchema = z31.object({
2676
+ title: z31.string().trim().min(1).max(1e3).optional(),
2677
+ body: z31.object({
2678
+ content: z31.string().max(16e3),
2679
+ contentType: z31.literal("text")
2680
+ }).strict().optional(),
2681
+ status: z31.enum(["notStarted", "inProgress", "completed", "waitingOnOthers", "deferred"]).optional(),
2682
+ importance: z31.enum(["low", "normal", "high"]).optional(),
2683
+ dueDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
2684
+ reminderDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
2685
+ isReminderOn: z31.boolean().optional()
2686
+ }).strict();
2687
+ var MicrosoftTodoListInputSchema = z31.object({
2688
+ displayName: z31.string().trim().min(1).max(255)
2689
+ }).strict();
2690
+ var MicrosoftTodoRequestSchema = z31.object({
2691
+ operation: MicrosoftTodoOperationSchema,
2692
+ listId: MicrosoftTodoIdSchema.optional(),
2693
+ taskId: MicrosoftTodoIdSchema.optional(),
2694
+ list: MicrosoftTodoListInputSchema.optional(),
2695
+ task: MicrosoftTodoTaskInputSchema.optional(),
2696
+ cursor: z31.string().min(1).max(8192).optional(),
2697
+ etag: z31.string().min(1).max(512).regex(/^[^\r\n]+$/).optional()
2698
+ }).strict();
2699
+ var MicrosoftTodoListSchema = z31.object({
2700
+ id: MicrosoftTodoIdSchema,
2701
+ displayName: z31.string().max(1e3),
2702
+ isOwner: z31.boolean(),
2703
+ isShared: z31.boolean(),
2704
+ wellknownListName: z31.string().max(128),
2705
+ etag: z31.string().max(512).optional()
2706
+ }).strict();
2707
+ var MicrosoftTodoTaskSchema = z31.object({
2708
+ id: MicrosoftTodoIdSchema,
2709
+ title: z31.string().max(1e3),
2710
+ body: z31.object({ content: z31.string().max(16e3), contentType: z31.string().max(32) }).strict(),
2711
+ status: z31.string().max(64),
2712
+ importance: z31.string().max(32),
2713
+ dueDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
2714
+ reminderDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
2715
+ isReminderOn: z31.boolean(),
2716
+ lastModifiedDateTime: z31.string().max(64),
2717
+ etag: z31.string().max(512).optional()
2718
+ }).strict();
2719
+ var MicrosoftTodoResultSchema = z31.object({
2720
+ ok: z31.literal(true),
2721
+ enabled: z31.boolean(),
2722
+ connected: z31.boolean(),
2723
+ authorizationUrl: z31.url().optional(),
2724
+ lists: z31.array(MicrosoftTodoListSchema).max(100).optional(),
2725
+ list: MicrosoftTodoListSchema.optional(),
2726
+ tasks: z31.array(MicrosoftTodoTaskSchema).max(100).optional(),
2727
+ task: MicrosoftTodoTaskSchema.optional(),
2728
+ nextCursor: z31.string().max(8192).optional(),
2729
+ deleted: z31.boolean().optional()
2730
+ }).strict();
2731
+ var MicrosoftTodoAndroidSchemas = {
2732
+ MicrosoftTodoDateTime: MicrosoftTodoDateTimeSchema,
2733
+ MicrosoftTodoTaskInput: MicrosoftTodoTaskInputSchema,
2734
+ MicrosoftTodoListInput: MicrosoftTodoListInputSchema,
2735
+ MicrosoftTodoRequest: MicrosoftTodoRequestSchema,
2736
+ MicrosoftTodoList: MicrosoftTodoListSchema,
2737
+ MicrosoftTodoTask: MicrosoftTodoTaskSchema,
2738
+ MicrosoftTodoResult: MicrosoftTodoResultSchema
2739
+ };
2740
+
2741
+ // ../../shared/protocol/dist/relay-features.js
2742
+ import { z as z32 } from "zod";
2743
+ var RelayFeaturesSchema = z32.object({
2744
+ microsoftTodo: z32.boolean(),
2745
+ modelGateway: z32.boolean(),
2746
+ sessionImages: z32.boolean(),
2747
+ webClient: z32.boolean()
2748
+ }).strict();
2749
+ var RelayFeatureAndroidSchemas = { RelayFeatures: RelayFeaturesSchema };
2750
+
2751
+ // ../../shared/protocol/dist/codegen/android-schemas.js
2752
+ var AndroidProtocolSchemas = {
2753
+ MobileIdentityProof: MobileIdentityProofSchema,
2754
+ MobileAuthorizationClaim: MobileAuthorizationClaimSchema,
2755
+ MobileAuthorizationPoll: MobileAuthorizationPollSchema,
2756
+ MobileAuthorizationResult: MobileAuthorizationResultSchema,
2757
+ BrowserOpenUrlParams: BrowserOpenUrlParamsSchema,
2758
+ BrowserOpenUrlResult: BrowserOpenUrlResultSchema,
2759
+ TimelineImageBlobRequest: TimelineImageBlobRequestSchema,
2760
+ TimelineImageBlobResult: TimelineImageBlobResultSchema,
2761
+ SessionImageUploadRequest: SessionImageUploadRequestSchema,
2762
+ SessionImageScope: SessionImageScopeSchema,
2763
+ SessionImageUploadResult: SessionImageUploadResultSchema,
2764
+ SessionImageCommitResult: SessionImageCommitResultSchema,
2765
+ SessionImageDownloadResult: SessionImageDownloadResultSchema,
2766
+ ...WorkbenchAndroidSchemas,
2767
+ ...ScheduleAndroidSchemas,
2768
+ ...MicrosoftTodoAndroidSchemas,
2769
+ ...RelayFeatureAndroidSchemas,
2770
+ SessionCommunication: SessionCommunicationSchema,
2771
+ SessionGitDiffData: SessionGitDiffDataSchema,
2772
+ SessionGitDiffEntry: SessionGitDiffPartialEntrySchema,
2773
+ SessionGitDiffResultData: SessionGitDiffPartialResultDataSchema,
2774
+ SessionGitDiffFileError: SessionGitDiffFileErrorSchema,
2775
+ SessionGitDiffGzipResultData: SessionGitDiffGzipResultDataSchema,
2776
+ SessionRenameData: SessionRenameDataSchema,
2777
+ SessionRenameResultData: SessionRenameResultDataSchema,
2778
+ SessionDirectoryListData: SessionDirectoryListDataSchema,
2779
+ SessionDirectoryListResultData: SessionDirectoryListResultDataSchema,
2780
+ SessionFileReadData: SessionFileReadDataSchema,
2781
+ SessionFileReadResultData: SessionFileReadResultDataSchema,
2782
+ SessionFileReadV2ResultData: SessionFileReadV2ResultDataSchema,
2783
+ SessionFileDownloadData: SessionFileDownloadDataSchema,
2784
+ SessionFileDownloadResultData: SessionFileDownloadResultDataSchema,
2785
+ SessionResourceReadData: SessionResourceReadDataSchema,
2786
+ SessionResourceReadResultData: SessionResourceReadResultDataSchema,
2787
+ SessionDirectoryListRequest: SessionDirectoryListRequestSchema,
2788
+ SessionDirectoryEntry: SessionDirectoryEntrySchema,
2789
+ SessionDirectoryListResponse: SessionDirectoryListResponseSchema,
2790
+ SessionGitProject: SessionGitProjectSchema,
2791
+ SessionProjectIdentityResultData: SessionProjectIdentityResultDataSchema,
2792
+ V2SocketAuth: V2SocketAuthSchema,
2793
+ SecureMessage: SecureMessageSchema,
2794
+ SecureDeliveryError: SecureDeliveryErrorSchema,
2795
+ AuthUser: AuthUserSchema,
2796
+ RelayAuthDiscovery: RelayAuthDiscoverySchema,
2797
+ RelayAuthentication: RelayAuthDiscoverySchema.shape.authentication,
2798
+ AadAccountResult: AadAccountResultSchema,
2799
+ LoginRequest: LoginRequestSchema,
2800
+ LoginResult: LoginResultSchema,
2801
+ PcAccountRequest: PcAccountRequestSchema,
2802
+ PcAccountResult: PcAccountResultSchema,
2803
+ PairingExchangeRequest: PairingExchangeRequestSchema,
2804
+ PairingExchangeResult: PairingExchangeResultSchema,
2805
+ MobileTransferMachine: MobileTransferMachineSchema,
2806
+ MobileTransferPayload: MobileTransferPayloadSchema,
2807
+ MobileTransferPart: MobileTransferPartSchema,
2808
+ MobileTransferUploadRequest: MobileTransferUploadRequestSchema,
2809
+ MobileTransferUploadResult: MobileTransferUploadResultSchema,
2810
+ MobileTransferDownloadResult: MobileTransferDownloadResultSchema,
2811
+ MobileLoginRequest: MobileLoginRequestSchema,
2812
+ MachinePresence: MachinePresenceSchema,
2813
+ MachineOffline: MachineOfflineSchema,
2814
+ MachineListRequest: MachineListRequestSchema,
2815
+ MachineListResult: MachineListResultSchema,
2816
+ SessionSummary: SessionSummarySchema,
2817
+ GroupChatParticipant: GroupChatParticipantSchema,
2818
+ GroupChatInfo: GroupChatInfoSchema,
2819
+ GroupChatCreateData: GroupChatCreateDataSchema,
2820
+ GroupChatCreateResultData: GroupChatCreateResultDataSchema,
2821
+ SessionsSnapshot: SessionsSnapshotSchema,
2822
+ SessionListRequest: SessionListRequestSchema,
2823
+ SessionListResult: SessionListResultSchema,
2824
+ WorkspaceOption: WorkspaceOptionSchema,
2825
+ CopilotModelOption: CopilotModelOptionSchema,
2826
+ SessionOptionsRequest: SessionOptionsRequestSchema,
2827
+ SessionOptionsResult: SessionOptionsResultSchema,
2828
+ SessionCreateRequest: SessionCreateRequestSchema,
2829
+ SessionCreateResult: SessionCreateResultSchema,
2830
+ SessionDeleteRequest: SessionDeleteRequestSchema,
2831
+ SessionDeleteResult: SessionDeleteResultSchema,
2832
+ SessionConfigureRequest: SessionConfigureRequestSchema,
2833
+ SessionConfigureResult: SessionConfigureResultSchema,
2834
+ SessionRemoteRequest: SessionRemoteRequestSchema,
2835
+ SessionRemoteStatus: SessionRemoteStatusSchema,
2836
+ SessionRemoteResult: SessionRemoteResultSchema,
2837
+ ConversationAttachment: ConversationAttachmentSchema,
2838
+ PromptImageAttachment: PromptImageAttachmentSchema,
2839
+ ConversationActivityStep: ConversationActivityStepSchema,
2840
+ ConversationPlanTodo: ConversationPlanTodoSchema,
2841
+ ConversationItem: ConversationItemSchema,
2842
+ SessionAssistantPreview: SessionAssistantPreviewSchema,
2843
+ SessionUserPreview: SessionUserPreviewSchema,
2844
+ SessionTimelinePageRequest: SessionTimelinePageRequestSchema,
2845
+ SessionWatchRequest: SessionWatchRequestSchema,
2846
+ SessionWatchResult: SessionWatchResultSchema,
2847
+ SessionTimelinePage: SessionTimelinePageSchema,
2848
+ SessionTimelinePageResult: SessionTimelinePageResultSchema,
2849
+ TimelineWatermark: TimelineWatermarkSchema,
2850
+ TimelineSyncRequest: TimelineSyncRequestSchema,
2851
+ TimelineTextAppend: TimelineTextAppendSchema,
2852
+ TimelineSyncEvent: TimelineSyncEventSchema,
2853
+ TimelineSyncResponse: TimelineSyncResponseSchema,
2854
+ TimelineImageRequest: TimelineImageRequestSchema,
2855
+ TimelineImageChunk: TimelineImageChunkSchema,
2856
+ SessionPromptRequest: SessionPromptRequestSchema,
2857
+ SessionPromptResult: SessionPromptResultSchema,
2858
+ SessionActivityUpdate: SessionActivityUpdateSchema,
2859
+ SessionAbortRequest: SessionAbortRequestSchema,
2860
+ SessionAbortResult: SessionAbortResultSchema,
2861
+ ConversationItemUpsert: ConversationItemUpsertSchema,
2862
+ ConversationActivityStepUpsert: ConversationActivityStepUpsertSchema,
2863
+ SessionTimelineInvalidated: SessionTimelineInvalidatedSchema,
2864
+ InteractionFormField: InteractionFormFieldSchema,
2865
+ InteractionRequest: InteractionRequestSchema,
2866
+ InteractionResponse: InteractionResponseSchema,
2867
+ InteractionRequestPayload: InteractionRequestPayloadSchema,
2868
+ InteractionRespondRequest: InteractionRespondRequestSchema,
2869
+ InteractionRespondResult: InteractionRespondResultSchema,
2870
+ PermissionRequestPayload: PermissionRequestPayloadSchema,
2871
+ PermissionRespondRequest: PermissionRespondRequestSchema,
2872
+ PermissionRespondResult: PermissionRespondResultSchema,
2873
+ ProtocolError: ProtocolErrorSchema
2874
+ };
2875
+
2876
+ export {
2877
+ MobileAuthorizationIdSchema,
2878
+ AuthUserSchema,
2879
+ AadAccountResultSchema,
2880
+ RELAY_AUTH_DISCOVERY_PATH,
2881
+ RelayAuthenticationSchema,
2882
+ RelayAuthDiscoverySchema,
2883
+ PcAccountRequestSchema,
2884
+ PcAccountResultSchema,
2885
+ PairingStatusRequestSchema,
2886
+ MobileIdentityPublicKeySchema,
2887
+ MobileAuthorizationListResultSchema,
2888
+ PcEnrollmentIdSchema,
2889
+ PcEnrollmentStartRequestSchema,
2890
+ PcEnrollmentVerifierRequestSchema,
2891
+ MicrosoftEnrollmentFailureSchema,
2892
+ MicrosoftMutationResultSchema,
2893
+ PcEnrollmentExchangeResultSchema,
2894
+ PcBrowserRedirectUriSchema,
2895
+ PcBrowserAuthorizationStartRequestSchema,
2896
+ PcBrowserAuthorizationStartResultSchema,
2897
+ PcBrowserAuthorizationCallbackSchema,
2898
+ SECURE_MESSAGE_MAX_CIPHERTEXT_LENGTH,
2899
+ SESSION_TIMELINE_PAGE_SIZE,
2900
+ SessionTimelinePageRequestSchema,
2901
+ SessionTimelinePageSchema
2902
+ };