@agentknight/client 0.9.49 → 0.9.51

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