@agentknight/client 0.9.56 → 0.9.59

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.
@@ -1211,30 +1211,103 @@ var PeerDeliverySchema = z16.object({
1211
1211
  }).strict();
1212
1212
 
1213
1213
  // ../../shared/protocol/dist/transport/a2a.js
1214
+ import { z as z19 } from "zod";
1215
+
1216
+ // ../../shared/protocol/dist/transport/encrypted-peer.js
1217
+ import { z as z18 } from "zod";
1218
+
1219
+ // ../../shared/protocol/dist/sessions/session-communication.js
1214
1220
  import { z as z17 } from "zod";
1221
+ var SessionCommunicationIdSchema = z17.string().min(1).max(256).refine((value) => value === value.trim(), "Expected an unpadded identity");
1222
+ var SessionCommunicationIdentityShape = {
1223
+ requestId: SessionCommunicationIdSchema,
1224
+ machineId: SessionCommunicationIdSchema,
1225
+ sessionId: SessionCommunicationIdSchema,
1226
+ operation: z17.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/u),
1227
+ version: z17.number().int().positive().max(2147483647)
1228
+ };
1229
+ var SessionCommunicationDataSchema = z17.record(z17.string(), z17.json());
1230
+ var SessionCommunicationRequestSchema = z17.object({
1231
+ ...SessionCommunicationIdentityShape,
1232
+ kind: z17.literal("request"),
1233
+ data: SessionCommunicationDataSchema
1234
+ }).strict();
1235
+ var SessionCommunicationResponseSchema = z17.object({
1236
+ ...SessionCommunicationIdentityShape,
1237
+ kind: z17.literal("response"),
1238
+ data: SessionCommunicationDataSchema
1239
+ }).strict();
1240
+ var SessionCommunicationErrorSchema = z17.object({
1241
+ ...SessionCommunicationIdentityShape,
1242
+ kind: z17.literal("error"),
1243
+ error: ProtocolFailureSchema
1244
+ }).strict();
1245
+ var SessionCommunicationSchema = z17.discriminatedUnion("kind", [
1246
+ SessionCommunicationRequestSchema,
1247
+ SessionCommunicationResponseSchema,
1248
+ SessionCommunicationErrorSchema
1249
+ ]);
1250
+ function sessionCommunicationOperationCapability(operation, version) {
1251
+ return `${operation}.v${version}`;
1252
+ }
1253
+
1254
+ // ../../shared/protocol/dist/transport/encrypted-peer.js
1255
+ var ENCRYPTED_PEER_AUTHORIZE_OPERATION = "peer.authorize";
1256
+ var ENCRYPTED_PEER_VERSION = 1;
1257
+ var ENCRYPTED_PEER_AUTHORIZE_CAPABILITY = sessionCommunicationOperationCapability(ENCRYPTED_PEER_AUTHORIZE_OPERATION, ENCRYPTED_PEER_VERSION);
1258
+ var ENCRYPTED_PEER_MAX_LENGTH = 36e4;
1259
+ var GroupIdSchema = z18.uuid().refine((id) => id === id.toLowerCase(), "Expected a canonical group ID");
1260
+ var EncryptedPeerAuthorizationSchema = z18.object({
1261
+ groupId: GroupIdSchema,
1262
+ peerMachineId: IdSchema,
1263
+ peerSessionId: IdSchema,
1264
+ key: z18.string().regex(/^[A-Za-z0-9_-]{43}$/u)
1265
+ }).strict();
1266
+ var EncryptedPeerAuthorizationResultSchema = z18.object({
1267
+ groupId: GroupIdSchema,
1268
+ keyId: z18.string().regex(/^[A-Za-z0-9_-]{22}$/u)
1269
+ }).strict();
1270
+ var ENCRYPTED_GROUP_CREATE_OPERATION = "group-chat.create-encrypted";
1271
+ var ENCRYPTED_GROUP_CREATE_CAPABILITY = sessionCommunicationOperationCapability(ENCRYPTED_GROUP_CREATE_OPERATION, ENCRYPTED_PEER_VERSION);
1272
+ var EncryptedGroupCreateSchema = z18.object({
1273
+ groupId: GroupIdSchema,
1274
+ peerMachineId: IdSchema,
1275
+ peerSessionId: IdSchema,
1276
+ peerTitle: z18.string().trim().min(1).max(260)
1277
+ }).strict();
1278
+ var EncryptedPeerMessageSchema = SecureMessageSchema.refine((message) => message.sender === "pc" && message.event === "session.communication" && message.recipientClientId !== void 0 && message.ciphertext.length <= ENCRYPTED_PEER_MAX_LENGTH, "Expected a bounded, addressed encrypted peer message");
1279
+
1280
+ // ../../shared/protocol/dist/transport/a2a.js
1215
1281
  var A2A_BODY_MAX_LENGTH = 65536;
