@agentknight/client 0.9.50 → 0.9.52

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