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