1216
- var A2aRelayRequestSchema = z17.object({
1282
+ var A2aRelayRequestSchema = z19.object({
1217
1283
  userId: IdSchema,
1218
1284
  sourceMachineId: IdSchema,
1219
1285
  targetSessionId: IdSchema,
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()
1224
- }).strict().refine((request) => request.kind !== "card" || request.body === "", {
1286
+ endpointUrl: z19.url().max(2048),
1287
+ kind: z19.enum(["card", "rpc", "encrypted"]),
1288
+ body: z19.string().max(ENCRYPTED_PEER_MAX_LENGTH + 4096),
1289
+ protocolVersion: z19.string().max(32).optional()
1290
+ }).strict().refine((request) => request.kind === "encrypted" || request.body.length <= A2A_BODY_MAX_LENGTH, {
1291
+ path: ["body"],
1292
+ message: "Plaintext A2A body exceeds the text budget"
1293
+ }).refine((request) => request.kind !== "card" || request.body === "", {
1225
1294
  path: ["body"],
1226
1295
  message: "Agent card requests must have an empty body"
1227
1296
  });
1228
- var A2aRelayResponseSchema = z17.object({
1229
- status: z17.number().int().min(200).max(599),
1230
- body: z17.string().max(A2A_BODY_MAX_LENGTH)
1231
- }).strict();
1297
+ var A2aRelayResponseSchema = z19.object({
1298
+ status: z19.number().int().min(200).max(599),
1299
+ body: z19.string().max(ENCRYPTED_PEER_MAX_LENGTH + 4096),
1300
+ encrypted: z19.literal(true).optional()
1301
+ }).strict().refine((response) => response.encrypted === true || response.body.length <= A2A_BODY_MAX_LENGTH, {
1302
+ path: ["body"],
1303
+ message: "Plaintext A2A response exceeds the text budget"
1304
+ });
1232
1305
 
1233
1306
  // ../../shared/protocol/dist/transport/browser-open-url.js
1234
- import { z as z18 } from "zod";
1307
+ import { z as z20 } from "zod";
1235
1308
  var BROWSER_OPEN_URL_MAX_LENGTH = 8192;
1236
- var BrowserOpenUrlParamsSchema = z18.strictObject({
1237
- url: z18.string().min(1).max(BROWSER_OPEN_URL_MAX_LENGTH).refine((value) => {
1309
+ var BrowserOpenUrlParamsSchema = z20.strictObject({
1310
+ url: z20.string().min(1).max(BROWSER_OPEN_URL_MAX_LENGTH).refine((value) => {
1238
1311
  if (!/^https?:\/\//i.test(value) || /[\s\p{Cc}\\]/u.test(value) || /%(?![0-9a-f]{2})/i.test(value))
1239
1312
  return false;
1240
1313
  const authority = value.split(/[/?#]/)[2];
@@ -1247,58 +1320,23 @@ var BrowserOpenUrlParamsSchema = z18.strictObject({
1247
1320
  }
1248
1321
  }, "Expected an absolute HTTP(S) URL without credentials or whitespace")
1249
1322
  });
1250
- var BrowserOpenUrlResultSchema = z18.strictObject({ opened: z18.literal(true) });
1323
+ var BrowserOpenUrlResultSchema = z20.strictObject({ opened: z20.literal(true) });
1251
1324
 
1252
1325
  // ../../shared/protocol/dist/transport/device-text-input.js
1253
- import { z as z19 } from "zod";
1326
+ import { z as z21 } from "zod";
1254
1327
  var DEVICE_TEXT_INPUT_MAX_LENGTH = 1e5;
1255
- var DeviceTextInputDataSchema = z19.object({
1256
- text: z19.string().min(1).max(DEVICE_TEXT_INPUT_MAX_LENGTH).refine((value) => value.trim().length > 0 && !value.includes("\0")),
1257
- expiresAt: z19.number().int().nonnegative()
1258
- }).strict();
1259
- var DeviceTextInputResultSchema = z19.object({
1260
- clipboardUpdated: z19.boolean(),
1261
- pasteAttempted: z19.boolean(),
1262
- pasteShortcutSent: z19.boolean()
1328
+ var DeviceTextInputDataSchema = z21.object({
1329
+ text: z21.string().min(1).max(DEVICE_TEXT_INPUT_MAX_LENGTH).refine((value) => value.trim().length > 0 && !value.includes("\0")),
1330
+ expiresAt: z21.number().int().nonnegative()
1331
+ }).strict();
1332
+ var DeviceTextInputResultSchema = z21.object({
1333
+ clipboardUpdated: z21.boolean(),
1334
+ pasteAttempted: z21.boolean(),
1335
+ pasteShortcutSent: z21.boolean()
1263
1336
  }).strict().refine((result) => (!result.pasteAttempted || result.clipboardUpdated) && (!result.pasteShortcutSent || result.pasteAttempted));
1264
1337
 
1265
- // ../../shared/protocol/dist/sessions/session-communication.js
1266
- import { z as z20 } from "zod";
1267
- var SessionCommunicationIdSchema = z20.string().min(1).max(256).refine((value) => value === value.trim(), "Expected an unpadded identity");
1268
- var SessionCommunicationIdentityShape = {
1269
- requestId: SessionCommunicationIdSchema,
1270
- machineId: SessionCommunicationIdSchema,
1271
- sessionId: SessionCommunicationIdSchema,
1272
- operation: z20.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/u),
1273
- version: z20.number().int().positive().max(2147483647)
1274
- };
1275
- var SessionCommunicationDataSchema = z20.record(z20.string(), z20.json());
1276
- var SessionCommunicationRequestSchema = z20.object({
1277
- ...SessionCommunicationIdentityShape,
1278
- kind: z20.literal("request"),
1279
- data: SessionCommunicationDataSchema
1280
- }).strict();
1281
- var SessionCommunicationResponseSchema = z20.object({
1282
- ...SessionCommunicationIdentityShape,
1283
- kind: z20.literal("response"),
1284
- data: SessionCommunicationDataSchema
1285
- }).strict();
1286
- var SessionCommunicationErrorSchema = z20.object({
1287
- ...SessionCommunicationIdentityShape,
1288
- kind: z20.literal("error"),
1289
- error: ProtocolFailureSchema
1290
- }).strict();
1291
- var SessionCommunicationSchema = z20.discriminatedUnion("kind", [
1292
- SessionCommunicationRequestSchema,
1293
- SessionCommunicationResponseSchema,
1294
- SessionCommunicationErrorSchema
1295
- ]);
1296
- function sessionCommunicationOperationCapability(operation, version) {
1297
- return `${operation}.v${version}`;
1298
- }
1299
-
1300
1338
  // ../../shared/protocol/dist/sessions/session-workspace.js
1301
- import { z as z21 } from "zod";
1339
+ import { z as z22 } from "zod";
1302
1340
  var SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH = 32768;
1303
1341
  var SESSION_PROJECT_IDENTITY_MAX_RESPONSE_BYTES = 640 * 1024;
1304
1342
  var SESSION_DIRECTORY_MAX_PATH_LENGTH = 1024;
@@ -1339,47 +1377,52 @@ function isSafeSessionDirectoryPath(path) {
1339
1377
  const segments = path.split("/");
1340
1378
  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));
1341
1379
  }
1342
- var SessionDirectoryListRequestSchema = z21.object({
1380
+ var SessionDirectoryListRequestSchema = z22.object({
1343
1381
  requestId: IdSchema,
1344
1382
  machineId: IdSchema,
1345
1383
  sessionId: IdSchema,
1346
- path: z21.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH)
1347
- }).strict();
1348
- var SessionDirectoryEntrySchema = z21.object({
1349
- name: z21.string().min(1).max(255),
1350
- kind: z21.enum(["directory", "file", "blocked"])
1351
- }).strict();
1352
- var SessionDirectoryListDataSchema = SessionDirectoryListRequestSchema.pick({ path: true });
1353
- var SessionDirectoryListResultDataSchema = z21.object({
1354
- path: z21.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH),
1355
- rootRevision: z21.string().min(1).max(128),
1356
- entries: z21.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES)
1357
- }).strict();
1358
- var SessionDirectoryListResponseSchema = SessionDirectoryListRequestSchema.extend({
1359
- rootRevision: z21.string().min(1).max(128).optional(),
1360
- entries: z21.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES).optional(),
1361
- error: ProtocolFailureSchema.optional()
1384
+ path: z22.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH),
1385
+ space: z22.literal("session").optional()
1386
+ }).strict();
1387
+ var SessionDirectoryEntrySchema = z22.object({
1388
+ name: z22.string().min(1).max(255),
1389
+ kind: z22.enum(["directory", "file", "blocked"])
1390
+ }).strict();
1391
+ var SessionDirectoryListDataSchema = SessionDirectoryListRequestSchema.pick({ path: true, space: true });
1392
+ var SessionDirectoryListResultDataSchema = z22.object({
1393
+ path: z22.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH),
1394
+ rootRevision: z22.string().min(1).max(128),
1395
+ entries: z22.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES),
1396
+ rootPath: z22.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional()
1397
+ }).strict();
1398
+ var SessionDirectoryListResponseSchema = SessionDirectoryListRequestSchema.omit({ space: true }).extend({
1399
+ rootRevision: z22.string().min(1).max(128).optional(),
1400
+ entries: z22.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES).optional(),
1401
+ error: ProtocolFailureSchema.optional(),
1402
+ space: z22.literal("session").optional(),
1403
+ rootPath: z22.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional()
1362
1404
  }).superRefine((response, context) => {
1363
1405
  if (response.error === void 0 ? response.entries === void 0 || response.rootRevision === void 0 : response.entries !== void 0 || response.rootRevision !== void 0) {
1364
1406
  context.addIssue({ code: "custom", message: "Expected directory success or failure" });
1365
1407
  }
1366
1408
  });
1367
- var SessionFileReadDataSchema = z21.object({
1368
- path: z21.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
1369
- rootRevision: z21.string().regex(/^[A-Za-z0-9_-]{43}$/u)
1409
+ var SessionFileReadDataSchema = z22.object({
1410
+ path: z22.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
1411
+ rootRevision: z22.string().regex(/^[A-Za-z0-9_-]{43}$/u),
1412
+ space: z22.literal("session").optional()
1370
1413
  }).strict();
1371
1414
  function fileResultSchema(mediaTypes, extended) {
1372
1415
  const maxOriginal = extended ? SESSION_FILE_V2_MAX_ORIGINAL_BYTES : SESSION_FILE_MAX_ORIGINAL_BYTES;
1373
1416
  const maxTransfer = extended ? SESSION_FILE_V2_MAX_TRANSFER_BYTES : SESSION_FILE_MAX_TRANSFER_BYTES;
1374
- return z21.object({
1417
+ return z22.object({
1375
1418
  path: SessionFileReadDataSchema.shape.path,
1376
1419
  rootRevision: SessionFileReadDataSchema.shape.rootRevision,
1377
- mediaType: z21.enum(mediaTypes),
1378
- originalByteLength: z21.number().int().min(0).max(maxOriginal),
1420
+ mediaType: z22.enum(mediaTypes),
1421
+ originalByteLength: z22.number().int().min(0).max(maxOriginal),
1379
1422
  // Canonical length after decompression, not the length of the transport bytes.
1380
- byteLength: z21.number().int().min(0).max(maxOriginal),
1381
- encoding: z21.enum(["identity", "gzip"]),
1382
- data: z21.string().max(extended ? SESSION_FILE_V2_MAX_BASE64_LENGTH : SESSION_FILE_MAX_BASE64_LENGTH)
1423
+ byteLength: z22.number().int().min(0).max(maxOriginal),
1424
+ encoding: z22.enum(["identity", "gzip"]),
1425
+ data: z22.string().max(extended ? SESSION_FILE_V2_MAX_BASE64_LENGTH : SESSION_FILE_MAX_BASE64_LENGTH)
1383
1426
  }).strict().superRefine((result, context) => {
1384
1427
  const invalid = () => context.addIssue({ code: "custom", message: "Invalid file content" });
1385
1428
  if (result.encoding === "gzip" !== result.originalByteLength >= SESSION_FILE_GZIP_THRESHOLD_BYTES)
@@ -1399,19 +1442,19 @@ var SessionFileReadResultDataSchema = fileResultSchema(SESSION_FILE_MEDIA_TYPES,
1399
1442
  var SessionFileReadV2ResultDataSchema = fileResultSchema(SESSION_FILE_V2_MEDIA_TYPES, true);
1400
1443
  var SessionFileDownloadDataSchema = SessionFileReadDataSchema;
1401
1444
  var SessionFileDownloadResultDataSchema = fileResultSchema(["application/octet-stream"], true);
1402
- var SessionGitProjectSchema = z21.object({
1403
- localRepositoryKey: z21.string().length(43).regex(/^[A-Za-z0-9_-]{43}$/),
1404
- worktreeRoot: z21.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH),
1405
- mainWorktreeRoot: z21.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional(),
1406
- gitRemoteUrl: z21.string().max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional()
1407
- }).strict();
1408
- var SessionProjectIdentityRequestDataSchema = z21.object({}).strict();
1409
- var SessionProjectIdentityResultDataSchema = z21.object({
1445
+ var SessionGitProjectSchema = z22.object({
1446
+ localRepositoryKey: z22.string().length(43).regex(/^[A-Za-z0-9_-]{43}$/),
1447
+ worktreeRoot: z22.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH),
1448
+ mainWorktreeRoot: z22.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional(),
1449
+ gitRemoteUrl: z22.string().max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional()
1450
+ }).strict();
1451
+ var SessionProjectIdentityRequestDataSchema = z22.object({}).strict();
1452
+ var SessionProjectIdentityResultDataSchema = z22.object({
1410
1453
  project: SessionGitProjectSchema.optional()
1411
1454
  }).strict();
1412
1455
 
1413
1456
  // ../../shared/protocol/dist/sessions/session-git-diff.js
1414
- import { z as z22 } from "zod";
1457
+ import { z as z23 } from "zod";
1415
1458
  var SESSION_GIT_DIFF_GZIP_MIN_BYTES = 2 * 1024;
1416
1459
  var SESSION_GIT_DIFF_MAX_FILES = 500;
1417
1460
  var SESSION_GIT_DIFF_MAX_PATCH_BYTES = 128 * 1024;
@@ -1419,24 +1462,24 @@ var SESSION_GIT_DIFF_MAX_RESPONSE_BYTES = 512 * 1024;
1419
1462
  var SESSION_GIT_DIFF_MAX_TRANSFER_BYTES = SESSION_GIT_DIFF_MAX_RESPONSE_BYTES + 1024;
1420
1463
  var SESSION_GIT_DIFF_MAX_BASE64_LENGTH = Math.ceil(SESSION_GIT_DIFF_MAX_TRANSFER_BYTES / 3) * 4;
1421
1464
  var SESSION_GIT_DIFF_MAX_GZIP_RESPONSE_BYTES = SESSION_GIT_DIFF_MAX_BASE64_LENGTH + 1024;
1422
- var commitSchema = z22.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u);
1423
- var SessionGitDiffDataSchema = z22.object({
1465
+ var commitSchema = z23.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u);
1466
+ var SessionGitDiffDataSchema = z23.object({
1424
1467
  rootRevision: SessionFileReadDataSchema.shape.rootRevision,
1425
1468
  path: SessionFileReadDataSchema.shape.path.optional(),
1426
1469
  baseCommit: commitSchema.optional()
1427
1470
  }).strict().refine((value) => value.path === void 0 === (value.baseCommit === void 0), "A file diff must identify its listed base commit");
1428
- var SessionGitDiffEntrySchema = z22.object({
1471
+ var SessionGitDiffEntrySchema = z23.object({
1429
1472
  path: SessionFileReadDataSchema.shape.path,
1430
- status: z22.enum(["added", "modified", "deleted", "untracked"])
1473
+ status: z23.enum(["added", "modified", "deleted", "untracked"])
1431
1474
  }).strict();
1432
- var SessionGitDiffResultDataSchema = z22.object({
1475
+ var SessionGitDiffResultDataSchema = z23.object({
1433
1476
  rootRevision: SessionFileReadDataSchema.shape.rootRevision,
1434
- baseRef: z22.enum(["origin/main", "main"]),
1477
+ baseRef: z23.enum(["origin/main", "main"]),
1435
1478
  baseCommit: commitSchema,
1436
- files: z22.array(SessionGitDiffEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional(),
1479
+ files: z23.array(SessionGitDiffEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional(),
1437
1480
  path: SessionFileReadDataSchema.shape.path.optional(),
1438
- patch: z22.string().max(SESSION_GIT_DIFF_MAX_PATCH_BYTES).optional(),
1439
- binary: z22.boolean().optional()
1481
+ patch: z23.string().max(SESSION_GIT_DIFF_MAX_PATCH_BYTES).optional(),
1482
+ binary: z23.boolean().optional()
1440
1483
  }).strict().superRefine((value, context) => {
1441
1484
  const encoder = new TextEncoder();
1442
1485
  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) {
@@ -1450,13 +1493,13 @@ var SessionGitDiffResultDataSchema = z22.object({
1450
1493
  context.addIssue({ code: "custom", message: "Expected a text patch or an explicit binary change" });
1451
1494
  }
1452
1495
  });
1453
- var SessionGitDiffFileErrorSchema = z22.object({
1454
- code: z22.enum(["DIFF_BLOCKED", "DIFF_FILE_UNAVAILABLE"]),
1455
- message: z22.string().min(1).max(512)
1496
+ var SessionGitDiffFileErrorSchema = z23.object({
1497
+ code: z23.enum(["DIFF_BLOCKED", "DIFF_FILE_UNAVAILABLE"]),
1498
+ message: z23.string().min(1).max(512)
1456
1499
  }).strict();
1457
1500
  var SessionGitDiffPartialEntrySchema = SessionGitDiffEntrySchema.extend({
1458
1501
  // Error paths are display-only: they must never be used for file requests.
1459
- path: z22.string().min(1).max(32768).refine((value) => !value.includes("\0")),
1502
+ path: z23.string().min(1).max(32768).refine((value) => !value.includes("\0")),
1460
1503
  error: SessionGitDiffFileErrorSchema.optional()
1461
1504
  }).superRefine((value, context) => {
1462
1505
  if (value.error === void 0 && !SessionGitDiffEntrySchema.shape.path.safeParse(value.path).success) {
@@ -1464,12 +1507,12 @@ var SessionGitDiffPartialEntrySchema = SessionGitDiffEntrySchema.extend({
1464
1507
  }
1465
1508
  });
1466
1509
  var SessionGitDiffPartialResultDataSchema = SessionGitDiffResultDataSchema.safeExtend({
1467
- files: z22.array(SessionGitDiffPartialEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional()
1510
+ files: z23.array(SessionGitDiffPartialEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional()
1468
1511
  });
1469
- var SessionGitDiffGzipResultDataSchema = z22.object({
1470
- encoding: z22.literal("gzip"),
1471
- byteLength: z22.number().int().min(1).max(SESSION_GIT_DIFF_MAX_RESPONSE_BYTES),
1472
- data: z22.string().max(SESSION_GIT_DIFF_MAX_BASE64_LENGTH).regex(/^[A-Za-z0-9+/]*={0,2}$/u)
1512
+ var SessionGitDiffGzipResultDataSchema = z23.object({
1513
+ encoding: z23.literal("gzip"),
1514
+ byteLength: z23.number().int().min(1).max(SESSION_GIT_DIFF_MAX_RESPONSE_BYTES),
1515
+ data: z23.string().max(SESSION_GIT_DIFF_MAX_BASE64_LENGTH).regex(/^[A-Za-z0-9+/]*={0,2}$/u)
1473
1516
  }).strict().superRefine((value, context) => {
1474
1517
  const padding = value.data.endsWith("==") ? 2 : value.data.endsWith("=") ? 1 : 0;
1475
1518
  const bytes = value.data.length / 4 * 3 - padding;
@@ -1479,13 +1522,13 @@ var SessionGitDiffGzipResultDataSchema = z22.object({
1479
1522
  context.addIssue({ code: "custom", message: "Invalid gzip transfer" });
1480
1523
  }
1481
1524
  });
1482
- var SessionGitDiffV2ResultDataSchema = z22.union([
1525
+ var SessionGitDiffV2ResultDataSchema = z23.union([
1483
1526
  SessionGitDiffResultDataSchema,
1484
1527
  SessionGitDiffGzipResultDataSchema
1485
1528
  ]);
1486
1529
 
1487
1530
  // ../../shared/protocol/dist/sessions/session-resource.js
1488
- import { z as z23 } from "zod";
1531
+ import { z as z24 } from "zod";
1489
1532
  var SESSION_RESOURCE_MAX_ORIGINAL_BYTES = 499999;
1490
1533
  var SESSION_RESOURCE_GZIP_THRESHOLD_BYTES = 20 * 1024;
1491
1534
  var SESSION_RESOURCE_MAX_IMAGE_PIXELS = 16 * 1024 * 1024;
@@ -1499,18 +1542,19 @@ var SESSION_RESOURCE_MEDIA_TYPES = [
1499
1542
  "text/css",
1500
1543
  "text/javascript"
1501
1544
  ];
1502
- var SessionResourceReadDataSchema = z23.object({
1503
- path: z23.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
1504
- rootRevision: z23.string().regex(/^[A-Za-z0-9_-]{43}$/u)
1545
+ var SessionResourceReadDataSchema = z24.object({
1546
+ path: z24.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
1547
+ rootRevision: z24.string().regex(/^[A-Za-z0-9_-]{43}$/u),
1548
+ space: z24.literal("session").optional()
1505
1549
  }).strict();
1506
- var SessionResourceReadResultDataSchema = z23.object({
1550
+ var SessionResourceReadResultDataSchema = z24.object({
1507
1551
  path: SessionResourceReadDataSchema.shape.path,
1508
1552
  rootRevision: SessionResourceReadDataSchema.shape.rootRevision,
1509
- mediaType: z23.enum(SESSION_RESOURCE_MEDIA_TYPES),
1510
- originalByteLength: z23.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
1511
- byteLength: z23.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
1512
- encoding: z23.enum(["identity", "gzip"]),
1513
- data: z23.string().max(SESSION_RESOURCE_MAX_BASE64_LENGTH)
1553
+ mediaType: z24.enum(SESSION_RESOURCE_MEDIA_TYPES),
1554
+ originalByteLength: z24.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
1555
+ byteLength: z24.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
1556
+ encoding: z24.enum(["identity", "gzip"]),
1557
+ data: z24.string().max(SESSION_RESOURCE_MAX_BASE64_LENGTH)
1514
1558
  }).strict().superRefine((result, context) => {
1515
1559
  const invalid = () => context.addIssue({ code: "custom", message: "Invalid resource content" });
1516
1560
  if (result.encoding === "gzip" !== result.originalByteLength >= SESSION_RESOURCE_GZIP_THRESHOLD_BYTES || result.byteLength !== result.originalByteLength || result.mediaType.startsWith("image/") && result.byteLength === 0)
@@ -1523,114 +1567,119 @@ var SessionResourceReadResultDataSchema = z23.object({
1523
1567
  });
1524
1568
 
1525
1569
  // ../../shared/protocol/dist/sessions/session-images.js
1526
- import { z as z24 } from "zod";
1570
+ import { z as z25 } from "zod";
1527
1571
  var SESSION_IMAGE_MAX_BYTES = 3 * 1024 * 1024;
1528
1572
  var SESSION_IMAGE_MAX_PIXELS = 16 * 1024 * 1024;
1529
- var SessionImageIdSchema = z24.uuid();
1530
- var DirectUrlSchema = z24.string().regex(/^https:\/\/[^/?#@\\\s\x00-\x1f\x7f]+(?:[/?][^#\\\s\x00-\x1f\x7f]*)?$/u).refine((raw) => {
1573
+ var SessionImageIdSchema = z25.uuid();
1574
+ var DirectUrlSchema = z25.string().regex(/^https:\/\/[^/?#@\\\s\x00-\x1f\x7f]+(?:[/?][^#\\\s\x00-\x1f\x7f]*)?$/u).refine((raw) => {
1531
1575
  if (!URL.canParse(raw))
1532
1576
  return false;
1533
1577
  const url = new URL(raw);
1534
1578
  return url.protocol === "https:" && url.username === "" && url.password === "" && url.hash === "";
1535
1579
  }, "Direct transfers require HTTPS without userinfo, fragments or unsafe characters");
1536
- var ProxyUrlSchema = z24.string().regex(/^\/api\/v3\/session-images\/[0-9a-f-]+\/content\?[^#\\\s\x00-\x1f\x7f]+$/u);
1537
- var SessionImageTransferHeadersSchema = z24.record(z24.string().regex(/^(?:content-type|if-none-match|x-ms-blob-type)$/u), z24.string().min(1).max(256).regex(/^[\x20-\x7e]+$/u));
1538
- var SessionImageUploadRequestSchema = z24.object({
1580
+ var ProxyUrlSchema = z25.string().regex(/^\/api\/v3\/session-images\/[0-9a-f-]+\/content\?[^#\\\s\x00-\x1f\x7f]+$/u);
1581
+ var SessionImageTransferHeadersSchema = z25.record(z25.string().regex(/^(?:content-type|if-none-match|x-ms-blob-type)$/u), z25.string().min(1).max(256).regex(/^[\x20-\x7e]+$/u));
1582
+ var SessionImageUploadRequestSchema = z25.object({
1539
1583
  machineId: IdSchema,
1540
1584
  sessionId: IdSchema,
1541
- sizeBytes: z24.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES)
1542
- }).strict();
1543
- var SessionImageScopeSchema = z24.object({
1585
+ sizeBytes: z25.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES),
1586
+ verifiedContent: z25.object({
1587
+ sha256: z25.string().regex(/^[a-f0-9]{64}$/u),
1588
+ width: z25.number().int().min(1).max(SESSION_IMAGE_MAX_PIXELS),
1589
+ height: z25.number().int().min(1).max(SESSION_IMAGE_MAX_PIXELS)
1590
+ }).strict().refine((image) => image.width * image.height <= SESSION_IMAGE_MAX_PIXELS, "Image dimensions exceed the pixel bound").optional()
1591
+ }).strict();
1592
+ var SessionImageScopeSchema = z25.object({
1544
1593
  machineId: IdSchema,
1545
1594
  sessionId: IdSchema
1546
1595
  }).strict();
1547
1596
  var UploadResultFields = {
1548
1597
  imageId: SessionImageIdSchema,
1549
- uploadExpiresAt: z24.number().int().positive(),
1550
- method: z24.literal("PUT"),
1551
- contentType: z24.literal("image/webp"),
1598
+ uploadExpiresAt: z25.number().int().positive(),
1599
+ method: z25.literal("PUT"),
1600
+ contentType: z25.literal("image/webp"),
1552
1601
  headers: SessionImageTransferHeadersSchema.refine((headers) => headers["content-type"] === "image/webp")
1553
1602
  };
1554
- var SessionImageUploadResultSchema = z24.discriminatedUnion("mode", [
1555
- z24.object({ ...UploadResultFields, mode: z24.literal("direct"), uploadUrl: DirectUrlSchema }).strict(),
1556
- z24.object({ ...UploadResultFields, mode: z24.literal("proxy"), uploadUrl: ProxyUrlSchema }).strict()
1603
+ var SessionImageUploadResultSchema = z25.discriminatedUnion("mode", [
1604
+ z25.object({ ...UploadResultFields, mode: z25.literal("direct"), uploadUrl: DirectUrlSchema }).strict(),
1605
+ z25.object({ ...UploadResultFields, mode: z25.literal("proxy"), uploadUrl: ProxyUrlSchema }).strict()
1557
1606
  ]);
1558
- var SessionImageCommitResultSchema = z24.object({
1607
+ var SessionImageCommitResultSchema = z25.object({
1559
1608
  imageId: SessionImageIdSchema,
1560
1609
  machineId: IdSchema,
1561
1610
  sessionId: IdSchema,
1562
- sizeBytes: z24.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES),
1563
- width: z24.number().int().positive(),
1564
- height: z24.number().int().positive(),
1565
- sha256: z24.string().regex(/^[a-f0-9]{64}$/u),
1566
- expiresAt: z24.number().int().positive()
1611
+ sizeBytes: z25.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES),
1612
+ width: z25.number().int().positive(),
1613
+ height: z25.number().int().positive(),
1614
+ sha256: z25.string().regex(/^[a-f0-9]{64}$/u),
1615
+ expiresAt: z25.number().int().positive()
1567
1616
  }).strict();
1568
1617
  var DownloadResultFields = {
1569
1618
  image: SessionImageCommitResultSchema,
1570
- downloadExpiresAt: z24.number().int().positive(),
1571
- method: z24.literal("GET"),
1619
+ downloadExpiresAt: z25.number().int().positive(),
1620
+ method: z25.literal("GET"),
1572
1621
  headers: SessionImageTransferHeadersSchema
1573
1622
  };
1574
- var SessionImageDownloadResultSchema = z24.discriminatedUnion("mode", [
1575
- z24.object({ ...DownloadResultFields, mode: z24.literal("direct"), downloadUrl: DirectUrlSchema }).strict(),
1576
- z24.object({ ...DownloadResultFields, mode: z24.literal("proxy"), downloadUrl: ProxyUrlSchema }).strict()
1623
+ var SessionImageDownloadResultSchema = z25.discriminatedUnion("mode", [
1624
+ z25.object({ ...DownloadResultFields, mode: z25.literal("direct"), downloadUrl: DirectUrlSchema }).strict(),
1625
+ z25.object({ ...DownloadResultFields, mode: z25.literal("proxy"), downloadUrl: ProxyUrlSchema }).strict()
1577
1626
  ]);
1578
- var TimelineImageBlobRequestSchema = z24.object({
1579
- sha256: z24.string().regex(/^[a-f0-9]{64}$/u)
1627
+ var TimelineImageBlobRequestSchema = z25.object({
1628
+ sha256: z25.string().regex(/^[a-f0-9]{64}$/u)
1580
1629
  }).strict();
1581
- var TimelineImageBlobResultSchema = z24.object({
1630
+ var TimelineImageBlobResultSchema = z25.object({
1582
1631
  sha256: TimelineImageBlobRequestSchema.shape.sha256,
1583
1632
  image: SessionImageCommitResultSchema
1584
1633
  }).strict();
1585
1634
 
1586
1635
  // ../../shared/protocol/dist/sessions/session-rename.js
1587
- import { z as z25 } from "zod";
1636
+ import { z as z26 } from "zod";
1588
1637
  var SESSION_RENAME_OPERATION = "session.rename";
1589
1638
  var SESSION_RENAME_VERSION = 1;
1590
1639
  var SESSION_RENAME_CAPABILITY = sessionCommunicationOperationCapability(SESSION_RENAME_OPERATION, SESSION_RENAME_VERSION);
1591
1640
  var SESSION_NAME_MAX_LENGTH = 100;
1592
- var SessionNameSchema = z25.string().regex(/^[^\u0000-\u001f\u007f]*$/u).trim().min(1).max(SESSION_NAME_MAX_LENGTH);
1593
- var SessionRenameDataSchema = z25.object({ name: SessionNameSchema }).strict();
1594
- var SessionRenameResultDataSchema = z25.object({ name: SessionNameSchema }).strict();
1641
+ var SessionNameSchema = z26.string().regex(/^[^\u0000-\u001f\u007f]*$/u).trim().min(1).max(SESSION_NAME_MAX_LENGTH);
1642
+ var SessionRenameDataSchema = z26.object({ name: SessionNameSchema }).strict();
1643
+ var SessionRenameResultDataSchema = z26.object({ name: SessionNameSchema }).strict();
1595
1644
 
1596
1645
  // ../../shared/protocol/dist/sessions/sessions.js
1597
- import { z as z26 } from "zod";
1598
- var GroupChatParticipantSchema = z26.object({
1646
+ import { z as z27 } from "zod";
1647
+ var GroupChatParticipantSchema = z27.object({
1599
1648
  sessionId: IdSchema,
1600
- title: z26.string().trim().min(1).max(260)
1649
+ title: z27.string().trim().min(1).max(260)
1601
1650
  }).strict();
1602
- var GroupChatInfoSchema = z26.object({
1603
- participants: z26.array(GroupChatParticipantSchema).length(2).refine((participants) => new Set(participants.map((participant) => participant.sessionId)).size === 2, "A group requires two different sessions"),
1604
- state: z26.enum(["ready", "running", "paused", "blocked"])
1651
+ var GroupChatInfoSchema = z27.object({
1652
+ participants: z27.array(GroupChatParticipantSchema).length(2).refine((participants) => new Set(participants.map((participant) => participant.sessionId)).size === 2, "A group requires two different sessions"),
1653
+ state: z27.enum(["ready", "running", "paused", "blocked"])
1605
1654
  }).strict();
1606
- var SessionSummarySchema = z26.object({
1655
+ var SessionSummarySchema = z27.object({
1607
1656
  userId: IdSchema,
1608
1657
  sessionId: IdSchema,
1609
1658
  machineId: IdSchema,
1610
- summary: z26.string().max(4096).optional(),
1611
- renameSupported: z26.boolean().optional(),
1612
- workingDirectory: z26.string().max(32768).optional(),
1613
- gitRoot: z26.string().max(32768).optional(),
1614
- repository: z26.string().max(1024).optional(),
1615
- gitRemoteUrl: z26.string().max(32768).optional(),
1616
- branch: z26.string().max(1024).optional(),
1617
- isRemote: z26.boolean(),
1659
+ summary: z27.string().max(4096).optional(),
1660
+ renameSupported: z27.boolean().optional(),
1661
+ workingDirectory: z27.string().max(32768).optional(),
1662
+ gitRoot: z27.string().max(32768).optional(),
1663
+ repository: z27.string().max(1024).optional(),
1664
+ gitRemoteUrl: z27.string().max(32768).optional(),
1665
+ branch: z27.string().max(1024).optional(),
1666
+ isRemote: z27.boolean(),
1618
1667
  createdAt: IsoDateSchema,
1619
1668
  modifiedAt: IsoDateSchema,
1620
1669
  groupChat: GroupChatInfoSchema.optional()
1621
1670
  });
1622
- var SessionsSnapshotSchema = z26.object({
1671
+ var SessionsSnapshotSchema = z27.object({
1623
1672
  userId: IdSchema,
1624
1673
  machineId: IdSchema,
1625
- machineName: z26.string().trim().min(1).max(120),
1626
- platform: z26.string().trim().min(1).max(64),
1674
+ machineName: z27.string().trim().min(1).max(120),
1675
+ platform: z27.string().trim().min(1).max(64),
1627
1676
  agentRunId: IdSchema,
1628
- sequence: z26.number().int().positive(),
1677
+ sequence: z27.number().int().positive(),
1629
1678
  generatedAt: IsoDateSchema,
1630
- complete: z26.boolean(),
1631
- totalCount: z26.number().int().nonnegative(),
1632
- nextCursor: z26.string().min(1).max(1024).optional(),
1633
- sessions: z26.array(SessionSummarySchema)
1679
+ complete: z27.boolean(),
1680
+ totalCount: z27.number().int().nonnegative(),
1681
+ nextCursor: z27.string().min(1).max(1024).optional(),
1682
+ sessions: z27.array(SessionSummarySchema)
1634
1683
  }).superRefine((snapshot, context) => {
1635
1684
  if (snapshot.totalCount < snapshot.sessions.length) {
1636
1685
  context.addIssue({
@@ -1672,47 +1721,47 @@ var SessionsSnapshotSchema = z26.object({
1672
1721
  sessionIds.add(session.sessionId);
1673
1722
  }
1674
1723
  });
1675
- var SessionListRequestSchema = z26.object({
1724
+ var SessionListRequestSchema = z27.object({
1676
1725
  requestId: IdSchema,
1677
1726
  machineId: IdSchema,
1678
- cursor: z26.string().min(1).max(1024).optional()
1727
+ cursor: z27.string().min(1).max(1024).optional()
1679
1728
  });
1680
- var SessionListResultSchema = z26.discriminatedUnion("ok", [
1681
- z26.object({
1682
- ok: z26.literal(true),
1729
+ var SessionListResultSchema = z27.discriminatedUnion("ok", [
1730
+ z27.object({
1731
+ ok: z27.literal(true),
1683
1732
  requestId: IdSchema,
1684
1733
  machineId: IdSchema,
1685
1734
  snapshot: SessionsSnapshotSchema
1686
1735
  }),
1687
- z26.object({
1688
- ok: z26.literal(false),
1736
+ z27.object({
1737
+ ok: z27.literal(false),
1689
1738
  requestId: IdSchema,
1690
1739
  machineId: IdSchema,
1691
1740
  error: ProtocolFailureSchema
1692
1741
  })
1693
1742
  ]);
1694
- var SessionAgentModeSchema = z26.enum([
1743
+ var SessionAgentModeSchema = z27.enum([
1695
1744
  "interactive",
1696
1745
  "plan",
1697
1746
  "autopilot"
1698
1747
  ]);
1699
- var AgentConfigurationOptionSchema = z26.object({
1748
+ var AgentConfigurationOptionSchema = z27.object({
1700
1749
  id: IdSchema,
1701
- name: z26.string().trim().min(1).max(260),
1702
- value: z26.string().min(1).max(256),
1703
- options: z26.array(z26.object({
1704
- value: z26.string().min(1).max(256),
1705
- name: z26.string().trim().min(1).max(260)
1750
+ name: z27.string().trim().min(1).max(260),
1751
+ value: z27.string().min(1).max(256),
1752
+ options: z27.array(z27.object({
1753
+ value: z27.string().min(1).max(256),
1754
+ name: z27.string().trim().min(1).max(260)
1706
1755
  }).strict()).min(1).max(100)
1707
1756
  }).strict();
1708
- var AgentConfigurationChangeSchema = z26.object({
1757
+ var AgentConfigurationChangeSchema = z27.object({
1709
1758
  id: IdSchema,
1710
- value: z26.string().min(1).max(256)
1759
+ value: z27.string().min(1).max(256)
1711
1760
  }).strict();
1712
- var WorkspaceOptionSchema = z26.object({
1761
+ var WorkspaceOptionSchema = z27.object({
1713
1762
  id: IdSchema,
1714
- name: z26.string().trim().min(1).max(260),
1715
- path: z26.string().trim().min(1).max(32768)
1763
+ name: z27.string().trim().min(1).max(260),
1764
+ path: z27.string().trim().min(1).max(32768)
1716
1765
  });
1717
1766
  var REASONING_EFFORTS = [
1718
1767
  "low",
@@ -1721,113 +1770,113 @@ var REASONING_EFFORTS = [
1721
1770
  "xhigh",
1722
1771
  "max"
1723
1772
  ];
1724
- var ReasoningEffortSchema = z26.enum(REASONING_EFFORTS);
1725
- var CopilotModelOptionSchema = z26.object({
1773
+ var ReasoningEffortSchema = z27.enum(REASONING_EFFORTS);
1774
+ var CopilotModelOptionSchema = z27.object({
1726
1775
  id: IdSchema,
1727
- name: z26.string().trim().min(1).max(260),
1728
- isDefault: z26.boolean(),
1729
- supportedReasoningEfforts: z26.array(ReasoningEffortSchema).optional(),
1776
+ name: z27.string().trim().min(1).max(260),
1777
+ isDefault: z27.boolean(),
1778
+ supportedReasoningEfforts: z27.array(ReasoningEffortSchema).optional(),
1730
1779
  defaultReasoningEffort: ReasoningEffortSchema.optional(),
1731
- creation: z26.object({
1780
+ creation: z27.object({
1732
1781
  agentId: IdSchema,
1733
- agentName: z26.string().trim().min(1).max(260),
1734
- modelName: z26.string().trim().min(1).max(260),
1735
- agentModes: z26.array(SessionAgentModeSchema).min(1),
1736
- reasoningEffortConfigurationSupported: z26.boolean(),
1737
- isDefault: z26.boolean()
1782
+ agentName: z27.string().trim().min(1).max(260),
1783
+ modelName: z27.string().trim().min(1).max(260),
1784
+ agentModes: z27.array(SessionAgentModeSchema).min(1),
1785
+ reasoningEffortConfigurationSupported: z27.boolean(),
1786
+ isDefault: z27.boolean()
1738
1787
  }).strict().optional()
1739
1788
  });
1740
- var SessionReasoningEffortSchema = z26.enum([
1789
+ var SessionReasoningEffortSchema = z27.enum([
1741
1790
  "default",
1742
1791
  ...REASONING_EFFORTS
1743
1792
  ]);
1744
- var CurrentReasoningEffortSchema = z26.string().trim().min(1).max(64);
1745
- var SessionToolInfoSchema = z26.object({
1746
- name: z26.string().trim().min(1).max(260),
1747
- description: z26.string().trim().min(1).max(4096).optional(),
1748
- deferred: z26.boolean().optional()
1749
- });
1750
- var SessionSlashCommandInfoSchema = z26.object({
1751
- name: z26.string().trim().min(1).max(260),
1752
- description: z26.string().trim().min(1).max(4096).optional(),
1753
- kind: z26.enum(["builtin", "skill", "client"])
1754
- });
1755
- var SessionSkillInfoSchema = z26.object({
1756
- name: z26.string().trim().min(1).max(260),
1757
- description: z26.string().trim().min(1).max(4096).optional(),
1758
- source: z26.string().trim().min(1).max(260),
1759
- enabled: z26.boolean(),
1760
- userInvocable: z26.boolean(),
1761
- commandName: z26.string().trim().min(1).max(260).optional()
1762
- });
1763
- var SessionEnvironmentInfoSchema = z26.object({
1764
- tools: z26.array(SessionToolInfoSchema).max(512),
1765
- slashCommands: z26.array(SessionSlashCommandInfoSchema).max(512),
1766
- skills: z26.array(SessionSkillInfoSchema).max(512)
1767
- });
1768
- var SessionOptionsRequestSchema = z26.object({
1793
+ var CurrentReasoningEffortSchema = z27.string().trim().min(1).max(64);
1794
+ var SessionToolInfoSchema = z27.object({
1795
+ name: z27.string().trim().min(1).max(260),
1796
+ description: z27.string().trim().min(1).max(4096).optional(),
1797
+ deferred: z27.boolean().optional()
1798
+ });
1799
+ var SessionSlashCommandInfoSchema = z27.object({
1800
+ name: z27.string().trim().min(1).max(260),
1801
+ description: z27.string().trim().min(1).max(4096).optional(),
1802
+ kind: z27.enum(["builtin", "skill", "client"])
1803
+ });
1804
+ var SessionSkillInfoSchema = z27.object({
1805
+ name: z27.string().trim().min(1).max(260),
1806
+ description: z27.string().trim().min(1).max(4096).optional(),
1807
+ source: z27.string().trim().min(1).max(260),
1808
+ enabled: z27.boolean(),
1809
+ userInvocable: z27.boolean(),
1810
+ commandName: z27.string().trim().min(1).max(260).optional()
1811
+ });
1812
+ var SessionEnvironmentInfoSchema = z27.object({
1813
+ tools: z27.array(SessionToolInfoSchema).max(512),
1814
+ slashCommands: z27.array(SessionSlashCommandInfoSchema).max(512),
1815
+ skills: z27.array(SessionSkillInfoSchema).max(512)
1816
+ });
1817
+ var SessionOptionsRequestSchema = z27.object({
1769
1818
  requestId: IdSchema,
1770
1819
  machineId: IdSchema,
1771
1820
  sessionId: IdSchema.optional(),
1772
1821
  workspaceId: IdSchema.optional(),
1773
- capabilities: z26.array(IdSchema).max(64).optional()
1822
+ capabilities: z27.array(IdSchema).max(64).optional()
1774
1823
  });
1775
- var SessionOptionsResultSchema = z26.discriminatedUnion("ok", [
1776
- z26.object({
1777
- ok: z26.literal(true),
1824
+ var SessionOptionsResultSchema = z27.discriminatedUnion("ok", [
1825
+ z27.object({
1826
+ ok: z27.literal(true),
1778
1827
  requestId: IdSchema,
1779
1828
  machineId: IdSchema,
1780
1829
  sessionId: IdSchema.optional(),
1781
- workspaces: z26.array(WorkspaceOptionSchema),
1782
- models: z26.array(CopilotModelOptionSchema).min(1),
1783
- modelRefreshError: z26.string().min(1).max(4096).optional(),
1784
- agentModes: z26.array(SessionAgentModeSchema).min(1),
1785
- reasoningEffortConfigurationSupported: z26.literal(true).optional(),
1786
- fileAttachmentsSupported: z26.boolean().optional(),
1787
- worktreeCreationSupported: z26.literal(true).optional(),
1788
- worktreeBranches: z26.array(z26.string().min(1).max(1024)).optional(),
1789
- worktreeCurrentBranch: z26.string().min(1).max(1024).optional(),
1830
+ workspaces: z27.array(WorkspaceOptionSchema),
1831
+ models: z27.array(CopilotModelOptionSchema).min(1),
1832
+ modelRefreshError: z27.string().min(1).max(4096).optional(),
1833
+ agentModes: z27.array(SessionAgentModeSchema).min(1),
1834
+ reasoningEffortConfigurationSupported: z27.literal(true).optional(),
1835
+ fileAttachmentsSupported: z27.boolean().optional(),
1836
+ worktreeCreationSupported: z27.literal(true).optional(),
1837
+ worktreeBranches: z27.array(z27.string().min(1).max(1024)).optional(),
1838
+ worktreeCurrentBranch: z27.string().min(1).max(1024).optional(),
1790
1839
  currentModelId: IdSchema.optional(),
1791
1840
  currentAgentMode: SessionAgentModeSchema.optional(),
1792
1841
  currentReasoningEffort: CurrentReasoningEffortSchema.optional(),
1793
1842
  environment: SessionEnvironmentInfoSchema.optional(),
1794
- environmentPending: z26.literal(true).optional(),
1795
- agentName: z26.string().trim().min(1).max(260).optional(),
1796
- configOptions: z26.array(AgentConfigurationOptionSchema).max(32).optional()
1843
+ environmentPending: z27.literal(true).optional(),
1844
+ agentName: z27.string().trim().min(1).max(260).optional(),
1845
+ configOptions: z27.array(AgentConfigurationOptionSchema).max(32).optional()
1797
1846
  }),
1798
- z26.object({
1799
- ok: z26.literal(false),
1847
+ z27.object({
1848
+ ok: z27.literal(false),
1800
1849
  requestId: IdSchema,
1801
1850
  machineId: IdSchema,
1802
1851
  sessionId: IdSchema.optional(),
1803
1852
  error: ProtocolFailureSchema,
1804
- failureStage: z26.enum(["models", "configuration", "workspaces"]).optional(),
1805
- models: z26.array(CopilotModelOptionSchema).min(1).optional(),
1806
- agentModes: z26.array(SessionAgentModeSchema).min(1).optional(),
1807
- reasoningEffortConfigurationSupported: z26.literal(true).optional(),
1808
- fileAttachmentsSupported: z26.boolean().optional(),
1853
+ failureStage: z27.enum(["models", "configuration", "workspaces"]).optional(),
1854
+ models: z27.array(CopilotModelOptionSchema).min(1).optional(),
1855
+ agentModes: z27.array(SessionAgentModeSchema).min(1).optional(),
1856
+ reasoningEffortConfigurationSupported: z27.literal(true).optional(),
1857
+ fileAttachmentsSupported: z27.boolean().optional(),
1809
1858
  currentModelId: IdSchema.optional(),
1810
1859
  currentAgentMode: SessionAgentModeSchema.optional(),
1811
1860
  currentReasoningEffort: CurrentReasoningEffortSchema.optional(),
1812
- agentName: z26.string().trim().min(1).max(260).optional(),
1813
- configOptions: z26.array(AgentConfigurationOptionSchema).max(32).optional()
1861
+ agentName: z27.string().trim().min(1).max(260).optional(),
1862
+ configOptions: z27.array(AgentConfigurationOptionSchema).max(32).optional()
1814
1863
  })
1815
1864
  ]);
1816
- var SessionCreateRequestSchema = z26.object({
1865
+ var SessionCreateRequestSchema = z27.object({
1817
1866
  requestId: IdSchema,
1818
1867
  machineId: IdSchema,
1819
1868
  workspaceId: IdSchema,
1820
1869
  modelId: IdSchema,
1821
1870
  agentMode: SessionAgentModeSchema,
1822
1871
  reasoningEffort: SessionReasoningEffortSchema.optional(),
1823
- worktree: z26.object({
1824
- branchName: z26.string().trim().min(1).max(120).optional(),
1825
- baseBranch: z26.string().trim().min(1).max(1024).optional()
1872
+ worktree: z27.object({
1873
+ branchName: z27.string().trim().min(1).max(120).optional(),
1874
+ baseBranch: z27.string().trim().min(1).max(1024).optional()
1826
1875
  }).strict().optional()
1827
1876
  });
1828
- var SessionCreateResultSchema = z26.discriminatedUnion("ok", [
1829
- z26.object({
1830
- ok: z26.literal(true),
1877
+ var SessionCreateResultSchema = z27.discriminatedUnion("ok", [
1878
+ z27.object({
1879
+ ok: z27.literal(true),
1831
1880
  requestId: IdSchema,
1832
1881
  machineId: IdSchema,
1833
1882
  session: SessionSummarySchema,
@@ -1835,34 +1884,34 @@ var SessionCreateResultSchema = z26.discriminatedUnion("ok", [
1835
1884
  agentMode: SessionAgentModeSchema,
1836
1885
  reasoningEffort: SessionReasoningEffortSchema.optional()
1837
1886
  }),
1838
- z26.object({
1839
- ok: z26.literal(false),
1887
+ z27.object({
1888
+ ok: z27.literal(false),
1840
1889
  requestId: IdSchema,
1841
1890
  machineId: IdSchema,
1842
1891
  error: ProtocolFailureSchema
1843
1892
  })
1844
1893
  ]);
1845
- var SessionDeleteRequestSchema = z26.object({
1894
+ var SessionDeleteRequestSchema = z27.object({
1846
1895
  requestId: IdSchema,
1847
1896
  machineId: IdSchema,
1848
1897
  sessionId: IdSchema
1849
1898
  }).strict();
1850
- var SessionDeleteResultSchema = z26.discriminatedUnion("ok", [
1851
- z26.object({
1852
- ok: z26.literal(true),
1899
+ var SessionDeleteResultSchema = z27.discriminatedUnion("ok", [
1900
+ z27.object({
1901
+ ok: z27.literal(true),
1853
1902
  requestId: IdSchema,
1854
1903
  machineId: IdSchema,
1855
1904
  sessionId: IdSchema
1856
1905
  }).strict(),
1857
- z26.object({
1858
- ok: z26.literal(false),
1906
+ z27.object({
1907
+ ok: z27.literal(false),
1859
1908
  requestId: IdSchema,
1860
1909
  machineId: IdSchema,
1861
1910
  sessionId: IdSchema,
1862
1911
  error: ProtocolFailureSchema
1863
1912
  }).strict()
1864
1913
  ]);
1865
- var SessionConfigureRequestSchema = z26.object({
1914
+ var SessionConfigureRequestSchema = z27.object({
1866
1915
  requestId: IdSchema,
1867
1916
  machineId: IdSchema,
1868
1917
  sessionId: IdSchema,
@@ -1871,59 +1920,59 @@ var SessionConfigureRequestSchema = z26.object({
1871
1920
  reasoningEffort: SessionReasoningEffortSchema.optional(),
1872
1921
  configOption: AgentConfigurationChangeSchema.optional()
1873
1922
  }).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" });
1874
- var SessionConfigureResultSchema = z26.discriminatedUnion("ok", [
1875
- z26.object({
1876
- ok: z26.literal(true),
1923
+ var SessionConfigureResultSchema = z27.discriminatedUnion("ok", [
1924
+ z27.object({
1925
+ ok: z27.literal(true),
1877
1926
  requestId: IdSchema,
1878
1927
  machineId: IdSchema,
1879
1928
  sessionId: IdSchema,
1880
1929
  modelId: IdSchema.optional(),
1881
1930
  agentMode: SessionAgentModeSchema,
1882
1931
  reasoningEffort: CurrentReasoningEffortSchema.optional(),
1883
- configOptions: z26.array(AgentConfigurationOptionSchema).max(32).optional()
1932
+ configOptions: z27.array(AgentConfigurationOptionSchema).max(32).optional()
1884
1933
  }),
1885
- z26.object({
1886
- ok: z26.literal(false),
1934
+ z27.object({
1935
+ ok: z27.literal(false),
1887
1936
  requestId: IdSchema,
1888
1937
  machineId: IdSchema,
1889
1938
  sessionId: IdSchema,
1890
1939
  error: ProtocolFailureSchema
1891
1940
  })
1892
1941
  ]);
1893
- var SessionRemoteActionSchema = z26.enum([
1942
+ var SessionRemoteActionSchema = z27.enum([
1894
1943
  "status",
1895
1944
  "enable",
1896
1945
  "disable"
1897
1946
  ]);
1898
- var SessionRemoteStateSchema = z26.enum([
1947
+ var SessionRemoteStateSchema = z27.enum([
1899
1948
  "off",
1900
1949
  "connecting",
1901
1950
  "active",
1902
1951
  "error"
1903
1952
  ]);
1904
- var SessionRemoteRequestSchema = z26.object({
1953
+ var SessionRemoteRequestSchema = z27.object({
1905
1954
  requestId: IdSchema,
1906
1955
  machineId: IdSchema,
1907
1956
  sessionId: IdSchema,
1908
1957
  action: SessionRemoteActionSchema
1909
1958
  });
1910
- var SessionRemoteStatusSchema = z26.object({
1959
+ var SessionRemoteStatusSchema = z27.object({
1911
1960
  state: SessionRemoteStateSchema,
1912
1961
  attachedSessionId: IdSchema.optional(),
1913
- url: z26.url().max(32768).optional(),
1914
- steerable: z26.boolean(),
1962
+ url: z27.url().max(32768).optional(),
1963
+ steerable: z27.boolean(),
1915
1964
  error: ProtocolFailureSchema.optional()
1916
1965
  });
1917
- var SessionRemoteResultSchema = z26.discriminatedUnion("ok", [
1918
- z26.object({
1919
- ok: z26.literal(true),
1966
+ var SessionRemoteResultSchema = z27.discriminatedUnion("ok", [
1967
+ z27.object({
1968
+ ok: z27.literal(true),
1920
1969
  requestId: IdSchema,
1921
1970
  machineId: IdSchema,
1922
1971
  sessionId: IdSchema,
1923
1972
  status: SessionRemoteStatusSchema
1924
1973
  }),
1925
- z26.object({
1926
- ok: z26.literal(false),
1974
+ z27.object({
1975
+ ok: z27.literal(false),
1927
1976
  requestId: IdSchema,
1928
1977
  machineId: IdSchema,
1929
1978
  sessionId: IdSchema,
@@ -1932,34 +1981,34 @@ var SessionRemoteResultSchema = z26.discriminatedUnion("ok", [
1932
1981
  ]);
1933
1982
 
1934
1983
  // ../../shared/protocol/dist/sessions/group-chat.js
1935
- import { z as z27 } from "zod";
1984
+ import { z as z28 } from "zod";
1936
1985
  var GROUP_CHAT_CREATE_OPERATION = "group-chat.create";
1937
1986
  var GROUP_CHAT_CREATE_VERSION = 1;
1938
1987
  var GROUP_CHAT_CREATE_CAPABILITY = sessionCommunicationOperationCapability(GROUP_CHAT_CREATE_OPERATION, GROUP_CHAT_CREATE_VERSION);
1939
- var GroupChatCreateDataSchema = z27.object({
1988
+ var GroupChatCreateDataSchema = z28.object({
1940
1989
  peerSessionId: IdSchema
1941
1990
  }).strict();
1942
- var GroupChatCreateResultDataSchema = z27.object({
1991
+ var GroupChatCreateResultDataSchema = z28.object({
1943
1992
  session: SessionSummarySchema.refine((session) => session.groupChat !== void 0, "Group creation must return a virtual group session")
1944
1993
  }).strict();
1945
1994
 
1946
1995
  // ../../shared/protocol/dist/sessions/prompts.js
1947
- import { z as z28 } from "zod";
1948
- var SessionAvatarPersonaSchema = z28.object({
1949
- role: z28.enum(["designer", "filmmaker", "developer", "secretary", "default"]),
1950
- displayName: z28.string().trim().min(1).max(40).regex(/^[^\u0000-\u001f\u007f-\u009f]*$/).optional()
1996
+ import { z as z29 } from "zod";
1997
+ var SessionAvatarPersonaSchema = z29.object({
1998
+ role: z29.enum(["designer", "filmmaker", "developer", "secretary", "default"]),
1999
+ displayName: z29.string().trim().min(1).max(40).regex(/^[^\u0000-\u001f\u007f-\u009f]*$/).optional()
1951
2000
  }).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" });
1952
2001
  var MAX_PROMPT_IMAGE_BYTES = 3 * 1024 * 1024;
1953
- var SessionPromptRequestSchema = z28.object({
2002
+ var SessionPromptRequestSchema = z29.object({
1954
2003
  requestId: IdSchema,
1955
2004
  operationId: IdSchema,
1956
2005
  machineId: IdSchema,
1957
2006
  sessionId: IdSchema,
1958
- prompt: z28.string().trim().max(1e5),
1959
- attachments: z28.array(PromptImageAttachmentSchema).max(4).optional(),
1960
- fileAttachments: z28.array(PromptFileAttachmentSchema).max(4).optional(),
2007
+ prompt: z29.string().trim().max(1e5),
2008
+ attachments: z29.array(PromptImageAttachmentSchema).max(4).optional(),
2009
+ fileAttachments: z29.array(PromptFileAttachmentSchema).max(4).optional(),
1961
2010
  avatarPersona: SessionAvatarPersonaSchema.optional(),
1962
- mode: z28.enum(["enqueue", "immediate"]).default("enqueue")
2011
+ mode: z29.enum(["enqueue", "immediate"]).default("enqueue")
1963
2012
  }).strict().superRefine((request, context) => {
1964
2013
  if (request.prompt.length === 0 && (request.attachments?.length ?? 0) === 0 && (request.fileAttachments?.length ?? 0) === 0) {
1965
2014
  context.addIssue({
@@ -1985,22 +2034,22 @@ var SessionPromptRequestSchema = z28.object({
1985
2034
  });
1986
2035
  }
1987
2036
  });
1988
- var SessionPromptResultSchema = z28.discriminatedUnion("ok", [
1989
- z28.object({
1990
- ok: z28.literal(true),
2037
+ var SessionPromptResultSchema = z29.discriminatedUnion("ok", [
2038
+ z29.object({
2039
+ ok: z29.literal(true),
1991
2040
  requestId: IdSchema,
1992
2041
  operationId: IdSchema,
1993
2042
  machineId: IdSchema,
1994
2043
  sessionId: IdSchema,
1995
2044
  messageId: IdSchema,
1996
- mode: z28.enum(["enqueue", "immediate"]),
1997
- deliveryState: z28.enum(["queued", "processing"]),
2045
+ mode: z29.enum(["enqueue", "immediate"]),
2046
+ deliveryState: z29.enum(["queued", "processing"]),
1998
2047
  // Negotiated lower bound from the native event clock. Exact text and history
1999
2048
  // ownership checks still apply; this is not an identity or proof of persistence.
2000
2049
  submittedAt: IsoDateSchema.optional()
2001
2050
  }),
2002
- z28.object({
2003
- ok: z28.literal(false),
2051
+ z29.object({
2052
+ ok: z29.literal(false),
2004
2053
  requestId: IdSchema,
2005
2054
  operationId: IdSchema,
2006
2055
  machineId: IdSchema,
@@ -2008,29 +2057,29 @@ var SessionPromptResultSchema = z28.discriminatedUnion("ok", [
2008
2057
  error: ProtocolFailureSchema
2009
2058
  })
2010
2059
  ]);
2011
- var SessionActivityUpdateSchema = z28.object({
2060
+ var SessionActivityUpdateSchema = z29.object({
2012
2061
  userId: IdSchema,
2013
2062
  machineId: IdSchema,
2014
2063
  sessionId: IdSchema,
2015
- state: z28.enum(["working", "idle"]),
2064
+ state: z29.enum(["working", "idle"]),
2016
2065
  occurredAt: IsoDateSchema,
2017
2066
  assistantPreview: SessionAssistantPreviewSchema.optional(),
2018
2067
  userPreview: SessionUserPreviewSchema.optional()
2019
2068
  });
2020
- var SessionAbortRequestSchema = z28.object({
2069
+ var SessionAbortRequestSchema = z29.object({
2021
2070
  requestId: IdSchema,
2022
2071
  machineId: IdSchema,
2023
2072
  sessionId: IdSchema
2024
2073
  });
2025
- var SessionAbortResultSchema = z28.discriminatedUnion("ok", [
2026
- z28.object({
2027
- ok: z28.literal(true),
2074
+ var SessionAbortResultSchema = z29.discriminatedUnion("ok", [
2075
+ z29.object({
2076
+ ok: z29.literal(true),
2028
2077
  requestId: IdSchema,
2029
2078
  machineId: IdSchema,
2030
2079
  sessionId: IdSchema
2031
2080
  }),
2032
- z28.object({
2033
- ok: z28.literal(false),
2081
+ z29.object({
2082
+ ok: z29.literal(false),
2034
2083
  requestId: IdSchema,
2035
2084
  machineId: IdSchema,
2036
2085
  sessionId: IdSchema,
@@ -2039,12 +2088,12 @@ var SessionAbortResultSchema = z28.discriminatedUnion("ok", [
2039
2088
  ]);
2040
2089
 
2041
2090
  // ../../shared/protocol/dist/sessions/interactions.js
2042
- import { z as z29 } from "zod";
2043
- var InteractionFormFieldSchema = z29.object({
2091
+ import { z as z30 } from "zod";
2092
+ var InteractionFormFieldSchema = z30.object({
2044
2093
  id: IdSchema,
2045
- label: z29.string().trim().min(1).max(1024),
2046
- description: z29.string().max(2048).optional(),
2047
- inputType: z29.enum([
2094
+ label: z30.string().trim().min(1).max(1024),
2095
+ description: z30.string().max(2048).optional(),
2096
+ inputType: z30.enum([
2048
2097
  "text",
2049
2098
  "number",
2050
2099
  "integer",
@@ -2052,77 +2101,77 @@ var InteractionFormFieldSchema = z29.object({
2052
2101
  "select",
2053
2102
  "multi-select"
2054
2103
  ]),
2055
- required: z29.boolean(),
2056
- options: z29.array(z29.string().max(1024)).max(100),
2057
- defaultValue: z29.union([
2058
- z29.string().max(4096),
2059
- z29.number().finite(),
2060
- z29.boolean(),
2061
- z29.array(z29.string().max(1024)).max(100)
2104
+ required: z30.boolean(),
2105
+ options: z30.array(z30.string().max(1024)).max(100),
2106
+ defaultValue: z30.union([
2107
+ z30.string().max(4096),
2108
+ z30.number().finite(),
2109
+ z30.boolean(),
2110
+ z30.array(z30.string().max(1024)).max(100)
2062
2111
  ]).optional(),
2063
- minimum: z29.number().finite().optional(),
2064
- maximum: z29.number().finite().optional(),
2065
- minLength: z29.number().int().nonnegative().max(1e6).optional(),
2066
- maxLength: z29.number().int().nonnegative().max(1e6).optional(),
2067
- minItems: z29.number().int().nonnegative().max(100).optional(),
2068
- maxItems: z29.number().int().nonnegative().max(100).optional(),
2069
- format: z29.enum(["email", "uri", "date", "date-time"]).optional()
2070
- }).strict();
2071
- var InteractionPermissionRequestSchema = z29.object({
2072
- kind: z29.literal("permission"),
2112
+ minimum: z30.number().finite().optional(),
2113
+ maximum: z30.number().finite().optional(),
2114
+ minLength: z30.number().int().nonnegative().max(1e6).optional(),
2115
+ maxLength: z30.number().int().nonnegative().max(1e6).optional(),
2116
+ minItems: z30.number().int().nonnegative().max(100).optional(),
2117
+ maxItems: z30.number().int().nonnegative().max(100).optional(),
2118
+ format: z30.enum(["email", "uri", "date", "date-time"]).optional()
2119
+ }).strict();
2120
+ var InteractionPermissionRequestSchema = z30.object({
2121
+ kind: z30.literal("permission"),
2073
2122
  permissionKind: IdSchema,
2074
- title: z29.string().trim().min(1).max(256),
2075
- description: z29.string().max(4096),
2076
- canApproveSession: z29.boolean(),
2077
- canApproveAlways: z29.boolean().optional(),
2078
- approvalScope: z29.string().trim().min(1).max(4096).optional()
2079
- }).strict();
2080
- var InteractionUserInputRequestSchema = z29.object({
2081
- kind: z29.literal("user_input"),
2082
- question: z29.string().trim().min(1).max(4096),
2083
- choices: z29.array(z29.string().max(1024)).max(100),
2084
- allowFreeform: z29.boolean()
2085
- }).strict();
2086
- var InteractionElicitationRequestSchema = z29.object({
2087
- kind: z29.literal("elicitation"),
2088
- message: z29.string().trim().min(1).max(4096),
2089
- mode: z29.enum(["form", "url"]),
2090
- source: z29.string().trim().min(1).max(256).optional(),
2091
- url: z29.url().max(32768).optional(),
2092
- fields: z29.array(InteractionFormFieldSchema).max(100)
2093
- }).strict();
2094
- var InteractionMcpOauthRequestSchema = z29.object({
2095
- kind: z29.literal("mcp_oauth"),
2096
- serverName: z29.string().trim().min(1).max(256),
2097
- serverUrl: z29.url().max(32768),
2098
- reason: z29.enum(["initial", "refresh", "reauth", "upscope"]),
2099
- responseMode: z29.literal("cancel-only")
2100
- }).strict();
2101
- var InteractionMcpHeadersRequestSchema = z29.object({
2102
- kind: z29.literal("mcp_headers"),
2103
- serverName: z29.string().trim().min(1).max(256),
2104
- serverUrl: z29.url().max(32768),
2105
- reason: z29.string().trim().min(1).max(256),
2106
- responseMode: z29.literal("none-only")
2107
- }).strict();
2108
- var InteractionAutoModeSwitchRequestSchema = z29.object({
2109
- kind: z29.literal("auto_mode_switch"),
2123
+ title: z30.string().trim().min(1).max(256),
2124
+ description: z30.string().max(4096),
2125
+ canApproveSession: z30.boolean(),
2126
+ canApproveAlways: z30.boolean().optional(),
2127
+ approvalScope: z30.string().trim().min(1).max(4096).optional()
2128
+ }).strict();
2129
+ var InteractionUserInputRequestSchema = z30.object({
2130
+ kind: z30.literal("user_input"),
2131
+ question: z30.string().trim().min(1).max(4096),
2132
+ choices: z30.array(z30.string().max(1024)).max(100),
2133
+ allowFreeform: z30.boolean()
2134
+ }).strict();
2135
+ var InteractionElicitationRequestSchema = z30.object({
2136
+ kind: z30.literal("elicitation"),
2137
+ message: z30.string().trim().min(1).max(4096),
2138
+ mode: z30.enum(["form", "url"]),
2139
+ source: z30.string().trim().min(1).max(256).optional(),
2140
+ url: z30.url().max(32768).optional(),
2141
+ fields: z30.array(InteractionFormFieldSchema).max(100)
2142
+ }).strict();
2143
+ var InteractionMcpOauthRequestSchema = z30.object({
2144
+ kind: z30.literal("mcp_oauth"),
2145
+ serverName: z30.string().trim().min(1).max(256),
2146
+ serverUrl: z30.url().max(32768),
2147
+ reason: z30.enum(["initial", "refresh", "reauth", "upscope"]),
2148
+ responseMode: z30.literal("cancel-only")
2149
+ }).strict();
2150
+ var InteractionMcpHeadersRequestSchema = z30.object({
2151
+ kind: z30.literal("mcp_headers"),
2152
+ serverName: z30.string().trim().min(1).max(256),
2153
+ serverUrl: z30.url().max(32768),
2154
+ reason: z30.string().trim().min(1).max(256),
2155
+ responseMode: z30.literal("none-only")
2156
+ }).strict();
2157
+ var InteractionAutoModeSwitchRequestSchema = z30.object({
2158
+ kind: z30.literal("auto_mode_switch"),
2110
2159
  errorCode: IdSchema.optional(),
2111
- retryAfterSeconds: z29.number().int().nonnegative().optional()
2112
- }).strict();
2113
- var InteractionSessionLimitsRequestSchema = z29.object({
2114
- kind: z29.literal("session_limits"),
2115
- maxAiCredits: z29.number().finite().nonnegative(),
2116
- usedAiCredits: z29.number().finite().nonnegative()
2117
- }).strict();
2118
- var InteractionExitPlanRequestSchema = z29.object({
2119
- kind: z29.literal("exit_plan"),
2120
- summary: z29.string().max(4096),
2121
- planContent: z29.string().max(1e5).optional(),
2122
- actions: z29.array(IdSchema).min(1).max(20),
2160
+ retryAfterSeconds: z30.number().int().nonnegative().optional()
2161
+ }).strict();
2162
+ var InteractionSessionLimitsRequestSchema = z30.object({
2163
+ kind: z30.literal("session_limits"),
2164
+ maxAiCredits: z30.number().finite().nonnegative(),
2165
+ usedAiCredits: z30.number().finite().nonnegative()
2166
+ }).strict();
2167
+ var InteractionExitPlanRequestSchema = z30.object({
2168
+ kind: z30.literal("exit_plan"),
2169
+ summary: z30.string().max(4096),
2170
+ planContent: z30.string().max(1e5).optional(),
2171
+ actions: z30.array(IdSchema).min(1).max(20),
2123
2172
  recommendedAction: IdSchema
2124
2173
  }).strict();
2125
- var InteractionRequestSchema = z29.discriminatedUnion("kind", [
2174
+ var InteractionRequestSchema = z30.discriminatedUnion("kind", [
2126
2175
  InteractionPermissionRequestSchema,
2127
2176
  InteractionUserInputRequestSchema,
2128
2177
  InteractionElicitationRequestSchema,
@@ -2132,81 +2181,81 @@ var InteractionRequestSchema = z29.discriminatedUnion("kind", [
2132
2181
  InteractionSessionLimitsRequestSchema,
2133
2182
  InteractionExitPlanRequestSchema
2134
2183
  ]);
2135
- var InteractionPermissionResponseSchema = z29.object({
2136
- kind: z29.literal("permission"),
2137
- decision: z29.enum(["approve-once", "approve-for-session", "approve-always", "reject"]),
2138
- feedback: z29.string().trim().min(1).max(2048).optional()
2139
- }).strict();
2140
- var InteractionUserInputResponseSchema = z29.object({
2141
- kind: z29.literal("user_input"),
2142
- answer: z29.string().max(1e5),
2143
- wasFreeform: z29.boolean()
2144
- }).strict();
2145
- var InteractionFieldValueSchema = z29.union([
2146
- z29.string().max(4096),
2147
- z29.number(),
2148
- z29.boolean(),
2149
- z29.array(z29.string().max(1024)).max(100)
2150
- ]);
2151
- var InteractionElicitationResponseSchema = z29.object({
2152
- kind: z29.literal("elicitation"),
2153
- action: z29.enum(["accept", "decline", "cancel"]),
2154
- values: z29.record(z29.string().max(256), InteractionFieldValueSchema)
2155
- }).strict();
2156
- var InteractionMcpOauthResponseSchema = z29.object({
2157
- kind: z29.literal("mcp_oauth"),
2158
- action: z29.literal("cancel")
2159
- }).strict();
2160
- var InteractionMcpHeadersResponseSchema = z29.object({
2161
- kind: z29.literal("mcp_headers"),
2162
- action: z29.literal("none")
2163
- }).strict();
2164
- var InteractionAutoModeSwitchResponseSchema = z29.object({
2165
- kind: z29.literal("auto_mode_switch"),
2166
- action: z29.enum(["yes", "yes_always", "no"])
2167
- }).strict();
2168
- var InteractionSessionLimitsResponseSchema = z29.object({
2169
- kind: z29.literal("session_limits"),
2170
- action: z29.enum(["add", "set", "unset", "cancel"]),
2171
- additionalAiCredits: z29.number().positive().optional(),
2172
- maxAiCredits: z29.number().positive().optional()
2184
+ var InteractionPermissionResponseSchema = z30.object({
2185
+ kind: z30.literal("permission"),
2186
+ decision: z30.enum(["approve-once", "approve-for-session", "approve-always", "reject"]),
2187
+ feedback: z30.string().trim().min(1).max(2048).optional()
2188
+ }).strict();
2189
+ var InteractionUserInputResponseSchema = z30.object({
2190
+ kind: z30.literal("user_input"),
2191
+ answer: z30.string().max(1e5),
2192
+ wasFreeform: z30.boolean()
2193
+ }).strict();
2194
+ var InteractionFieldValueSchema = z30.union([
2195
+ z30.string().max(4096),
2196
+ z30.number(),
2197
+ z30.boolean(),
2198
+ z30.array(z30.string().max(1024)).max(100)
2199
+ ]);
2200
+ var InteractionElicitationResponseSchema = z30.object({
2201
+ kind: z30.literal("elicitation"),
2202
+ action: z30.enum(["accept", "decline", "cancel"]),
2203
+ values: z30.record(z30.string().max(256), InteractionFieldValueSchema)
2204
+ }).strict();
2205
+ var InteractionMcpOauthResponseSchema = z30.object({
2206
+ kind: z30.literal("mcp_oauth"),
2207
+ action: z30.literal("cancel")
2208
+ }).strict();
2209
+ var InteractionMcpHeadersResponseSchema = z30.object({
2210
+ kind: z30.literal("mcp_headers"),
2211
+ action: z30.literal("none")
2212
+ }).strict();
2213
+ var InteractionAutoModeSwitchResponseSchema = z30.object({
2214
+ kind: z30.literal("auto_mode_switch"),
2215
+ action: z30.enum(["yes", "yes_always", "no"])
2216
+ }).strict();
2217
+ var InteractionSessionLimitsResponseSchema = z30.object({
2218
+ kind: z30.literal("session_limits"),
2219
+ action: z30.enum(["add", "set", "unset", "cancel"]),
2220
+ additionalAiCredits: z30.number().positive().optional(),
2221
+ maxAiCredits: z30.number().positive().optional()
2173
2222
  }).strict().superRefine((response, context) => {
2174
2223
  if (response.action === "add" && response.additionalAiCredits === void 0) {
2175
2224
  context.addIssue({
2176
- code: z29.ZodIssueCode.custom,
2225
+ code: z30.ZodIssueCode.custom,
2177
2226
  path: ["additionalAiCredits"],
2178
2227
  message: "additionalAiCredits is required for add"
2179
2228
  });
2180
2229
  }
2181
2230
  if (response.action === "set" && response.maxAiCredits === void 0) {
2182
2231
  context.addIssue({
2183
- code: z29.ZodIssueCode.custom,
2232
+ code: z30.ZodIssueCode.custom,
2184
2233
  path: ["maxAiCredits"],
2185
2234
  message: "maxAiCredits is required for set"
2186
2235
  });
2187
2236
  }
2188
2237
  if (response.action !== "add" && response.additionalAiCredits !== void 0) {
2189
2238
  context.addIssue({
2190
- code: z29.ZodIssueCode.custom,
2239
+ code: z30.ZodIssueCode.custom,
2191
2240
  path: ["additionalAiCredits"],
2192
2241
  message: "additionalAiCredits is only valid for add"
2193
2242
  });
2194
2243
  }
2195
2244
  if (response.action !== "set" && response.maxAiCredits !== void 0) {
2196
2245
  context.addIssue({
2197
- code: z29.ZodIssueCode.custom,
2246
+ code: z30.ZodIssueCode.custom,
2198
2247
  path: ["maxAiCredits"],
2199
2248
  message: "maxAiCredits is only valid for set"
2200
2249
  });
2201
2250
  }
2202
2251
  });
2203
- var InteractionExitPlanResponseSchema = z29.object({
2204
- kind: z29.literal("exit_plan"),
2205
- approved: z29.boolean(),
2252
+ var InteractionExitPlanResponseSchema = z30.object({
2253
+ kind: z30.literal("exit_plan"),
2254
+ approved: z30.boolean(),
2206
2255
  selectedAction: IdSchema.optional(),
2207
- feedback: z29.string().trim().min(1).max(4096).optional()
2256
+ feedback: z30.string().trim().min(1).max(4096).optional()
2208
2257
  }).strict();
2209
- var InteractionResponseSchema = z29.discriminatedUnion("kind", [
2258
+ var InteractionResponseSchema = z30.discriminatedUnion("kind", [
2210
2259
  InteractionPermissionResponseSchema,
2211
2260
  InteractionUserInputResponseSchema,
2212
2261
  InteractionElicitationResponseSchema,
@@ -2216,30 +2265,30 @@ var InteractionResponseSchema = z29.discriminatedUnion("kind", [
2216
2265
  InteractionSessionLimitsResponseSchema,
2217
2266
  InteractionExitPlanResponseSchema
2218
2267
  ]);
2219
- var InteractionRequestPayloadSchema = z29.object({
2268
+ var InteractionRequestPayloadSchema = z30.object({
2220
2269
  interactionRequestId: IdSchema,
2221
2270
  userId: IdSchema,
2222
2271
  machineId: IdSchema,
2223
2272
  sessionId: IdSchema,
2224
2273
  request: InteractionRequestSchema
2225
2274
  }).strict();
2226
- var InteractionRespondRequestSchema = z29.object({
2275
+ var InteractionRespondRequestSchema = z30.object({
2227
2276
  requestId: IdSchema,
2228
2277
  interactionRequestId: IdSchema,
2229
2278
  machineId: IdSchema,
2230
2279
  sessionId: IdSchema,
2231
2280
  response: InteractionResponseSchema
2232
2281
  }).strict();
2233
- var InteractionRespondResultSchema = z29.discriminatedUnion("ok", [
2234
- z29.object({
2235
- ok: z29.literal(true),
2282
+ var InteractionRespondResultSchema = z30.discriminatedUnion("ok", [
2283
+ z30.object({
2284
+ ok: z30.literal(true),
2236
2285
  requestId: IdSchema,
2237
2286
  interactionRequestId: IdSchema,
2238
2287
  machineId: IdSchema,
2239
2288
  sessionId: IdSchema
2240
2289
  }).strict(),
2241
- z29.object({
2242
- ok: z29.literal(false),
2290
+ z30.object({
2291
+ ok: z30.literal(false),
2243
2292
  requestId: IdSchema,
2244
2293
  interactionRequestId: IdSchema,
2245
2294
  machineId: IdSchema,
@@ -2247,31 +2296,31 @@ var InteractionRespondResultSchema = z29.discriminatedUnion("ok", [
2247
2296
  error: ProtocolFailureSchema
2248
2297
  }).strict()
2249
2298
  ]);
2250
- var PermissionRequestPayloadSchema = z29.object({
2299
+ var PermissionRequestPayloadSchema = z30.object({
2251
2300
  permissionRequestId: IdSchema,
2252
2301
  userId: IdSchema,
2253
2302
  machineId: IdSchema,
2254
2303
  sessionId: IdSchema,
2255
- request: z29.record(z29.string(), z29.unknown())
2304
+ request: z30.record(z30.string(), z30.unknown())
2256
2305
  });
2257
- var PermissionRespondRequestSchema = z29.object({
2306
+ var PermissionRespondRequestSchema = z30.object({
2258
2307
  requestId: IdSchema,
2259
2308
  permissionRequestId: IdSchema,
2260
2309
  machineId: IdSchema,
2261
2310
  sessionId: IdSchema,
2262
- decision: z29.enum(["approve-once", "reject"]),
2263
- feedback: z29.string().trim().min(1).max(2048).optional()
2311
+ decision: z30.enum(["approve-once", "reject"]),
2312
+ feedback: z30.string().trim().min(1).max(2048).optional()
2264
2313
  });
2265
- var PermissionRespondResultSchema = z29.discriminatedUnion("ok", [
2266
- z29.object({
2267
- ok: z29.literal(true),
2314
+ var PermissionRespondResultSchema = z30.discriminatedUnion("ok", [
2315
+ z30.object({
2316
+ ok: z30.literal(true),
2268
2317
  requestId: IdSchema,
2269
2318
  permissionRequestId: IdSchema,
2270
2319
  machineId: IdSchema,
2271
2320
  sessionId: IdSchema
2272
2321
  }),
2273
- z29.object({
2274
- ok: z29.literal(false),
2322
+ z30.object({
2323
+ ok: z30.literal(false),
2275
2324
  requestId: IdSchema,
2276
2325
  permissionRequestId: IdSchema,
2277
2326
  machineId: IdSchema,
@@ -2281,42 +2330,42 @@ var PermissionRespondResultSchema = z29.discriminatedUnion("ok", [
2281
2330
  ]);
2282
2331
 
2283
2332
  // ../../shared/protocol/dist/conversation/timeline-sync.js
2284
- import { z as z30 } from "zod";
2333
+ import { z as z31 } from "zod";
2285
2334
  var TIMELINE_SYNC_MAX_EVENTS = 128;
2286
2335
  var TIMELINE_SYNC_MAX_BYTES = 6 * 1024 * 1024;
2287
2336
  var TIMELINE_IMAGE_CHUNK_BYTES = 48 * 1024;
2288
2337
  var TIMELINE_IMAGE_MAX_BYTES = 3 * 1024 * 1024;
2289
- var identity = z30.string().min(1).max(256);
2290
- var sequence = z30.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
2291
- var hash = z30.string().regex(/^[a-f0-9]{64}$/u);
2292
- var TimelineWatermarkSchema = z30.object({
2338
+ var identity = z31.string().min(1).max(256);
2339
+ var sequence = z31.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
2340
+ var hash = z31.string().regex(/^[a-f0-9]{64}$/u);
2341
+ var TimelineWatermarkSchema = z31.object({
2293
2342
  epoch: identity,
2294
2343
  sequence
2295
2344
  }).strict();
2296
- var TimelineSyncRequestSchema = z30.object({
2345
+ var TimelineSyncRequestSchema = z31.object({
2297
2346
  watermark: TimelineWatermarkSchema.optional(),
2298
- waitMs: z30.number().int().min(0).max(2e4).optional(),
2299
- resume: z30.boolean().optional()
2347
+ waitMs: z31.number().int().min(0).max(2e4).optional(),
2348
+ resume: z31.boolean().optional()
2300
2349
  }).strict();
2301
- var TimelineTextAppendSchema = z30.object({
2350
+ var TimelineTextAppendSchema = z31.object({
2302
2351
  itemId: identity,
2303
- baseRevision: z30.number().int().positive(),
2304
- revision: z30.number().int().positive(),
2305
- appendText: z30.string().min(1).max(5e5),
2306
- sourceEventIds: z30.array(identity).min(1).max(1e3).optional(),
2307
- sourceMessageIds: z30.array(identity).min(1).max(1e3).optional(),
2308
- sourceInteractionIds: z30.array(identity).min(1).max(1e3).optional()
2309
- }).strict();
2310
- var TimelineSyncEventSchema = z30.discriminatedUnion("kind", [
2311
- z30.object({ kind: z30.literal("upsert"), sequence, item: ConversationItemSchema }).strict(),
2312
- z30.object({ kind: z30.literal("append"), sequence, append: TimelineTextAppendSchema }).strict(),
2313
- z30.object({
2314
- kind: z30.literal("step"),
2352
+ baseRevision: z31.number().int().positive(),
2353
+ revision: z31.number().int().positive(),
2354
+ appendText: z31.string().min(1).max(5e5),
2355
+ sourceEventIds: z31.array(identity).min(1).max(1e3).optional(),
2356
+ sourceMessageIds: z31.array(identity).min(1).max(1e3).optional(),
2357
+ sourceInteractionIds: z31.array(identity).min(1).max(1e3).optional()
2358
+ }).strict();
2359
+ var TimelineSyncEventSchema = z31.discriminatedUnion("kind", [
2360
+ z31.object({ kind: z31.literal("upsert"), sequence, item: ConversationItemSchema }).strict(),
2361
+ z31.object({ kind: z31.literal("append"), sequence, append: TimelineTextAppendSchema }).strict(),
2362
+ z31.object({
2363
+ kind: z31.literal("step"),
2315
2364
  sequence,
2316
2365
  upsert: ConversationActivityStepUpsertSchema
2317
2366
  }).strict()
2318
2367
  ]);
2319
- var TimelineResyncReasonSchema = z30.enum([
2368
+ var TimelineResyncReasonSchema = z31.enum([
2320
2369
  "initial",
2321
2370
  "epoch-changed",
2322
2371
  "evicted",
@@ -2325,36 +2374,36 @@ var TimelineResyncReasonSchema = z30.enum([
2325
2374
  "rewind",
2326
2375
  "oversized"
2327
2376
  ]);
2328
- var TimelineSyncResponseSchema = z30.discriminatedUnion("status", [
2329
- z30.object({
2330
- status: z30.literal("snapshot"),
2377
+ var TimelineSyncResponseSchema = z31.discriminatedUnion("status", [
2378
+ z31.object({
2379
+ status: z31.literal("snapshot"),
2331
2380
  watermark: TimelineWatermarkSchema,
2332
2381
  page: SessionTimelinePageSchema
2333
2382
  }).strict(),
2334
- z30.object({
2335
- status: z30.literal("replay"),
2383
+ z31.object({
2384
+ status: z31.literal("replay"),
2336
2385
  watermark: TimelineWatermarkSchema,
2337
2386
  afterSequence: sequence,
2338
- events: z30.array(TimelineSyncEventSchema).max(TIMELINE_SYNC_MAX_EVENTS),
2339
- hasMore: z30.boolean()
2387
+ events: z31.array(TimelineSyncEventSchema).max(TIMELINE_SYNC_MAX_EVENTS),
2388
+ hasMore: z31.boolean()
2340
2389
  }).strict(),
2341
- z30.object({
2342
- status: z30.literal("resync"),
2390
+ z31.object({
2391
+ status: z31.literal("resync"),
2343
2392
  epoch: identity,
2344
2393
  reason: TimelineResyncReasonSchema
2345
2394
  }).strict()
2346
2395
  ]);
2347
- var TimelineImageRequestSchema = z30.object({
2396
+ var TimelineImageRequestSchema = z31.object({
2348
2397
  sha256: hash,
2349
- offset: z30.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1)
2398
+ offset: z31.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1)
2350
2399
  }).strict();
2351
- var TimelineImageChunkSchema = z30.object({
2400
+ var TimelineImageChunkSchema = z31.object({
2352
2401
  sha256: hash,
2353
- offset: z30.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1),
2354
- totalBytes: z30.number().int().positive().max(TIMELINE_IMAGE_MAX_BYTES),
2355
- mimeType: z30.enum(["image/gif", "image/jpeg", "image/png", "image/webp"]),
2356
- data: z30.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),
2357
- eof: z30.boolean()
2402
+ offset: z31.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1),
2403
+ totalBytes: z31.number().int().positive().max(TIMELINE_IMAGE_MAX_BYTES),
2404
+ mimeType: z31.enum(["image/gif", "image/jpeg", "image/png", "image/webp"]),
2405
+ data: z31.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),
2406
+ eof: z31.boolean()
2358
2407
  }).strict().superRefine((chunk, context) => {
2359
2408
  const padding = chunk.data.endsWith("==") ? 2 : chunk.data.endsWith("=") ? 1 : 0;
2360
2409
  const length = chunk.data.length / 4 * 3 - padding;
@@ -2365,10 +2414,10 @@ var TimelineImageChunkSchema = z30.object({
2365
2414
  });
2366
2415
 
2367
2416
  // ../../shared/protocol/dist/workbench.js
2368
- import { z as z32 } from "zod";
2417
+ import { z as z33 } from "zod";
2369
2418
 
2370
2419
  // ../../shared/protocol/dist/schedules.js
2371
- import { z as z31 } from "zod";
2420
+ import { z as z32 } from "zod";
2372
2421
  var SCHEDULE_OPERATIONS = [
2373
2422
  "schedule.snapshot",
2374
2423
  "schedule.create",
@@ -2376,90 +2425,90 @@ var SCHEDULE_OPERATIONS = [
2376
2425
  "schedule.draft.dismiss",
2377
2426
  "schedule.resume"
2378
2427
  ];
2379
- var Id = z31.string().min(1).max(256);
2380
- var NativeId = z31.number().int().positive().max(Number.MAX_SAFE_INTEGER);
2381
- var Time = z31.iso.datetime({ offset: true });
2382
- var WorkbenchScheduleRuleSchema = z31.discriminatedUnion("kind", [
2383
- z31.object({ kind: z31.literal("once"), at: Time }).strict(),
2384
- z31.object({
2385
- kind: z31.literal("interval"),
2386
- seconds: z31.number().int().min(10).max(86400),
2387
- recurring: z31.boolean().optional()
2428
+ var Id = z32.string().min(1).max(256);
2429
+ var NativeId = z32.number().int().positive().max(Number.MAX_SAFE_INTEGER);
2430
+ var Time = z32.iso.datetime({ offset: true });
2431
+ var WorkbenchScheduleRuleSchema = z32.discriminatedUnion("kind", [
2432
+ z32.object({ kind: z32.literal("once"), at: Time }).strict(),
2433
+ z32.object({
2434
+ kind: z32.literal("interval"),
2435
+ seconds: z32.number().int().min(10).max(86400),
2436
+ recurring: z32.boolean().optional()
2388
2437
  }).strict(),
2389
- z31.object({
2390
- kind: z31.literal("cron"),
2391
- expression: z31.string().trim().min(9).max(256).regex(/^\S+(?: +\S+){4}$/),
2392
- timezone: z31.string().min(1).max(128).regex(/^[A-Za-z0-9_+./-]+$/)
2438
+ z32.object({
2439
+ kind: z32.literal("cron"),
2440
+ expression: z32.string().trim().min(9).max(256).regex(/^\S+(?: +\S+){4}$/),
2441
+ timezone: z32.string().min(1).max(128).regex(/^[A-Za-z0-9_+./-]+$/)
2393
2442
  }).strict()
2394
2443
  ]);
2395
2444
  var Content = {
2396
2445
  rule: WorkbenchScheduleRuleSchema,
2397
- prompt: z31.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."),
2398
- skill: z31.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.")
2446
+ prompt: z32.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."),
2447
+ skill: z32.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.")
2399
2448
  };
2400
- var WorkbenchScheduleProposalSchema = z31.object(Content).strict().refine((value) => value.prompt.trim().length > 0 || value.skill !== void 0, { message: "A prompt or skill is required" });
2401
- var WorkbenchScheduleDraftSchema = z31.object({
2402
- id: z31.uuid(),
2449
+ var WorkbenchScheduleProposalSchema = z32.object(Content).strict().refine((value) => value.prompt.trim().length > 0 || value.skill !== void 0, { message: "A prompt or skill is required" });
2450
+ var WorkbenchScheduleDraftSchema = z32.object({
2451
+ id: z32.uuid(),
2403
2452
  createdAt: Time,
2404
2453
  ...Content
2405
2454
  }).strict();
2406
- var WorkbenchScheduleEntrySchema = z31.object({
2455
+ var WorkbenchScheduleEntrySchema = z32.object({
2407
2456
  id: NativeId,
2408
- prompt: z31.string().max(1e5),
2409
- displayPrompt: z31.string().max(1e5).optional(),
2410
- recurring: z31.boolean(),
2457
+ prompt: z32.string().max(1e5),
2458
+ displayPrompt: z32.string().max(1e5).optional(),
2459
+ recurring: z32.boolean(),
2411
2460
  nextRunAt: Time,
2412
- intervalMs: z31.number().int().positive().optional(),
2413
- cron: z31.string().max(256).optional(),
2414
- timezone: z31.string().max(128).optional(),
2461
+ intervalMs: z32.number().int().positive().optional(),
2462
+ cron: z32.string().max(256).optional(),
2463
+ timezone: z32.string().max(128).optional(),
2415
2464
  at: Time.optional()
2416
2465
  }).strict();
2417
- var WorkbenchScheduleResultSchema = z31.object({
2466
+ var WorkbenchScheduleResultSchema = z32.object({
2418
2467
  id: Id,
2419
2468
  scheduleId: NativeId,
2420
2469
  triggerEventId: Id,
2421
2470
  time: Time,
2422
- prompt: z31.string().max(16e3),
2423
- status: z31.enum(["reply", "error", "merged", "pending", "unknown"]),
2424
- reply: z31.string().max(16e3).optional(),
2471
+ prompt: z32.string().max(16e3),
2472
+ status: z32.enum(["reply", "error", "merged", "pending", "unknown"]),
2473
+ reply: z32.string().max(16e3).optional(),
2425
2474
  replyEventId: Id.optional(),
2426
- error: z31.string().max(1024).optional()
2427
- }).strict();
2428
- var WorkbenchScheduleSnapshotSchema = z31.object({
2429
- state: z31.enum(["active", "needs-resume"]),
2430
- workingDirectory: z31.string().max(32768).optional(),
2431
- timezone: z31.string().max(128).optional(),
2432
- entries: z31.array(WorkbenchScheduleEntrySchema).max(256),
2433
- drafts: z31.array(WorkbenchScheduleDraftSchema).max(100),
2434
- results: z31.array(WorkbenchScheduleResultSchema).max(100),
2435
- historyTruncated: z31.boolean(),
2475
+ error: z32.string().max(1024).optional()
2476
+ }).strict();
2477
+ var WorkbenchScheduleSnapshotSchema = z32.object({
2478
+ state: z32.enum(["active", "needs-resume"]),
2479
+ workingDirectory: z32.string().max(32768).optional(),
2480
+ timezone: z32.string().max(128).optional(),
2481
+ entries: z32.array(WorkbenchScheduleEntrySchema).max(256),
2482
+ drafts: z32.array(WorkbenchScheduleDraftSchema).max(100),
2483
+ results: z32.array(WorkbenchScheduleResultSchema).max(100),
2484
+ historyTruncated: z32.boolean(),
2436
2485
  sampledAt: Time
2437
2486
  }).strict();
2438
2487
  var Submission = {
2439
- operationId: z31.uuid(),
2440
- operationCreatedAt: z31.iso.datetime(),
2488
+ operationId: z32.uuid(),
2489
+ operationCreatedAt: z32.iso.datetime(),
2441
2490
  expectedAgentRunId: Id
2442
2491
  };
2443
- var WorkbenchScheduleCreateRequestSchema = z31.object({
2492
+ var WorkbenchScheduleCreateRequestSchema = z32.object({
2444
2493
  ...Submission,
2445
2494
  ...Content,
2446
- draftId: z31.uuid().optional()
2495
+ draftId: z32.uuid().optional()
2447
2496
  }).strict().refine((value) => value.prompt.trim().length > 0 || value.skill !== void 0, { message: "A prompt or skill is required" });
2448
- var WorkbenchScheduleCreateResultSchema = z31.object({
2497
+ var WorkbenchScheduleCreateResultSchema = z32.object({
2449
2498
  snapshot: WorkbenchScheduleSnapshotSchema,
2450
- verified: z31.boolean()
2499
+ verified: z32.boolean()
2451
2500
  }).strict();
2452
- var WorkbenchScheduleDeleteRequestSchema = z31.object({
2501
+ var WorkbenchScheduleDeleteRequestSchema = z32.object({
2453
2502
  ...Submission,
2454
2503
  id: NativeId
2455
2504
  }).strict();
2456
- var WorkbenchScheduleDeleteResultSchema = z31.object({
2505
+ var WorkbenchScheduleDeleteResultSchema = z32.object({
2457
2506
  snapshot: WorkbenchScheduleSnapshotSchema,
2458
- removed: z31.boolean()
2507
+ removed: z32.boolean()
2459
2508
  }).strict();
2460
- var WorkbenchScheduleDraftDismissRequestSchema = z31.object({
2509
+ var WorkbenchScheduleDraftDismissRequestSchema = z32.object({
2461
2510
  ...Submission,
2462
- draftId: z31.uuid()
2511
+ draftId: z32.uuid()
2463
2512
  }).strict();
2464
2513
  var ScheduleAndroidSchemas = {
2465
2514
  WorkbenchScheduleRule: WorkbenchScheduleRuleSchema,
@@ -2476,10 +2525,10 @@ var ScheduleAndroidSchemas = {
2476
2525
  };
2477
2526
 
2478
2527
  // ../../shared/protocol/dist/workbench.js
2479
- var Id2 = z32.string().trim().min(1).max(256);
2480
- var Text = z32.string().max(1e5);
2481
- var Count = z32.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
2482
- var Failure = z32.object({ code: Id2, message: z32.string().min(1).max(1024) }).strict();
2528
+ var Id2 = z33.string().trim().min(1).max(256);
2529
+ var Text = z33.string().max(1e5);
2530
+ var Count = z33.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
2531
+ var Failure = z33.object({ code: Id2, message: z33.string().min(1).max(1024) }).strict();
2483
2532
  var WORKBENCH_OPERATIONS = [
2484
2533
  "operation.get",
2485
2534
  "question.ask",
@@ -2494,108 +2543,110 @@ var WORKBENCH_OPERATIONS = [
2494
2543
  "queue.snapshot",
2495
2544
  "queue.mutate",
2496
2545
  "insights.read",
2546
+ "reasoning.read",
2547
+ "analytics.read",
2497
2548
  "context.compact",
2498
2549
  ...SCHEDULE_OPERATIONS
2499
2550
  ];
2500
2551
  var Submission2 = {
2501
- operationId: z32.uuid(),
2502
- operationCreatedAt: z32.iso.datetime(),
2552
+ operationId: z33.uuid(),
2553
+ operationCreatedAt: z33.iso.datetime(),
2503
2554
  expectedAgentRunId: Id2
2504
2555
  };
2505
- var WorkbenchOperationGetSchema = z32.object({ operationId: z32.uuid() }).strict();
2506
- var WorkbenchOperationStatusSchema = z32.object({
2507
- operationId: z32.uuid(),
2508
- operation: z32.enum(WORKBENCH_OPERATIONS),
2556
+ var WorkbenchOperationGetSchema = z33.object({ operationId: z33.uuid() }).strict();
2557
+ var WorkbenchOperationStatusSchema = z33.object({
2558
+ operationId: z33.uuid(),
2559
+ operation: z33.enum(WORKBENCH_OPERATIONS),
2509
2560
  agentRunId: Id2,
2510
- state: z32.enum(["running", "succeeded", "failed", "uncertain", "result-expired"]),
2511
- result: z32.record(z32.string(), z32.json()).optional(),
2561
+ state: z33.enum(["running", "succeeded", "failed", "uncertain", "result-expired"]),
2562
+ result: z33.record(z33.string(), z33.json()).optional(),
2512
2563
  error: Failure.optional()
2513
2564
  }).strict().superRefine((value, context) => {
2514
2565
  if (value.state === "succeeded" !== (value.result !== void 0) || (value.state === "failed" || value.state === "uncertain") !== (value.error !== void 0)) {
2515
2566
  context.addIssue({ code: "custom", message: "Invalid operation state payload" });
2516
2567
  }
2517
2568
  });
2518
- var WorkbenchAskRequestSchema = z32.object({
2569
+ var WorkbenchAskRequestSchema = z33.object({
2519
2570
  ...Submission2,
2520
- question: z32.string().trim().min(1).max(16e3)
2571
+ question: z33.string().trim().min(1).max(16e3)
2521
2572
  }).strict();
2522
- var WorkbenchAskResultSchema = z32.object({ answer: Text }).strict();
2523
- var WorkbenchEmptyRequestSchema = z32.object({}).strict();
2524
- var WorkbenchSubmitRequestSchema = z32.object(Submission2).strict();
2525
- var WorkbenchResearchCreateRequestSchema = z32.object({
2573
+ var WorkbenchAskResultSchema = z33.object({ answer: Text }).strict();
2574
+ var WorkbenchEmptyRequestSchema = z33.object({}).strict();
2575
+ var WorkbenchSubmitRequestSchema = z33.object(Submission2).strict();
2576
+ var WorkbenchResearchCreateRequestSchema = z33.object({
2526
2577
  ...Submission2,
2527
- title: z32.string().trim().min(1).max(120),
2528
- question: z32.string().trim().min(1).max(16e3),
2578
+ title: z33.string().trim().min(1).max(120),
2579
+ question: z33.string().trim().min(1).max(16e3),
2529
2580
  sourceItemId: Id2.optional(),
2530
- deferInitialPrompt: z32.literal(true).optional()
2581
+ deferInitialPrompt: z33.literal(true).optional()
2531
2582
  }).strict();
2532
- var WorkbenchResearchThreadSchema = z32.object({
2583
+ var WorkbenchResearchThreadSchema = z33.object({
2533
2584
  sessionId: Id2,
2534
2585
  parentSessionId: Id2,
2535
- title: z32.string().min(1).max(120),
2536
- createdAt: z32.iso.datetime(),
2586
+ title: z33.string().min(1).max(120),
2587
+ createdAt: z33.iso.datetime(),
2537
2588
  contextAnchor: Id2.optional(),
2538
- contextTruncated: z32.boolean(),
2539
- detached: z32.boolean(),
2540
- state: z32.enum(["creating", "ready", "failed"])
2589
+ contextTruncated: z33.boolean(),
2590
+ detached: z33.boolean(),
2591
+ state: z33.enum(["creating", "ready", "failed"])
2541
2592
  }).strict();
2542
- var WorkbenchResearchCreateResultSchema = z32.object({
2593
+ var WorkbenchResearchCreateResultSchema = z33.object({
2543
2594
  thread: WorkbenchResearchThreadSchema
2544
2595
  }).strict();
2545
- var WorkbenchResearchListResultSchema = z32.object({
2546
- threads: z32.array(WorkbenchResearchThreadSchema).max(100)
2596
+ var WorkbenchResearchListResultSchema = z33.object({
2597
+ threads: z33.array(WorkbenchResearchThreadSchema).max(100)
2547
2598
  }).strict();
2548
- var WorkbenchResearchTimelineRequestSchema = z32.object({
2599
+ var WorkbenchResearchTimelineRequestSchema = z33.object({
2549
2600
  cursor: Id2.optional()
2550
2601
  }).strict();
2551
- var WorkbenchResearchSendRequestSchema = z32.object({
2602
+ var WorkbenchResearchSendRequestSchema = z33.object({
2552
2603
  ...Submission2,
2553
- prompt: z32.string().trim().min(1).max(16e3)
2554
- }).strict();
2555
- var WorkbenchResearchSendResultSchema = z32.object({ messageId: Id2 }).strict();
2556
- var WorkbenchCompletedResultSchema = z32.object({ completed: z32.boolean() }).strict();
2557
- var WorkbenchCommandSchema = z32.object({
2558
- name: z32.string().min(1).max(260),
2559
- description: z32.string().max(4096),
2560
- argumentHint: z32.string().max(1024).optional(),
2561
- kind: z32.enum(["builtin", "skill", "client"]),
2562
- allowDuringExecution: z32.boolean(),
2563
- supported: z32.boolean(),
2564
- reason: z32.string().max(1024).optional()
2565
- }).strict();
2566
- var WorkbenchCommandListResultSchema = z32.object({
2567
- commands: z32.array(WorkbenchCommandSchema).max(512)
2568
- }).strict();
2569
- var WorkbenchCommandInvokeRequestSchema = z32.object({
2604
+ prompt: z33.string().trim().min(1).max(16e3)
2605
+ }).strict();
2606
+ var WorkbenchResearchSendResultSchema = z33.object({ messageId: Id2 }).strict();
2607
+ var WorkbenchCompletedResultSchema = z33.object({ completed: z33.boolean() }).strict();
2608
+ var WorkbenchCommandSchema = z33.object({
2609
+ name: z33.string().min(1).max(260),
2610
+ description: z33.string().max(4096),
2611
+ argumentHint: z33.string().max(1024).optional(),
2612
+ kind: z33.enum(["builtin", "skill", "client"]),
2613
+ allowDuringExecution: z33.boolean(),
2614
+ supported: z33.boolean(),
2615
+ reason: z33.string().max(1024).optional()
2616
+ }).strict();
2617
+ var WorkbenchCommandListResultSchema = z33.object({
2618
+ commands: z33.array(WorkbenchCommandSchema).max(512)
2619
+ }).strict();
2620
+ var WorkbenchCommandInvokeRequestSchema = z33.object({
2570
2621
  ...Submission2,
2571
- name: z32.string().trim().min(1).max(260),
2572
- input: z32.string().max(16e3)
2573
- }).strict();
2574
- var WorkbenchCommandChoiceSchema = z32.object({
2575
- name: z32.string().min(1).max(260),
2576
- label: z32.string().min(1).max(1024),
2577
- input: z32.string().max(16e3)
2578
- }).strict();
2579
- var WorkbenchCommandResultSchema = z32.discriminatedUnion("kind", [
2580
- z32.object({ kind: z32.literal("text"), text: Text }).strict(),
2581
- z32.object({ kind: z32.literal("completed") }).strict(),
2582
- z32.object({ kind: z32.literal("sent"), messageId: Id2 }).strict(),
2583
- z32.object({
2584
- kind: z32.literal("select-subcommand"),
2585
- choices: z32.array(WorkbenchCommandChoiceSchema).min(1).max(100)
2622
+ name: z33.string().trim().min(1).max(260),
2623
+ input: z33.string().max(16e3)
2624
+ }).strict();
2625
+ var WorkbenchCommandChoiceSchema = z33.object({
2626
+ name: z33.string().min(1).max(260),
2627
+ label: z33.string().min(1).max(1024),
2628
+ input: z33.string().max(16e3)
2629
+ }).strict();
2630
+ var WorkbenchCommandResultSchema = z33.discriminatedUnion("kind", [
2631
+ z33.object({ kind: z33.literal("text"), text: Text }).strict(),
2632
+ z33.object({ kind: z33.literal("completed") }).strict(),
2633
+ z33.object({ kind: z33.literal("sent"), messageId: Id2 }).strict(),
2634
+ z33.object({
2635
+ kind: z33.literal("select-subcommand"),
2636
+ choices: z33.array(WorkbenchCommandChoiceSchema).min(1).max(100)
2586
2637
  }).strict()
2587
2638
  ]);
2588
- var WorkbenchQueueItemSchema = z32.object({
2639
+ var WorkbenchQueueItemSchema = z33.object({
2589
2640
  id: Id2,
2590
- kind: z32.string().min(1).max(64),
2591
- texts: z32.array(z32.string().max(1e5)).min(1).max(100),
2592
- actions: z32.array(z32.enum(["edit", "remove", "move", "send-now"])).max(4)
2641
+ kind: z33.string().min(1).max(64),
2642
+ texts: z33.array(z33.string().max(1e5)).min(1).max(100),
2643
+ actions: z33.array(z33.enum(["edit", "remove", "move", "send-now"])).max(4)
2593
2644
  }).strict();
2594
- var WorkbenchQueueSnapshotSchema = z32.object({
2645
+ var WorkbenchQueueSnapshotSchema = z33.object({
2595
2646
  generation: Id2,
2596
2647
  revision: Id2,
2597
- items: z32.array(WorkbenchQueueItemSchema).max(512),
2598
- steeringMessages: z32.array(z32.string().max(1e5)).max(512)
2648
+ items: z33.array(WorkbenchQueueItemSchema).max(512),
2649
+ steeringMessages: z33.array(z33.string().max(1e5)).max(512)
2599
2650
  }).strict();
2600
2651
  var QueueMutation = {
2601
2652
  ...Submission2,
@@ -2603,51 +2654,140 @@ var QueueMutation = {
2603
2654
  revision: Id2,
2604
2655
  id: Id2
2605
2656
  };
2606
- var WorkbenchQueueMutationRequestSchema = z32.discriminatedUnion("action", [
2607
- z32.object({ ...QueueMutation, action: z32.literal("edit"), prompt: z32.string().trim().min(1).max(1e5) }).strict(),
2608
- z32.object({ ...QueueMutation, action: z32.literal("remove") }).strict(),
2609
- z32.object({ ...QueueMutation, action: z32.literal("move"), toPosition: z32.number().int().min(0).max(511) }).strict(),
2610
- z32.object({ ...QueueMutation, action: z32.literal("send-now") }).strict()
2611
- ]);
2612
- var WorkbenchQueueMutationResultSchema = z32.object({
2613
- changed: z32.boolean(),
2657
+ var WorkbenchQueueMutationRequestSchema = z33.discriminatedUnion("action", [
2658
+ z33.object({ ...QueueMutation, action: z33.literal("edit"), prompt: z33.string().trim().min(1).max(1e5) }).strict(),
2659
+ z33.object({ ...QueueMutation, action: z33.literal("remove") }).strict(),
2660
+ z33.object({ ...QueueMutation, action: z33.literal("move"), toPosition: z33.number().int().min(0).max(511) }).strict(),
2661
+ z33.object({ ...QueueMutation, action: z33.literal("send-now") }).strict()
2662
+ ]);
2663
+ var WorkbenchQueueMutationResultSchema = z33.object({
2664
+ changed: z33.boolean(),
2614
2665
  snapshot: WorkbenchQueueSnapshotSchema
2615
2666
  }).strict();
2616
- var WorkbenchTokenMetricSchema = z32.object({
2617
- kind: z32.string().min(1).max(128),
2667
+ var WorkbenchTokenMetricSchema = z33.object({
2668
+ kind: z33.string().min(1).max(128),
2618
2669
  count: Count
2619
2670
  }).strict();
2620
- var WorkbenchModelUsageSchema = z32.object({
2671
+ var WorkbenchModelUsageSchema = z33.object({
2621
2672
  model: Id2,
2622
2673
  requests: Count,
2623
- premiumRequestCost: z32.number().finite().nonnegative(),
2624
- tokens: z32.array(WorkbenchTokenMetricSchema).max(32)
2674
+ premiumRequestCost: z33.number().finite().nonnegative(),
2675
+ tokens: z33.array(WorkbenchTokenMetricSchema).max(32)
2625
2676
  }).strict();
2626
- var WorkbenchContextSchema = z32.object({
2677
+ var WorkbenchContextSchema = z33.object({
2627
2678
  currentTokens: Count,
2628
2679
  tokenLimit: Count,
2629
2680
  systemTokens: Count.optional(),
2630
2681
  conversationTokens: Count.optional(),
2631
- toolTokens: Count.optional()
2682
+ toolTokens: Count.optional(),
2683
+ displayLimit: Count.optional(),
2684
+ compactionThreshold: Count.optional()
2685
+ }).strict();
2686
+ var WorkbenchContextSourceSchema = z33.object({
2687
+ id: Id2,
2688
+ kind: Id2,
2689
+ label: z33.string().min(1).max(256),
2690
+ tokens: Count,
2691
+ parentId: Id2.optional()
2692
+ }).strict();
2693
+ var WorkbenchContextSampleSchema = z33.object({
2694
+ id: Id2,
2695
+ timestamp: z33.iso.datetime(),
2696
+ tokens: Count,
2697
+ limit: Count,
2698
+ messages: Count
2632
2699
  }).strict();
2633
- var WorkbenchInsightsSchema = z32.object({
2634
- sampledAt: z32.iso.datetime(),
2700
+ var WorkbenchCompactionSchema = z33.object({
2701
+ id: Id2,
2702
+ timestamp: z33.iso.datetime(),
2703
+ success: z33.boolean(),
2704
+ before: Count.optional(),
2705
+ after: Count.optional(),
2706
+ removed: Count.optional(),
2707
+ messagesRemoved: Count.optional(),
2708
+ trigger: Id2.optional(),
2709
+ basis: Id2.optional(),
2710
+ durationMs: z33.number().finite().nonnegative().optional(),
2711
+ inputTokens: Count.optional(),
2712
+ outputTokens: Count.optional()
2713
+ }).strict();
2714
+ var WorkbenchUsageCallSchema = z33.object({
2715
+ id: Id2,
2716
+ timestamp: z33.iso.datetime(),
2717
+ model: Id2,
2718
+ agentId: Id2.optional(),
2719
+ input: Count.optional(),
2720
+ output: Count.optional(),
2721
+ cache: Count.optional(),
2722
+ requestBytes: Count.optional(),
2723
+ wireBytes: Count.optional(),
2724
+ durationMs: z33.number().finite().nonnegative().optional(),
2725
+ firstOutputMs: z33.number().finite().nonnegative().optional()
2726
+ }).strict();
2727
+ var WorkbenchTelemetrySchema = z33.object({
2728
+ since: z33.iso.datetime(),
2729
+ observedSince: z33.iso.datetime(),
2730
+ dropped: Count,
2731
+ gapSince: z33.iso.datetime().optional(),
2732
+ truncated: z33.boolean(),
2733
+ samples: z33.array(WorkbenchContextSampleSchema).max(120),
2734
+ compactions: z33.array(WorkbenchCompactionSchema).max(40),
2735
+ calls: z33.array(WorkbenchUsageCallSchema).max(120)
2736
+ }).strict();
2737
+ var WorkbenchStorageSchema = z33.object({
2738
+ bytes: Count,
2739
+ files: Count,
2740
+ sampledAt: z33.iso.datetime(),
2741
+ partial: z33.boolean()
2742
+ }).strict();
2743
+ var WorkbenchInsightsSchema = z33.object({
2744
+ sampledAt: z33.iso.datetime(),
2635
2745
  generation: Id2,
2636
2746
  model: Id2.optional(),
2637
2747
  totalUserRequests: Count,
2638
- premiumRequestCost: z32.number().finite().nonnegative(),
2639
- nanoAiu: z32.string().regex(/^\d+$/).max(40).optional(),
2640
- tokens: z32.array(WorkbenchTokenMetricSchema).max(32),
2641
- models: z32.array(WorkbenchModelUsageSchema).max(100),
2748
+ premiumRequestCost: z33.number().finite().nonnegative(),
2749
+ nanoAiu: z33.string().regex(/^\d+$/).max(40).optional(),
2750
+ tokens: z33.array(WorkbenchTokenMetricSchema).max(32),
2751
+ models: z33.array(WorkbenchModelUsageSchema).max(100),
2642
2752
  context: WorkbenchContextSchema.optional(),
2643
- canCompact: z32.boolean(),
2644
- compactUnavailableReason: z32.string().max(1024).optional()
2645
- }).strict();
2646
- var WorkbenchCompactResultSchema = z32.object({
2647
- success: z32.boolean(),
2753
+ canCompact: z33.boolean(),
2754
+ compactUnavailableReason: z33.string().max(1024).optional(),
2755
+ composition: z33.array(WorkbenchTokenMetricSchema).max(8).optional(),
2756
+ sources: z33.array(WorkbenchContextSourceSchema).max(24).optional(),
2757
+ sourcesTruncated: z33.boolean().optional(),
2758
+ heaviestMessages: z33.array(WorkbenchContextSourceSchema).max(10).optional(),
2759
+ compactionCount: Count.optional(),
2760
+ telemetry: WorkbenchTelemetrySchema.optional(),
2761
+ storage: WorkbenchStorageSchema.optional()
2762
+ }).strict();
2763
+ var WorkbenchCompactResultSchema = z33.object({
2764
+ success: z33.boolean(),
2648
2765
  tokensRemoved: Count,
2649
2766
  messagesRemoved: Count
2650
2767
  }).strict();
2768
+ var WORKBENCH_REASONING_PAGE_SIZE = 20;
2769
+ var WORKBENCH_REASONING_TEXT_LIMIT = 5e4;
2770
+ var WorkbenchReasoningRequestSchema = z33.object({
2771
+ cursor: z33.string().min(1).max(8192).optional()
2772
+ }).strict();
2773
+ var WorkbenchReasoningBlockSchema = z33.object({
2774
+ id: Id2,
2775
+ timestamp: z33.iso.datetime(),
2776
+ agentId: Id2.optional(),
2777
+ content: z33.string().max(WORKBENCH_REASONING_TEXT_LIMIT),
2778
+ truncated: z33.boolean()
2779
+ }).strict();
2780
+ var WorkbenchDecisionNodeSchema = WorkbenchReasoningBlockSchema.extend({
2781
+ kind: z33.enum(["rationale", "plan", "tool", "subagent", "response", "compaction"]),
2782
+ title: z33.string().min(1).max(256),
2783
+ status: z33.enum(["recorded", "started", "completed", "failed"])
2784
+ }).strict();
2785
+ var WorkbenchReasoningPageSchema = z33.object({
2786
+ blocks: z33.array(WorkbenchReasoningBlockSchema).max(WORKBENCH_REASONING_PAGE_SIZE),
2787
+ cursor: z33.string().min(1).max(8192),
2788
+ hasMore: z33.boolean(),
2789
+ nodes: z33.array(WorkbenchDecisionNodeSchema).max(WORKBENCH_REASONING_PAGE_SIZE).optional()
2790
+ }).strict();
2651
2791
  var WorkbenchAndroidSchemas = {
2652
2792
  WorkbenchOperationGet: WorkbenchOperationGetSchema,
2653
2793
  WorkbenchOperationStatus: WorkbenchOperationStatusSchema,
@@ -2674,13 +2814,82 @@ var WorkbenchAndroidSchemas = {
2674
2814
  WorkbenchTokenMetric: WorkbenchTokenMetricSchema,
2675
2815
  WorkbenchModelUsage: WorkbenchModelUsageSchema,
2676
2816
  WorkbenchContext: WorkbenchContextSchema,
2817
+ WorkbenchContextSource: WorkbenchContextSourceSchema,
2818
+ WorkbenchContextSample: WorkbenchContextSampleSchema,
2819
+ WorkbenchCompaction: WorkbenchCompactionSchema,
2820
+ WorkbenchUsageCall: WorkbenchUsageCallSchema,
2821
+ WorkbenchTelemetry: WorkbenchTelemetrySchema,
2822
+ WorkbenchStorage: WorkbenchStorageSchema,
2677
2823
  WorkbenchInsights: WorkbenchInsightsSchema,
2678
- WorkbenchCompactResult: WorkbenchCompactResultSchema
2824
+ WorkbenchCompactResult: WorkbenchCompactResultSchema,
2825
+ WorkbenchReasoningRequest: WorkbenchReasoningRequestSchema,
2826
+ WorkbenchReasoningBlock: WorkbenchReasoningBlockSchema,
2827
+ WorkbenchDecisionNode: WorkbenchDecisionNodeSchema,
2828
+ WorkbenchReasoningPage: WorkbenchReasoningPageSchema
2829
+ };
2830
+
2831
+ // ../../shared/protocol/dist/session-analytics.js
2832
+ import { z as z34 } from "zod";
2833
+ var Count2 = z34.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
2834
+ var DateKey = z34.string().regex(/^\d{4}-\d{2}-\d{2}$/u);
2835
+ var SessionAnalyticsRequestSchema = z34.object({
2836
+ since: z34.iso.datetime(),
2837
+ until: z34.iso.datetime(),
2838
+ timeZone: z34.string().min(1).max(128)
2839
+ }).strict();
2840
+ var SessionAnalyticsModelSchema = z34.object({
2841
+ model: z34.string().min(1).max(256),
2842
+ calls: Count2,
2843
+ inputTokens: Count2,
2844
+ outputTokens: Count2,
2845
+ cacheReadTokens: Count2.optional()
2846
+ }).strict();
2847
+ var SessionAnalyticsDaySchema = z34.object({
2848
+ date: DateKey,
2849
+ messages: Count2,
2850
+ models: z34.array(SessionAnalyticsModelSchema).max(256)
2851
+ }).strict();
2852
+ var SessionAnalyticsKeywordSchema = z34.object({
2853
+ term: z34.string().min(2).max(64),
2854
+ messages: Count2
2855
+ }).strict();
2856
+ var SessionAnalyticsUserDaySchema = z34.object({
2857
+ date: DateKey,
2858
+ messages: Count2,
2859
+ keywords: z34.array(SessionAnalyticsKeywordSchema).max(48),
2860
+ keywordsTruncated: z34.boolean()
2861
+ }).strict();
2862
+ var SessionAnalyticsCoverageSchema = z34.object({
2863
+ recordingStartedAt: z34.iso.datetime(),
2864
+ usageObservedSince: z34.iso.datetime(),
2865
+ historyIndexedAt: z34.iso.datetime().optional(),
2866
+ droppedEvents: Count2,
2867
+ usageSource: z34.literal("observed")
2868
+ }).strict();
2869
+ var SessionAnalyticsResultSchema = z34.object({
2870
+ sampledAt: z34.iso.datetime(),
2871
+ days: z34.array(SessionAnalyticsDaySchema).max(9),
2872
+ historyTruncated: z34.boolean(),
2873
+ usageTruncated: z34.boolean(),
2874
+ skills: z34.array(SessionSkillInfoSchema).max(512).optional(),
2875
+ skillsSampledAt: z34.iso.datetime().optional(),
2876
+ userActivity: z34.array(SessionAnalyticsUserDaySchema).max(9).optional(),
2877
+ coverage: SessionAnalyticsCoverageSchema.optional()
2878
+ }).strict();
2879
+ var SessionAnalyticsAndroidSchemas = {
2880
+ SessionAnalyticsRequest: SessionAnalyticsRequestSchema,
2881
+ SessionAnalyticsModel: SessionAnalyticsModelSchema,
2882
+ SessionAnalyticsDay: SessionAnalyticsDaySchema,
2883
+ SessionAnalyticsResult: SessionAnalyticsResultSchema,
2884
+ SessionAnalyticsSkill: SessionSkillInfoSchema,
2885
+ SessionAnalyticsKeyword: SessionAnalyticsKeywordSchema,
2886
+ SessionAnalyticsUserDay: SessionAnalyticsUserDaySchema,
2887
+ SessionAnalyticsCoverage: SessionAnalyticsCoverageSchema
2679
2888
  };
2680
2889
 
2681
2890
  // ../../shared/protocol/dist/microsoft-todo.js
2682
- import { z as z33 } from "zod";
2683
- var MicrosoftTodoOperationSchema = z33.enum([
2891
+ import { z as z35 } from "zod";
2892
+ var MicrosoftTodoOperationSchema = z35.enum([
2684
2893
  "status",
2685
2894
  "connect",
2686
2895
  "disconnect",
@@ -2695,66 +2904,66 @@ var MicrosoftTodoOperationSchema = z33.enum([
2695
2904
  "update_task",
2696
2905
  "delete_task"
2697
2906
  ]);
2698
- var MicrosoftTodoIdSchema = z33.string().min(1).max(1024).regex(/^[A-Za-z0-9_/=+-]+$/);
2699
- var MicrosoftTodoDateTimeSchema = z33.object({
2700
- dateTime: z33.string().min(1).max(64).regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,7})?$/),
2701
- timeZone: z33.string().min(1).max(128)
2907
+ var MicrosoftTodoIdSchema = z35.string().min(1).max(1024).regex(/^[A-Za-z0-9_/=+-]+$/);
2908
+ var MicrosoftTodoDateTimeSchema = z35.object({
2909
+ dateTime: z35.string().min(1).max(64).regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,7})?$/),
2910
+ timeZone: z35.string().min(1).max(128)
2702
2911
  }).strict();
2703
- var MicrosoftTodoTaskInputSchema = z33.object({
2704
- title: z33.string().trim().min(1).max(1e3).optional(),
2705
- body: z33.object({
2706
- content: z33.string().max(16e3),
2707
- contentType: z33.literal("text")
2912
+ var MicrosoftTodoTaskInputSchema = z35.object({
2913
+ title: z35.string().trim().min(1).max(1e3).optional(),
2914
+ body: z35.object({
2915
+ content: z35.string().max(16e3),
2916
+ contentType: z35.literal("text")
2708
2917
  }).strict().optional(),
2709
- status: z33.enum(["notStarted", "inProgress", "completed", "waitingOnOthers", "deferred"]).optional(),
2710
- importance: z33.enum(["low", "normal", "high"]).optional(),
2918
+ status: z35.enum(["notStarted", "inProgress", "completed", "waitingOnOthers", "deferred"]).optional(),
2919
+ importance: z35.enum(["low", "normal", "high"]).optional(),
2711
2920
  dueDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
2712
2921
  reminderDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
2713
- isReminderOn: z33.boolean().optional()
2922
+ isReminderOn: z35.boolean().optional()
2714
2923
  }).strict();
2715
- var MicrosoftTodoListInputSchema = z33.object({
2716
- displayName: z33.string().trim().min(1).max(255)
2924
+ var MicrosoftTodoListInputSchema = z35.object({
2925
+ displayName: z35.string().trim().min(1).max(255)
2717
2926
  }).strict();
2718
- var MicrosoftTodoRequestSchema = z33.object({
2927
+ var MicrosoftTodoRequestSchema = z35.object({
2719
2928
  operation: MicrosoftTodoOperationSchema,
2720
2929
  listId: MicrosoftTodoIdSchema.optional(),
2721
2930
  taskId: MicrosoftTodoIdSchema.optional(),
2722
2931
  list: MicrosoftTodoListInputSchema.optional(),
2723
2932
  task: MicrosoftTodoTaskInputSchema.optional(),
2724
- cursor: z33.string().min(1).max(8192).optional(),
2725
- etag: z33.string().min(1).max(512).regex(/^[^\r\n]+$/).optional()
2933
+ cursor: z35.string().min(1).max(8192).optional(),
2934
+ etag: z35.string().min(1).max(512).regex(/^[^\r\n]+$/).optional()
2726
2935
  }).strict();
2727
- var MicrosoftTodoListSchema = z33.object({
2936
+ var MicrosoftTodoListSchema = z35.object({
2728
2937
  id: MicrosoftTodoIdSchema,
2729
- displayName: z33.string().max(1e3),
2730
- isOwner: z33.boolean(),
2731
- isShared: z33.boolean(),
2732
- wellknownListName: z33.string().max(128),
2733
- etag: z33.string().max(512).optional()
2938
+ displayName: z35.string().max(1e3),
2939
+ isOwner: z35.boolean(),
2940
+ isShared: z35.boolean(),
2941
+ wellknownListName: z35.string().max(128),
2942
+ etag: z35.string().max(512).optional()
2734
2943
  }).strict();
2735
- var MicrosoftTodoTaskSchema = z33.object({
2944
+ var MicrosoftTodoTaskSchema = z35.object({
2736
2945
  id: MicrosoftTodoIdSchema,
2737
- title: z33.string().max(1e3),
2738
- body: z33.object({ content: z33.string().max(16e3), contentType: z33.string().max(32) }).strict(),
2739
- status: z33.string().max(64),
2740
- importance: z33.string().max(32),
2946
+ title: z35.string().max(1e3),
2947
+ body: z35.object({ content: z35.string().max(16e3), contentType: z35.string().max(32) }).strict(),
2948
+ status: z35.string().max(64),
2949
+ importance: z35.string().max(32),
2741
2950
  dueDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
2742
2951
  reminderDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
2743
- isReminderOn: z33.boolean(),
2744
- lastModifiedDateTime: z33.string().max(64),
2745
- etag: z33.string().max(512).optional()
2746
- }).strict();
2747
- var MicrosoftTodoResultSchema = z33.object({
2748
- ok: z33.literal(true),
2749
- enabled: z33.boolean(),
2750
- connected: z33.boolean(),
2751
- authorizationUrl: z33.url().optional(),
2752
- lists: z33.array(MicrosoftTodoListSchema).max(100).optional(),
2952
+ isReminderOn: z35.boolean(),
2953
+ lastModifiedDateTime: z35.string().max(64),
2954
+ etag: z35.string().max(512).optional()
2955
+ }).strict();
2956
+ var MicrosoftTodoResultSchema = z35.object({
2957
+ ok: z35.literal(true),
2958
+ enabled: z35.boolean(),
2959
+ connected: z35.boolean(),
2960
+ authorizationUrl: z35.url().optional(),
2961
+ lists: z35.array(MicrosoftTodoListSchema).max(100).optional(),
2753
2962
  list: MicrosoftTodoListSchema.optional(),
2754
- tasks: z33.array(MicrosoftTodoTaskSchema).max(100).optional(),
2963
+ tasks: z35.array(MicrosoftTodoTaskSchema).max(100).optional(),
2755
2964
  task: MicrosoftTodoTaskSchema.optional(),
2756
- nextCursor: z33.string().max(8192).optional(),
2757
- deleted: z33.boolean().optional()
2965
+ nextCursor: z35.string().max(8192).optional(),
2966
+ deleted: z35.boolean().optional()
2758
2967
  }).strict();
2759
2968
  var MicrosoftTodoAndroidSchemas = {
2760
2969
  MicrosoftTodoDateTime: MicrosoftTodoDateTimeSchema,
@@ -2767,15 +2976,144 @@ var MicrosoftTodoAndroidSchemas = {
2767
2976
  };
2768
2977
 
2769
2978
  // ../../shared/protocol/dist/relay-features.js
2770
- import { z as z34 } from "zod";
2771
- var RelayFeaturesSchema = z34.object({
2772
- microsoftTodo: z34.boolean(),
2773
- modelGateway: z34.boolean(),
2774
- sessionImages: z34.boolean(),
2775
- webClient: z34.boolean()
2979
+ import { z as z36 } from "zod";
2980
+ var RelayFeaturesSchema = z36.object({
2981
+ microsoftTodo: z36.boolean(),
2982
+ modelGateway: z36.boolean(),
2983
+ sessionImages: z36.boolean(),
2984
+ webClient: z36.boolean()
2776
2985
  }).strict();
2777
2986
  var RelayFeatureAndroidSchemas = { RelayFeatures: RelayFeaturesSchema };
2778
2987
 
2988
+ // ../../shared/protocol/dist/web-copilot.js
2989
+ import { z as z37 } from "zod";
2990
+ var secret = z37.string().min(1).max(16384).regex(/^[^\s]+$/);
2991
+ var WebModelReasoningSchema = z37.enum(["minimal", "low", "medium", "high", "xhigh", "max"]);
2992
+ var WebModelImageSchema = z37.object({
2993
+ type: z37.literal("image_url"),
2994
+ image_url: z37.object({ url: z37.string().max(6e5).regex(/^data:image\/(?:png|jpeg|webp);base64,[A-Za-z0-9+/]+={0,2}$/) }).strict()
2995
+ }).strict();
2996
+ var WebModelUserContentSchema = z37.union([
2997
+ z37.string().max(2e5),
2998
+ z37.array(z37.union([
2999
+ z37.object({ type: z37.literal("text"), text: z37.string().max(2e5) }).strict(),
3000
+ WebModelImageSchema
3001
+ ])).min(1).max(5)
3002
+ ]);
3003
+ var ToolCallSchema = z37.object({
3004
+ id: z37.string().min(1).max(256),
3005
+ type: z37.literal("function"),
3006
+ function: z37.object({ name: z37.string().min(1).max(256), arguments: z37.string().max(8e3) }).strict()
3007
+ }).strict();
3008
+ var WebCopilotCompletionSchema = z37.object({
3009
+ messages: z37.array(z37.union([
3010
+ z37.object({ role: z37.literal("system"), content: z37.string().max(2e5) }).strict(),
3011
+ z37.object({ role: z37.literal("user"), content: WebModelUserContentSchema }).strict(),
3012
+ z37.object({
3013
+ role: z37.literal("assistant"),
3014
+ content: z37.string().max(2e5).nullable().optional(),
3015
+ tool_calls: z37.array(ToolCallSchema).min(1).max(16).optional()
3016
+ }).strict(),
3017
+ z37.object({ role: z37.literal("tool"), content: z37.string().max(2e5), tool_call_id: z37.string().min(1).max(256) }).strict()
3018
+ ])).min(1).max(512),
3019
+ tools: z37.array(z37.object({
3020
+ type: z37.literal("function"),
3021
+ function: z37.object({
3022
+ name: z37.string().min(1).max(256),
3023
+ description: z37.string().max(4e3),
3024
+ parameters: z37.record(z37.string(), z37.unknown())
3025
+ }).strict()
3026
+ }).strict()).min(1).max(32).optional(),
3027
+ reasoning_effort: WebModelReasoningSchema.optional(),
3028
+ stream: z37.literal(false)
3029
+ }).strict();
3030
+ var WebCopilotActionSchema = z37.discriminatedUnion("action", [
3031
+ z37.object({ action: z37.literal("status") }).strict(),
3032
+ z37.object({ action: z37.literal("start") }).strict(),
3033
+ z37.object({ action: z37.literal("poll"), deviceCode: secret }).strict(),
3034
+ z37.object({ action: z37.literal("models"), token: secret }).strict(),
3035
+ z37.object({
3036
+ action: z37.literal("complete"),
3037
+ token: secret,
3038
+ model: z37.string().min(1).max(256),
3039
+ request: WebCopilotCompletionSchema
3040
+ }).strict()
3041
+ ]);
3042
+ var WebCopilotRequestSchema = z37.object({
3043
+ mobileCredential: z37.string().min(64).max(8192),
3044
+ clientId: z37.string().min(1).max(256),
3045
+ proof: MobileIdentityProofSchema,
3046
+ request: WebCopilotActionSchema
3047
+ }).strict();
3048
+ var WebCopilotDeviceSchema = z37.object({
3049
+ deviceCode: secret,
3050
+ userCode: z37.string().regex(/^[A-Z0-9]{4}-[A-Z0-9]{4}$/),
3051
+ verificationUri: z37.literal("https://github.com/login/device"),
3052
+ expiresIn: z37.number().int().positive().max(86400),
3053
+ interval: z37.number().int().positive().max(300)
3054
+ });
3055
+ var WebCopilotPollSchema = z37.discriminatedUnion("state", [
3056
+ z37.object({ state: z37.literal("pending") }),
3057
+ z37.object({ state: z37.literal("slow_down"), interval: z37.number().int().positive().max(300).optional() }),
3058
+ z37.object({ state: z37.literal("complete"), token: secret })
3059
+ ]);
3060
+ var WebCopilotModelSchema = z37.object({
3061
+ id: z37.string().min(1).max(256),
3062
+ name: z37.string().min(1).max(256),
3063
+ api: z37.enum(["chat", "responses"]).optional(),
3064
+ // Older Relays advertised only tool-capable, text-only chat models.
3065
+ supportsTools: z37.boolean().optional(),
3066
+ supportsImages: z37.boolean().optional(),
3067
+ reasoningEfforts: z37.array(WebModelReasoningSchema).max(6).optional()
3068
+ });
3069
+ var WebCopilotModelsSchema = z37.object({ models: z37.array(WebCopilotModelSchema).max(512) });
3070
+
3071
+ // ../../shared/protocol/dist/web-research.js
3072
+ import { z as z38 } from "zod";
3073
+ var text = (max) => z38.string().trim().min(1).max(max).regex(/^[^\u0000-\u001f\u007f]+$/u);
3074
+ var WebResearchActionSchema = z38.discriminatedUnion("action", [
3075
+ z38.object({ action: z38.literal("status") }).strict(),
3076
+ z38.object({ action: z38.literal("search"), query: text(300), kind: z38.enum(["web", "news", "code"]) }).strict(),
3077
+ z38.object({
3078
+ action: z38.literal("github"),
3079
+ repository: text(200).regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/u).refine((value) => value.split("/").every((part) => part !== "." && part !== "..")),
3080
+ path: text(1024).refine((value) => !value.includes("\\") && value.split("/").every((part) => part !== "." && part !== "..")).optional(),
3081
+ ref: text(200).optional()
3082
+ }).strict()
3083
+ ]);
3084
+ var WebResearchRequestSchema = z38.object({
3085
+ clientId: z38.string().min(1).max(256),
3086
+ mobileCredential: z38.string().min(64).max(8192),
3087
+ proof: MobileIdentityProofSchema,
3088
+ request: WebResearchActionSchema
3089
+ }).strict();
3090
+ var WebResearchSourceSchema = z38.object({
3091
+ title: z38.string().max(500),
3092
+ url: z38.string().url().max(4096),
3093
+ publishedAt: z38.string().optional(),
3094
+ snippet: z38.string().max(2e3).optional()
3095
+ });
3096
+ var WebResearchResultSchema = z38.discriminatedUnion("kind", [
3097
+ z38.object({
3098
+ kind: z38.literal("search"),
3099
+ provider: z38.string(),
3100
+ retrievedAt: z38.string(),
3101
+ coverage: z38.string(),
3102
+ results: z38.array(WebResearchSourceSchema).max(10)
3103
+ }),
3104
+ z38.object({
3105
+ kind: z38.literal("github"),
3106
+ repository: z38.string(),
3107
+ path: z38.string(),
3108
+ results: z38.array(WebResearchSourceSchema).length(1),
3109
+ coverage: z38.string(),
3110
+ entries: z38.array(z38.object({ name: z38.string(), path: z38.string(), type: z38.string(), sha: z38.string() })).max(50).optional(),
3111
+ content: z38.string().max(16e3).optional(),
3112
+ sha: z38.string().optional(),
3113
+ truncated: z38.boolean()
3114
+ })
3115
+ ]);
3116
+
2779
3117
  // ../../shared/protocol/dist/codegen/android-schemas.js
2780
3118
  var AndroidProtocolSchemas = {
2781
3119
  SessionImageStorage: SessionImageStorageSchema,
@@ -2795,6 +3133,7 @@ var AndroidProtocolSchemas = {
2795
3133
  SessionImageCommitResult: SessionImageCommitResultSchema,
2796
3134
  SessionImageDownloadResult: SessionImageDownloadResultSchema,
2797
3135
  ...WorkbenchAndroidSchemas,
3136
+ ...SessionAnalyticsAndroidSchemas,
2798
3137
  ...ScheduleAndroidSchemas,
2799
3138
  ...MicrosoftTodoAndroidSchemas,
2800
3139
  ...RelayFeatureAndroidSchemas,
@@ -2849,6 +3188,9 @@ var AndroidProtocolSchemas = {
2849
3188
  GroupChatInfo: GroupChatInfoSchema,
2850
3189
  GroupChatCreateData: GroupChatCreateDataSchema,
2851
3190
  GroupChatCreateResultData: GroupChatCreateResultDataSchema,
3191
+ EncryptedPeerAuthorization: EncryptedPeerAuthorizationSchema,
3192
+ EncryptedPeerAuthorizationResult: EncryptedPeerAuthorizationResultSchema,
3193
+ EncryptedGroupCreate: EncryptedGroupCreateSchema,
2852
3194
  SessionsSnapshot: SessionsSnapshotSchema,
2853
3195
  SessionListRequest: SessionListRequestSchema,
2854
3196
  SessionListResult: SessionListResultSchema,