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