@agentknight/client 0.9.57 → 0.9.59

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