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