@agentknight/client 0.9.52 → 0.9.55

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.
@@ -1249,33 +1249,46 @@ var BrowserOpenUrlParamsSchema = z18.strictObject({
1249
1249
  });
1250
1250
  var BrowserOpenUrlResultSchema = z18.strictObject({ opened: z18.literal(true) });
1251
1251
 
1252
- // ../../shared/protocol/dist/sessions/session-communication.js
1252
+ // ../../shared/protocol/dist/transport/device-text-input.js
1253
1253
  import { z as z19 } from "zod";
1254
- var SessionCommunicationIdSchema = z19.string().min(1).max(256).refine((value) => value === value.trim(), "Expected an unpadded identity");
1254
+ 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()
1263
+ }).strict().refine((result) => (!result.pasteAttempted || result.clipboardUpdated) && (!result.pasteShortcutSent || result.pasteAttempted));
1264
+
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");
1255
1268
  var SessionCommunicationIdentityShape = {
1256
1269
  requestId: SessionCommunicationIdSchema,
1257
1270
  machineId: SessionCommunicationIdSchema,
1258
1271
  sessionId: SessionCommunicationIdSchema,
1259
- operation: z19.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/u),
1260
- version: z19.number().int().positive().max(2147483647)
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)
1261
1274
  };
1262
- var SessionCommunicationDataSchema = z19.record(z19.string(), z19.json());
1263
- var SessionCommunicationRequestSchema = z19.object({
1275
+ var SessionCommunicationDataSchema = z20.record(z20.string(), z20.json());
1276
+ var SessionCommunicationRequestSchema = z20.object({
1264
1277
  ...SessionCommunicationIdentityShape,
1265
- kind: z19.literal("request"),
1278
+ kind: z20.literal("request"),
1266
1279
  data: SessionCommunicationDataSchema
1267
1280
  }).strict();
1268
- var SessionCommunicationResponseSchema = z19.object({
1281
+ var SessionCommunicationResponseSchema = z20.object({
1269
1282
  ...SessionCommunicationIdentityShape,
1270
- kind: z19.literal("response"),
1283
+ kind: z20.literal("response"),
1271
1284
  data: SessionCommunicationDataSchema
1272
1285
  }).strict();
1273
- var SessionCommunicationErrorSchema = z19.object({
1286
+ var SessionCommunicationErrorSchema = z20.object({
1274
1287
  ...SessionCommunicationIdentityShape,
1275
- kind: z19.literal("error"),
1288
+ kind: z20.literal("error"),
1276
1289
  error: ProtocolFailureSchema
1277
1290
  }).strict();
1278
- var SessionCommunicationSchema = z19.discriminatedUnion("kind", [
1291
+ var SessionCommunicationSchema = z20.discriminatedUnion("kind", [
1279
1292
  SessionCommunicationRequestSchema,
1280
1293
  SessionCommunicationResponseSchema,
1281
1294
  SessionCommunicationErrorSchema
@@ -1285,7 +1298,7 @@ function sessionCommunicationOperationCapability(operation, version) {
1285
1298
  }
1286
1299
 
1287
1300
  // ../../shared/protocol/dist/sessions/session-workspace.js
1288
- import { z as z20 } from "zod";
1301
+ import { z as z21 } from "zod";
1289
1302
  var SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH = 32768;
1290
1303
  var SESSION_PROJECT_IDENTITY_MAX_RESPONSE_BYTES = 640 * 1024;
1291
1304
  var SESSION_DIRECTORY_MAX_PATH_LENGTH = 1024;
@@ -1326,47 +1339,47 @@ function isSafeSessionDirectoryPath(path) {
1326
1339
  const segments = path.split("/");
1327
1340
  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));
1328
1341
  }
1329
- var SessionDirectoryListRequestSchema = z20.object({
1342
+ var SessionDirectoryListRequestSchema = z21.object({
1330
1343
  requestId: IdSchema,
1331
1344
  machineId: IdSchema,
1332
1345
  sessionId: IdSchema,
1333
- path: z20.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH)
1346
+ path: z21.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH)
1334
1347
  }).strict();
1335
- var SessionDirectoryEntrySchema = z20.object({
1336
- name: z20.string().min(1).max(255),
1337
- kind: z20.enum(["directory", "file", "blocked"])
1348
+ var SessionDirectoryEntrySchema = z21.object({
1349
+ name: z21.string().min(1).max(255),
1350
+ kind: z21.enum(["directory", "file", "blocked"])
1338
1351
  }).strict();
1339
1352
  var SessionDirectoryListDataSchema = SessionDirectoryListRequestSchema.pick({ path: true });
1340
- var SessionDirectoryListResultDataSchema = z20.object({
1341
- path: z20.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH),
1342
- rootRevision: z20.string().min(1).max(128),
1343
- entries: z20.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES)
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)
1344
1357
  }).strict();
1345
1358
  var SessionDirectoryListResponseSchema = SessionDirectoryListRequestSchema.extend({
1346
- rootRevision: z20.string().min(1).max(128).optional(),
1347
- entries: z20.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES).optional(),
1359
+ rootRevision: z21.string().min(1).max(128).optional(),
1360
+ entries: z21.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES).optional(),
1348
1361
  error: ProtocolFailureSchema.optional()
1349
1362
  }).superRefine((response, context) => {
1350
1363
  if (response.error === void 0 ? response.entries === void 0 || response.rootRevision === void 0 : response.entries !== void 0 || response.rootRevision !== void 0) {
1351
1364
  context.addIssue({ code: "custom", message: "Expected directory success or failure" });
1352
1365
  }
1353
1366
  });
1354
- var SessionFileReadDataSchema = z20.object({
1355
- path: z20.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
1356
- rootRevision: z20.string().regex(/^[A-Za-z0-9_-]{43}$/u)
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)
1357
1370
  }).strict();
1358
1371
  function fileResultSchema(mediaTypes, extended) {
1359
1372
  const maxOriginal = extended ? SESSION_FILE_V2_MAX_ORIGINAL_BYTES : SESSION_FILE_MAX_ORIGINAL_BYTES;
1360
1373
  const maxTransfer = extended ? SESSION_FILE_V2_MAX_TRANSFER_BYTES : SESSION_FILE_MAX_TRANSFER_BYTES;
1361
- return z20.object({
1374
+ return z21.object({
1362
1375
  path: SessionFileReadDataSchema.shape.path,
1363
1376
  rootRevision: SessionFileReadDataSchema.shape.rootRevision,
1364
- mediaType: z20.enum(mediaTypes),
1365
- originalByteLength: z20.number().int().min(0).max(maxOriginal),
1377
+ mediaType: z21.enum(mediaTypes),
1378
+ originalByteLength: z21.number().int().min(0).max(maxOriginal),
1366
1379
  // Canonical length after decompression, not the length of the transport bytes.
1367
- byteLength: z20.number().int().min(0).max(maxOriginal),
1368
- encoding: z20.enum(["identity", "gzip"]),
1369
- data: z20.string().max(extended ? SESSION_FILE_V2_MAX_BASE64_LENGTH : SESSION_FILE_MAX_BASE64_LENGTH)
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)
1370
1383
  }).strict().superRefine((result, context) => {
1371
1384
  const invalid = () => context.addIssue({ code: "custom", message: "Invalid file content" });
1372
1385
  if (result.encoding === "gzip" !== result.originalByteLength >= SESSION_FILE_GZIP_THRESHOLD_BYTES)
@@ -1386,19 +1399,19 @@ var SessionFileReadResultDataSchema = fileResultSchema(SESSION_FILE_MEDIA_TYPES,
1386
1399
  var SessionFileReadV2ResultDataSchema = fileResultSchema(SESSION_FILE_V2_MEDIA_TYPES, true);
1387
1400
  var SessionFileDownloadDataSchema = SessionFileReadDataSchema;
1388
1401
  var SessionFileDownloadResultDataSchema = fileResultSchema(["application/octet-stream"], true);
1389
- var SessionGitProjectSchema = z20.object({
1390
- localRepositoryKey: z20.string().length(43).regex(/^[A-Za-z0-9_-]{43}$/),
1391
- worktreeRoot: z20.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH),
1392
- mainWorktreeRoot: z20.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional(),
1393
- gitRemoteUrl: z20.string().max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional()
1394
- }).strict();
1395
- var SessionProjectIdentityRequestDataSchema = z20.object({}).strict();
1396
- var SessionProjectIdentityResultDataSchema = z20.object({
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({
1397
1410
  project: SessionGitProjectSchema.optional()
1398
1411
  }).strict();
1399
1412
 
1400
1413
  // ../../shared/protocol/dist/sessions/session-git-diff.js
1401
- import { z as z21 } from "zod";
1414
+ import { z as z22 } from "zod";
1402
1415
  var SESSION_GIT_DIFF_GZIP_MIN_BYTES = 2 * 1024;
1403
1416
  var SESSION_GIT_DIFF_MAX_FILES = 500;
1404
1417
  var SESSION_GIT_DIFF_MAX_PATCH_BYTES = 128 * 1024;
@@ -1406,24 +1419,24 @@ var SESSION_GIT_DIFF_MAX_RESPONSE_BYTES = 512 * 1024;
1406
1419
  var SESSION_GIT_DIFF_MAX_TRANSFER_BYTES = SESSION_GIT_DIFF_MAX_RESPONSE_BYTES + 1024;
1407
1420
  var SESSION_GIT_DIFF_MAX_BASE64_LENGTH = Math.ceil(SESSION_GIT_DIFF_MAX_TRANSFER_BYTES / 3) * 4;
1408
1421
  var SESSION_GIT_DIFF_MAX_GZIP_RESPONSE_BYTES = SESSION_GIT_DIFF_MAX_BASE64_LENGTH + 1024;
1409
- var commitSchema = z21.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u);
1410
- var SessionGitDiffDataSchema = z21.object({
1422
+ var commitSchema = z22.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u);
1423
+ var SessionGitDiffDataSchema = z22.object({
1411
1424
  rootRevision: SessionFileReadDataSchema.shape.rootRevision,
1412
1425
  path: SessionFileReadDataSchema.shape.path.optional(),
1413
1426
  baseCommit: commitSchema.optional()
1414
1427
  }).strict().refine((value) => value.path === void 0 === (value.baseCommit === void 0), "A file diff must identify its listed base commit");
1415
- var SessionGitDiffEntrySchema = z21.object({
1428
+ var SessionGitDiffEntrySchema = z22.object({
1416
1429
  path: SessionFileReadDataSchema.shape.path,
1417
- status: z21.enum(["added", "modified", "deleted", "untracked"])
1430
+ status: z22.enum(["added", "modified", "deleted", "untracked"])
1418
1431
  }).strict();
1419
- var SessionGitDiffResultDataSchema = z21.object({
1432
+ var SessionGitDiffResultDataSchema = z22.object({
1420
1433
  rootRevision: SessionFileReadDataSchema.shape.rootRevision,
1421
- baseRef: z21.enum(["origin/main", "main"]),
1434
+ baseRef: z22.enum(["origin/main", "main"]),
1422
1435
  baseCommit: commitSchema,
1423
- files: z21.array(SessionGitDiffEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional(),
1436
+ files: z22.array(SessionGitDiffEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional(),
1424
1437
  path: SessionFileReadDataSchema.shape.path.optional(),
1425
- patch: z21.string().max(SESSION_GIT_DIFF_MAX_PATCH_BYTES).optional(),
1426
- binary: z21.boolean().optional()
1438
+ patch: z22.string().max(SESSION_GIT_DIFF_MAX_PATCH_BYTES).optional(),
1439
+ binary: z22.boolean().optional()
1427
1440
  }).strict().superRefine((value, context) => {
1428
1441
  const encoder = new TextEncoder();
1429
1442
  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) {
@@ -1437,13 +1450,13 @@ var SessionGitDiffResultDataSchema = z21.object({
1437
1450
  context.addIssue({ code: "custom", message: "Expected a text patch or an explicit binary change" });
1438
1451
  }
1439
1452
  });
1440
- var SessionGitDiffFileErrorSchema = z21.object({
1441
- code: z21.enum(["DIFF_BLOCKED", "DIFF_FILE_UNAVAILABLE"]),
1442
- message: z21.string().min(1).max(512)
1453
+ var SessionGitDiffFileErrorSchema = z22.object({
1454
+ code: z22.enum(["DIFF_BLOCKED", "DIFF_FILE_UNAVAILABLE"]),
1455
+ message: z22.string().min(1).max(512)
1443
1456
  }).strict();
1444
1457
  var SessionGitDiffPartialEntrySchema = SessionGitDiffEntrySchema.extend({
1445
1458
  // Error paths are display-only: they must never be used for file requests.
1446
- path: z21.string().min(1).max(32768).refine((value) => !value.includes("\0")),
1459
+ path: z22.string().min(1).max(32768).refine((value) => !value.includes("\0")),
1447
1460
  error: SessionGitDiffFileErrorSchema.optional()
1448
1461
  }).superRefine((value, context) => {
1449
1462
  if (value.error === void 0 && !SessionGitDiffEntrySchema.shape.path.safeParse(value.path).success) {
@@ -1451,12 +1464,12 @@ var SessionGitDiffPartialEntrySchema = SessionGitDiffEntrySchema.extend({
1451
1464
  }
1452
1465
  });
1453
1466
  var SessionGitDiffPartialResultDataSchema = SessionGitDiffResultDataSchema.safeExtend({
1454
- files: z21.array(SessionGitDiffPartialEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional()
1467
+ files: z22.array(SessionGitDiffPartialEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional()
1455
1468
  });
1456
- var SessionGitDiffGzipResultDataSchema = z21.object({
1457
- encoding: z21.literal("gzip"),
1458
- byteLength: z21.number().int().min(1).max(SESSION_GIT_DIFF_MAX_RESPONSE_BYTES),
1459
- data: z21.string().max(SESSION_GIT_DIFF_MAX_BASE64_LENGTH).regex(/^[A-Za-z0-9+/]*={0,2}$/u)
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)
1460
1473
  }).strict().superRefine((value, context) => {
1461
1474
  const padding = value.data.endsWith("==") ? 2 : value.data.endsWith("=") ? 1 : 0;
1462
1475
  const bytes = value.data.length / 4 * 3 - padding;
@@ -1466,13 +1479,13 @@ var SessionGitDiffGzipResultDataSchema = z21.object({
1466
1479
  context.addIssue({ code: "custom", message: "Invalid gzip transfer" });
1467
1480
  }
1468
1481
  });
1469
- var SessionGitDiffV2ResultDataSchema = z21.union([
1482
+ var SessionGitDiffV2ResultDataSchema = z22.union([
1470
1483
  SessionGitDiffResultDataSchema,
1471
1484
  SessionGitDiffGzipResultDataSchema
1472
1485
  ]);
1473
1486
 
1474
1487
  // ../../shared/protocol/dist/sessions/session-resource.js
1475
- import { z as z22 } from "zod";
1488
+ import { z as z23 } from "zod";
1476
1489
  var SESSION_RESOURCE_MAX_ORIGINAL_BYTES = 499999;
1477
1490
  var SESSION_RESOURCE_GZIP_THRESHOLD_BYTES = 20 * 1024;
1478
1491
  var SESSION_RESOURCE_MAX_IMAGE_PIXELS = 16 * 1024 * 1024;
@@ -1486,18 +1499,18 @@ var SESSION_RESOURCE_MEDIA_TYPES = [
1486
1499
  "text/css",
1487
1500
  "text/javascript"
1488
1501
  ];
1489
- var SessionResourceReadDataSchema = z22.object({
1490
- path: z22.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
1491
- rootRevision: z22.string().regex(/^[A-Za-z0-9_-]{43}$/u)
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)
1492
1505
  }).strict();
1493
- var SessionResourceReadResultDataSchema = z22.object({
1506
+ var SessionResourceReadResultDataSchema = z23.object({
1494
1507
  path: SessionResourceReadDataSchema.shape.path,
1495
1508
  rootRevision: SessionResourceReadDataSchema.shape.rootRevision,
1496
- mediaType: z22.enum(SESSION_RESOURCE_MEDIA_TYPES),
1497
- originalByteLength: z22.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
1498
- byteLength: z22.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
1499
- encoding: z22.enum(["identity", "gzip"]),
1500
- data: z22.string().max(SESSION_RESOURCE_MAX_BASE64_LENGTH)
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)
1501
1514
  }).strict().superRefine((result, context) => {
1502
1515
  const invalid = () => context.addIssue({ code: "custom", message: "Invalid resource content" });
1503
1516
  if (result.encoding === "gzip" !== result.originalByteLength >= SESSION_RESOURCE_GZIP_THRESHOLD_BYTES || result.byteLength !== result.originalByteLength || result.mediaType.startsWith("image/") && result.byteLength === 0)
@@ -1510,114 +1523,114 @@ var SessionResourceReadResultDataSchema = z22.object({
1510
1523
  });
1511
1524
 
1512
1525
  // ../../shared/protocol/dist/sessions/session-images.js
1513
- import { z as z23 } from "zod";
1526
+ import { z as z24 } from "zod";
1514
1527
  var SESSION_IMAGE_MAX_BYTES = 3 * 1024 * 1024;
1515
1528
  var SESSION_IMAGE_MAX_PIXELS = 16 * 1024 * 1024;
1516
- var SessionImageIdSchema = z23.uuid();
1517
- var DirectUrlSchema = z23.string().regex(/^https:\/\/[^/?#@\\\s\x00-\x1f\x7f]+(?:[/?][^#\\\s\x00-\x1f\x7f]*)?$/u).refine((raw) => {
1529
+ var SessionImageIdSchema = z24.uuid();
1530
+ var DirectUrlSchema = z24.string().regex(/^https:\/\/[^/?#@\\\s\x00-\x1f\x7f]+(?:[/?][^#\\\s\x00-\x1f\x7f]*)?$/u).refine((raw) => {
1518
1531
  if (!URL.canParse(raw))
1519
1532
  return false;
1520
1533
  const url = new URL(raw);
1521
1534
  return url.protocol === "https:" && url.username === "" && url.password === "" && url.hash === "";
1522
1535
  }, "Direct transfers require HTTPS without userinfo, fragments or unsafe characters");
1523
- var ProxyUrlSchema = z23.string().regex(/^\/api\/v3\/session-images\/[0-9a-f-]+\/content\?[^#\\\s\x00-\x1f\x7f]+$/u);
1524
- var SessionImageTransferHeadersSchema = z23.record(z23.string().regex(/^(?:content-type|if-none-match|x-ms-blob-type)$/u), z23.string().min(1).max(256).regex(/^[\x20-\x7e]+$/u));
1525
- var SessionImageUploadRequestSchema = z23.object({
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({
1526
1539
  machineId: IdSchema,
1527
1540
  sessionId: IdSchema,
1528
- sizeBytes: z23.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES)
1541
+ sizeBytes: z24.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES)
1529
1542
  }).strict();
1530
- var SessionImageScopeSchema = z23.object({
1543
+ var SessionImageScopeSchema = z24.object({
1531
1544
  machineId: IdSchema,
1532
1545
  sessionId: IdSchema
1533
1546
  }).strict();
1534
1547
  var UploadResultFields = {
1535
1548
  imageId: SessionImageIdSchema,
1536
- uploadExpiresAt: z23.number().int().positive(),
1537
- method: z23.literal("PUT"),
1538
- contentType: z23.literal("image/webp"),
1549
+ uploadExpiresAt: z24.number().int().positive(),
1550
+ method: z24.literal("PUT"),
1551
+ contentType: z24.literal("image/webp"),
1539
1552
  headers: SessionImageTransferHeadersSchema.refine((headers) => headers["content-type"] === "image/webp")
1540
1553
  };
1541
- var SessionImageUploadResultSchema = z23.discriminatedUnion("mode", [
1542
- z23.object({ ...UploadResultFields, mode: z23.literal("direct"), uploadUrl: DirectUrlSchema }).strict(),
1543
- z23.object({ ...UploadResultFields, mode: z23.literal("proxy"), uploadUrl: ProxyUrlSchema }).strict()
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()
1544
1557
  ]);
1545
- var SessionImageCommitResultSchema = z23.object({
1558
+ var SessionImageCommitResultSchema = z24.object({
1546
1559
  imageId: SessionImageIdSchema,
1547
1560
  machineId: IdSchema,
1548
1561
  sessionId: IdSchema,
1549
- sizeBytes: z23.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES),
1550
- width: z23.number().int().positive(),
1551
- height: z23.number().int().positive(),
1552
- sha256: z23.string().regex(/^[a-f0-9]{64}$/u),
1553
- expiresAt: z23.number().int().positive()
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()
1554
1567
  }).strict();
1555
1568
  var DownloadResultFields = {
1556
1569
  image: SessionImageCommitResultSchema,
1557
- downloadExpiresAt: z23.number().int().positive(),
1558
- method: z23.literal("GET"),
1570
+ downloadExpiresAt: z24.number().int().positive(),
1571
+ method: z24.literal("GET"),
1559
1572
  headers: SessionImageTransferHeadersSchema
1560
1573
  };
1561
- var SessionImageDownloadResultSchema = z23.discriminatedUnion("mode", [
1562
- z23.object({ ...DownloadResultFields, mode: z23.literal("direct"), downloadUrl: DirectUrlSchema }).strict(),
1563
- z23.object({ ...DownloadResultFields, mode: z23.literal("proxy"), downloadUrl: ProxyUrlSchema }).strict()
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()
1564
1577
  ]);
1565
- var TimelineImageBlobRequestSchema = z23.object({
1566
- sha256: z23.string().regex(/^[a-f0-9]{64}$/u)
1578
+ var TimelineImageBlobRequestSchema = z24.object({
1579
+ sha256: z24.string().regex(/^[a-f0-9]{64}$/u)
1567
1580
  }).strict();
1568
- var TimelineImageBlobResultSchema = z23.object({
1581
+ var TimelineImageBlobResultSchema = z24.object({
1569
1582
  sha256: TimelineImageBlobRequestSchema.shape.sha256,
1570
1583
  image: SessionImageCommitResultSchema
1571
1584
  }).strict();
1572
1585
 
1573
1586
  // ../../shared/protocol/dist/sessions/session-rename.js
1574
- import { z as z24 } from "zod";
1587
+ import { z as z25 } from "zod";
1575
1588
  var SESSION_RENAME_OPERATION = "session.rename";
1576
1589
  var SESSION_RENAME_VERSION = 1;
1577
1590
  var SESSION_RENAME_CAPABILITY = sessionCommunicationOperationCapability(SESSION_RENAME_OPERATION, SESSION_RENAME_VERSION);
1578
1591
  var SESSION_NAME_MAX_LENGTH = 100;
1579
- var SessionNameSchema = z24.string().regex(/^[^\u0000-\u001f\u007f]*$/u).trim().min(1).max(SESSION_NAME_MAX_LENGTH);
1580
- var SessionRenameDataSchema = z24.object({ name: SessionNameSchema }).strict();
1581
- var SessionRenameResultDataSchema = z24.object({ name: SessionNameSchema }).strict();
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();
1582
1595
 
1583
1596
  // ../../shared/protocol/dist/sessions/sessions.js
1584
- import { z as z25 } from "zod";
1585
- var GroupChatParticipantSchema = z25.object({
1597
+ import { z as z26 } from "zod";
1598
+ var GroupChatParticipantSchema = z26.object({
1586
1599
  sessionId: IdSchema,
1587
- title: z25.string().trim().min(1).max(260)
1600
+ title: z26.string().trim().min(1).max(260)
1588
1601
  }).strict();
1589
- var GroupChatInfoSchema = z25.object({
1590
- participants: z25.array(GroupChatParticipantSchema).length(2).refine((participants) => new Set(participants.map((participant) => participant.sessionId)).size === 2, "A group requires two different sessions"),
1591
- state: z25.enum(["ready", "running", "paused", "blocked"])
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"])
1592
1605
  }).strict();
1593
- var SessionSummarySchema = z25.object({
1606
+ var SessionSummarySchema = z26.object({
1594
1607
  userId: IdSchema,
1595
1608
  sessionId: IdSchema,
1596
1609
  machineId: IdSchema,
1597
- summary: z25.string().max(4096).optional(),
1598
- renameSupported: z25.boolean().optional(),
1599
- workingDirectory: z25.string().max(32768).optional(),
1600
- gitRoot: z25.string().max(32768).optional(),
1601
- repository: z25.string().max(1024).optional(),
1602
- gitRemoteUrl: z25.string().max(32768).optional(),
1603
- branch: z25.string().max(1024).optional(),
1604
- isRemote: z25.boolean(),
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(),
1605
1618
  createdAt: IsoDateSchema,
1606
1619
  modifiedAt: IsoDateSchema,
1607
1620
  groupChat: GroupChatInfoSchema.optional()
1608
1621
  });
1609
- var SessionsSnapshotSchema = z25.object({
1622
+ var SessionsSnapshotSchema = z26.object({
1610
1623
  userId: IdSchema,
1611
1624
  machineId: IdSchema,
1612
- machineName: z25.string().trim().min(1).max(120),
1613
- platform: z25.string().trim().min(1).max(64),
1625
+ machineName: z26.string().trim().min(1).max(120),
1626
+ platform: z26.string().trim().min(1).max(64),
1614
1627
  agentRunId: IdSchema,
1615
- sequence: z25.number().int().positive(),
1628
+ sequence: z26.number().int().positive(),
1616
1629
  generatedAt: IsoDateSchema,
1617
- complete: z25.boolean(),
1618
- totalCount: z25.number().int().nonnegative(),
1619
- nextCursor: z25.string().min(1).max(1024).optional(),
1620
- sessions: z25.array(SessionSummarySchema)
1630
+ complete: z26.boolean(),
1631
+ totalCount: z26.number().int().nonnegative(),
1632
+ nextCursor: z26.string().min(1).max(1024).optional(),
1633
+ sessions: z26.array(SessionSummarySchema)
1621
1634
  }).superRefine((snapshot, context) => {
1622
1635
  if (snapshot.totalCount < snapshot.sessions.length) {
1623
1636
  context.addIssue({
@@ -1659,47 +1672,47 @@ var SessionsSnapshotSchema = z25.object({
1659
1672
  sessionIds.add(session.sessionId);
1660
1673
  }
1661
1674
  });
1662
- var SessionListRequestSchema = z25.object({
1675
+ var SessionListRequestSchema = z26.object({
1663
1676
  requestId: IdSchema,
1664
1677
  machineId: IdSchema,
1665
- cursor: z25.string().min(1).max(1024).optional()
1678
+ cursor: z26.string().min(1).max(1024).optional()
1666
1679
  });
1667
- var SessionListResultSchema = z25.discriminatedUnion("ok", [
1668
- z25.object({
1669
- ok: z25.literal(true),
1680
+ var SessionListResultSchema = z26.discriminatedUnion("ok", [
1681
+ z26.object({
1682
+ ok: z26.literal(true),
1670
1683
  requestId: IdSchema,
1671
1684
  machineId: IdSchema,
1672
1685
  snapshot: SessionsSnapshotSchema
1673
1686
  }),
1674
- z25.object({
1675
- ok: z25.literal(false),
1687
+ z26.object({
1688
+ ok: z26.literal(false),
1676
1689
  requestId: IdSchema,
1677
1690
  machineId: IdSchema,
1678
1691
  error: ProtocolFailureSchema
1679
1692
  })
1680
1693
  ]);
1681
- var SessionAgentModeSchema = z25.enum([
1694
+ var SessionAgentModeSchema = z26.enum([
1682
1695
  "interactive",
1683
1696
  "plan",
1684
1697
  "autopilot"
1685
1698
  ]);
1686
- var AgentConfigurationOptionSchema = z25.object({
1699
+ var AgentConfigurationOptionSchema = z26.object({
1687
1700
  id: IdSchema,
1688
- name: z25.string().trim().min(1).max(260),
1689
- value: z25.string().min(1).max(256),
1690
- options: z25.array(z25.object({
1691
- value: z25.string().min(1).max(256),
1692
- name: z25.string().trim().min(1).max(260)
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)
1693
1706
  }).strict()).min(1).max(100)
1694
1707
  }).strict();
1695
- var AgentConfigurationChangeSchema = z25.object({
1708
+ var AgentConfigurationChangeSchema = z26.object({
1696
1709
  id: IdSchema,
1697
- value: z25.string().min(1).max(256)
1710
+ value: z26.string().min(1).max(256)
1698
1711
  }).strict();
1699
- var WorkspaceOptionSchema = z25.object({
1712
+ var WorkspaceOptionSchema = z26.object({
1700
1713
  id: IdSchema,
1701
- name: z25.string().trim().min(1).max(260),
1702
- path: z25.string().trim().min(1).max(32768)
1714
+ name: z26.string().trim().min(1).max(260),
1715
+ path: z26.string().trim().min(1).max(32768)
1703
1716
  });
1704
1717
  var REASONING_EFFORTS = [
1705
1718
  "low",
@@ -1708,113 +1721,113 @@ var REASONING_EFFORTS = [
1708
1721
  "xhigh",
1709
1722
  "max"
1710
1723
  ];
1711
- var ReasoningEffortSchema = z25.enum(REASONING_EFFORTS);
1712
- var CopilotModelOptionSchema = z25.object({
1724
+ var ReasoningEffortSchema = z26.enum(REASONING_EFFORTS);
1725
+ var CopilotModelOptionSchema = z26.object({
1713
1726
  id: IdSchema,
1714
- name: z25.string().trim().min(1).max(260),
1715
- isDefault: z25.boolean(),
1716
- supportedReasoningEfforts: z25.array(ReasoningEffortSchema).optional(),
1727
+ name: z26.string().trim().min(1).max(260),
1728
+ isDefault: z26.boolean(),
1729
+ supportedReasoningEfforts: z26.array(ReasoningEffortSchema).optional(),
1717
1730
  defaultReasoningEffort: ReasoningEffortSchema.optional(),
1718
- creation: z25.object({
1731
+ creation: z26.object({
1719
1732
  agentId: IdSchema,
1720
- agentName: z25.string().trim().min(1).max(260),
1721
- modelName: z25.string().trim().min(1).max(260),
1722
- agentModes: z25.array(SessionAgentModeSchema).min(1),
1723
- reasoningEffortConfigurationSupported: z25.boolean(),
1724
- isDefault: z25.boolean()
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()
1725
1738
  }).strict().optional()
1726
1739
  });
1727
- var SessionReasoningEffortSchema = z25.enum([
1740
+ var SessionReasoningEffortSchema = z26.enum([
1728
1741
  "default",
1729
1742
  ...REASONING_EFFORTS
1730
1743
  ]);
1731
- var CurrentReasoningEffortSchema = z25.string().trim().min(1).max(64);
1732
- var SessionToolInfoSchema = z25.object({
1733
- name: z25.string().trim().min(1).max(260),
1734
- description: z25.string().trim().min(1).max(4096).optional(),
1735
- deferred: z25.boolean().optional()
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()
1736
1749
  });
1737
- var SessionSlashCommandInfoSchema = z25.object({
1738
- name: z25.string().trim().min(1).max(260),
1739
- description: z25.string().trim().min(1).max(4096).optional(),
1740
- kind: z25.enum(["builtin", "skill", "client"])
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"])
1741
1754
  });
1742
- var SessionSkillInfoSchema = z25.object({
1743
- name: z25.string().trim().min(1).max(260),
1744
- description: z25.string().trim().min(1).max(4096).optional(),
1745
- source: z25.string().trim().min(1).max(260),
1746
- enabled: z25.boolean(),
1747
- userInvocable: z25.boolean(),
1748
- commandName: z25.string().trim().min(1).max(260).optional()
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()
1749
1762
  });
1750
- var SessionEnvironmentInfoSchema = z25.object({
1751
- tools: z25.array(SessionToolInfoSchema).max(512),
1752
- slashCommands: z25.array(SessionSlashCommandInfoSchema).max(512),
1753
- skills: z25.array(SessionSkillInfoSchema).max(512)
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)
1754
1767
  });
1755
- var SessionOptionsRequestSchema = z25.object({
1768
+ var SessionOptionsRequestSchema = z26.object({
1756
1769
  requestId: IdSchema,
1757
1770
  machineId: IdSchema,
1758
1771
  sessionId: IdSchema.optional(),
1759
1772
  workspaceId: IdSchema.optional(),
1760
- capabilities: z25.array(IdSchema).max(64).optional()
1773
+ capabilities: z26.array(IdSchema).max(64).optional()
1761
1774
  });
1762
- var SessionOptionsResultSchema = z25.discriminatedUnion("ok", [
1763
- z25.object({
1764
- ok: z25.literal(true),
1775
+ var SessionOptionsResultSchema = z26.discriminatedUnion("ok", [
1776
+ z26.object({
1777
+ ok: z26.literal(true),
1765
1778
  requestId: IdSchema,
1766
1779
  machineId: IdSchema,
1767
1780
  sessionId: IdSchema.optional(),
1768
- workspaces: z25.array(WorkspaceOptionSchema),
1769
- models: z25.array(CopilotModelOptionSchema).min(1),
1770
- modelRefreshError: z25.string().min(1).max(4096).optional(),
1771
- agentModes: z25.array(SessionAgentModeSchema).min(1),
1772
- reasoningEffortConfigurationSupported: z25.literal(true).optional(),
1773
- fileAttachmentsSupported: z25.boolean().optional(),
1774
- worktreeCreationSupported: z25.literal(true).optional(),
1775
- worktreeBranches: z25.array(z25.string().min(1).max(1024)).optional(),
1776
- worktreeCurrentBranch: z25.string().min(1).max(1024).optional(),
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(),
1777
1790
  currentModelId: IdSchema.optional(),
1778
1791
  currentAgentMode: SessionAgentModeSchema.optional(),
1779
1792
  currentReasoningEffort: CurrentReasoningEffortSchema.optional(),
1780
1793
  environment: SessionEnvironmentInfoSchema.optional(),
1781
- environmentPending: z25.literal(true).optional(),
1782
- agentName: z25.string().trim().min(1).max(260).optional(),
1783
- configOptions: z25.array(AgentConfigurationOptionSchema).max(32).optional()
1794
+ environmentPending: z26.literal(true).optional(),
1795
+ agentName: z26.string().trim().min(1).max(260).optional(),
1796
+ configOptions: z26.array(AgentConfigurationOptionSchema).max(32).optional()
1784
1797
  }),
1785
- z25.object({
1786
- ok: z25.literal(false),
1798
+ z26.object({
1799
+ ok: z26.literal(false),
1787
1800
  requestId: IdSchema,
1788
1801
  machineId: IdSchema,
1789
1802
  sessionId: IdSchema.optional(),
1790
1803
  error: ProtocolFailureSchema,
1791
- failureStage: z25.enum(["models", "configuration", "workspaces"]).optional(),
1792
- models: z25.array(CopilotModelOptionSchema).min(1).optional(),
1793
- agentModes: z25.array(SessionAgentModeSchema).min(1).optional(),
1794
- reasoningEffortConfigurationSupported: z25.literal(true).optional(),
1795
- fileAttachmentsSupported: z25.boolean().optional(),
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(),
1796
1809
  currentModelId: IdSchema.optional(),
1797
1810
  currentAgentMode: SessionAgentModeSchema.optional(),
1798
1811
  currentReasoningEffort: CurrentReasoningEffortSchema.optional(),
1799
- agentName: z25.string().trim().min(1).max(260).optional(),
1800
- configOptions: z25.array(AgentConfigurationOptionSchema).max(32).optional()
1812
+ agentName: z26.string().trim().min(1).max(260).optional(),
1813
+ configOptions: z26.array(AgentConfigurationOptionSchema).max(32).optional()
1801
1814
  })
1802
1815
  ]);
1803
- var SessionCreateRequestSchema = z25.object({
1816
+ var SessionCreateRequestSchema = z26.object({
1804
1817
  requestId: IdSchema,
1805
1818
  machineId: IdSchema,
1806
1819
  workspaceId: IdSchema,
1807
1820
  modelId: IdSchema,
1808
1821
  agentMode: SessionAgentModeSchema,
1809
1822
  reasoningEffort: SessionReasoningEffortSchema.optional(),
1810
- worktree: z25.object({
1811
- branchName: z25.string().trim().min(1).max(120).optional(),
1812
- baseBranch: z25.string().trim().min(1).max(1024).optional()
1823
+ worktree: z26.object({
1824
+ branchName: z26.string().trim().min(1).max(120).optional(),
1825
+ baseBranch: z26.string().trim().min(1).max(1024).optional()
1813
1826
  }).strict().optional()
1814
1827
  });
1815
- var SessionCreateResultSchema = z25.discriminatedUnion("ok", [
1816
- z25.object({
1817
- ok: z25.literal(true),
1828
+ var SessionCreateResultSchema = z26.discriminatedUnion("ok", [
1829
+ z26.object({
1830
+ ok: z26.literal(true),
1818
1831
  requestId: IdSchema,
1819
1832
  machineId: IdSchema,
1820
1833
  session: SessionSummarySchema,
@@ -1822,34 +1835,34 @@ var SessionCreateResultSchema = z25.discriminatedUnion("ok", [
1822
1835
  agentMode: SessionAgentModeSchema,
1823
1836
  reasoningEffort: SessionReasoningEffortSchema.optional()
1824
1837
  }),
1825
- z25.object({
1826
- ok: z25.literal(false),
1838
+ z26.object({
1839
+ ok: z26.literal(false),
1827
1840
  requestId: IdSchema,
1828
1841
  machineId: IdSchema,
1829
1842
  error: ProtocolFailureSchema
1830
1843
  })
1831
1844
  ]);
1832
- var SessionDeleteRequestSchema = z25.object({
1845
+ var SessionDeleteRequestSchema = z26.object({
1833
1846
  requestId: IdSchema,
1834
1847
  machineId: IdSchema,
1835
1848
  sessionId: IdSchema
1836
1849
  }).strict();
1837
- var SessionDeleteResultSchema = z25.discriminatedUnion("ok", [
1838
- z25.object({
1839
- ok: z25.literal(true),
1850
+ var SessionDeleteResultSchema = z26.discriminatedUnion("ok", [
1851
+ z26.object({
1852
+ ok: z26.literal(true),
1840
1853
  requestId: IdSchema,
1841
1854
  machineId: IdSchema,
1842
1855
  sessionId: IdSchema
1843
1856
  }).strict(),
1844
- z25.object({
1845
- ok: z25.literal(false),
1857
+ z26.object({
1858
+ ok: z26.literal(false),
1846
1859
  requestId: IdSchema,
1847
1860
  machineId: IdSchema,
1848
1861
  sessionId: IdSchema,
1849
1862
  error: ProtocolFailureSchema
1850
1863
  }).strict()
1851
1864
  ]);
1852
- var SessionConfigureRequestSchema = z25.object({
1865
+ var SessionConfigureRequestSchema = z26.object({
1853
1866
  requestId: IdSchema,
1854
1867
  machineId: IdSchema,
1855
1868
  sessionId: IdSchema,
@@ -1858,59 +1871,59 @@ var SessionConfigureRequestSchema = z25.object({
1858
1871
  reasoningEffort: SessionReasoningEffortSchema.optional(),
1859
1872
  configOption: AgentConfigurationChangeSchema.optional()
1860
1873
  }).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" });
1861
- var SessionConfigureResultSchema = z25.discriminatedUnion("ok", [
1862
- z25.object({
1863
- ok: z25.literal(true),
1874
+ var SessionConfigureResultSchema = z26.discriminatedUnion("ok", [
1875
+ z26.object({
1876
+ ok: z26.literal(true),
1864
1877
  requestId: IdSchema,
1865
1878
  machineId: IdSchema,
1866
1879
  sessionId: IdSchema,
1867
1880
  modelId: IdSchema.optional(),
1868
1881
  agentMode: SessionAgentModeSchema,
1869
1882
  reasoningEffort: CurrentReasoningEffortSchema.optional(),
1870
- configOptions: z25.array(AgentConfigurationOptionSchema).max(32).optional()
1883
+ configOptions: z26.array(AgentConfigurationOptionSchema).max(32).optional()
1871
1884
  }),
1872
- z25.object({
1873
- ok: z25.literal(false),
1885
+ z26.object({
1886
+ ok: z26.literal(false),
1874
1887
  requestId: IdSchema,
1875
1888
  machineId: IdSchema,
1876
1889
  sessionId: IdSchema,
1877
1890
  error: ProtocolFailureSchema
1878
1891
  })
1879
1892
  ]);
1880
- var SessionRemoteActionSchema = z25.enum([
1893
+ var SessionRemoteActionSchema = z26.enum([
1881
1894
  "status",
1882
1895
  "enable",
1883
1896
  "disable"
1884
1897
  ]);
1885
- var SessionRemoteStateSchema = z25.enum([
1898
+ var SessionRemoteStateSchema = z26.enum([
1886
1899
  "off",
1887
1900
  "connecting",
1888
1901
  "active",
1889
1902
  "error"
1890
1903
  ]);
1891
- var SessionRemoteRequestSchema = z25.object({
1904
+ var SessionRemoteRequestSchema = z26.object({
1892
1905
  requestId: IdSchema,
1893
1906
  machineId: IdSchema,
1894
1907
  sessionId: IdSchema,
1895
1908
  action: SessionRemoteActionSchema
1896
1909
  });
1897
- var SessionRemoteStatusSchema = z25.object({
1910
+ var SessionRemoteStatusSchema = z26.object({
1898
1911
  state: SessionRemoteStateSchema,
1899
1912
  attachedSessionId: IdSchema.optional(),
1900
- url: z25.url().max(32768).optional(),
1901
- steerable: z25.boolean(),
1913
+ url: z26.url().max(32768).optional(),
1914
+ steerable: z26.boolean(),
1902
1915
  error: ProtocolFailureSchema.optional()
1903
1916
  });
1904
- var SessionRemoteResultSchema = z25.discriminatedUnion("ok", [
1905
- z25.object({
1906
- ok: z25.literal(true),
1917
+ var SessionRemoteResultSchema = z26.discriminatedUnion("ok", [
1918
+ z26.object({
1919
+ ok: z26.literal(true),
1907
1920
  requestId: IdSchema,
1908
1921
  machineId: IdSchema,
1909
1922
  sessionId: IdSchema,
1910
1923
  status: SessionRemoteStatusSchema
1911
1924
  }),
1912
- z25.object({
1913
- ok: z25.literal(false),
1925
+ z26.object({
1926
+ ok: z26.literal(false),
1914
1927
  requestId: IdSchema,
1915
1928
  machineId: IdSchema,
1916
1929
  sessionId: IdSchema,
@@ -1919,34 +1932,34 @@ var SessionRemoteResultSchema = z25.discriminatedUnion("ok", [
1919
1932
  ]);
1920
1933
 
1921
1934
  // ../../shared/protocol/dist/sessions/group-chat.js
1922
- import { z as z26 } from "zod";
1935
+ import { z as z27 } from "zod";
1923
1936
  var GROUP_CHAT_CREATE_OPERATION = "group-chat.create";
1924
1937
  var GROUP_CHAT_CREATE_VERSION = 1;
1925
1938
  var GROUP_CHAT_CREATE_CAPABILITY = sessionCommunicationOperationCapability(GROUP_CHAT_CREATE_OPERATION, GROUP_CHAT_CREATE_VERSION);
1926
- var GroupChatCreateDataSchema = z26.object({
1939
+ var GroupChatCreateDataSchema = z27.object({
1927
1940
  peerSessionId: IdSchema
1928
1941
  }).strict();
1929
- var GroupChatCreateResultDataSchema = z26.object({
1942
+ var GroupChatCreateResultDataSchema = z27.object({
1930
1943
  session: SessionSummarySchema.refine((session) => session.groupChat !== void 0, "Group creation must return a virtual group session")
1931
1944
  }).strict();
1932
1945
 
1933
1946
  // ../../shared/protocol/dist/sessions/prompts.js
1934
- import { z as z27 } from "zod";
1935
- var SessionAvatarPersonaSchema = z27.object({
1936
- role: z27.enum(["designer", "filmmaker", "developer", "secretary", "default"]),
1937
- displayName: z27.string().trim().min(1).max(40).regex(/^[^\u0000-\u001f\u007f-\u009f]*$/).optional()
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()
1938
1951
  }).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" });
1939
1952
  var MAX_PROMPT_IMAGE_BYTES = 3 * 1024 * 1024;
1940
- var SessionPromptRequestSchema = z27.object({
1953
+ var SessionPromptRequestSchema = z28.object({
1941
1954
  requestId: IdSchema,
1942
1955
  operationId: IdSchema,
1943
1956
  machineId: IdSchema,
1944
1957
  sessionId: IdSchema,
1945
- prompt: z27.string().trim().max(1e5),
1946
- attachments: z27.array(PromptImageAttachmentSchema).max(4).optional(),
1947
- fileAttachments: z27.array(PromptFileAttachmentSchema).max(4).optional(),
1958
+ prompt: z28.string().trim().max(1e5),
1959
+ attachments: z28.array(PromptImageAttachmentSchema).max(4).optional(),
1960
+ fileAttachments: z28.array(PromptFileAttachmentSchema).max(4).optional(),
1948
1961
  avatarPersona: SessionAvatarPersonaSchema.optional(),
1949
- mode: z27.enum(["enqueue", "immediate"]).default("enqueue")
1962
+ mode: z28.enum(["enqueue", "immediate"]).default("enqueue")
1950
1963
  }).strict().superRefine((request, context) => {
1951
1964
  if (request.prompt.length === 0 && (request.attachments?.length ?? 0) === 0 && (request.fileAttachments?.length ?? 0) === 0) {
1952
1965
  context.addIssue({
@@ -1972,22 +1985,22 @@ var SessionPromptRequestSchema = z27.object({
1972
1985
  });
1973
1986
  }
1974
1987
  });
1975
- var SessionPromptResultSchema = z27.discriminatedUnion("ok", [
1976
- z27.object({
1977
- ok: z27.literal(true),
1988
+ var SessionPromptResultSchema = z28.discriminatedUnion("ok", [
1989
+ z28.object({
1990
+ ok: z28.literal(true),
1978
1991
  requestId: IdSchema,
1979
1992
  operationId: IdSchema,
1980
1993
  machineId: IdSchema,
1981
1994
  sessionId: IdSchema,
1982
1995
  messageId: IdSchema,
1983
- mode: z27.enum(["enqueue", "immediate"]),
1984
- deliveryState: z27.enum(["queued", "processing"]),
1996
+ mode: z28.enum(["enqueue", "immediate"]),
1997
+ deliveryState: z28.enum(["queued", "processing"]),
1985
1998
  // Negotiated lower bound from the native event clock. Exact text and history
1986
1999
  // ownership checks still apply; this is not an identity or proof of persistence.
1987
2000
  submittedAt: IsoDateSchema.optional()
1988
2001
  }),
1989
- z27.object({
1990
- ok: z27.literal(false),
2002
+ z28.object({
2003
+ ok: z28.literal(false),
1991
2004
  requestId: IdSchema,
1992
2005
  operationId: IdSchema,
1993
2006
  machineId: IdSchema,
@@ -1995,29 +2008,29 @@ var SessionPromptResultSchema = z27.discriminatedUnion("ok", [
1995
2008
  error: ProtocolFailureSchema
1996
2009
  })
1997
2010
  ]);
1998
- var SessionActivityUpdateSchema = z27.object({
2011
+ var SessionActivityUpdateSchema = z28.object({
1999
2012
  userId: IdSchema,
2000
2013
  machineId: IdSchema,
2001
2014
  sessionId: IdSchema,
2002
- state: z27.enum(["working", "idle"]),
2015
+ state: z28.enum(["working", "idle"]),
2003
2016
  occurredAt: IsoDateSchema,
2004
2017
  assistantPreview: SessionAssistantPreviewSchema.optional(),
2005
2018
  userPreview: SessionUserPreviewSchema.optional()
2006
2019
  });
2007
- var SessionAbortRequestSchema = z27.object({
2020
+ var SessionAbortRequestSchema = z28.object({
2008
2021
  requestId: IdSchema,
2009
2022
  machineId: IdSchema,
2010
2023
  sessionId: IdSchema
2011
2024
  });
2012
- var SessionAbortResultSchema = z27.discriminatedUnion("ok", [
2013
- z27.object({
2014
- ok: z27.literal(true),
2025
+ var SessionAbortResultSchema = z28.discriminatedUnion("ok", [
2026
+ z28.object({
2027
+ ok: z28.literal(true),
2015
2028
  requestId: IdSchema,
2016
2029
  machineId: IdSchema,
2017
2030
  sessionId: IdSchema
2018
2031
  }),
2019
- z27.object({
2020
- ok: z27.literal(false),
2032
+ z28.object({
2033
+ ok: z28.literal(false),
2021
2034
  requestId: IdSchema,
2022
2035
  machineId: IdSchema,
2023
2036
  sessionId: IdSchema,
@@ -2026,12 +2039,12 @@ var SessionAbortResultSchema = z27.discriminatedUnion("ok", [
2026
2039
  ]);
2027
2040
 
2028
2041
  // ../../shared/protocol/dist/sessions/interactions.js
2029
- import { z as z28 } from "zod";
2030
- var InteractionFormFieldSchema = z28.object({
2042
+ import { z as z29 } from "zod";
2043
+ var InteractionFormFieldSchema = z29.object({
2031
2044
  id: IdSchema,
2032
- label: z28.string().trim().min(1).max(1024),
2033
- description: z28.string().max(2048).optional(),
2034
- inputType: z28.enum([
2045
+ label: z29.string().trim().min(1).max(1024),
2046
+ description: z29.string().max(2048).optional(),
2047
+ inputType: z29.enum([
2035
2048
  "text",
2036
2049
  "number",
2037
2050
  "integer",
@@ -2039,77 +2052,77 @@ var InteractionFormFieldSchema = z28.object({
2039
2052
  "select",
2040
2053
  "multi-select"
2041
2054
  ]),
2042
- required: z28.boolean(),
2043
- options: z28.array(z28.string().max(1024)).max(100),
2044
- defaultValue: z28.union([
2045
- z28.string().max(4096),
2046
- z28.number().finite(),
2047
- z28.boolean(),
2048
- z28.array(z28.string().max(1024)).max(100)
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)
2049
2062
  ]).optional(),
2050
- minimum: z28.number().finite().optional(),
2051
- maximum: z28.number().finite().optional(),
2052
- minLength: z28.number().int().nonnegative().max(1e6).optional(),
2053
- maxLength: z28.number().int().nonnegative().max(1e6).optional(),
2054
- minItems: z28.number().int().nonnegative().max(100).optional(),
2055
- maxItems: z28.number().int().nonnegative().max(100).optional(),
2056
- format: z28.enum(["email", "uri", "date", "date-time"]).optional()
2057
- }).strict();
2058
- var InteractionPermissionRequestSchema = z28.object({
2059
- kind: z28.literal("permission"),
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"),
2060
2073
  permissionKind: IdSchema,
2061
- title: z28.string().trim().min(1).max(256),
2062
- description: z28.string().max(4096),
2063
- canApproveSession: z28.boolean(),
2064
- canApproveAlways: z28.boolean().optional(),
2065
- approvalScope: z28.string().trim().min(1).max(4096).optional()
2066
- }).strict();
2067
- var InteractionUserInputRequestSchema = z28.object({
2068
- kind: z28.literal("user_input"),
2069
- question: z28.string().trim().min(1).max(4096),
2070
- choices: z28.array(z28.string().max(1024)).max(100),
2071
- allowFreeform: z28.boolean()
2072
- }).strict();
2073
- var InteractionElicitationRequestSchema = z28.object({
2074
- kind: z28.literal("elicitation"),
2075
- message: z28.string().trim().min(1).max(4096),
2076
- mode: z28.enum(["form", "url"]),
2077
- source: z28.string().trim().min(1).max(256).optional(),
2078
- url: z28.url().max(32768).optional(),
2079
- fields: z28.array(InteractionFormFieldSchema).max(100)
2080
- }).strict();
2081
- var InteractionMcpOauthRequestSchema = z28.object({
2082
- kind: z28.literal("mcp_oauth"),
2083
- serverName: z28.string().trim().min(1).max(256),
2084
- serverUrl: z28.url().max(32768),
2085
- reason: z28.enum(["initial", "refresh", "reauth", "upscope"]),
2086
- responseMode: z28.literal("cancel-only")
2087
- }).strict();
2088
- var InteractionMcpHeadersRequestSchema = z28.object({
2089
- kind: z28.literal("mcp_headers"),
2090
- serverName: z28.string().trim().min(1).max(256),
2091
- serverUrl: z28.url().max(32768),
2092
- reason: z28.string().trim().min(1).max(256),
2093
- responseMode: z28.literal("none-only")
2094
- }).strict();
2095
- var InteractionAutoModeSwitchRequestSchema = z28.object({
2096
- kind: z28.literal("auto_mode_switch"),
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"),
2097
2110
  errorCode: IdSchema.optional(),
2098
- retryAfterSeconds: z28.number().int().nonnegative().optional()
2099
- }).strict();
2100
- var InteractionSessionLimitsRequestSchema = z28.object({
2101
- kind: z28.literal("session_limits"),
2102
- maxAiCredits: z28.number().finite().nonnegative(),
2103
- usedAiCredits: z28.number().finite().nonnegative()
2104
- }).strict();
2105
- var InteractionExitPlanRequestSchema = z28.object({
2106
- kind: z28.literal("exit_plan"),
2107
- summary: z28.string().max(4096),
2108
- planContent: z28.string().max(1e5).optional(),
2109
- actions: z28.array(IdSchema).min(1).max(20),
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),
2110
2123
  recommendedAction: IdSchema
2111
2124
  }).strict();
2112
- var InteractionRequestSchema = z28.discriminatedUnion("kind", [
2125
+ var InteractionRequestSchema = z29.discriminatedUnion("kind", [
2113
2126
  InteractionPermissionRequestSchema,
2114
2127
  InteractionUserInputRequestSchema,
2115
2128
  InteractionElicitationRequestSchema,
@@ -2119,81 +2132,81 @@ var InteractionRequestSchema = z28.discriminatedUnion("kind", [
2119
2132
  InteractionSessionLimitsRequestSchema,
2120
2133
  InteractionExitPlanRequestSchema
2121
2134
  ]);
2122
- var InteractionPermissionResponseSchema = z28.object({
2123
- kind: z28.literal("permission"),
2124
- decision: z28.enum(["approve-once", "approve-for-session", "approve-always", "reject"]),
2125
- feedback: z28.string().trim().min(1).max(2048).optional()
2126
- }).strict();
2127
- var InteractionUserInputResponseSchema = z28.object({
2128
- kind: z28.literal("user_input"),
2129
- answer: z28.string().max(1e5),
2130
- wasFreeform: z28.boolean()
2131
- }).strict();
2132
- var InteractionFieldValueSchema = z28.union([
2133
- z28.string().max(4096),
2134
- z28.number(),
2135
- z28.boolean(),
2136
- z28.array(z28.string().max(1024)).max(100)
2137
- ]);
2138
- var InteractionElicitationResponseSchema = z28.object({
2139
- kind: z28.literal("elicitation"),
2140
- action: z28.enum(["accept", "decline", "cancel"]),
2141
- values: z28.record(z28.string().max(256), InteractionFieldValueSchema)
2142
- }).strict();
2143
- var InteractionMcpOauthResponseSchema = z28.object({
2144
- kind: z28.literal("mcp_oauth"),
2145
- action: z28.literal("cancel")
2146
- }).strict();
2147
- var InteractionMcpHeadersResponseSchema = z28.object({
2148
- kind: z28.literal("mcp_headers"),
2149
- action: z28.literal("none")
2150
- }).strict();
2151
- var InteractionAutoModeSwitchResponseSchema = z28.object({
2152
- kind: z28.literal("auto_mode_switch"),
2153
- action: z28.enum(["yes", "yes_always", "no"])
2154
- }).strict();
2155
- var InteractionSessionLimitsResponseSchema = z28.object({
2156
- kind: z28.literal("session_limits"),
2157
- action: z28.enum(["add", "set", "unset", "cancel"]),
2158
- additionalAiCredits: z28.number().positive().optional(),
2159
- maxAiCredits: z28.number().positive().optional()
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()
2160
2173
  }).strict().superRefine((response, context) => {
2161
2174
  if (response.action === "add" && response.additionalAiCredits === void 0) {
2162
2175
  context.addIssue({
2163
- code: z28.ZodIssueCode.custom,
2176
+ code: z29.ZodIssueCode.custom,
2164
2177
  path: ["additionalAiCredits"],
2165
2178
  message: "additionalAiCredits is required for add"
2166
2179
  });
2167
2180
  }
2168
2181
  if (response.action === "set" && response.maxAiCredits === void 0) {
2169
2182
  context.addIssue({
2170
- code: z28.ZodIssueCode.custom,
2183
+ code: z29.ZodIssueCode.custom,
2171
2184
  path: ["maxAiCredits"],
2172
2185
  message: "maxAiCredits is required for set"
2173
2186
  });
2174
2187
  }
2175
2188
  if (response.action !== "add" && response.additionalAiCredits !== void 0) {
2176
2189
  context.addIssue({
2177
- code: z28.ZodIssueCode.custom,
2190
+ code: z29.ZodIssueCode.custom,
2178
2191
  path: ["additionalAiCredits"],
2179
2192
  message: "additionalAiCredits is only valid for add"
2180
2193
  });
2181
2194
  }
2182
2195
  if (response.action !== "set" && response.maxAiCredits !== void 0) {
2183
2196
  context.addIssue({
2184
- code: z28.ZodIssueCode.custom,
2197
+ code: z29.ZodIssueCode.custom,
2185
2198
  path: ["maxAiCredits"],
2186
2199
  message: "maxAiCredits is only valid for set"
2187
2200
  });
2188
2201
  }
2189
2202
  });
2190
- var InteractionExitPlanResponseSchema = z28.object({
2191
- kind: z28.literal("exit_plan"),
2192
- approved: z28.boolean(),
2203
+ var InteractionExitPlanResponseSchema = z29.object({
2204
+ kind: z29.literal("exit_plan"),
2205
+ approved: z29.boolean(),
2193
2206
  selectedAction: IdSchema.optional(),
2194
- feedback: z28.string().trim().min(1).max(4096).optional()
2207
+ feedback: z29.string().trim().min(1).max(4096).optional()
2195
2208
  }).strict();
2196
- var InteractionResponseSchema = z28.discriminatedUnion("kind", [
2209
+ var InteractionResponseSchema = z29.discriminatedUnion("kind", [
2197
2210
  InteractionPermissionResponseSchema,
2198
2211
  InteractionUserInputResponseSchema,
2199
2212
  InteractionElicitationResponseSchema,
@@ -2203,30 +2216,30 @@ var InteractionResponseSchema = z28.discriminatedUnion("kind", [
2203
2216
  InteractionSessionLimitsResponseSchema,
2204
2217
  InteractionExitPlanResponseSchema
2205
2218
  ]);
2206
- var InteractionRequestPayloadSchema = z28.object({
2219
+ var InteractionRequestPayloadSchema = z29.object({
2207
2220
  interactionRequestId: IdSchema,
2208
2221
  userId: IdSchema,
2209
2222
  machineId: IdSchema,
2210
2223
  sessionId: IdSchema,
2211
2224
  request: InteractionRequestSchema
2212
2225
  }).strict();
2213
- var InteractionRespondRequestSchema = z28.object({
2226
+ var InteractionRespondRequestSchema = z29.object({
2214
2227
  requestId: IdSchema,
2215
2228
  interactionRequestId: IdSchema,
2216
2229
  machineId: IdSchema,
2217
2230
  sessionId: IdSchema,
2218
2231
  response: InteractionResponseSchema
2219
2232
  }).strict();
2220
- var InteractionRespondResultSchema = z28.discriminatedUnion("ok", [
2221
- z28.object({
2222
- ok: z28.literal(true),
2233
+ var InteractionRespondResultSchema = z29.discriminatedUnion("ok", [
2234
+ z29.object({
2235
+ ok: z29.literal(true),
2223
2236
  requestId: IdSchema,
2224
2237
  interactionRequestId: IdSchema,
2225
2238
  machineId: IdSchema,
2226
2239
  sessionId: IdSchema
2227
2240
  }).strict(),
2228
- z28.object({
2229
- ok: z28.literal(false),
2241
+ z29.object({
2242
+ ok: z29.literal(false),
2230
2243
  requestId: IdSchema,
2231
2244
  interactionRequestId: IdSchema,
2232
2245
  machineId: IdSchema,
@@ -2234,31 +2247,31 @@ var InteractionRespondResultSchema = z28.discriminatedUnion("ok", [
2234
2247
  error: ProtocolFailureSchema
2235
2248
  }).strict()
2236
2249
  ]);
2237
- var PermissionRequestPayloadSchema = z28.object({
2250
+ var PermissionRequestPayloadSchema = z29.object({
2238
2251
  permissionRequestId: IdSchema,
2239
2252
  userId: IdSchema,
2240
2253
  machineId: IdSchema,
2241
2254
  sessionId: IdSchema,
2242
- request: z28.record(z28.string(), z28.unknown())
2255
+ request: z29.record(z29.string(), z29.unknown())
2243
2256
  });
2244
- var PermissionRespondRequestSchema = z28.object({
2257
+ var PermissionRespondRequestSchema = z29.object({
2245
2258
  requestId: IdSchema,
2246
2259
  permissionRequestId: IdSchema,
2247
2260
  machineId: IdSchema,
2248
2261
  sessionId: IdSchema,
2249
- decision: z28.enum(["approve-once", "reject"]),
2250
- feedback: z28.string().trim().min(1).max(2048).optional()
2262
+ decision: z29.enum(["approve-once", "reject"]),
2263
+ feedback: z29.string().trim().min(1).max(2048).optional()
2251
2264
  });
2252
- var PermissionRespondResultSchema = z28.discriminatedUnion("ok", [
2253
- z28.object({
2254
- ok: z28.literal(true),
2265
+ var PermissionRespondResultSchema = z29.discriminatedUnion("ok", [
2266
+ z29.object({
2267
+ ok: z29.literal(true),
2255
2268
  requestId: IdSchema,
2256
2269
  permissionRequestId: IdSchema,
2257
2270
  machineId: IdSchema,
2258
2271
  sessionId: IdSchema
2259
2272
  }),
2260
- z28.object({
2261
- ok: z28.literal(false),
2273
+ z29.object({
2274
+ ok: z29.literal(false),
2262
2275
  requestId: IdSchema,
2263
2276
  permissionRequestId: IdSchema,
2264
2277
  machineId: IdSchema,
@@ -2268,42 +2281,42 @@ var PermissionRespondResultSchema = z28.discriminatedUnion("ok", [
2268
2281
  ]);
2269
2282
 
2270
2283
  // ../../shared/protocol/dist/conversation/timeline-sync.js
2271
- import { z as z29 } from "zod";
2284
+ import { z as z30 } from "zod";
2272
2285
  var TIMELINE_SYNC_MAX_EVENTS = 128;
2273
2286
  var TIMELINE_SYNC_MAX_BYTES = 6 * 1024 * 1024;
2274
2287
  var TIMELINE_IMAGE_CHUNK_BYTES = 48 * 1024;
2275
2288
  var TIMELINE_IMAGE_MAX_BYTES = 3 * 1024 * 1024;
2276
- var identity = z29.string().min(1).max(256);
2277
- var sequence = z29.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
2278
- var hash = z29.string().regex(/^[a-f0-9]{64}$/u);
2279
- var TimelineWatermarkSchema = z29.object({
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({
2280
2293
  epoch: identity,
2281
2294
  sequence
2282
2295
  }).strict();
2283
- var TimelineSyncRequestSchema = z29.object({
2296
+ var TimelineSyncRequestSchema = z30.object({
2284
2297
  watermark: TimelineWatermarkSchema.optional(),
2285
- waitMs: z29.number().int().min(0).max(2e4).optional(),
2286
- resume: z29.boolean().optional()
2298
+ waitMs: z30.number().int().min(0).max(2e4).optional(),
2299
+ resume: z30.boolean().optional()
2287
2300
  }).strict();
2288
- var TimelineTextAppendSchema = z29.object({
2301
+ var TimelineTextAppendSchema = z30.object({
2289
2302
  itemId: identity,
2290
- baseRevision: z29.number().int().positive(),
2291
- revision: z29.number().int().positive(),
2292
- appendText: z29.string().min(1).max(5e5),
2293
- sourceEventIds: z29.array(identity).min(1).max(1e3).optional(),
2294
- sourceMessageIds: z29.array(identity).min(1).max(1e3).optional(),
2295
- sourceInteractionIds: z29.array(identity).min(1).max(1e3).optional()
2296
- }).strict();
2297
- var TimelineSyncEventSchema = z29.discriminatedUnion("kind", [
2298
- z29.object({ kind: z29.literal("upsert"), sequence, item: ConversationItemSchema }).strict(),
2299
- z29.object({ kind: z29.literal("append"), sequence, append: TimelineTextAppendSchema }).strict(),
2300
- z29.object({
2301
- kind: z29.literal("step"),
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"),
2302
2315
  sequence,
2303
2316
  upsert: ConversationActivityStepUpsertSchema
2304
2317
  }).strict()
2305
2318
  ]);
2306
- var TimelineResyncReasonSchema = z29.enum([
2319
+ var TimelineResyncReasonSchema = z30.enum([
2307
2320
  "initial",
2308
2321
  "epoch-changed",
2309
2322
  "evicted",
@@ -2312,36 +2325,36 @@ var TimelineResyncReasonSchema = z29.enum([
2312
2325
  "rewind",
2313
2326
  "oversized"
2314
2327
  ]);
2315
- var TimelineSyncResponseSchema = z29.discriminatedUnion("status", [
2316
- z29.object({
2317
- status: z29.literal("snapshot"),
2328
+ var TimelineSyncResponseSchema = z30.discriminatedUnion("status", [
2329
+ z30.object({
2330
+ status: z30.literal("snapshot"),
2318
2331
  watermark: TimelineWatermarkSchema,
2319
2332
  page: SessionTimelinePageSchema
2320
2333
  }).strict(),
2321
- z29.object({
2322
- status: z29.literal("replay"),
2334
+ z30.object({
2335
+ status: z30.literal("replay"),
2323
2336
  watermark: TimelineWatermarkSchema,
2324
2337
  afterSequence: sequence,
2325
- events: z29.array(TimelineSyncEventSchema).max(TIMELINE_SYNC_MAX_EVENTS),
2326
- hasMore: z29.boolean()
2338
+ events: z30.array(TimelineSyncEventSchema).max(TIMELINE_SYNC_MAX_EVENTS),
2339
+ hasMore: z30.boolean()
2327
2340
  }).strict(),
2328
- z29.object({
2329
- status: z29.literal("resync"),
2341
+ z30.object({
2342
+ status: z30.literal("resync"),
2330
2343
  epoch: identity,
2331
2344
  reason: TimelineResyncReasonSchema
2332
2345
  }).strict()
2333
2346
  ]);
2334
- var TimelineImageRequestSchema = z29.object({
2347
+ var TimelineImageRequestSchema = z30.object({
2335
2348
  sha256: hash,
2336
- offset: z29.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1)
2349
+ offset: z30.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1)
2337
2350
  }).strict();
2338
- var TimelineImageChunkSchema = z29.object({
2351
+ var TimelineImageChunkSchema = z30.object({
2339
2352
  sha256: hash,
2340
- offset: z29.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1),
2341
- totalBytes: z29.number().int().positive().max(TIMELINE_IMAGE_MAX_BYTES),
2342
- mimeType: z29.enum(["image/gif", "image/jpeg", "image/png", "image/webp"]),
2343
- data: z29.string().min(4).max(Math.ceil(TIMELINE_IMAGE_CHUNK_BYTES / 3) * 4).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u),
2344
- eof: z29.boolean()
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()
2345
2358
  }).strict().superRefine((chunk, context) => {
2346
2359
  const padding = chunk.data.endsWith("==") ? 2 : chunk.data.endsWith("=") ? 1 : 0;
2347
2360
  const length = chunk.data.length / 4 * 3 - padding;
@@ -2352,10 +2365,10 @@ var TimelineImageChunkSchema = z29.object({
2352
2365
  });
2353
2366
 
2354
2367
  // ../../shared/protocol/dist/workbench.js
2355
- import { z as z31 } from "zod";
2368
+ import { z as z32 } from "zod";
2356
2369
 
2357
2370
  // ../../shared/protocol/dist/schedules.js
2358
- import { z as z30 } from "zod";
2371
+ import { z as z31 } from "zod";
2359
2372
  var SCHEDULE_OPERATIONS = [
2360
2373
  "schedule.snapshot",
2361
2374
  "schedule.create",
@@ -2363,90 +2376,90 @@ var SCHEDULE_OPERATIONS = [
2363
2376
  "schedule.draft.dismiss",
2364
2377
  "schedule.resume"
2365
2378
  ];
2366
- var Id = z30.string().min(1).max(256);
2367
- var NativeId = z30.number().int().positive().max(Number.MAX_SAFE_INTEGER);
2368
- var Time = z30.iso.datetime({ offset: true });
2369
- var WorkbenchScheduleRuleSchema = z30.discriminatedUnion("kind", [
2370
- z30.object({ kind: z30.literal("once"), at: Time }).strict(),
2371
- z30.object({
2372
- kind: z30.literal("interval"),
2373
- seconds: z30.number().int().min(10).max(86400),
2374
- recurring: z30.boolean().optional()
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()
2375
2388
  }).strict(),
2376
- z30.object({
2377
- kind: z30.literal("cron"),
2378
- expression: z30.string().trim().min(9).max(256).regex(/^\S+(?: +\S+){4}$/),
2379
- timezone: z30.string().min(1).max(128).regex(/^[A-Za-z0-9_+./-]+$/)
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_+./-]+$/)
2380
2393
  }).strict()
2381
2394
  ]);
2382
2395
  var Content = {
2383
2396
  rule: WorkbenchScheduleRuleSchema,
2384
- prompt: z30.string().max(16e3).describe("The execution prompt, or ONLY the user's exact arguments when skill is set. Do not include the skill name, slash prefix, scheduling instructions, or extra explanation in skill arguments."),
2385
- skill: z30.string().min(1).max(256).regex(/^[A-Za-z0-9][A-Za-z0-9_.:-]*$/).optional().describe("A genuine callable skill name from this session, without the leading slash. Set this field when the user requests a skill; put only its exact arguments in prompt.")
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.")
2386
2399
  };
2387
- var WorkbenchScheduleProposalSchema = z30.object(Content).strict().refine((value) => value.prompt.trim().length > 0 || value.skill !== void 0, { message: "A prompt or skill is required" });
2388
- var WorkbenchScheduleDraftSchema = z30.object({
2389
- id: z30.uuid(),
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(),
2390
2403
  createdAt: Time,
2391
2404
  ...Content
2392
2405
  }).strict();
2393
- var WorkbenchScheduleEntrySchema = z30.object({
2406
+ var WorkbenchScheduleEntrySchema = z31.object({
2394
2407
  id: NativeId,
2395
- prompt: z30.string().max(1e5),
2396
- displayPrompt: z30.string().max(1e5).optional(),
2397
- recurring: z30.boolean(),
2408
+ prompt: z31.string().max(1e5),
2409
+ displayPrompt: z31.string().max(1e5).optional(),
2410
+ recurring: z31.boolean(),
2398
2411
  nextRunAt: Time,
2399
- intervalMs: z30.number().int().positive().optional(),
2400
- cron: z30.string().max(256).optional(),
2401
- timezone: z30.string().max(128).optional(),
2412
+ intervalMs: z31.number().int().positive().optional(),
2413
+ cron: z31.string().max(256).optional(),
2414
+ timezone: z31.string().max(128).optional(),
2402
2415
  at: Time.optional()
2403
2416
  }).strict();
2404
- var WorkbenchScheduleResultSchema = z30.object({
2417
+ var WorkbenchScheduleResultSchema = z31.object({
2405
2418
  id: Id,
2406
2419
  scheduleId: NativeId,
2407
2420
  triggerEventId: Id,
2408
2421
  time: Time,
2409
- prompt: z30.string().max(16e3),
2410
- status: z30.enum(["reply", "error", "merged", "pending", "unknown"]),
2411
- reply: z30.string().max(16e3).optional(),
2422
+ prompt: z31.string().max(16e3),
2423
+ status: z31.enum(["reply", "error", "merged", "pending", "unknown"]),
2424
+ reply: z31.string().max(16e3).optional(),
2412
2425
  replyEventId: Id.optional(),
2413
- error: z30.string().max(1024).optional()
2414
- }).strict();
2415
- var WorkbenchScheduleSnapshotSchema = z30.object({
2416
- state: z30.enum(["active", "needs-resume"]),
2417
- workingDirectory: z30.string().max(32768).optional(),
2418
- timezone: z30.string().max(128).optional(),
2419
- entries: z30.array(WorkbenchScheduleEntrySchema).max(256),
2420
- drafts: z30.array(WorkbenchScheduleDraftSchema).max(100),
2421
- results: z30.array(WorkbenchScheduleResultSchema).max(100),
2422
- historyTruncated: z30.boolean(),
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(),
2423
2436
  sampledAt: Time
2424
2437
  }).strict();
2425
2438
  var Submission = {
2426
- operationId: z30.uuid(),
2427
- operationCreatedAt: z30.iso.datetime(),
2439
+ operationId: z31.uuid(),
2440
+ operationCreatedAt: z31.iso.datetime(),
2428
2441
  expectedAgentRunId: Id
2429
2442
  };
2430
- var WorkbenchScheduleCreateRequestSchema = z30.object({
2443
+ var WorkbenchScheduleCreateRequestSchema = z31.object({
2431
2444
  ...Submission,
2432
2445
  ...Content,
2433
- draftId: z30.uuid().optional()
2446
+ draftId: z31.uuid().optional()
2434
2447
  }).strict().refine((value) => value.prompt.trim().length > 0 || value.skill !== void 0, { message: "A prompt or skill is required" });
2435
- var WorkbenchScheduleCreateResultSchema = z30.object({
2448
+ var WorkbenchScheduleCreateResultSchema = z31.object({
2436
2449
  snapshot: WorkbenchScheduleSnapshotSchema,
2437
- verified: z30.boolean()
2450
+ verified: z31.boolean()
2438
2451
  }).strict();
2439
- var WorkbenchScheduleDeleteRequestSchema = z30.object({
2452
+ var WorkbenchScheduleDeleteRequestSchema = z31.object({
2440
2453
  ...Submission,
2441
2454
  id: NativeId
2442
2455
  }).strict();
2443
- var WorkbenchScheduleDeleteResultSchema = z30.object({
2456
+ var WorkbenchScheduleDeleteResultSchema = z31.object({
2444
2457
  snapshot: WorkbenchScheduleSnapshotSchema,
2445
- removed: z30.boolean()
2458
+ removed: z31.boolean()
2446
2459
  }).strict();
2447
- var WorkbenchScheduleDraftDismissRequestSchema = z30.object({
2460
+ var WorkbenchScheduleDraftDismissRequestSchema = z31.object({
2448
2461
  ...Submission,
2449
- draftId: z30.uuid()
2462
+ draftId: z31.uuid()
2450
2463
  }).strict();
2451
2464
  var ScheduleAndroidSchemas = {
2452
2465
  WorkbenchScheduleRule: WorkbenchScheduleRuleSchema,
@@ -2463,10 +2476,10 @@ var ScheduleAndroidSchemas = {
2463
2476
  };
2464
2477
 
2465
2478
  // ../../shared/protocol/dist/workbench.js
2466
- var Id2 = z31.string().trim().min(1).max(256);
2467
- var Text = z31.string().max(1e5);
2468
- var Count = z31.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
2469
- var Failure = z31.object({ code: Id2, message: z31.string().min(1).max(1024) }).strict();
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();
2470
2483
  var WORKBENCH_OPERATIONS = [
2471
2484
  "operation.get",
2472
2485
  "question.ask",
@@ -2485,104 +2498,104 @@ var WORKBENCH_OPERATIONS = [
2485
2498
  ...SCHEDULE_OPERATIONS
2486
2499
  ];
2487
2500
  var Submission2 = {
2488
- operationId: z31.uuid(),
2489
- operationCreatedAt: z31.iso.datetime(),
2501
+ operationId: z32.uuid(),
2502
+ operationCreatedAt: z32.iso.datetime(),
2490
2503
  expectedAgentRunId: Id2
2491
2504
  };
2492
- var WorkbenchOperationGetSchema = z31.object({ operationId: z31.uuid() }).strict();
2493
- var WorkbenchOperationStatusSchema = z31.object({
2494
- operationId: z31.uuid(),
2495
- operation: z31.enum(WORKBENCH_OPERATIONS),
2505
+ var WorkbenchOperationGetSchema = z32.object({ operationId: z32.uuid() }).strict();
2506
+ var WorkbenchOperationStatusSchema = z32.object({
2507
+ operationId: z32.uuid(),
2508
+ operation: z32.enum(WORKBENCH_OPERATIONS),
2496
2509
  agentRunId: Id2,
2497
- state: z31.enum(["running", "succeeded", "failed", "uncertain", "result-expired"]),
2498
- result: z31.record(z31.string(), z31.json()).optional(),
2510
+ state: z32.enum(["running", "succeeded", "failed", "uncertain", "result-expired"]),
2511
+ result: z32.record(z32.string(), z32.json()).optional(),
2499
2512
  error: Failure.optional()
2500
2513
  }).strict().superRefine((value, context) => {
2501
2514
  if (value.state === "succeeded" !== (value.result !== void 0) || (value.state === "failed" || value.state === "uncertain") !== (value.error !== void 0)) {
2502
2515
  context.addIssue({ code: "custom", message: "Invalid operation state payload" });
2503
2516
  }
2504
2517
  });
2505
- var WorkbenchAskRequestSchema = z31.object({
2518
+ var WorkbenchAskRequestSchema = z32.object({
2506
2519
  ...Submission2,
2507
- question: z31.string().trim().min(1).max(16e3)
2520
+ question: z32.string().trim().min(1).max(16e3)
2508
2521
  }).strict();
2509
- var WorkbenchAskResultSchema = z31.object({ answer: Text }).strict();
2510
- var WorkbenchEmptyRequestSchema = z31.object({}).strict();
2511
- var WorkbenchSubmitRequestSchema = z31.object(Submission2).strict();
2512
- var WorkbenchResearchCreateRequestSchema = z31.object({
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({
2513
2526
  ...Submission2,
2514
- title: z31.string().trim().min(1).max(120),
2515
- question: z31.string().trim().min(1).max(16e3),
2527
+ title: z32.string().trim().min(1).max(120),
2528
+ question: z32.string().trim().min(1).max(16e3),
2516
2529
  sourceItemId: Id2.optional(),
2517
- deferInitialPrompt: z31.literal(true).optional()
2530
+ deferInitialPrompt: z32.literal(true).optional()
2518
2531
  }).strict();
2519
- var WorkbenchResearchThreadSchema = z31.object({
2532
+ var WorkbenchResearchThreadSchema = z32.object({
2520
2533
  sessionId: Id2,
2521
2534
  parentSessionId: Id2,
2522
- title: z31.string().min(1).max(120),
2523
- createdAt: z31.iso.datetime(),
2535
+ title: z32.string().min(1).max(120),
2536
+ createdAt: z32.iso.datetime(),
2524
2537
  contextAnchor: Id2.optional(),
2525
- contextTruncated: z31.boolean(),
2526
- detached: z31.boolean(),
2527
- state: z31.enum(["creating", "ready", "failed"])
2538
+ contextTruncated: z32.boolean(),
2539
+ detached: z32.boolean(),
2540
+ state: z32.enum(["creating", "ready", "failed"])
2528
2541
  }).strict();
2529
- var WorkbenchResearchCreateResultSchema = z31.object({
2542
+ var WorkbenchResearchCreateResultSchema = z32.object({
2530
2543
  thread: WorkbenchResearchThreadSchema
2531
2544
  }).strict();
2532
- var WorkbenchResearchListResultSchema = z31.object({
2533
- threads: z31.array(WorkbenchResearchThreadSchema).max(100)
2545
+ var WorkbenchResearchListResultSchema = z32.object({
2546
+ threads: z32.array(WorkbenchResearchThreadSchema).max(100)
2534
2547
  }).strict();
2535
- var WorkbenchResearchTimelineRequestSchema = z31.object({
2548
+ var WorkbenchResearchTimelineRequestSchema = z32.object({
2536
2549
  cursor: Id2.optional()
2537
2550
  }).strict();
2538
- var WorkbenchResearchSendRequestSchema = z31.object({
2551
+ var WorkbenchResearchSendRequestSchema = z32.object({
2539
2552
  ...Submission2,
2540
- prompt: z31.string().trim().min(1).max(16e3)
2541
- }).strict();
2542
- var WorkbenchResearchSendResultSchema = z31.object({ messageId: Id2 }).strict();
2543
- var WorkbenchCompletedResultSchema = z31.object({ completed: z31.boolean() }).strict();
2544
- var WorkbenchCommandSchema = z31.object({
2545
- name: z31.string().min(1).max(260),
2546
- description: z31.string().max(4096),
2547
- argumentHint: z31.string().max(1024).optional(),
2548
- kind: z31.enum(["builtin", "skill", "client"]),
2549
- allowDuringExecution: z31.boolean(),
2550
- supported: z31.boolean(),
2551
- reason: z31.string().max(1024).optional()
2552
- }).strict();
2553
- var WorkbenchCommandListResultSchema = z31.object({
2554
- commands: z31.array(WorkbenchCommandSchema).max(512)
2555
- }).strict();
2556
- var WorkbenchCommandInvokeRequestSchema = z31.object({
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({
2557
2570
  ...Submission2,
2558
- name: z31.string().trim().min(1).max(260),
2559
- input: z31.string().max(16e3)
2560
- }).strict();
2561
- var WorkbenchCommandChoiceSchema = z31.object({
2562
- name: z31.string().min(1).max(260),
2563
- label: z31.string().min(1).max(1024),
2564
- input: z31.string().max(16e3)
2565
- }).strict();
2566
- var WorkbenchCommandResultSchema = z31.discriminatedUnion("kind", [
2567
- z31.object({ kind: z31.literal("text"), text: Text }).strict(),
2568
- z31.object({ kind: z31.literal("completed") }).strict(),
2569
- z31.object({ kind: z31.literal("sent"), messageId: Id2 }).strict(),
2570
- z31.object({
2571
- kind: z31.literal("select-subcommand"),
2572
- choices: z31.array(WorkbenchCommandChoiceSchema).min(1).max(100)
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)
2573
2586
  }).strict()
2574
2587
  ]);
2575
- var WorkbenchQueueItemSchema = z31.object({
2588
+ var WorkbenchQueueItemSchema = z32.object({
2576
2589
  id: Id2,
2577
- kind: z31.string().min(1).max(64),
2578
- texts: z31.array(z31.string().max(1e5)).min(1).max(100),
2579
- actions: z31.array(z31.enum(["edit", "remove", "move", "send-now"])).max(4)
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)
2580
2593
  }).strict();
2581
- var WorkbenchQueueSnapshotSchema = z31.object({
2594
+ var WorkbenchQueueSnapshotSchema = z32.object({
2582
2595
  generation: Id2,
2583
2596
  revision: Id2,
2584
- items: z31.array(WorkbenchQueueItemSchema).max(512),
2585
- steeringMessages: z31.array(z31.string().max(1e5)).max(512)
2597
+ items: z32.array(WorkbenchQueueItemSchema).max(512),
2598
+ steeringMessages: z32.array(z32.string().max(1e5)).max(512)
2586
2599
  }).strict();
2587
2600
  var QueueMutation = {
2588
2601
  ...Submission2,
@@ -2590,48 +2603,48 @@ var QueueMutation = {
2590
2603
  revision: Id2,
2591
2604
  id: Id2
2592
2605
  };
2593
- var WorkbenchQueueMutationRequestSchema = z31.discriminatedUnion("action", [
2594
- z31.object({ ...QueueMutation, action: z31.literal("edit"), prompt: z31.string().trim().min(1).max(1e5) }).strict(),
2595
- z31.object({ ...QueueMutation, action: z31.literal("remove") }).strict(),
2596
- z31.object({ ...QueueMutation, action: z31.literal("move"), toPosition: z31.number().int().min(0).max(511) }).strict(),
2597
- z31.object({ ...QueueMutation, action: z31.literal("send-now") }).strict()
2598
- ]);
2599
- var WorkbenchQueueMutationResultSchema = z31.object({
2600
- changed: z31.boolean(),
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(),
2601
2614
  snapshot: WorkbenchQueueSnapshotSchema
2602
2615
  }).strict();
2603
- var WorkbenchTokenMetricSchema = z31.object({
2604
- kind: z31.string().min(1).max(128),
2616
+ var WorkbenchTokenMetricSchema = z32.object({
2617
+ kind: z32.string().min(1).max(128),
2605
2618
  count: Count
2606
2619
  }).strict();
2607
- var WorkbenchModelUsageSchema = z31.object({
2620
+ var WorkbenchModelUsageSchema = z32.object({
2608
2621
  model: Id2,
2609
2622
  requests: Count,
2610
- premiumRequestCost: z31.number().finite().nonnegative(),
2611
- tokens: z31.array(WorkbenchTokenMetricSchema).max(32)
2623
+ premiumRequestCost: z32.number().finite().nonnegative(),
2624
+ tokens: z32.array(WorkbenchTokenMetricSchema).max(32)
2612
2625
  }).strict();
2613
- var WorkbenchContextSchema = z31.object({
2626
+ var WorkbenchContextSchema = z32.object({
2614
2627
  currentTokens: Count,
2615
2628
  tokenLimit: Count,
2616
2629
  systemTokens: Count.optional(),
2617
2630
  conversationTokens: Count.optional(),
2618
2631
  toolTokens: Count.optional()
2619
2632
  }).strict();
2620
- var WorkbenchInsightsSchema = z31.object({
2621
- sampledAt: z31.iso.datetime(),
2633
+ var WorkbenchInsightsSchema = z32.object({
2634
+ sampledAt: z32.iso.datetime(),
2622
2635
  generation: Id2,
2623
2636
  model: Id2.optional(),
2624
2637
  totalUserRequests: Count,
2625
- premiumRequestCost: z31.number().finite().nonnegative(),
2626
- nanoAiu: z31.string().regex(/^\d+$/).max(40).optional(),
2627
- tokens: z31.array(WorkbenchTokenMetricSchema).max(32),
2628
- models: z31.array(WorkbenchModelUsageSchema).max(100),
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),
2629
2642
  context: WorkbenchContextSchema.optional(),
2630
- canCompact: z31.boolean(),
2631
- compactUnavailableReason: z31.string().max(1024).optional()
2643
+ canCompact: z32.boolean(),
2644
+ compactUnavailableReason: z32.string().max(1024).optional()
2632
2645
  }).strict();
2633
- var WorkbenchCompactResultSchema = z31.object({
2634
- success: z31.boolean(),
2646
+ var WorkbenchCompactResultSchema = z32.object({
2647
+ success: z32.boolean(),
2635
2648
  tokensRemoved: Count,
2636
2649
  messagesRemoved: Count
2637
2650
  }).strict();
@@ -2666,8 +2679,8 @@ var WorkbenchAndroidSchemas = {
2666
2679
  };
2667
2680
 
2668
2681
  // ../../shared/protocol/dist/microsoft-todo.js
2669
- import { z as z32 } from "zod";
2670
- var MicrosoftTodoOperationSchema = z32.enum([
2682
+ import { z as z33 } from "zod";
2683
+ var MicrosoftTodoOperationSchema = z33.enum([
2671
2684
  "status",
2672
2685
  "connect",
2673
2686
  "disconnect",
@@ -2682,66 +2695,66 @@ var MicrosoftTodoOperationSchema = z32.enum([
2682
2695
  "update_task",
2683
2696
  "delete_task"
2684
2697
  ]);
2685
- var MicrosoftTodoIdSchema = z32.string().min(1).max(1024).regex(/^[A-Za-z0-9_/=+-]+$/);
2686
- var MicrosoftTodoDateTimeSchema = z32.object({
2687
- dateTime: z32.string().min(1).max(64).regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,7})?$/),
2688
- timeZone: z32.string().min(1).max(128)
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)
2689
2702
  }).strict();
2690
- var MicrosoftTodoTaskInputSchema = z32.object({
2691
- title: z32.string().trim().min(1).max(1e3).optional(),
2692
- body: z32.object({
2693
- content: z32.string().max(16e3),
2694
- contentType: z32.literal("text")
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")
2695
2708
  }).strict().optional(),
2696
- status: z32.enum(["notStarted", "inProgress", "completed", "waitingOnOthers", "deferred"]).optional(),
2697
- importance: z32.enum(["low", "normal", "high"]).optional(),
2709
+ status: z33.enum(["notStarted", "inProgress", "completed", "waitingOnOthers", "deferred"]).optional(),
2710
+ importance: z33.enum(["low", "normal", "high"]).optional(),
2698
2711
  dueDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
2699
2712
  reminderDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
2700
- isReminderOn: z32.boolean().optional()
2713
+ isReminderOn: z33.boolean().optional()
2701
2714
  }).strict();
2702
- var MicrosoftTodoListInputSchema = z32.object({
2703
- displayName: z32.string().trim().min(1).max(255)
2715
+ var MicrosoftTodoListInputSchema = z33.object({
2716
+ displayName: z33.string().trim().min(1).max(255)
2704
2717
  }).strict();
2705
- var MicrosoftTodoRequestSchema = z32.object({
2718
+ var MicrosoftTodoRequestSchema = z33.object({
2706
2719
  operation: MicrosoftTodoOperationSchema,
2707
2720
  listId: MicrosoftTodoIdSchema.optional(),
2708
2721
  taskId: MicrosoftTodoIdSchema.optional(),
2709
2722
  list: MicrosoftTodoListInputSchema.optional(),
2710
2723
  task: MicrosoftTodoTaskInputSchema.optional(),
2711
- cursor: z32.string().min(1).max(8192).optional(),
2712
- etag: z32.string().min(1).max(512).regex(/^[^\r\n]+$/).optional()
2724
+ cursor: z33.string().min(1).max(8192).optional(),
2725
+ etag: z33.string().min(1).max(512).regex(/^[^\r\n]+$/).optional()
2713
2726
  }).strict();
2714
- var MicrosoftTodoListSchema = z32.object({
2727
+ var MicrosoftTodoListSchema = z33.object({
2715
2728
  id: MicrosoftTodoIdSchema,
2716
- displayName: z32.string().max(1e3),
2717
- isOwner: z32.boolean(),
2718
- isShared: z32.boolean(),
2719
- wellknownListName: z32.string().max(128),
2720
- etag: z32.string().max(512).optional()
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()
2721
2734
  }).strict();
2722
- var MicrosoftTodoTaskSchema = z32.object({
2735
+ var MicrosoftTodoTaskSchema = z33.object({
2723
2736
  id: MicrosoftTodoIdSchema,
2724
- title: z32.string().max(1e3),
2725
- body: z32.object({ content: z32.string().max(16e3), contentType: z32.string().max(32) }).strict(),
2726
- status: z32.string().max(64),
2727
- importance: z32.string().max(32),
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),
2728
2741
  dueDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
2729
2742
  reminderDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
2730
- isReminderOn: z32.boolean(),
2731
- lastModifiedDateTime: z32.string().max(64),
2732
- etag: z32.string().max(512).optional()
2733
- }).strict();
2734
- var MicrosoftTodoResultSchema = z32.object({
2735
- ok: z32.literal(true),
2736
- enabled: z32.boolean(),
2737
- connected: z32.boolean(),
2738
- authorizationUrl: z32.url().optional(),
2739
- lists: z32.array(MicrosoftTodoListSchema).max(100).optional(),
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(),
2740
2753
  list: MicrosoftTodoListSchema.optional(),
2741
- tasks: z32.array(MicrosoftTodoTaskSchema).max(100).optional(),
2754
+ tasks: z33.array(MicrosoftTodoTaskSchema).max(100).optional(),
2742
2755
  task: MicrosoftTodoTaskSchema.optional(),
2743
- nextCursor: z32.string().max(8192).optional(),
2744
- deleted: z32.boolean().optional()
2756
+ nextCursor: z33.string().max(8192).optional(),
2757
+ deleted: z33.boolean().optional()
2745
2758
  }).strict();
2746
2759
  var MicrosoftTodoAndroidSchemas = {
2747
2760
  MicrosoftTodoDateTime: MicrosoftTodoDateTimeSchema,
@@ -2754,12 +2767,12 @@ var MicrosoftTodoAndroidSchemas = {
2754
2767
  };
2755
2768
 
2756
2769
  // ../../shared/protocol/dist/relay-features.js
2757
- import { z as z33 } from "zod";
2758
- var RelayFeaturesSchema = z33.object({
2759
- microsoftTodo: z33.boolean(),
2760
- modelGateway: z33.boolean(),
2761
- sessionImages: z33.boolean(),
2762
- webClient: z33.boolean()
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()
2763
2776
  }).strict();
2764
2777
  var RelayFeatureAndroidSchemas = { RelayFeatures: RelayFeaturesSchema };
2765
2778
 
@@ -2772,6 +2785,8 @@ var AndroidProtocolSchemas = {
2772
2785
  MobileAuthorizationResult: MobileAuthorizationResultSchema,
2773
2786
  BrowserOpenUrlParams: BrowserOpenUrlParamsSchema,
2774
2787
  BrowserOpenUrlResult: BrowserOpenUrlResultSchema,
2788
+ DeviceTextInputData: DeviceTextInputDataSchema,
2789
+ DeviceTextInputResult: DeviceTextInputResultSchema,
2775
2790
  TimelineImageBlobRequest: TimelineImageBlobRequestSchema,
2776
2791
  TimelineImageBlobResult: TimelineImageBlobResultSchema,
2777
2792
  SessionImageUploadRequest: SessionImageUploadRequestSchema,