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