@agentknight/client 0.9.49 → 0.9.50
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/LICENSE +201 -201
- package/README.md +356 -341
- package/dist/chunks/aad-relay-login-NABH6HML.js +14 -0
- package/dist/chunks/{chunk-NHA7HI6P.js → chunk-CYCBYXFV.js} +1 -1
- package/dist/chunks/{chunk-OZKXJ6L4.js → chunk-HWCSV7QP.js} +1305 -1087
- package/dist/chunks/chunk-XODJ7TIT.js +475 -0
- package/dist/chunks/{local-sessions-EZUANCR4.js → local-sessions-CLY45IWB.js} +1 -1
- package/dist/chunks/start-client-VGGH7W42.js +3971 -0
- package/dist/cli.js +12 -5
- package/dist/upgrade-worker.js +200 -4
- package/package.json +12 -4
- package/dist/chunks/start-client-C3PK6POG.js +0 -3428
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
#!/usr/bin/env node
|
|
2
2
|
|
|
3
|
-
// ../../shared/protocol/dist/
|
|
4
|
-
import { z as
|
|
3
|
+
// ../../shared/protocol/dist/auth/authentication.js
|
|
4
|
+
import { z as z4 } from "zod";
|
|
5
5
|
|
|
6
6
|
// ../../shared/protocol/dist/common/primitives.js
|
|
7
7
|
import { z } from "zod";
|
|
@@ -30,31 +30,199 @@ var ProtocolErrorSchema = z2.object({
|
|
|
30
30
|
message: z2.string().min(1).max(1024)
|
|
31
31
|
});
|
|
32
32
|
|
|
33
|
+
// ../../shared/protocol/dist/auth/mobile-identity.js
|
|
34
|
+
import { z as z3 } from "zod";
|
|
35
|
+
var MobileAuthorizationIdSchema = z3.string().regex(/^[A-Za-z0-9_-]{43}$/u);
|
|
36
|
+
var MobileIdentityProofSchema = z3.object({
|
|
37
|
+
timestamp: z3.number().int().positive(),
|
|
38
|
+
nonce: MobileAuthorizationIdSchema,
|
|
39
|
+
signature: z3.string().regex(/^[A-Za-z0-9_-]+$/u).min(340).max(700)
|
|
40
|
+
}).strict();
|
|
41
|
+
|
|
42
|
+
// ../../shared/protocol/dist/auth/authentication.js
|
|
43
|
+
var UserRoleSchema = z4.enum(["admin", "user"]);
|
|
44
|
+
var PasswordSchema = z4.string().min(1).max(4096);
|
|
45
|
+
var PcTokenLabelSchema = z4.string().trim().min(1).max(120);
|
|
46
|
+
var AuthUserSchema = z4.object({
|
|
47
|
+
userId: IdSchema,
|
|
48
|
+
username: UsernameSchema,
|
|
49
|
+
role: UserRoleSchema
|
|
50
|
+
}).strict();
|
|
51
|
+
var AadAccountResultSchema = z4.object({
|
|
52
|
+
authMode: z4.literal("aad"),
|
|
53
|
+
user: AuthUserSchema
|
|
54
|
+
}).strict();
|
|
55
|
+
var RELAY_AUTH_DISCOVERY_PATH = "/.well-known/agentknight-auth";
|
|
56
|
+
var RelayAuthenticationSchema = z4.discriminatedUnion("mode", [
|
|
57
|
+
z4.object({ mode: z4.literal("microsoft") }).strict(),
|
|
58
|
+
z4.object({
|
|
59
|
+
mode: z4.literal("aad"),
|
|
60
|
+
tenantId: z4.uuid(),
|
|
61
|
+
clientId: z4.uuid(),
|
|
62
|
+
apiClientId: z4.uuid()
|
|
63
|
+
}).strict()
|
|
64
|
+
]);
|
|
65
|
+
var RelayAuthDiscoverySchema = z4.object({
|
|
66
|
+
version: z4.literal(1),
|
|
67
|
+
authentication: z4.discriminatedUnion("mode", [...RelayAuthenticationSchema.options, z4.object({ mode: z4.literal("token") }).strict()])
|
|
68
|
+
}).strict();
|
|
69
|
+
var LoginRequestSchema = z4.object({
|
|
70
|
+
username: UsernameSchema,
|
|
71
|
+
password: PasswordSchema
|
|
72
|
+
});
|
|
73
|
+
var LoginResultSchema = z4.discriminatedUnion("ok", [
|
|
74
|
+
z4.object({
|
|
75
|
+
ok: z4.literal(true),
|
|
76
|
+
accessToken: z4.string().min(32),
|
|
77
|
+
expiresAt: z4.number().int().positive(),
|
|
78
|
+
user: AuthUserSchema
|
|
79
|
+
}),
|
|
80
|
+
z4.object({
|
|
81
|
+
ok: z4.literal(false),
|
|
82
|
+
error: ProtocolFailureSchema
|
|
83
|
+
})
|
|
84
|
+
]);
|
|
85
|
+
var MobileLoginRequestSchema = z4.object({
|
|
86
|
+
mobileCredential: z4.string().min(64).max(4096),
|
|
87
|
+
clientId: IdSchema,
|
|
88
|
+
proof: MobileIdentityProofSchema.optional()
|
|
89
|
+
});
|
|
90
|
+
var PcAccountRequestSchema = z4.object({
|
|
91
|
+
userId: IdSchema,
|
|
92
|
+
machineId: IdSchema
|
|
93
|
+
}).strict();
|
|
94
|
+
var PcAccountResultSchema = z4.discriminatedUnion("ok", [
|
|
95
|
+
z4.object({
|
|
96
|
+
ok: z4.literal(true),
|
|
97
|
+
user: AuthUserSchema,
|
|
98
|
+
method: z4.enum(["microsoft", "token"])
|
|
99
|
+
}).strict(),
|
|
100
|
+
z4.object({
|
|
101
|
+
ok: z4.literal(false),
|
|
102
|
+
error: ProtocolFailureSchema
|
|
103
|
+
}).strict()
|
|
104
|
+
]);
|
|
105
|
+
var AdminUserSummarySchema = z4.object({
|
|
106
|
+
userId: IdSchema,
|
|
107
|
+
username: UsernameSchema,
|
|
108
|
+
role: UserRoleSchema,
|
|
109
|
+
createdAt: z4.number().int().nonnegative(),
|
|
110
|
+
updatedAt: z4.number().int().nonnegative(),
|
|
111
|
+
disabledAt: z4.number().int().nonnegative().nullable()
|
|
112
|
+
}).strict();
|
|
113
|
+
var AdminFailureResultSchema = z4.object({
|
|
114
|
+
ok: z4.literal(false),
|
|
115
|
+
error: ProtocolFailureSchema
|
|
116
|
+
}).strict();
|
|
117
|
+
var AdminUserListResultSchema = z4.discriminatedUnion("ok", [
|
|
118
|
+
z4.object({
|
|
119
|
+
ok: z4.literal(true),
|
|
120
|
+
users: z4.array(AdminUserSummarySchema)
|
|
121
|
+
}).strict(),
|
|
122
|
+
AdminFailureResultSchema
|
|
123
|
+
]);
|
|
124
|
+
var AdminUserCreateRequestSchema = z4.object({
|
|
125
|
+
username: UsernameSchema,
|
|
126
|
+
password: PasswordSchema
|
|
127
|
+
}).strict();
|
|
128
|
+
var AdminUserCreateResultSchema = z4.discriminatedUnion("ok", [
|
|
129
|
+
z4.object({
|
|
130
|
+
ok: z4.literal(true),
|
|
131
|
+
user: AdminUserSummarySchema
|
|
132
|
+
}).strict(),
|
|
133
|
+
AdminFailureResultSchema
|
|
134
|
+
]);
|
|
135
|
+
var AdminUserStatusRequestSchema = z4.object({
|
|
136
|
+
userId: IdSchema,
|
|
137
|
+
disabled: z4.boolean()
|
|
138
|
+
}).strict();
|
|
139
|
+
var AdminUserStatusResultSchema = z4.discriminatedUnion("ok", [
|
|
140
|
+
z4.object({
|
|
141
|
+
ok: z4.literal(true),
|
|
142
|
+
user: AdminUserSummarySchema
|
|
143
|
+
}).strict(),
|
|
144
|
+
AdminFailureResultSchema
|
|
145
|
+
]);
|
|
146
|
+
var AdminUserPasswordRequestSchema = z4.object({
|
|
147
|
+
userId: IdSchema,
|
|
148
|
+
password: PasswordSchema
|
|
149
|
+
}).strict();
|
|
150
|
+
var AdminUserPasswordResultSchema = z4.discriminatedUnion("ok", [
|
|
151
|
+
z4.object({
|
|
152
|
+
ok: z4.literal(true),
|
|
153
|
+
user: AdminUserSummarySchema
|
|
154
|
+
}).strict(),
|
|
155
|
+
AdminFailureResultSchema
|
|
156
|
+
]);
|
|
157
|
+
var PcServiceTokenSummarySchema = z4.object({
|
|
158
|
+
tokenId: IdSchema,
|
|
159
|
+
userId: IdSchema,
|
|
160
|
+
label: PcTokenLabelSchema,
|
|
161
|
+
createdAt: z4.number().int().nonnegative(),
|
|
162
|
+
lastUsedAt: z4.number().int().nonnegative().nullable(),
|
|
163
|
+
revokedAt: z4.number().int().nonnegative().nullable()
|
|
164
|
+
}).strict();
|
|
165
|
+
var AdminPcTokenListRequestSchema = z4.object({
|
|
166
|
+
userId: IdSchema
|
|
167
|
+
}).strict();
|
|
168
|
+
var AdminPcTokenListResultSchema = z4.discriminatedUnion("ok", [
|
|
169
|
+
z4.object({
|
|
170
|
+
ok: z4.literal(true),
|
|
171
|
+
tokens: z4.array(PcServiceTokenSummarySchema)
|
|
172
|
+
}).strict(),
|
|
173
|
+
AdminFailureResultSchema
|
|
174
|
+
]);
|
|
175
|
+
var AdminPcTokenIssueRequestSchema = z4.object({
|
|
176
|
+
userId: IdSchema,
|
|
177
|
+
label: PcTokenLabelSchema
|
|
178
|
+
}).strict();
|
|
179
|
+
var AdminPcTokenIssueResultSchema = z4.discriminatedUnion("ok", [
|
|
180
|
+
z4.object({
|
|
181
|
+
ok: z4.literal(true),
|
|
182
|
+
token: z4.string().min(32).max(256),
|
|
183
|
+
pcToken: PcServiceTokenSummarySchema
|
|
184
|
+
}).strict(),
|
|
185
|
+
AdminFailureResultSchema
|
|
186
|
+
]);
|
|
187
|
+
var AdminPcTokenRevokeRequestSchema = z4.object({
|
|
188
|
+
tokenId: IdSchema
|
|
189
|
+
}).strict();
|
|
190
|
+
var AdminPcTokenRevokeResultSchema = z4.discriminatedUnion("ok", [
|
|
191
|
+
z4.object({
|
|
192
|
+
ok: z4.literal(true),
|
|
193
|
+
pcToken: PcServiceTokenSummarySchema
|
|
194
|
+
}).strict(),
|
|
195
|
+
AdminFailureResultSchema
|
|
196
|
+
]);
|
|
197
|
+
|
|
198
|
+
// ../../shared/protocol/dist/conversation/timeline.js
|
|
199
|
+
import { z as z7 } from "zod";
|
|
200
|
+
|
|
33
201
|
// ../../shared/protocol/dist/conversation/conversation.js
|
|
34
|
-
import { z as
|
|
202
|
+
import { z as z6 } from "zod";
|
|
35
203
|
|
|
36
204
|
// ../../shared/protocol/dist/conversation/attachments.js
|
|
37
|
-
import { z as
|
|
205
|
+
import { z as z5 } from "zod";
|
|
38
206
|
var MAX_INLINE_IMAGE_BYTES = 3 * 1024 * 1024;
|
|
39
207
|
var MAX_INLINE_HTML_BYTES = 512 * 1024;
|
|
40
208
|
var MAX_PROMPT_FILE_BYTES = 1024 * 1024;
|
|
41
|
-
var InlineImageMimeTypeSchema =
|
|
209
|
+
var InlineImageMimeTypeSchema = z5.enum([
|
|
42
210
|
"image/gif",
|
|
43
211
|
"image/jpeg",
|
|
44
212
|
"image/png",
|
|
45
213
|
"image/webp"
|
|
46
214
|
]);
|
|
47
|
-
var Base64DataSchema =
|
|
48
|
-
var Sha256Schema =
|
|
215
|
+
var Base64DataSchema = z5.string().min(4).max(Math.ceil(MAX_INLINE_IMAGE_BYTES / 3) * 4).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/, "Expected canonical base64 data");
|
|
216
|
+
var Sha256Schema = z5.string().regex(/^[a-f0-9]{64}$/);
|
|
49
217
|
function decodedBase64ByteLength(value) {
|
|
50
218
|
const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
|
|
51
219
|
return value.length / 4 * 3 - padding;
|
|
52
220
|
}
|
|
53
|
-
var PromptImageAttachmentSchema =
|
|
54
|
-
name:
|
|
55
|
-
mimeType:
|
|
221
|
+
var PromptImageAttachmentSchema = z5.object({
|
|
222
|
+
name: z5.string().trim().min(1).max(255),
|
|
223
|
+
mimeType: z5.enum(["image/jpeg", "image/png", "image/webp"]),
|
|
56
224
|
data: Base64DataSchema,
|
|
57
|
-
byteLength:
|
|
225
|
+
byteLength: z5.number().int().positive().max(MAX_INLINE_IMAGE_BYTES),
|
|
58
226
|
sha256: Sha256Schema
|
|
59
227
|
}).strict().superRefine((attachment, context) => {
|
|
60
228
|
if (decodedBase64ByteLength(attachment.data) !== attachment.byteLength) {
|
|
@@ -65,11 +233,11 @@ var PromptImageAttachmentSchema = z3.object({
|
|
|
65
233
|
});
|
|
66
234
|
}
|
|
67
235
|
});
|
|
68
|
-
var PromptFileAttachmentSchema =
|
|
69
|
-
name:
|
|
70
|
-
mimeType:
|
|
236
|
+
var PromptFileAttachmentSchema = z5.object({
|
|
237
|
+
name: z5.string().trim().min(1).max(255).regex(/^[^\\/\x00-\x1f\x7f]+$/).refine((name) => name !== "." && name !== "..", "Expected a filename"),
|
|
238
|
+
mimeType: z5.string().max(256).regex(/^[a-zA-Z0-9!#$&^_.+-]+\/[a-zA-Z0-9!#$&^_.+-]+$/),
|
|
71
239
|
data: Base64DataSchema.max(Math.ceil(MAX_PROMPT_FILE_BYTES / 3) * 4),
|
|
72
|
-
byteLength:
|
|
240
|
+
byteLength: z5.number().int().positive().max(MAX_PROMPT_FILE_BYTES),
|
|
73
241
|
sha256: Sha256Schema
|
|
74
242
|
}).strict().superRefine((attachment, context) => {
|
|
75
243
|
if (decodedBase64ByteLength(attachment.data) !== attachment.byteLength) {
|
|
@@ -80,8 +248,8 @@ var PromptFileAttachmentSchema = z3.object({
|
|
|
80
248
|
});
|
|
81
249
|
}
|
|
82
250
|
});
|
|
83
|
-
var ConversationAttachmentSchema =
|
|
84
|
-
kind:
|
|
251
|
+
var ConversationAttachmentSchema = z5.object({
|
|
252
|
+
kind: z5.enum([
|
|
85
253
|
"file",
|
|
86
254
|
"image",
|
|
87
255
|
"html",
|
|
@@ -89,13 +257,13 @@ var ConversationAttachmentSchema = z3.object({
|
|
|
89
257
|
"github-reference",
|
|
90
258
|
"unknown"
|
|
91
259
|
]),
|
|
92
|
-
name:
|
|
93
|
-
mimeType:
|
|
94
|
-
uri:
|
|
260
|
+
name: z5.string().trim().min(1).max(1024),
|
|
261
|
+
mimeType: z5.string().trim().min(1).max(256).optional(),
|
|
262
|
+
uri: z5.string().trim().min(1).max(32768).optional(),
|
|
95
263
|
data: Base64DataSchema.optional(),
|
|
96
|
-
byteLength:
|
|
264
|
+
byteLength: z5.number().int().positive().max(MAX_INLINE_IMAGE_BYTES).optional(),
|
|
97
265
|
sha256: Sha256Schema.optional(),
|
|
98
|
-
imageRef:
|
|
266
|
+
imageRef: z5.literal("sha256").optional()
|
|
99
267
|
}).strict().superRefine((attachment, context) => {
|
|
100
268
|
if (attachment.imageRef !== void 0) {
|
|
101
269
|
if (attachment.kind !== "image" || attachment.data !== void 0 || attachment.sha256 === void 0 || attachment.byteLength === void 0 || !InlineImageMimeTypeSchema.safeParse(attachment.mimeType).success) {
|
|
@@ -157,12 +325,12 @@ var CONVERSATION_ACTIVITY_STEP_LIMIT = 1e3;
|
|
|
157
325
|
var CONVERSATION_SOURCE_ID_LIMIT = 1e3;
|
|
158
326
|
var ConversationItemBaseShape = {
|
|
159
327
|
id: IdSchema,
|
|
160
|
-
revision:
|
|
328
|
+
revision: z6.number().int().positive(),
|
|
161
329
|
turnId: IdSchema,
|
|
162
330
|
timestamp: IsoDateSchema,
|
|
163
|
-
sourceEventIds:
|
|
164
|
-
sourceMessageIds:
|
|
165
|
-
sourceInteractionIds:
|
|
331
|
+
sourceEventIds: z6.array(IdSchema).min(1).max(CONVERSATION_SOURCE_ID_LIMIT),
|
|
332
|
+
sourceMessageIds: z6.array(IdSchema).min(1).max(CONVERSATION_SOURCE_ID_LIMIT).optional(),
|
|
333
|
+
sourceInteractionIds: z6.array(IdSchema).min(1).max(CONVERSATION_SOURCE_ID_LIMIT).optional()
|
|
166
334
|
};
|
|
167
335
|
var MAX_INLINE_IMAGE_MESSAGE_BYTES = 3 * 1024 * 1024;
|
|
168
336
|
var MAX_INLINE_IMAGES_PER_MESSAGE = 4;
|
|
@@ -170,67 +338,67 @@ var ActivityStepTimeShape = {
|
|
|
170
338
|
// First observed event time; completion updates must not move an existing call.
|
|
171
339
|
timestamp: IsoDateSchema.optional()
|
|
172
340
|
};
|
|
173
|
-
var ConversationToolStepSchema =
|
|
341
|
+
var ConversationToolStepSchema = z6.object({
|
|
174
342
|
id: IdSchema,
|
|
175
|
-
kind:
|
|
176
|
-
name:
|
|
177
|
-
status:
|
|
343
|
+
kind: z6.literal("tool"),
|
|
344
|
+
name: z6.string().trim().min(1).max(256),
|
|
345
|
+
status: z6.enum(["running", "completed", "failed"]),
|
|
178
346
|
...ActivityStepTimeShape
|
|
179
347
|
}).strict();
|
|
180
|
-
var ConversationSkillStepSchema =
|
|
348
|
+
var ConversationSkillStepSchema = z6.object({
|
|
181
349
|
id: IdSchema,
|
|
182
|
-
kind:
|
|
183
|
-
name:
|
|
184
|
-
status:
|
|
185
|
-
description:
|
|
186
|
-
source:
|
|
350
|
+
kind: z6.literal("skill"),
|
|
351
|
+
name: z6.string().trim().min(1).max(256),
|
|
352
|
+
status: z6.literal("completed"),
|
|
353
|
+
description: z6.string().trim().min(1).max(2048).optional(),
|
|
354
|
+
source: z6.string().trim().min(1).max(256).optional(),
|
|
187
355
|
...ActivityStepTimeShape
|
|
188
356
|
}).strict();
|
|
189
|
-
var ConversationSubagentStepSchema =
|
|
357
|
+
var ConversationSubagentStepSchema = z6.object({
|
|
190
358
|
id: IdSchema,
|
|
191
|
-
kind:
|
|
192
|
-
name:
|
|
193
|
-
status:
|
|
194
|
-
description:
|
|
195
|
-
model:
|
|
196
|
-
durationMs:
|
|
197
|
-
resultSummary:
|
|
198
|
-
error:
|
|
359
|
+
kind: z6.literal("subagent"),
|
|
360
|
+
name: z6.string().trim().min(1).max(256),
|
|
361
|
+
status: z6.enum(["running", "completed", "failed"]),
|
|
362
|
+
description: z6.string().trim().min(1).max(2048).optional(),
|
|
363
|
+
model: z6.string().trim().min(1).max(256).optional(),
|
|
364
|
+
durationMs: z6.number().int().nonnegative().optional(),
|
|
365
|
+
resultSummary: z6.string().max(4096).optional(),
|
|
366
|
+
error: z6.string().max(4096).optional(),
|
|
199
367
|
...ActivityStepTimeShape
|
|
200
368
|
}).strict();
|
|
201
|
-
var ConversationPermissionStepSchema =
|
|
369
|
+
var ConversationPermissionStepSchema = z6.object({
|
|
202
370
|
id: IdSchema,
|
|
203
|
-
kind:
|
|
204
|
-
name:
|
|
205
|
-
status:
|
|
206
|
-
description:
|
|
207
|
-
resultSummary:
|
|
208
|
-
error:
|
|
371
|
+
kind: z6.literal("permission"),
|
|
372
|
+
name: z6.string().trim().min(1).max(256),
|
|
373
|
+
status: z6.enum(["running", "completed", "failed"]),
|
|
374
|
+
description: z6.string().trim().min(1).max(2048).optional(),
|
|
375
|
+
resultSummary: z6.string().max(4096).optional(),
|
|
376
|
+
error: z6.string().max(4096).optional(),
|
|
209
377
|
...ActivityStepTimeShape
|
|
210
378
|
}).strict();
|
|
211
|
-
var ConversationActivityStepSchema =
|
|
379
|
+
var ConversationActivityStepSchema = z6.discriminatedUnion("kind", [
|
|
212
380
|
ConversationToolStepSchema,
|
|
213
381
|
ConversationSkillStepSchema,
|
|
214
382
|
ConversationSubagentStepSchema,
|
|
215
383
|
ConversationPermissionStepSchema
|
|
216
384
|
]);
|
|
217
|
-
var ConversationHumanMessageSchema =
|
|
385
|
+
var ConversationHumanMessageSchema = z6.object({
|
|
218
386
|
...ConversationItemBaseShape,
|
|
219
|
-
kind:
|
|
220
|
-
actor:
|
|
221
|
-
content:
|
|
222
|
-
attachments:
|
|
387
|
+
kind: z6.literal("human-message"),
|
|
388
|
+
actor: z6.literal("human"),
|
|
389
|
+
content: z6.string().max(1e5),
|
|
390
|
+
attachments: z6.array(ConversationAttachmentSchema).max(100),
|
|
223
391
|
operationId: IdSchema.optional()
|
|
224
392
|
}).strict();
|
|
225
|
-
var ConversationAssistantMessageSchema =
|
|
393
|
+
var ConversationAssistantMessageSchema = z6.object({
|
|
226
394
|
...ConversationItemBaseShape,
|
|
227
|
-
kind:
|
|
228
|
-
actor:
|
|
229
|
-
content:
|
|
230
|
-
attachments:
|
|
231
|
-
model:
|
|
395
|
+
kind: z6.literal("assistant-message"),
|
|
396
|
+
actor: z6.enum(["assistant", "subagent"]),
|
|
397
|
+
content: z6.string().max(5e5),
|
|
398
|
+
attachments: z6.array(ConversationAttachmentSchema).max(100).optional(),
|
|
399
|
+
model: z6.string().trim().min(1).max(256).optional(),
|
|
232
400
|
agentId: IdSchema.optional(),
|
|
233
|
-
final:
|
|
401
|
+
final: z6.boolean()
|
|
234
402
|
}).strict().superRefine((message, context) => {
|
|
235
403
|
const inlineImages = message.attachments?.filter((attachment) => attachment.kind === "image" && attachment.data !== void 0) ?? [];
|
|
236
404
|
if (inlineImages.length > MAX_INLINE_IMAGES_PER_MESSAGE) {
|
|
@@ -249,371 +417,233 @@ var ConversationAssistantMessageSchema = z4.object({
|
|
|
249
417
|
});
|
|
250
418
|
}
|
|
251
419
|
});
|
|
252
|
-
var ConversationActivityGroupSchema =
|
|
420
|
+
var ConversationActivityGroupSchema = z6.object({
|
|
253
421
|
...ConversationItemBaseShape,
|
|
254
|
-
kind:
|
|
255
|
-
actor:
|
|
256
|
-
status:
|
|
257
|
-
steps:
|
|
422
|
+
kind: z6.literal("activity-group"),
|
|
423
|
+
actor: z6.enum(["assistant", "subagent"]),
|
|
424
|
+
status: z6.enum(["running", "completed", "failed"]),
|
|
425
|
+
steps: z6.array(ConversationActivityStepSchema).max(CONVERSATION_ACTIVITY_STEP_LIMIT)
|
|
258
426
|
}).strict();
|
|
259
|
-
var ConversationNoticeSchema =
|
|
427
|
+
var ConversationNoticeSchema = z6.object({
|
|
260
428
|
...ConversationItemBaseShape,
|
|
261
|
-
kind:
|
|
262
|
-
actor:
|
|
263
|
-
severity:
|
|
264
|
-
title:
|
|
265
|
-
content:
|
|
266
|
-
presentation:
|
|
267
|
-
}).strict();
|
|
268
|
-
var ConversationPlanTodoSchema =
|
|
429
|
+
kind: z6.literal("notice"),
|
|
430
|
+
actor: z6.enum(["system", "assistant", "subagent"]),
|
|
431
|
+
severity: z6.enum(["info", "success", "warning", "error"]),
|
|
432
|
+
title: z6.string().trim().min(1).max(256),
|
|
433
|
+
content: z6.string().max(4096),
|
|
434
|
+
presentation: z6.literal("compact").optional()
|
|
435
|
+
}).strict();
|
|
436
|
+
var ConversationPlanTodoSchema = z6.object({
|
|
269
437
|
id: IdSchema,
|
|
270
|
-
title:
|
|
271
|
-
description:
|
|
272
|
-
status:
|
|
273
|
-
dependsOn:
|
|
438
|
+
title: z6.string().trim().min(1).max(1024),
|
|
439
|
+
description: z6.string().max(4096).optional(),
|
|
440
|
+
status: z6.string().trim().min(1).max(64),
|
|
441
|
+
dependsOn: z6.array(IdSchema).max(100)
|
|
274
442
|
}).strict();
|
|
275
|
-
var ConversationPlanUpdateSchema =
|
|
443
|
+
var ConversationPlanUpdateSchema = z6.object({
|
|
276
444
|
...ConversationItemBaseShape,
|
|
277
|
-
kind:
|
|
278
|
-
actor:
|
|
279
|
-
operation:
|
|
280
|
-
content:
|
|
281
|
-
todos:
|
|
445
|
+
kind: z6.literal("plan-update"),
|
|
446
|
+
actor: z6.enum(["assistant", "subagent"]),
|
|
447
|
+
operation: z6.enum(["created", "updated", "deleted"]),
|
|
448
|
+
content: z6.string().max(1e5),
|
|
449
|
+
todos: z6.array(ConversationPlanTodoSchema).max(1e3)
|
|
282
450
|
}).strict();
|
|
283
|
-
var ConversationItemSchema =
|
|
451
|
+
var ConversationItemSchema = z6.discriminatedUnion("kind", [
|
|
284
452
|
ConversationHumanMessageSchema,
|
|
285
453
|
ConversationAssistantMessageSchema,
|
|
286
454
|
ConversationActivityGroupSchema,
|
|
287
455
|
ConversationNoticeSchema,
|
|
288
456
|
ConversationPlanUpdateSchema
|
|
289
457
|
]);
|
|
290
|
-
var ConversationItemUpsertSchema =
|
|
458
|
+
var ConversationItemUpsertSchema = z6.object({
|
|
291
459
|
userId: IdSchema,
|
|
292
460
|
machineId: IdSchema,
|
|
293
461
|
sessionId: IdSchema,
|
|
294
462
|
item: ConversationItemSchema
|
|
295
463
|
});
|
|
296
|
-
var ConversationActivityStepUpsertSchema =
|
|
464
|
+
var ConversationActivityStepUpsertSchema = z6.object({
|
|
297
465
|
userId: IdSchema,
|
|
298
466
|
machineId: IdSchema,
|
|
299
467
|
sessionId: IdSchema,
|
|
300
468
|
activityId: IdSchema,
|
|
301
|
-
revision:
|
|
469
|
+
revision: z6.number().int().positive(),
|
|
302
470
|
turnId: IdSchema,
|
|
303
471
|
timestamp: IsoDateSchema,
|
|
304
|
-
actor:
|
|
305
|
-
status:
|
|
472
|
+
actor: z6.enum(["assistant", "subagent"]),
|
|
473
|
+
status: z6.enum(["running", "completed", "failed"]),
|
|
306
474
|
sourceEventId: IdSchema,
|
|
307
475
|
step: ConversationActivityStepSchema
|
|
308
476
|
}).strict();
|
|
309
477
|
|
|
310
478
|
// ../../shared/protocol/dist/conversation/timeline.js
|
|
311
|
-
var SessionUserPreviewSchema =
|
|
479
|
+
var SessionUserPreviewSchema = z7.object({
|
|
312
480
|
id: IdSchema,
|
|
313
|
-
revision:
|
|
481
|
+
revision: z7.number().int().positive(),
|
|
314
482
|
timestamp: IsoDateSchema,
|
|
315
|
-
text:
|
|
483
|
+
text: z7.string().max(4096)
|
|
316
484
|
});
|
|
317
|
-
var SessionAssistantPreviewSchema =
|
|
485
|
+
var SessionAssistantPreviewSchema = z7.object({
|
|
318
486
|
id: IdSchema,
|
|
319
|
-
revision:
|
|
487
|
+
revision: z7.number().int().positive(),
|
|
320
488
|
timestamp: IsoDateSchema,
|
|
321
|
-
sourceEventIds:
|
|
322
|
-
text:
|
|
323
|
-
final:
|
|
324
|
-
attachments:
|
|
325
|
-
kind:
|
|
489
|
+
sourceEventIds: z7.array(IdSchema).min(1).max(1e3),
|
|
490
|
+
text: z7.string().max(4096),
|
|
491
|
+
final: z7.boolean(),
|
|
492
|
+
attachments: z7.array(ConversationAttachmentSchema.refine((attachment) => attachment.kind === "image" && attachment.imageRef === "sha256", "Assistant previews contain image references only")).max(4),
|
|
493
|
+
kind: z7.enum(["assistant-message", "task-completion"]).optional()
|
|
326
494
|
});
|
|
327
495
|
var SESSION_TIMELINE_PAGE_SIZE = 100;
|
|
328
|
-
var SessionTimelinePageRequestSchema =
|
|
496
|
+
var SessionTimelinePageRequestSchema = z7.object({
|
|
329
497
|
requestId: IdSchema,
|
|
330
498
|
machineId: IdSchema,
|
|
331
499
|
sessionId: IdSchema,
|
|
332
|
-
cursor:
|
|
333
|
-
metadataOnly:
|
|
334
|
-
acceptContentEncodings:
|
|
335
|
-
imageReferences:
|
|
336
|
-
pageSize:
|
|
337
|
-
assistantPreview:
|
|
500
|
+
cursor: z7.string().max(32768).optional(),
|
|
501
|
+
metadataOnly: z7.boolean().optional(),
|
|
502
|
+
acceptContentEncodings: z7.array(z7.string().min(1).max(32)).max(8).optional(),
|
|
503
|
+
imageReferences: z7.boolean().optional(),
|
|
504
|
+
pageSize: z7.number().int().min(1).max(SESSION_TIMELINE_PAGE_SIZE).default(SESSION_TIMELINE_PAGE_SIZE),
|
|
505
|
+
assistantPreview: z7.boolean().optional()
|
|
338
506
|
});
|
|
339
|
-
var SessionWatchRequestSchema =
|
|
507
|
+
var SessionWatchRequestSchema = z7.object({
|
|
340
508
|
requestId: IdSchema,
|
|
341
509
|
machineId: IdSchema,
|
|
342
510
|
sessionId: IdSchema,
|
|
343
|
-
watching:
|
|
511
|
+
watching: z7.boolean()
|
|
344
512
|
}).strict();
|
|
345
|
-
var SessionWatchResultSchema =
|
|
346
|
-
|
|
347
|
-
ok:
|
|
513
|
+
var SessionWatchResultSchema = z7.discriminatedUnion("ok", [
|
|
514
|
+
z7.object({
|
|
515
|
+
ok: z7.literal(true),
|
|
348
516
|
requestId: IdSchema,
|
|
349
517
|
machineId: IdSchema,
|
|
350
518
|
sessionId: IdSchema,
|
|
351
|
-
watching:
|
|
519
|
+
watching: z7.boolean()
|
|
352
520
|
}).strict(),
|
|
353
|
-
|
|
354
|
-
ok:
|
|
521
|
+
z7.object({
|
|
522
|
+
ok: z7.literal(false),
|
|
355
523
|
requestId: IdSchema,
|
|
356
524
|
machineId: IdSchema,
|
|
357
525
|
sessionId: IdSchema,
|
|
358
|
-
watching:
|
|
526
|
+
watching: z7.boolean(),
|
|
359
527
|
error: ProtocolFailureSchema
|
|
360
528
|
}).strict()
|
|
361
529
|
]);
|
|
362
|
-
var SessionTimelinePageSchema =
|
|
363
|
-
items:
|
|
364
|
-
cursor:
|
|
365
|
-
hasMore:
|
|
366
|
-
cursorStatus:
|
|
530
|
+
var SessionTimelinePageSchema = z7.object({
|
|
531
|
+
items: z7.array(ConversationItemSchema).max(SESSION_TIMELINE_PAGE_SIZE),
|
|
532
|
+
cursor: z7.string().max(32768),
|
|
533
|
+
hasMore: z7.boolean(),
|
|
534
|
+
cursorStatus: z7.enum(["ok", "expired"]),
|
|
367
535
|
assistantPreview: SessionAssistantPreviewSchema.optional(),
|
|
368
536
|
userPreview: SessionUserPreviewSchema.optional(),
|
|
369
|
-
previewsComplete:
|
|
537
|
+
previewsComplete: z7.boolean().optional()
|
|
370
538
|
});
|
|
371
|
-
var SessionTimelinePageResultSchema =
|
|
372
|
-
|
|
373
|
-
ok:
|
|
539
|
+
var SessionTimelinePageResultSchema = z7.discriminatedUnion("ok", [
|
|
540
|
+
z7.object({
|
|
541
|
+
ok: z7.literal(true),
|
|
374
542
|
requestId: IdSchema,
|
|
375
543
|
machineId: IdSchema,
|
|
376
544
|
sessionId: IdSchema,
|
|
377
545
|
page: SessionTimelinePageSchema
|
|
378
546
|
}),
|
|
379
|
-
|
|
380
|
-
ok:
|
|
547
|
+
z7.object({
|
|
548
|
+
ok: z7.literal(false),
|
|
381
549
|
requestId: IdSchema,
|
|
382
550
|
machineId: IdSchema,
|
|
383
551
|
sessionId: IdSchema,
|
|
384
552
|
error: ProtocolFailureSchema
|
|
385
553
|
})
|
|
386
554
|
]);
|
|
387
|
-
var SessionTimelineInvalidatedSchema =
|
|
555
|
+
var SessionTimelineInvalidatedSchema = z7.object({
|
|
388
556
|
userId: IdSchema,
|
|
389
557
|
machineId: IdSchema,
|
|
390
558
|
sessionId: IdSchema,
|
|
391
|
-
reason:
|
|
559
|
+
reason: z7.enum(["clear", "rewind"]),
|
|
392
560
|
sourceEventId: IdSchema,
|
|
393
561
|
timestamp: IsoDateSchema
|
|
394
562
|
}).strict();
|
|
395
563
|
|
|
396
564
|
// ../../shared/protocol/dist/common/version.js
|
|
397
|
-
import { z as
|
|
565
|
+
import { z as z8 } from "zod";
|
|
398
566
|
var LEGACY_PROTOCOL_VERSION = 10;
|
|
399
567
|
var PROTOCOL_VERSION = 11;
|
|
400
568
|
var OLDEST_SUPPORTED_PROTOCOL_VERSION = 9;
|
|
401
|
-
var SupportedProtocolVersionSchema =
|
|
402
|
-
|
|
403
|
-
|
|
404
|
-
|
|
569
|
+
var SupportedProtocolVersionSchema = z8.union([
|
|
570
|
+
z8.literal(OLDEST_SUPPORTED_PROTOCOL_VERSION),
|
|
571
|
+
z8.literal(LEGACY_PROTOCOL_VERSION),
|
|
572
|
+
z8.literal(PROTOCOL_VERSION)
|
|
405
573
|
]);
|
|
406
574
|
var TRANSPORT_V2 = 2;
|
|
407
575
|
|
|
408
|
-
// ../../shared/protocol/dist/auth/authentication.js
|
|
409
|
-
import { z as z7 } from "zod";
|
|
410
|
-
var UserRoleSchema = z7.enum(["admin", "user"]);
|
|
411
|
-
var PasswordSchema = z7.string().min(1).max(4096);
|
|
412
|
-
var PcTokenLabelSchema = z7.string().trim().min(1).max(120);
|
|
413
|
-
var AuthUserSchema = z7.object({
|
|
414
|
-
userId: IdSchema,
|
|
415
|
-
username: UsernameSchema,
|
|
416
|
-
role: UserRoleSchema
|
|
417
|
-
}).strict();
|
|
418
|
-
var LoginRequestSchema = z7.object({
|
|
419
|
-
username: UsernameSchema,
|
|
420
|
-
password: PasswordSchema
|
|
421
|
-
});
|
|
422
|
-
var LoginResultSchema = z7.discriminatedUnion("ok", [
|
|
423
|
-
z7.object({
|
|
424
|
-
ok: z7.literal(true),
|
|
425
|
-
accessToken: z7.string().min(32),
|
|
426
|
-
expiresAt: z7.number().int().positive(),
|
|
427
|
-
user: AuthUserSchema
|
|
428
|
-
}),
|
|
429
|
-
z7.object({
|
|
430
|
-
ok: z7.literal(false),
|
|
431
|
-
error: ProtocolFailureSchema
|
|
432
|
-
})
|
|
433
|
-
]);
|
|
434
|
-
var MobileLoginRequestSchema = z7.object({
|
|
435
|
-
mobileCredential: z7.string().min(64).max(4096),
|
|
436
|
-
clientId: IdSchema
|
|
437
|
-
});
|
|
438
|
-
var PcAccountRequestSchema = z7.object({
|
|
439
|
-
userId: IdSchema,
|
|
440
|
-
machineId: IdSchema
|
|
441
|
-
}).strict();
|
|
442
|
-
var PcAccountResultSchema = z7.discriminatedUnion("ok", [
|
|
443
|
-
z7.object({
|
|
444
|
-
ok: z7.literal(true),
|
|
445
|
-
user: AuthUserSchema,
|
|
446
|
-
method: z7.enum(["microsoft", "token"])
|
|
447
|
-
}).strict(),
|
|
448
|
-
z7.object({
|
|
449
|
-
ok: z7.literal(false),
|
|
450
|
-
error: ProtocolFailureSchema
|
|
451
|
-
}).strict()
|
|
452
|
-
]);
|
|
453
|
-
var AdminUserSummarySchema = z7.object({
|
|
454
|
-
userId: IdSchema,
|
|
455
|
-
username: UsernameSchema,
|
|
456
|
-
role: UserRoleSchema,
|
|
457
|
-
createdAt: z7.number().int().nonnegative(),
|
|
458
|
-
updatedAt: z7.number().int().nonnegative(),
|
|
459
|
-
disabledAt: z7.number().int().nonnegative().nullable()
|
|
460
|
-
}).strict();
|
|
461
|
-
var AdminFailureResultSchema = z7.object({
|
|
462
|
-
ok: z7.literal(false),
|
|
463
|
-
error: ProtocolFailureSchema
|
|
464
|
-
}).strict();
|
|
465
|
-
var AdminUserListResultSchema = z7.discriminatedUnion("ok", [
|
|
466
|
-
z7.object({
|
|
467
|
-
ok: z7.literal(true),
|
|
468
|
-
users: z7.array(AdminUserSummarySchema)
|
|
469
|
-
}).strict(),
|
|
470
|
-
AdminFailureResultSchema
|
|
471
|
-
]);
|
|
472
|
-
var AdminUserCreateRequestSchema = z7.object({
|
|
473
|
-
username: UsernameSchema,
|
|
474
|
-
password: PasswordSchema
|
|
475
|
-
}).strict();
|
|
476
|
-
var AdminUserCreateResultSchema = z7.discriminatedUnion("ok", [
|
|
477
|
-
z7.object({
|
|
478
|
-
ok: z7.literal(true),
|
|
479
|
-
user: AdminUserSummarySchema
|
|
480
|
-
}).strict(),
|
|
481
|
-
AdminFailureResultSchema
|
|
482
|
-
]);
|
|
483
|
-
var AdminUserStatusRequestSchema = z7.object({
|
|
484
|
-
userId: IdSchema,
|
|
485
|
-
disabled: z7.boolean()
|
|
486
|
-
}).strict();
|
|
487
|
-
var AdminUserStatusResultSchema = z7.discriminatedUnion("ok", [
|
|
488
|
-
z7.object({
|
|
489
|
-
ok: z7.literal(true),
|
|
490
|
-
user: AdminUserSummarySchema
|
|
491
|
-
}).strict(),
|
|
492
|
-
AdminFailureResultSchema
|
|
493
|
-
]);
|
|
494
|
-
var AdminUserPasswordRequestSchema = z7.object({
|
|
495
|
-
userId: IdSchema,
|
|
496
|
-
password: PasswordSchema
|
|
497
|
-
}).strict();
|
|
498
|
-
var AdminUserPasswordResultSchema = z7.discriminatedUnion("ok", [
|
|
499
|
-
z7.object({
|
|
500
|
-
ok: z7.literal(true),
|
|
501
|
-
user: AdminUserSummarySchema
|
|
502
|
-
}).strict(),
|
|
503
|
-
AdminFailureResultSchema
|
|
504
|
-
]);
|
|
505
|
-
var PcServiceTokenSummarySchema = z7.object({
|
|
506
|
-
tokenId: IdSchema,
|
|
507
|
-
userId: IdSchema,
|
|
508
|
-
label: PcTokenLabelSchema,
|
|
509
|
-
createdAt: z7.number().int().nonnegative(),
|
|
510
|
-
lastUsedAt: z7.number().int().nonnegative().nullable(),
|
|
511
|
-
revokedAt: z7.number().int().nonnegative().nullable()
|
|
512
|
-
}).strict();
|
|
513
|
-
var AdminPcTokenListRequestSchema = z7.object({
|
|
514
|
-
userId: IdSchema
|
|
515
|
-
}).strict();
|
|
516
|
-
var AdminPcTokenListResultSchema = z7.discriminatedUnion("ok", [
|
|
517
|
-
z7.object({
|
|
518
|
-
ok: z7.literal(true),
|
|
519
|
-
tokens: z7.array(PcServiceTokenSummarySchema)
|
|
520
|
-
}).strict(),
|
|
521
|
-
AdminFailureResultSchema
|
|
522
|
-
]);
|
|
523
|
-
var AdminPcTokenIssueRequestSchema = z7.object({
|
|
524
|
-
userId: IdSchema,
|
|
525
|
-
label: PcTokenLabelSchema
|
|
526
|
-
}).strict();
|
|
527
|
-
var AdminPcTokenIssueResultSchema = z7.discriminatedUnion("ok", [
|
|
528
|
-
z7.object({
|
|
529
|
-
ok: z7.literal(true),
|
|
530
|
-
token: z7.string().min(32).max(256),
|
|
531
|
-
pcToken: PcServiceTokenSummarySchema
|
|
532
|
-
}).strict(),
|
|
533
|
-
AdminFailureResultSchema
|
|
534
|
-
]);
|
|
535
|
-
var AdminPcTokenRevokeRequestSchema = z7.object({
|
|
536
|
-
tokenId: IdSchema
|
|
537
|
-
}).strict();
|
|
538
|
-
var AdminPcTokenRevokeResultSchema = z7.discriminatedUnion("ok", [
|
|
539
|
-
z7.object({
|
|
540
|
-
ok: z7.literal(true),
|
|
541
|
-
pcToken: PcServiceTokenSummarySchema
|
|
542
|
-
}).strict(),
|
|
543
|
-
AdminFailureResultSchema
|
|
544
|
-
]);
|
|
545
|
-
|
|
546
576
|
// ../../shared/protocol/dist/auth/pairing.js
|
|
547
|
-
import { z as
|
|
577
|
+
import { z as z9 } from "zod";
|
|
548
578
|
var MOBILE_TRANSFER_MAX_PARTS = 64;
|
|
549
579
|
var MOBILE_TRANSFER_PART_DATA_MAX_LENGTH = 2600;
|
|
550
580
|
var MOBILE_TRANSFER_RELAY_TTL_MS = 10 * 60 * 1e3;
|
|
551
581
|
var MOBILE_TRANSFER_RELAY_MAX_CIPHERTEXT_LENGTH = 128 * 1024;
|
|
552
|
-
var PairingCreateRequestSchema =
|
|
582
|
+
var PairingCreateRequestSchema = z9.object({
|
|
553
583
|
userId: IdSchema,
|
|
554
584
|
machineId: IdSchema,
|
|
555
585
|
stableDeviceId: IdSchema.optional(),
|
|
556
|
-
machineName:
|
|
586
|
+
machineName: z9.string().trim().min(1).max(120),
|
|
557
587
|
keyId: Base64UrlKeyIdSchema.optional()
|
|
558
588
|
});
|
|
559
|
-
var PairingCreateResultSchema =
|
|
560
|
-
|
|
561
|
-
ok:
|
|
562
|
-
code:
|
|
563
|
-
expiresAt:
|
|
589
|
+
var PairingCreateResultSchema = z9.discriminatedUnion("ok", [
|
|
590
|
+
z9.object({
|
|
591
|
+
ok: z9.literal(true),
|
|
592
|
+
code: z9.string().min(32).max(256),
|
|
593
|
+
expiresAt: z9.number().int().positive(),
|
|
564
594
|
// Presence advertises the PC-only status endpoint; older Relays omit it.
|
|
565
|
-
statusId:
|
|
595
|
+
statusId: z9.string().regex(/^[A-Za-z0-9_-]{43}$/u).optional()
|
|
566
596
|
}),
|
|
567
|
-
|
|
568
|
-
ok:
|
|
597
|
+
z9.object({
|
|
598
|
+
ok: z9.literal(false),
|
|
569
599
|
error: ProtocolFailureSchema
|
|
570
600
|
})
|
|
571
601
|
]);
|
|
572
|
-
var PairingStatusRequestSchema =
|
|
602
|
+
var PairingStatusRequestSchema = z9.object({
|
|
573
603
|
userId: IdSchema,
|
|
574
604
|
machineId: IdSchema,
|
|
575
|
-
statusId:
|
|
605
|
+
statusId: z9.string().regex(/^[A-Za-z0-9_-]{43}$/u)
|
|
576
606
|
});
|
|
577
|
-
var PairingStatusSchema =
|
|
578
|
-
var PairingStatusResultSchema =
|
|
579
|
-
|
|
580
|
-
|
|
607
|
+
var PairingStatusSchema = z9.enum(["pending", "paired", "unavailable"]);
|
|
608
|
+
var PairingStatusResultSchema = z9.discriminatedUnion("ok", [
|
|
609
|
+
z9.object({ ok: z9.literal(true), state: PairingStatusSchema }),
|
|
610
|
+
z9.object({ ok: z9.literal(false), error: ProtocolFailureSchema })
|
|
581
611
|
]);
|
|
582
|
-
var PairingExchangeRequestSchema =
|
|
583
|
-
code:
|
|
612
|
+
var PairingExchangeRequestSchema = z9.object({
|
|
613
|
+
code: z9.string().min(32).max(256),
|
|
584
614
|
clientId: IdSchema
|
|
585
615
|
});
|
|
586
|
-
var PairingExchangeResultSchema =
|
|
587
|
-
|
|
588
|
-
ok:
|
|
589
|
-
accessToken:
|
|
590
|
-
expiresAt:
|
|
591
|
-
mobileCredential:
|
|
592
|
-
mobileCredentialExpiresAt:
|
|
616
|
+
var PairingExchangeResultSchema = z9.discriminatedUnion("ok", [
|
|
617
|
+
z9.object({
|
|
618
|
+
ok: z9.literal(true),
|
|
619
|
+
accessToken: z9.string().min(32),
|
|
620
|
+
expiresAt: z9.number().int().positive(),
|
|
621
|
+
mobileCredential: z9.string().min(64).max(4096),
|
|
622
|
+
mobileCredentialExpiresAt: z9.number().int().positive(),
|
|
593
623
|
stableDeviceId: IdSchema.optional(),
|
|
594
624
|
user: AuthUserSchema
|
|
595
625
|
}),
|
|
596
|
-
|
|
597
|
-
ok:
|
|
626
|
+
z9.object({
|
|
627
|
+
ok: z9.literal(false),
|
|
598
628
|
error: ProtocolFailureSchema
|
|
599
629
|
})
|
|
600
630
|
]);
|
|
601
|
-
var MobileTransferMachineSchema =
|
|
631
|
+
var MobileTransferMachineSchema = z9.object({
|
|
602
632
|
machineId: IdSchema,
|
|
603
|
-
mobileCredential:
|
|
604
|
-
contentKey:
|
|
605
|
-
relayUrl:
|
|
633
|
+
mobileCredential: z9.string().min(64).max(4096),
|
|
634
|
+
contentKey: z9.string().regex(/^[A-Za-z0-9_-]{43}$/u, "Expected a 32-byte base64url key"),
|
|
635
|
+
relayUrl: z9.url().max(2048).optional(),
|
|
606
636
|
relayUsername: UsernameSchema.optional(),
|
|
607
637
|
stableDeviceId: IdSchema.optional(),
|
|
608
|
-
pairedAt:
|
|
609
|
-
lastSeenAt:
|
|
610
|
-
sleeping:
|
|
611
|
-
selected:
|
|
638
|
+
pairedAt: z9.number().int().nonnegative().optional(),
|
|
639
|
+
lastSeenAt: z9.number().int().nonnegative().optional(),
|
|
640
|
+
sleeping: z9.boolean().optional(),
|
|
641
|
+
selected: z9.boolean().optional()
|
|
612
642
|
}).strict();
|
|
613
|
-
var MobileTransferPayloadSchema =
|
|
614
|
-
relayUrl:
|
|
643
|
+
var MobileTransferPayloadSchema = z9.object({
|
|
644
|
+
relayUrl: z9.url().max(2048),
|
|
615
645
|
username: UsernameSchema,
|
|
616
|
-
machines:
|
|
646
|
+
machines: z9.array(MobileTransferMachineSchema).min(1).max(32)
|
|
617
647
|
}).strict().superRefine((payload, context) => {
|
|
618
648
|
const normalizeEndpoint = (value) => value.trim().replace(/\/+$/u, "").replace(/^(https?):\/\/(\[[^\]]+\]|[^:/?#]+)(?::([0-9]+))?(?=\/|$)/iu, (_match, scheme, host, rawPort) => {
|
|
619
649
|
const protocol = scheme.toLowerCase();
|
|
@@ -652,35 +682,100 @@ var MobileTransferPayloadSchema = z8.object({
|
|
|
652
682
|
}
|
|
653
683
|
}
|
|
654
684
|
});
|
|
655
|
-
var MobileTransferPartSchema =
|
|
656
|
-
transferId:
|
|
657
|
-
part:
|
|
658
|
-
total:
|
|
659
|
-
data:
|
|
685
|
+
var MobileTransferPartSchema = z9.object({
|
|
686
|
+
transferId: z9.string().regex(/^[A-Za-z0-9_-]{43}$/u, "Expected a SHA-256 base64url digest"),
|
|
687
|
+
part: z9.number().int().min(1).max(MOBILE_TRANSFER_MAX_PARTS),
|
|
688
|
+
total: z9.number().int().min(2).max(MOBILE_TRANSFER_MAX_PARTS),
|
|
689
|
+
data: z9.string().min(1).max(MOBILE_TRANSFER_PART_DATA_MAX_LENGTH).regex(/^[A-Za-z0-9_-]+$/u, "Expected base64url data")
|
|
660
690
|
}).strict().refine(({ part, total }) => part <= total, {
|
|
661
691
|
message: "Part number must not exceed total parts",
|
|
662
692
|
path: ["part"]
|
|
663
693
|
});
|
|
664
|
-
var MobileTransferUploadRequestSchema =
|
|
665
|
-
ciphertext:
|
|
694
|
+
var MobileTransferUploadRequestSchema = z9.object({
|
|
695
|
+
ciphertext: z9.string().min(1).max(MOBILE_TRANSFER_RELAY_MAX_CIPHERTEXT_LENGTH).regex(/^[A-Za-z0-9_-]+$/u, "Expected base64url ciphertext")
|
|
666
696
|
}).strict();
|
|
667
|
-
var MobileTransferUploadResultSchema =
|
|
668
|
-
token:
|
|
669
|
-
expiresAt:
|
|
697
|
+
var MobileTransferUploadResultSchema = z9.object({
|
|
698
|
+
token: z9.string().regex(/^[A-Za-z0-9_-]{43}$/u, "Expected a 32-byte base64url token"),
|
|
699
|
+
expiresAt: z9.number().int().positive()
|
|
670
700
|
}).strict();
|
|
671
|
-
var MobileTransferDownloadResultSchema =
|
|
672
|
-
ciphertext:
|
|
701
|
+
var MobileTransferDownloadResultSchema = z9.object({
|
|
702
|
+
ciphertext: z9.string().min(1).max(MOBILE_TRANSFER_RELAY_MAX_CIPHERTEXT_LENGTH).regex(/^[A-Za-z0-9_-]+$/u, "Expected base64url ciphertext")
|
|
673
703
|
}).strict();
|
|
674
704
|
|
|
705
|
+
// ../../shared/protocol/dist/auth/mobile-authorization.js
|
|
706
|
+
import { z as z10 } from "zod";
|
|
707
|
+
var MobileIdentityPublicKeySchema = z10.string().regex(/^[A-Za-z0-9_-]+$/u).min(350).max(800);
|
|
708
|
+
var MobileAuthorizationScopeSchema = z10.object({
|
|
709
|
+
userId: IdSchema,
|
|
710
|
+
machineId: IdSchema
|
|
711
|
+
}).strict();
|
|
712
|
+
var MobileAuthorizationCreateSchema = MobileAuthorizationScopeSchema.extend({
|
|
713
|
+
keyId: Base64UrlKeyIdSchema,
|
|
714
|
+
machineName: z10.string().trim().min(1).max(120),
|
|
715
|
+
stableDeviceId: IdSchema.optional()
|
|
716
|
+
});
|
|
717
|
+
var MobileAuthorizationClaimSchema = z10.object({
|
|
718
|
+
requestId: MobileAuthorizationIdSchema,
|
|
719
|
+
code: MobileAuthorizationIdSchema,
|
|
720
|
+
publicKey: MobileIdentityPublicKeySchema,
|
|
721
|
+
deviceName: z10.string().trim().min(1).max(120),
|
|
722
|
+
proof: MobileIdentityProofSchema
|
|
723
|
+
}).strict();
|
|
724
|
+
var MobileAuthorizationPollSchema = z10.object({
|
|
725
|
+
requestId: MobileAuthorizationIdSchema,
|
|
726
|
+
proof: MobileIdentityProofSchema
|
|
727
|
+
}).strict();
|
|
728
|
+
var MobileAuthorizationDecisionSchema = MobileAuthorizationScopeSchema.extend({
|
|
729
|
+
requestId: MobileAuthorizationIdSchema,
|
|
730
|
+
action: z10.enum(["approve", "reject", "revoke"]),
|
|
731
|
+
encryptedKey: z10.string().regex(/^[A-Za-z0-9_-]+$/u).min(340).max(700).optional()
|
|
732
|
+
}).strict().superRefine((value, context) => {
|
|
733
|
+
if (value.action === "approve" !== (value.encryptedKey !== void 0)) {
|
|
734
|
+
context.addIssue({ code: "custom", message: "Only approval requires an encrypted content key." });
|
|
735
|
+
}
|
|
736
|
+
});
|
|
737
|
+
var MobileAuthorizationStateSchema = z10.enum(["open", "pending", "active", "rejected", "cancelled", "expired", "revoked"]);
|
|
738
|
+
var MobileAuthorizationViewSchema = z10.object({
|
|
739
|
+
requestId: MobileAuthorizationIdSchema,
|
|
740
|
+
state: MobileAuthorizationStateSchema,
|
|
741
|
+
deviceName: z10.string(),
|
|
742
|
+
clientId: z10.string(),
|
|
743
|
+
publicKey: z10.string(),
|
|
744
|
+
confirmationCode: z10.string(),
|
|
745
|
+
createdAt: z10.number().int(),
|
|
746
|
+
expiresAt: z10.number().int(),
|
|
747
|
+
decidedAt: z10.number().int().nullable(),
|
|
748
|
+
lastSeenAt: z10.number().int().nullable(),
|
|
749
|
+
online: z10.boolean()
|
|
750
|
+
});
|
|
751
|
+
var MobileAuthorizationCreateResultSchema = z10.object({
|
|
752
|
+
requestId: MobileAuthorizationIdSchema,
|
|
753
|
+
code: MobileAuthorizationIdSchema,
|
|
754
|
+
expiresAt: z10.number().int()
|
|
755
|
+
});
|
|
756
|
+
var MobileAuthorizationListResultSchema = z10.object({
|
|
757
|
+
clients: z10.array(MobileAuthorizationViewSchema)
|
|
758
|
+
});
|
|
759
|
+
var MobileAuthorizationResultSchema = z10.object({
|
|
760
|
+
ok: z10.boolean(),
|
|
761
|
+
state: MobileAuthorizationStateSchema.optional(),
|
|
762
|
+
encryptedKey: z10.string().optional(),
|
|
763
|
+
mobileCredential: z10.string().optional(),
|
|
764
|
+
mobileCredentialExpiresAt: z10.number().int().optional(),
|
|
765
|
+
stableDeviceId: IdSchema.optional(),
|
|
766
|
+
user: AuthUserSchema.optional(),
|
|
767
|
+
error: ProtocolFailureSchema.optional()
|
|
768
|
+
});
|
|
769
|
+
|
|
675
770
|
// ../../shared/protocol/dist/auth/microsoft-enrollment.js
|
|
676
|
-
import { z as
|
|
677
|
-
var MicrosoftIdentityReferenceSchema =
|
|
678
|
-
issuer:
|
|
679
|
-
clientId:
|
|
680
|
-
subject:
|
|
771
|
+
import { z as z11 } from "zod";
|
|
772
|
+
var MicrosoftIdentityReferenceSchema = z11.object({
|
|
773
|
+
issuer: z11.literal("https://login.microsoftonline.com/9188040d-6c67-4c5b-b112-36a304b66dad/v2.0"),
|
|
774
|
+
clientId: z11.uuid(),
|
|
775
|
+
subject: z11.string().min(1).max(255).regex(/^[\x21-\x7e]+$/)
|
|
681
776
|
}).strict();
|
|
682
|
-
var PcEnrollmentIdSchema =
|
|
683
|
-
var PcEnrollmentStateSchema =
|
|
777
|
+
var PcEnrollmentIdSchema = z11.uuid();
|
|
778
|
+
var PcEnrollmentStateSchema = z11.enum([
|
|
684
779
|
"pending",
|
|
685
780
|
"approved",
|
|
686
781
|
"issued",
|
|
@@ -688,79 +783,79 @@ var PcEnrollmentStateSchema = z9.enum([
|
|
|
688
783
|
"cancelled",
|
|
689
784
|
"expired"
|
|
690
785
|
]);
|
|
691
|
-
var PcEnrollmentStartRequestSchema =
|
|
692
|
-
machineId:
|
|
693
|
-
deviceName:
|
|
694
|
-
codeChallenge:
|
|
786
|
+
var PcEnrollmentStartRequestSchema = z11.object({
|
|
787
|
+
machineId: z11.string().min(1).max(128).regex(/^[A-Za-z0-9._:-]+$/),
|
|
788
|
+
deviceName: z11.string().trim().min(1).max(120).regex(/^[^\x00-\x1f\x7f]+$/),
|
|
789
|
+
codeChallenge: z11.string().regex(/^[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/)
|
|
695
790
|
}).strict();
|
|
696
|
-
var PcEnrollmentVerifierRequestSchema =
|
|
697
|
-
verifier:
|
|
791
|
+
var PcEnrollmentVerifierRequestSchema = z11.object({
|
|
792
|
+
verifier: z11.string().regex(/^[A-Za-z0-9._~-]{43,128}$/)
|
|
698
793
|
}).strict();
|
|
699
|
-
var MicrosoftCsrfRequestSchema =
|
|
700
|
-
csrfToken:
|
|
794
|
+
var MicrosoftCsrfRequestSchema = z11.object({
|
|
795
|
+
csrfToken: z11.string().min(1).max(256)
|
|
701
796
|
}).strict();
|
|
702
797
|
var PcEnrollmentApproveRequestSchema = MicrosoftCsrfRequestSchema.extend({
|
|
703
|
-
confirmationCode:
|
|
704
|
-
localCredentials:
|
|
705
|
-
username:
|
|
706
|
-
password:
|
|
798
|
+
confirmationCode: z11.string().regex(/^[A-F0-9]{8}$/),
|
|
799
|
+
localCredentials: z11.object({
|
|
800
|
+
username: z11.string().trim().min(1).max(120),
|
|
801
|
+
password: z11.string().min(1).max(4096)
|
|
707
802
|
}).strict().optional()
|
|
708
803
|
}).strict();
|
|
709
|
-
var MicrosoftEnrollmentFailureSchema =
|
|
710
|
-
ok:
|
|
711
|
-
error:
|
|
712
|
-
code:
|
|
713
|
-
message:
|
|
804
|
+
var MicrosoftEnrollmentFailureSchema = z11.object({
|
|
805
|
+
ok: z11.literal(false),
|
|
806
|
+
error: z11.object({
|
|
807
|
+
code: z11.string().min(1).max(128),
|
|
808
|
+
message: z11.string().min(1).max(1024)
|
|
714
809
|
}).strict()
|
|
715
810
|
}).strict();
|
|
716
|
-
var MicrosoftMutationResultSchema =
|
|
717
|
-
|
|
811
|
+
var MicrosoftMutationResultSchema = z11.discriminatedUnion("ok", [
|
|
812
|
+
z11.object({ ok: z11.literal(true) }).strict(),
|
|
718
813
|
MicrosoftEnrollmentFailureSchema
|
|
719
814
|
]);
|
|
720
|
-
var PcEnrollmentStartResultSchema =
|
|
721
|
-
|
|
722
|
-
ok:
|
|
815
|
+
var PcEnrollmentStartResultSchema = z11.discriminatedUnion("ok", [
|
|
816
|
+
z11.object({
|
|
817
|
+
ok: z11.literal(true),
|
|
723
818
|
enrollmentId: PcEnrollmentIdSchema,
|
|
724
|
-
confirmationCode:
|
|
725
|
-
verificationUri:
|
|
726
|
-
expiresAt:
|
|
727
|
-
intervalSeconds:
|
|
819
|
+
confirmationCode: z11.string().regex(/^[A-F0-9]{8}$/),
|
|
820
|
+
verificationUri: z11.url(),
|
|
821
|
+
expiresAt: z11.number().int().positive(),
|
|
822
|
+
intervalSeconds: z11.number().int().positive()
|
|
728
823
|
}).strict(),
|
|
729
824
|
MicrosoftEnrollmentFailureSchema
|
|
730
825
|
]);
|
|
731
|
-
var PcEnrollmentStatusResultSchema =
|
|
732
|
-
|
|
733
|
-
ok:
|
|
826
|
+
var PcEnrollmentStatusResultSchema = z11.discriminatedUnion("ok", [
|
|
827
|
+
z11.object({
|
|
828
|
+
ok: z11.literal(true),
|
|
734
829
|
state: PcEnrollmentStateSchema,
|
|
735
|
-
expiresAt:
|
|
830
|
+
expiresAt: z11.number().int().positive()
|
|
736
831
|
}).strict(),
|
|
737
832
|
MicrosoftEnrollmentFailureSchema
|
|
738
833
|
]);
|
|
739
|
-
var PcEnrollmentExchangeResultSchema =
|
|
740
|
-
|
|
741
|
-
ok:
|
|
742
|
-
token:
|
|
743
|
-
tokenId:
|
|
744
|
-
grantId:
|
|
834
|
+
var PcEnrollmentExchangeResultSchema = z11.discriminatedUnion("ok", [
|
|
835
|
+
z11.object({
|
|
836
|
+
ok: z11.literal(true),
|
|
837
|
+
token: z11.string().min(32).max(4096),
|
|
838
|
+
tokenId: z11.string().min(1).max(256),
|
|
839
|
+
grantId: z11.uuid(),
|
|
745
840
|
machineId: PcEnrollmentStartRequestSchema.shape.machineId,
|
|
746
841
|
user: AuthUserSchema,
|
|
747
|
-
confirmBy:
|
|
842
|
+
confirmBy: z11.number().int().positive()
|
|
748
843
|
}).strict(),
|
|
749
844
|
MicrosoftEnrollmentFailureSchema
|
|
750
845
|
]);
|
|
751
|
-
var PcBrowserRedirectUriSchema =
|
|
846
|
+
var PcBrowserRedirectUriSchema = z11.string().regex(/^http:\/\/127\.0\.0\.1:(?:[1-9]\d{0,3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5])\/relay-login\/callback$/);
|
|
752
847
|
var PcBrowserStateSchema = PcEnrollmentStartRequestSchema.shape.codeChallenge;
|
|
753
848
|
var PcBrowserAuthorizationCodeSchema = PcEnrollmentStartRequestSchema.shape.codeChallenge;
|
|
754
849
|
var PcBrowserAuthorizationStartRequestSchema = PcEnrollmentStartRequestSchema.extend({
|
|
755
850
|
redirectUri: PcBrowserRedirectUriSchema,
|
|
756
851
|
state: PcBrowserStateSchema
|
|
757
852
|
}).strict();
|
|
758
|
-
var PcBrowserAuthorizationStartResultSchema =
|
|
759
|
-
|
|
760
|
-
ok:
|
|
853
|
+
var PcBrowserAuthorizationStartResultSchema = z11.discriminatedUnion("ok", [
|
|
854
|
+
z11.object({
|
|
855
|
+
ok: z11.literal(true),
|
|
761
856
|
enrollmentId: PcEnrollmentIdSchema,
|
|
762
|
-
verificationUri:
|
|
763
|
-
expiresAt:
|
|
857
|
+
verificationUri: z11.url(),
|
|
858
|
+
expiresAt: z11.number().int().positive()
|
|
764
859
|
}).strict(),
|
|
765
860
|
MicrosoftEnrollmentFailureSchema
|
|
766
861
|
]);
|
|
@@ -768,63 +863,63 @@ var PcBrowserAuthorizationExchangeRequestSchema = PcEnrollmentVerifierRequestSch
|
|
|
768
863
|
code: PcBrowserAuthorizationCodeSchema,
|
|
769
864
|
redirectUri: PcBrowserRedirectUriSchema
|
|
770
865
|
}).strict();
|
|
771
|
-
var PcBrowserAuthorizationCallbackSchema =
|
|
772
|
-
|
|
773
|
-
|
|
866
|
+
var PcBrowserAuthorizationCallbackSchema = z11.union([
|
|
867
|
+
z11.object({ state: PcBrowserStateSchema, code: PcBrowserAuthorizationCodeSchema }).strict(),
|
|
868
|
+
z11.object({
|
|
774
869
|
state: PcBrowserStateSchema,
|
|
775
|
-
error:
|
|
870
|
+
error: z11.enum(["access_denied", "expired", "cancelled"])
|
|
776
871
|
}).strict()
|
|
777
872
|
]);
|
|
778
|
-
var MicrosoftDeviceSchema =
|
|
779
|
-
grantId:
|
|
780
|
-
tokenId:
|
|
873
|
+
var MicrosoftDeviceSchema = z11.object({
|
|
874
|
+
grantId: z11.uuid(),
|
|
875
|
+
tokenId: z11.string().min(1).max(256),
|
|
781
876
|
machineId: PcEnrollmentStartRequestSchema.shape.machineId,
|
|
782
877
|
deviceName: PcEnrollmentStartRequestSchema.shape.deviceName,
|
|
783
|
-
createdAt:
|
|
784
|
-
revokedAt:
|
|
878
|
+
createdAt: z11.number().int().nonnegative(),
|
|
879
|
+
revokedAt: z11.number().int().nonnegative().nullable()
|
|
785
880
|
}).strict();
|
|
786
|
-
var MicrosoftDevicesResultSchema =
|
|
787
|
-
|
|
788
|
-
ok:
|
|
881
|
+
var MicrosoftDevicesResultSchema = z11.discriminatedUnion("ok", [
|
|
882
|
+
z11.object({
|
|
883
|
+
ok: z11.literal(true),
|
|
789
884
|
identity: MicrosoftIdentityReferenceSchema,
|
|
790
|
-
devices:
|
|
885
|
+
devices: z11.array(MicrosoftDeviceSchema)
|
|
791
886
|
}).strict(),
|
|
792
887
|
MicrosoftEnrollmentFailureSchema
|
|
793
888
|
]);
|
|
794
889
|
var MicrosoftIdentitySummarySchema = MicrosoftIdentityReferenceSchema.extend({
|
|
795
|
-
identityId:
|
|
796
|
-
userId:
|
|
797
|
-
allowed:
|
|
798
|
-
decidedBy:
|
|
799
|
-
decidedAt:
|
|
800
|
-
createdAt:
|
|
801
|
-
lastLoginAt:
|
|
802
|
-
}).strict();
|
|
803
|
-
var MicrosoftIdentityAllowRequestSchema =
|
|
890
|
+
identityId: z11.uuid(),
|
|
891
|
+
userId: z11.string().min(1).max(256).nullable(),
|
|
892
|
+
allowed: z11.boolean(),
|
|
893
|
+
decidedBy: z11.string().min(1).max(256),
|
|
894
|
+
decidedAt: z11.number().int().nonnegative(),
|
|
895
|
+
createdAt: z11.number().int().nonnegative(),
|
|
896
|
+
lastLoginAt: z11.number().int().nonnegative().nullable()
|
|
897
|
+
}).strict();
|
|
898
|
+
var MicrosoftIdentityAllowRequestSchema = z11.object({
|
|
804
899
|
identity: MicrosoftIdentityReferenceSchema,
|
|
805
|
-
allowed:
|
|
900
|
+
allowed: z11.boolean()
|
|
806
901
|
}).strict();
|
|
807
|
-
var MicrosoftIdentityAllowResultSchema =
|
|
808
|
-
|
|
902
|
+
var MicrosoftIdentityAllowResultSchema = z11.discriminatedUnion("ok", [
|
|
903
|
+
z11.object({ ok: z11.literal(true), identity: MicrosoftIdentitySummarySchema }).strict(),
|
|
809
904
|
MicrosoftEnrollmentFailureSchema
|
|
810
905
|
]);
|
|
811
|
-
var MicrosoftIdentitiesResultSchema =
|
|
812
|
-
|
|
906
|
+
var MicrosoftIdentitiesResultSchema = z11.discriminatedUnion("ok", [
|
|
907
|
+
z11.object({ ok: z11.literal(true), identities: z11.array(MicrosoftIdentitySummarySchema) }).strict(),
|
|
813
908
|
MicrosoftEnrollmentFailureSchema
|
|
814
909
|
]);
|
|
815
|
-
var MicrosoftInvitationEmailSchema =
|
|
816
|
-
var MicrosoftInvitationCodeSchema =
|
|
817
|
-
var MicrosoftInvitationCreateRequestSchema =
|
|
910
|
+
var MicrosoftInvitationEmailSchema = z11.email().max(254).regex(/^[\x21-\x7e]+$/);
|
|
911
|
+
var MicrosoftInvitationCodeSchema = z11.string().length(24).regex(/^[A-F0-9]{24}$/);
|
|
912
|
+
var MicrosoftInvitationCreateRequestSchema = z11.object({
|
|
818
913
|
email: MicrosoftInvitationEmailSchema
|
|
819
914
|
}).strict();
|
|
820
|
-
var MicrosoftInvitationCreateResultSchema =
|
|
821
|
-
|
|
822
|
-
ok:
|
|
823
|
-
invitationId:
|
|
915
|
+
var MicrosoftInvitationCreateResultSchema = z11.discriminatedUnion("ok", [
|
|
916
|
+
z11.object({
|
|
917
|
+
ok: z11.literal(true),
|
|
918
|
+
invitationId: z11.uuid(),
|
|
824
919
|
email: MicrosoftInvitationEmailSchema,
|
|
825
920
|
code: MicrosoftInvitationCodeSchema,
|
|
826
|
-
expiresAt:
|
|
827
|
-
invitationUri:
|
|
921
|
+
expiresAt: z11.number().int().nonnegative(),
|
|
922
|
+
invitationUri: z11.url()
|
|
828
923
|
}).strict(),
|
|
829
924
|
MicrosoftEnrollmentFailureSchema
|
|
830
925
|
]);
|
|
@@ -833,8 +928,8 @@ var MicrosoftInvitationAcceptRequestSchema = MicrosoftCsrfRequestSchema.extend({
|
|
|
833
928
|
}).strict();
|
|
834
929
|
|
|
835
930
|
// ../../shared/protocol/dist/transport/event-names.js
|
|
836
|
-
import { z as
|
|
837
|
-
var PcSecureEventNameSchema =
|
|
931
|
+
import { z as z12 } from "zod";
|
|
932
|
+
var PcSecureEventNameSchema = z12.enum([
|
|
838
933
|
"session.communication",
|
|
839
934
|
"session.list.result",
|
|
840
935
|
"session.options.result",
|
|
@@ -856,7 +951,7 @@ var PcSecureEventNameSchema = z10.enum([
|
|
|
856
951
|
"permission.respond.result",
|
|
857
952
|
"sessions.snapshot"
|
|
858
953
|
]);
|
|
859
|
-
var MobileSecureEventNameSchema =
|
|
954
|
+
var MobileSecureEventNameSchema = z12.enum([
|
|
860
955
|
"session.communication",
|
|
861
956
|
"session.list",
|
|
862
957
|
"session.options",
|
|
@@ -871,7 +966,7 @@ var MobileSecureEventNameSchema = z10.enum([
|
|
|
871
966
|
"interaction.respond",
|
|
872
967
|
"permission.respond"
|
|
873
968
|
]);
|
|
874
|
-
var SecureEventNameSchema =
|
|
969
|
+
var SecureEventNameSchema = z12.enum([
|
|
875
970
|
"session.communication",
|
|
876
971
|
"session.list.result",
|
|
877
972
|
"session.options.result",
|
|
@@ -907,60 +1002,69 @@ var SecureEventNameSchema = z10.enum([
|
|
|
907
1002
|
]);
|
|
908
1003
|
|
|
909
1004
|
// ../../shared/protocol/dist/transport/transport.js
|
|
910
|
-
import { z as
|
|
911
|
-
var RoleSchema =
|
|
1005
|
+
import { z as z13 } from "zod";
|
|
1006
|
+
var RoleSchema = z13.enum(["pc", "mobile"]);
|
|
912
1007
|
var V2SocketAuthBaseShape = {
|
|
913
|
-
transportVersion:
|
|
914
|
-
protocolVersion:
|
|
915
|
-
token:
|
|
1008
|
+
transportVersion: z13.coerce.number().pipe(z13.literal(TRANSPORT_V2)),
|
|
1009
|
+
protocolVersion: z13.coerce.number().pipe(SupportedProtocolVersionSchema),
|
|
1010
|
+
token: z13.string().min(1),
|
|
916
1011
|
clientId: IdSchema,
|
|
917
1012
|
machineId: IdSchema,
|
|
918
1013
|
keyId: Base64UrlKeyIdSchema
|
|
919
1014
|
};
|
|
920
|
-
var V2PcSocketAuthSchema =
|
|
1015
|
+
var V2PcSocketAuthSchema = z13.object({
|
|
921
1016
|
...V2SocketAuthBaseShape,
|
|
922
|
-
role:
|
|
1017
|
+
role: z13.literal("pc"),
|
|
923
1018
|
userId: IdSchema
|
|
924
1019
|
}).strict();
|
|
925
|
-
var V2MobileSocketAuthSchema =
|
|
1020
|
+
var V2MobileSocketAuthSchema = z13.object({
|
|
926
1021
|
...V2SocketAuthBaseShape,
|
|
927
|
-
role:
|
|
928
|
-
mobileCredential:
|
|
1022
|
+
role: z13.literal("mobile"),
|
|
1023
|
+
mobileCredential: z13.string().min(64).max(4096),
|
|
1024
|
+
proof: z13.preprocess((value) => {
|
|
1025
|
+
if (typeof value !== "string" || value.length > 2048)
|
|
1026
|
+
return value;
|
|
1027
|
+
try {
|
|
1028
|
+
return JSON.parse(value);
|
|
1029
|
+
} catch {
|
|
1030
|
+
return value;
|
|
1031
|
+
}
|
|
1032
|
+
}, MobileIdentityProofSchema).optional()
|
|
929
1033
|
}).strict();
|
|
930
|
-
var V2SocketAuthSchema =
|
|
1034
|
+
var V2SocketAuthSchema = z13.discriminatedUnion("role", [
|
|
931
1035
|
V2PcSocketAuthSchema,
|
|
932
1036
|
V2MobileSocketAuthSchema
|
|
933
1037
|
]);
|
|
934
1038
|
var SECURE_MESSAGE_MAX_CIPHERTEXT_LENGTH = 16e6;
|
|
935
1039
|
var SecureMessageBaseShape = {
|
|
936
|
-
version:
|
|
937
|
-
algorithm:
|
|
1040
|
+
version: z13.literal(1),
|
|
1041
|
+
algorithm: z13.literal("A256GCM"),
|
|
938
1042
|
messageId: IdSchema,
|
|
939
1043
|
machineId: IdSchema,
|
|
940
1044
|
clientId: IdSchema,
|
|
941
1045
|
recipientClientId: IdSchema.optional(),
|
|
942
1046
|
keyId: Base64UrlKeyIdSchema,
|
|
943
|
-
sentAt:
|
|
944
|
-
nonce:
|
|
945
|
-
ciphertext:
|
|
1047
|
+
sentAt: z13.number().int().nonnegative(),
|
|
1048
|
+
nonce: z13.string().regex(/^[A-Za-z0-9_-]{16}$/u, "Expected a 12-byte base64url nonce"),
|
|
1049
|
+
ciphertext: z13.string().min(22).max(SECURE_MESSAGE_MAX_CIPHERTEXT_LENGTH).regex(/^[A-Za-z0-9_-]+$/u, "Expected base64url ciphertext")
|
|
946
1050
|
};
|
|
947
|
-
var SecureMessageSchema =
|
|
948
|
-
|
|
1051
|
+
var SecureMessageSchema = z13.discriminatedUnion("sender", [
|
|
1052
|
+
z13.object({
|
|
949
1053
|
...SecureMessageBaseShape,
|
|
950
|
-
sender:
|
|
1054
|
+
sender: z13.literal("pc"),
|
|
951
1055
|
event: PcSecureEventNameSchema
|
|
952
1056
|
}).strict(),
|
|
953
|
-
|
|
1057
|
+
z13.object({
|
|
954
1058
|
...SecureMessageBaseShape,
|
|
955
|
-
sender:
|
|
1059
|
+
sender: z13.literal("mobile"),
|
|
956
1060
|
event: MobileSecureEventNameSchema
|
|
957
1061
|
}).strict()
|
|
958
1062
|
]);
|
|
959
|
-
var SecureDeliveryErrorSchema =
|
|
1063
|
+
var SecureDeliveryErrorSchema = z13.object({
|
|
960
1064
|
messageId: IdSchema,
|
|
961
1065
|
event: SecureEventNameSchema,
|
|
962
1066
|
machineId: IdSchema,
|
|
963
|
-
code:
|
|
1067
|
+
code: z13.enum([
|
|
964
1068
|
"MACHINE_OFFLINE",
|
|
965
1069
|
"IDENTITY_MISMATCH",
|
|
966
1070
|
"KEY_ID_MISMATCH",
|
|
@@ -968,153 +1072,153 @@ var SecureDeliveryErrorSchema = z11.object({
|
|
|
968
1072
|
"SESSION_DELETE_UNSUPPORTED",
|
|
969
1073
|
"SESSION_COMMUNICATION_UNSUPPORTED"
|
|
970
1074
|
]),
|
|
971
|
-
message:
|
|
1075
|
+
message: z13.string().min(1).max(1024)
|
|
972
1076
|
}).strict();
|
|
973
1077
|
|
|
974
1078
|
// ../../shared/protocol/dist/transport/machines.js
|
|
975
|
-
import { z as
|
|
1079
|
+
import { z as z14 } from "zod";
|
|
976
1080
|
var MACHINE_HELLO_SDK_COMPAT_VERSION = "1.0.9";
|
|
977
1081
|
var MachineHelloBaseShape = {
|
|
978
1082
|
userId: IdSchema,
|
|
979
1083
|
machineId: IdSchema,
|
|
980
|
-
machineName:
|
|
981
|
-
platform:
|
|
1084
|
+
machineName: z14.string().trim().min(1).max(120),
|
|
1085
|
+
platform: z14.string().trim().min(1).max(64),
|
|
982
1086
|
agentRunId: IdSchema,
|
|
983
|
-
sdkVersion:
|
|
984
|
-
clientVersion:
|
|
985
|
-
capabilities:
|
|
1087
|
+
sdkVersion: z14.literal(MACHINE_HELLO_SDK_COMPAT_VERSION),
|
|
1088
|
+
clientVersion: z14.string().trim().min(1).max(64).optional(),
|
|
1089
|
+
capabilities: z14.array(IdSchema).max(64).optional()
|
|
986
1090
|
};
|
|
987
|
-
var OldestSupportedMachineHelloSchema =
|
|
1091
|
+
var OldestSupportedMachineHelloSchema = z14.object({
|
|
988
1092
|
...MachineHelloBaseShape,
|
|
989
|
-
protocolVersion:
|
|
1093
|
+
protocolVersion: z14.literal(OLDEST_SUPPORTED_PROTOCOL_VERSION)
|
|
990
1094
|
});
|
|
991
|
-
var LegacyMachineHelloSchema =
|
|
1095
|
+
var LegacyMachineHelloSchema = z14.object({
|
|
992
1096
|
...MachineHelloBaseShape,
|
|
993
|
-
protocolVersion:
|
|
1097
|
+
protocolVersion: z14.literal(LEGACY_PROTOCOL_VERSION)
|
|
994
1098
|
});
|
|
995
|
-
var MachineHelloSchema =
|
|
1099
|
+
var MachineHelloSchema = z14.object({
|
|
996
1100
|
...MachineHelloBaseShape,
|
|
997
|
-
protocolVersion:
|
|
1101
|
+
protocolVersion: z14.literal(PROTOCOL_VERSION)
|
|
998
1102
|
});
|
|
999
|
-
var CompatibleMachineHelloSchema =
|
|
1103
|
+
var CompatibleMachineHelloSchema = z14.union([
|
|
1000
1104
|
OldestSupportedMachineHelloSchema,
|
|
1001
1105
|
LegacyMachineHelloSchema,
|
|
1002
1106
|
MachineHelloSchema
|
|
1003
1107
|
]);
|
|
1004
|
-
var V2MachineHelloSchema =
|
|
1108
|
+
var V2MachineHelloSchema = z14.union([
|
|
1005
1109
|
OldestSupportedMachineHelloSchema.strict(),
|
|
1006
1110
|
LegacyMachineHelloSchema.strict(),
|
|
1007
1111
|
MachineHelloSchema.strict()
|
|
1008
1112
|
]);
|
|
1009
|
-
var MachineHeartbeatSchema =
|
|
1113
|
+
var MachineHeartbeatSchema = z14.object({
|
|
1010
1114
|
userId: IdSchema,
|
|
1011
1115
|
machineId: IdSchema,
|
|
1012
1116
|
agentRunId: IdSchema,
|
|
1013
|
-
sentAt:
|
|
1117
|
+
sentAt: z14.number().int().nonnegative()
|
|
1014
1118
|
});
|
|
1015
1119
|
var MachinePresenceStateShape = {
|
|
1016
|
-
online:
|
|
1017
|
-
connectedAt:
|
|
1018
|
-
lastSeen:
|
|
1120
|
+
online: z14.literal(true),
|
|
1121
|
+
connectedAt: z14.number().int().nonnegative(),
|
|
1122
|
+
lastSeen: z14.number().int().nonnegative()
|
|
1019
1123
|
};
|
|
1020
|
-
var MachinePresenceSchema =
|
|
1124
|
+
var MachinePresenceSchema = z14.union([
|
|
1021
1125
|
OldestSupportedMachineHelloSchema.extend(MachinePresenceStateShape),
|
|
1022
1126
|
LegacyMachineHelloSchema.extend(MachinePresenceStateShape),
|
|
1023
1127
|
MachineHelloSchema.extend(MachinePresenceStateShape)
|
|
1024
1128
|
]);
|
|
1025
|
-
var MachineOfflineSchema =
|
|
1129
|
+
var MachineOfflineSchema = z14.object({
|
|
1026
1130
|
userId: IdSchema,
|
|
1027
1131
|
machineId: IdSchema,
|
|
1028
1132
|
agentRunId: IdSchema,
|
|
1029
|
-
disconnectedAt:
|
|
1133
|
+
disconnectedAt: z14.number().int().nonnegative()
|
|
1030
1134
|
});
|
|
1031
|
-
var MobileDisconnectedSchema =
|
|
1135
|
+
var MobileDisconnectedSchema = z14.object({
|
|
1032
1136
|
clientId: IdSchema,
|
|
1033
1137
|
machineId: IdSchema,
|
|
1034
|
-
disconnectedAt:
|
|
1138
|
+
disconnectedAt: z14.number().int().nonnegative()
|
|
1035
1139
|
});
|
|
1036
|
-
var MobileConnectedSchema =
|
|
1140
|
+
var MobileConnectedSchema = z14.object({
|
|
1037
1141
|
clientId: IdSchema,
|
|
1038
1142
|
machineId: IdSchema,
|
|
1039
|
-
connectedAt:
|
|
1040
|
-
capabilities:
|
|
1143
|
+
connectedAt: z14.number().int().nonnegative(),
|
|
1144
|
+
capabilities: z14.array(IdSchema).max(64).optional()
|
|
1041
1145
|
});
|
|
1042
|
-
var MachineListRequestSchema =
|
|
1146
|
+
var MachineListRequestSchema = z14.object({
|
|
1043
1147
|
requestId: IdSchema
|
|
1044
1148
|
});
|
|
1045
|
-
var MachineListResultSchema =
|
|
1149
|
+
var MachineListResultSchema = z14.object({
|
|
1046
1150
|
requestId: IdSchema,
|
|
1047
|
-
machines:
|
|
1151
|
+
machines: z14.array(MachinePresenceSchema),
|
|
1048
1152
|
// Absent on older relays; PC presence capabilities alone do not negotiate routing.
|
|
1049
|
-
relayCapabilities:
|
|
1153
|
+
relayCapabilities: z14.array(IdSchema).max(64).optional()
|
|
1050
1154
|
});
|
|
1051
1155
|
|
|
1052
1156
|
// ../../shared/protocol/dist/transport/peer-message.js
|
|
1053
|
-
import { z as
|
|
1054
|
-
var PeerTextSchema =
|
|
1157
|
+
import { z as z15 } from "zod";
|
|
1158
|
+
var PeerTextSchema = z15.string().max(16e3).refine((value) => value.trim().length > 0);
|
|
1055
1159
|
var PeerMessageBaseShape = {
|
|
1056
|
-
version:
|
|
1160
|
+
version: z15.literal(1),
|
|
1057
1161
|
messageId: IdSchema,
|
|
1058
1162
|
sourceSessionId: IdSchema,
|
|
1059
1163
|
targetMachineId: IdSchema,
|
|
1060
1164
|
targetSessionId: IdSchema
|
|
1061
1165
|
};
|
|
1062
|
-
var PeerMessageSchema =
|
|
1063
|
-
|
|
1166
|
+
var PeerMessageSchema = z15.discriminatedUnion("kind", [
|
|
1167
|
+
z15.object({
|
|
1064
1168
|
...PeerMessageBaseShape,
|
|
1065
|
-
kind:
|
|
1169
|
+
kind: z15.literal("request"),
|
|
1066
1170
|
content: PeerTextSchema,
|
|
1067
|
-
timeoutMs:
|
|
1171
|
+
timeoutMs: z15.number().int().min(1e3).max(12e4)
|
|
1068
1172
|
}).strict(),
|
|
1069
|
-
|
|
1173
|
+
z15.object({
|
|
1070
1174
|
...PeerMessageBaseShape,
|
|
1071
|
-
kind:
|
|
1175
|
+
kind: z15.literal("response"),
|
|
1072
1176
|
requestId: IdSchema,
|
|
1073
1177
|
content: PeerTextSchema
|
|
1074
1178
|
}).strict(),
|
|
1075
|
-
|
|
1179
|
+
z15.object({
|
|
1076
1180
|
...PeerMessageBaseShape,
|
|
1077
|
-
kind:
|
|
1181
|
+
kind: z15.literal("error"),
|
|
1078
1182
|
requestId: IdSchema,
|
|
1079
|
-
code:
|
|
1080
|
-
message:
|
|
1183
|
+
code: z15.string().trim().min(1).max(80),
|
|
1184
|
+
message: z15.string().trim().min(1).max(1024)
|
|
1081
1185
|
}).strict(),
|
|
1082
|
-
|
|
1186
|
+
z15.object({
|
|
1083
1187
|
...PeerMessageBaseShape,
|
|
1084
|
-
kind:
|
|
1188
|
+
kind: z15.literal("cancel"),
|
|
1085
1189
|
requestId: IdSchema
|
|
1086
1190
|
}).strict()
|
|
1087
1191
|
]);
|
|
1088
|
-
var PeerDeliverySchema =
|
|
1192
|
+
var PeerDeliverySchema = z15.object({
|
|
1089
1193
|
sourceMachineId: IdSchema,
|
|
1090
1194
|
message: PeerMessageSchema
|
|
1091
1195
|
}).strict();
|
|
1092
1196
|
|
|
1093
1197
|
// ../../shared/protocol/dist/transport/a2a.js
|
|
1094
|
-
import { z as
|
|
1198
|
+
import { z as z16 } from "zod";
|
|
1095
1199
|
var A2A_BODY_MAX_LENGTH = 65536;
|
|
1096
|
-
var A2aRelayRequestSchema =
|
|
1200
|
+
var A2aRelayRequestSchema = z16.object({
|
|
1097
1201
|
userId: IdSchema,
|
|
1098
1202
|
sourceMachineId: IdSchema,
|
|
1099
1203
|
targetSessionId: IdSchema,
|
|
1100
|
-
endpointUrl:
|
|
1101
|
-
kind:
|
|
1102
|
-
body:
|
|
1103
|
-
protocolVersion:
|
|
1204
|
+
endpointUrl: z16.url().max(2048),
|
|
1205
|
+
kind: z16.enum(["card", "rpc"]),
|
|
1206
|
+
body: z16.string().max(A2A_BODY_MAX_LENGTH),
|
|
1207
|
+
protocolVersion: z16.string().max(32).optional()
|
|
1104
1208
|
}).strict().refine((request) => request.kind !== "card" || request.body === "", {
|
|
1105
1209
|
path: ["body"],
|
|
1106
1210
|
message: "Agent card requests must have an empty body"
|
|
1107
1211
|
});
|
|
1108
|
-
var A2aRelayResponseSchema =
|
|
1109
|
-
status:
|
|
1110
|
-
body:
|
|
1212
|
+
var A2aRelayResponseSchema = z16.object({
|
|
1213
|
+
status: z16.number().int().min(200).max(599),
|
|
1214
|
+
body: z16.string().max(A2A_BODY_MAX_LENGTH)
|
|
1111
1215
|
}).strict();
|
|
1112
1216
|
|
|
1113
1217
|
// ../../shared/protocol/dist/transport/browser-open-url.js
|
|
1114
|
-
import { z as
|
|
1218
|
+
import { z as z17 } from "zod";
|
|
1115
1219
|
var BROWSER_OPEN_URL_MAX_LENGTH = 8192;
|
|
1116
|
-
var BrowserOpenUrlParamsSchema =
|
|
1117
|
-
url:
|
|
1220
|
+
var BrowserOpenUrlParamsSchema = z17.strictObject({
|
|
1221
|
+
url: z17.string().min(1).max(BROWSER_OPEN_URL_MAX_LENGTH).refine((value) => {
|
|
1118
1222
|
if (!/^https?:\/\//i.test(value) || /[\s\p{Cc}\\]/u.test(value) || /%(?![0-9a-f]{2})/i.test(value))
|
|
1119
1223
|
return false;
|
|
1120
1224
|
const authority = value.split(/[/?#]/)[2];
|
|
@@ -1127,35 +1231,35 @@ var BrowserOpenUrlParamsSchema = z15.strictObject({
|
|
|
1127
1231
|
}
|
|
1128
1232
|
}, "Expected an absolute HTTP(S) URL without credentials or whitespace")
|
|
1129
1233
|
});
|
|
1130
|
-
var BrowserOpenUrlResultSchema =
|
|
1234
|
+
var BrowserOpenUrlResultSchema = z17.strictObject({ opened: z17.literal(true) });
|
|
1131
1235
|
|
|
1132
1236
|
// ../../shared/protocol/dist/sessions/session-communication.js
|
|
1133
|
-
import { z as
|
|
1134
|
-
var SessionCommunicationIdSchema =
|
|
1237
|
+
import { z as z18 } from "zod";
|
|
1238
|
+
var SessionCommunicationIdSchema = z18.string().min(1).max(256).refine((value) => value === value.trim(), "Expected an unpadded identity");
|
|
1135
1239
|
var SessionCommunicationIdentityShape = {
|
|
1136
1240
|
requestId: SessionCommunicationIdSchema,
|
|
1137
1241
|
machineId: SessionCommunicationIdSchema,
|
|
1138
1242
|
sessionId: SessionCommunicationIdSchema,
|
|
1139
|
-
operation:
|
|
1140
|
-
version:
|
|
1243
|
+
operation: z18.string().min(1).max(128).regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/u),
|
|
1244
|
+
version: z18.number().int().positive().max(2147483647)
|
|
1141
1245
|
};
|
|
1142
|
-
var SessionCommunicationDataSchema =
|
|
1143
|
-
var SessionCommunicationRequestSchema =
|
|
1246
|
+
var SessionCommunicationDataSchema = z18.record(z18.string(), z18.json());
|
|
1247
|
+
var SessionCommunicationRequestSchema = z18.object({
|
|
1144
1248
|
...SessionCommunicationIdentityShape,
|
|
1145
|
-
kind:
|
|
1249
|
+
kind: z18.literal("request"),
|
|
1146
1250
|
data: SessionCommunicationDataSchema
|
|
1147
1251
|
}).strict();
|
|
1148
|
-
var SessionCommunicationResponseSchema =
|
|
1252
|
+
var SessionCommunicationResponseSchema = z18.object({
|
|
1149
1253
|
...SessionCommunicationIdentityShape,
|
|
1150
|
-
kind:
|
|
1254
|
+
kind: z18.literal("response"),
|
|
1151
1255
|
data: SessionCommunicationDataSchema
|
|
1152
1256
|
}).strict();
|
|
1153
|
-
var SessionCommunicationErrorSchema =
|
|
1257
|
+
var SessionCommunicationErrorSchema = z18.object({
|
|
1154
1258
|
...SessionCommunicationIdentityShape,
|
|
1155
|
-
kind:
|
|
1259
|
+
kind: z18.literal("error"),
|
|
1156
1260
|
error: ProtocolFailureSchema
|
|
1157
1261
|
}).strict();
|
|
1158
|
-
var SessionCommunicationSchema =
|
|
1262
|
+
var SessionCommunicationSchema = z18.discriminatedUnion("kind", [
|
|
1159
1263
|
SessionCommunicationRequestSchema,
|
|
1160
1264
|
SessionCommunicationResponseSchema,
|
|
1161
1265
|
SessionCommunicationErrorSchema
|
|
@@ -1165,7 +1269,7 @@ function sessionCommunicationOperationCapability(operation, version) {
|
|
|
1165
1269
|
}
|
|
1166
1270
|
|
|
1167
1271
|
// ../../shared/protocol/dist/sessions/session-workspace.js
|
|
1168
|
-
import { z as
|
|
1272
|
+
import { z as z19 } from "zod";
|
|
1169
1273
|
var SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH = 32768;
|
|
1170
1274
|
var SESSION_PROJECT_IDENTITY_MAX_RESPONSE_BYTES = 640 * 1024;
|
|
1171
1275
|
var SESSION_DIRECTORY_MAX_PATH_LENGTH = 1024;
|
|
@@ -1206,47 +1310,47 @@ function isSafeSessionDirectoryPath(path) {
|
|
|
1206
1310
|
const segments = path.split("/");
|
|
1207
1311
|
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));
|
|
1208
1312
|
}
|
|
1209
|
-
var SessionDirectoryListRequestSchema =
|
|
1313
|
+
var SessionDirectoryListRequestSchema = z19.object({
|
|
1210
1314
|
requestId: IdSchema,
|
|
1211
1315
|
machineId: IdSchema,
|
|
1212
1316
|
sessionId: IdSchema,
|
|
1213
|
-
path:
|
|
1317
|
+
path: z19.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH)
|
|
1214
1318
|
}).strict();
|
|
1215
|
-
var SessionDirectoryEntrySchema =
|
|
1216
|
-
name:
|
|
1217
|
-
kind:
|
|
1319
|
+
var SessionDirectoryEntrySchema = z19.object({
|
|
1320
|
+
name: z19.string().min(1).max(255),
|
|
1321
|
+
kind: z19.enum(["directory", "file", "blocked"])
|
|
1218
1322
|
}).strict();
|
|
1219
1323
|
var SessionDirectoryListDataSchema = SessionDirectoryListRequestSchema.pick({ path: true });
|
|
1220
|
-
var SessionDirectoryListResultDataSchema =
|
|
1221
|
-
path:
|
|
1222
|
-
rootRevision:
|
|
1223
|
-
entries:
|
|
1324
|
+
var SessionDirectoryListResultDataSchema = z19.object({
|
|
1325
|
+
path: z19.string().max(SESSION_DIRECTORY_MAX_PATH_LENGTH),
|
|
1326
|
+
rootRevision: z19.string().min(1).max(128),
|
|
1327
|
+
entries: z19.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES)
|
|
1224
1328
|
}).strict();
|
|
1225
1329
|
var SessionDirectoryListResponseSchema = SessionDirectoryListRequestSchema.extend({
|
|
1226
|
-
rootRevision:
|
|
1227
|
-
entries:
|
|
1330
|
+
rootRevision: z19.string().min(1).max(128).optional(),
|
|
1331
|
+
entries: z19.array(SessionDirectoryEntrySchema).max(SESSION_DIRECTORY_MAX_ENTRIES).optional(),
|
|
1228
1332
|
error: ProtocolFailureSchema.optional()
|
|
1229
1333
|
}).superRefine((response, context) => {
|
|
1230
1334
|
if (response.error === void 0 ? response.entries === void 0 || response.rootRevision === void 0 : response.entries !== void 0 || response.rootRevision !== void 0) {
|
|
1231
1335
|
context.addIssue({ code: "custom", message: "Expected directory success or failure" });
|
|
1232
1336
|
}
|
|
1233
1337
|
});
|
|
1234
|
-
var SessionFileReadDataSchema =
|
|
1235
|
-
path:
|
|
1236
|
-
rootRevision:
|
|
1338
|
+
var SessionFileReadDataSchema = z19.object({
|
|
1339
|
+
path: z19.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
|
|
1340
|
+
rootRevision: z19.string().regex(/^[A-Za-z0-9_-]{43}$/u)
|
|
1237
1341
|
}).strict();
|
|
1238
1342
|
function fileResultSchema(mediaTypes, extended) {
|
|
1239
1343
|
const maxOriginal = extended ? SESSION_FILE_V2_MAX_ORIGINAL_BYTES : SESSION_FILE_MAX_ORIGINAL_BYTES;
|
|
1240
1344
|
const maxTransfer = extended ? SESSION_FILE_V2_MAX_TRANSFER_BYTES : SESSION_FILE_MAX_TRANSFER_BYTES;
|
|
1241
|
-
return
|
|
1345
|
+
return z19.object({
|
|
1242
1346
|
path: SessionFileReadDataSchema.shape.path,
|
|
1243
1347
|
rootRevision: SessionFileReadDataSchema.shape.rootRevision,
|
|
1244
|
-
mediaType:
|
|
1245
|
-
originalByteLength:
|
|
1348
|
+
mediaType: z19.enum(mediaTypes),
|
|
1349
|
+
originalByteLength: z19.number().int().min(0).max(maxOriginal),
|
|
1246
1350
|
// Canonical length after decompression, not the length of the transport bytes.
|
|
1247
|
-
byteLength:
|
|
1248
|
-
encoding:
|
|
1249
|
-
data:
|
|
1351
|
+
byteLength: z19.number().int().min(0).max(maxOriginal),
|
|
1352
|
+
encoding: z19.enum(["identity", "gzip"]),
|
|
1353
|
+
data: z19.string().max(extended ? SESSION_FILE_V2_MAX_BASE64_LENGTH : SESSION_FILE_MAX_BASE64_LENGTH)
|
|
1250
1354
|
}).strict().superRefine((result, context) => {
|
|
1251
1355
|
const invalid = () => context.addIssue({ code: "custom", message: "Invalid file content" });
|
|
1252
1356
|
if (result.encoding === "gzip" !== result.originalByteLength >= SESSION_FILE_GZIP_THRESHOLD_BYTES)
|
|
@@ -1266,19 +1370,19 @@ var SessionFileReadResultDataSchema = fileResultSchema(SESSION_FILE_MEDIA_TYPES,
|
|
|
1266
1370
|
var SessionFileReadV2ResultDataSchema = fileResultSchema(SESSION_FILE_V2_MEDIA_TYPES, true);
|
|
1267
1371
|
var SessionFileDownloadDataSchema = SessionFileReadDataSchema;
|
|
1268
1372
|
var SessionFileDownloadResultDataSchema = fileResultSchema(["application/octet-stream"], true);
|
|
1269
|
-
var SessionGitProjectSchema =
|
|
1270
|
-
localRepositoryKey:
|
|
1271
|
-
worktreeRoot:
|
|
1272
|
-
mainWorktreeRoot:
|
|
1273
|
-
gitRemoteUrl:
|
|
1274
|
-
}).strict();
|
|
1275
|
-
var SessionProjectIdentityRequestDataSchema =
|
|
1276
|
-
var SessionProjectIdentityResultDataSchema =
|
|
1373
|
+
var SessionGitProjectSchema = z19.object({
|
|
1374
|
+
localRepositoryKey: z19.string().length(43).regex(/^[A-Za-z0-9_-]{43}$/),
|
|
1375
|
+
worktreeRoot: z19.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH),
|
|
1376
|
+
mainWorktreeRoot: z19.string().min(1).max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional(),
|
|
1377
|
+
gitRemoteUrl: z19.string().max(SESSION_PROJECT_IDENTITY_MAX_PATH_LENGTH).optional()
|
|
1378
|
+
}).strict();
|
|
1379
|
+
var SessionProjectIdentityRequestDataSchema = z19.object({}).strict();
|
|
1380
|
+
var SessionProjectIdentityResultDataSchema = z19.object({
|
|
1277
1381
|
project: SessionGitProjectSchema.optional()
|
|
1278
1382
|
}).strict();
|
|
1279
1383
|
|
|
1280
1384
|
// ../../shared/protocol/dist/sessions/session-git-diff.js
|
|
1281
|
-
import { z as
|
|
1385
|
+
import { z as z20 } from "zod";
|
|
1282
1386
|
var SESSION_GIT_DIFF_GZIP_MIN_BYTES = 2 * 1024;
|
|
1283
1387
|
var SESSION_GIT_DIFF_MAX_FILES = 500;
|
|
1284
1388
|
var SESSION_GIT_DIFF_MAX_PATCH_BYTES = 128 * 1024;
|
|
@@ -1286,24 +1390,24 @@ var SESSION_GIT_DIFF_MAX_RESPONSE_BYTES = 512 * 1024;
|
|
|
1286
1390
|
var SESSION_GIT_DIFF_MAX_TRANSFER_BYTES = SESSION_GIT_DIFF_MAX_RESPONSE_BYTES + 1024;
|
|
1287
1391
|
var SESSION_GIT_DIFF_MAX_BASE64_LENGTH = Math.ceil(SESSION_GIT_DIFF_MAX_TRANSFER_BYTES / 3) * 4;
|
|
1288
1392
|
var SESSION_GIT_DIFF_MAX_GZIP_RESPONSE_BYTES = SESSION_GIT_DIFF_MAX_BASE64_LENGTH + 1024;
|
|
1289
|
-
var commitSchema =
|
|
1290
|
-
var SessionGitDiffDataSchema =
|
|
1393
|
+
var commitSchema = z20.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u);
|
|
1394
|
+
var SessionGitDiffDataSchema = z20.object({
|
|
1291
1395
|
rootRevision: SessionFileReadDataSchema.shape.rootRevision,
|
|
1292
1396
|
path: SessionFileReadDataSchema.shape.path.optional(),
|
|
1293
1397
|
baseCommit: commitSchema.optional()
|
|
1294
1398
|
}).strict().refine((value) => value.path === void 0 === (value.baseCommit === void 0), "A file diff must identify its listed base commit");
|
|
1295
|
-
var SessionGitDiffEntrySchema =
|
|
1399
|
+
var SessionGitDiffEntrySchema = z20.object({
|
|
1296
1400
|
path: SessionFileReadDataSchema.shape.path,
|
|
1297
|
-
status:
|
|
1401
|
+
status: z20.enum(["added", "modified", "deleted", "untracked"])
|
|
1298
1402
|
}).strict();
|
|
1299
|
-
var SessionGitDiffResultDataSchema =
|
|
1403
|
+
var SessionGitDiffResultDataSchema = z20.object({
|
|
1300
1404
|
rootRevision: SessionFileReadDataSchema.shape.rootRevision,
|
|
1301
|
-
baseRef:
|
|
1405
|
+
baseRef: z20.enum(["origin/main", "main"]),
|
|
1302
1406
|
baseCommit: commitSchema,
|
|
1303
|
-
files:
|
|
1407
|
+
files: z20.array(SessionGitDiffEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional(),
|
|
1304
1408
|
path: SessionFileReadDataSchema.shape.path.optional(),
|
|
1305
|
-
patch:
|
|
1306
|
-
binary:
|
|
1409
|
+
patch: z20.string().max(SESSION_GIT_DIFF_MAX_PATCH_BYTES).optional(),
|
|
1410
|
+
binary: z20.boolean().optional()
|
|
1307
1411
|
}).strict().superRefine((value, context) => {
|
|
1308
1412
|
const encoder = new TextEncoder();
|
|
1309
1413
|
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) {
|
|
@@ -1317,13 +1421,13 @@ var SessionGitDiffResultDataSchema = z18.object({
|
|
|
1317
1421
|
context.addIssue({ code: "custom", message: "Expected a text patch or an explicit binary change" });
|
|
1318
1422
|
}
|
|
1319
1423
|
});
|
|
1320
|
-
var SessionGitDiffFileErrorSchema =
|
|
1321
|
-
code:
|
|
1322
|
-
message:
|
|
1424
|
+
var SessionGitDiffFileErrorSchema = z20.object({
|
|
1425
|
+
code: z20.enum(["DIFF_BLOCKED", "DIFF_FILE_UNAVAILABLE"]),
|
|
1426
|
+
message: z20.string().min(1).max(512)
|
|
1323
1427
|
}).strict();
|
|
1324
1428
|
var SessionGitDiffPartialEntrySchema = SessionGitDiffEntrySchema.extend({
|
|
1325
1429
|
// Error paths are display-only: they must never be used for file requests.
|
|
1326
|
-
path:
|
|
1430
|
+
path: z20.string().min(1).max(32768).refine((value) => !value.includes("\0")),
|
|
1327
1431
|
error: SessionGitDiffFileErrorSchema.optional()
|
|
1328
1432
|
}).superRefine((value, context) => {
|
|
1329
1433
|
if (value.error === void 0 && !SessionGitDiffEntrySchema.shape.path.safeParse(value.path).success) {
|
|
@@ -1331,12 +1435,12 @@ var SessionGitDiffPartialEntrySchema = SessionGitDiffEntrySchema.extend({
|
|
|
1331
1435
|
}
|
|
1332
1436
|
});
|
|
1333
1437
|
var SessionGitDiffPartialResultDataSchema = SessionGitDiffResultDataSchema.safeExtend({
|
|
1334
|
-
files:
|
|
1438
|
+
files: z20.array(SessionGitDiffPartialEntrySchema).max(SESSION_GIT_DIFF_MAX_FILES).optional()
|
|
1335
1439
|
});
|
|
1336
|
-
var SessionGitDiffGzipResultDataSchema =
|
|
1337
|
-
encoding:
|
|
1338
|
-
byteLength:
|
|
1339
|
-
data:
|
|
1440
|
+
var SessionGitDiffGzipResultDataSchema = z20.object({
|
|
1441
|
+
encoding: z20.literal("gzip"),
|
|
1442
|
+
byteLength: z20.number().int().min(1).max(SESSION_GIT_DIFF_MAX_RESPONSE_BYTES),
|
|
1443
|
+
data: z20.string().max(SESSION_GIT_DIFF_MAX_BASE64_LENGTH).regex(/^[A-Za-z0-9+/]*={0,2}$/u)
|
|
1340
1444
|
}).strict().superRefine((value, context) => {
|
|
1341
1445
|
const padding = value.data.endsWith("==") ? 2 : value.data.endsWith("=") ? 1 : 0;
|
|
1342
1446
|
const bytes = value.data.length / 4 * 3 - padding;
|
|
@@ -1346,13 +1450,13 @@ var SessionGitDiffGzipResultDataSchema = z18.object({
|
|
|
1346
1450
|
context.addIssue({ code: "custom", message: "Invalid gzip transfer" });
|
|
1347
1451
|
}
|
|
1348
1452
|
});
|
|
1349
|
-
var SessionGitDiffV2ResultDataSchema =
|
|
1453
|
+
var SessionGitDiffV2ResultDataSchema = z20.union([
|
|
1350
1454
|
SessionGitDiffResultDataSchema,
|
|
1351
1455
|
SessionGitDiffGzipResultDataSchema
|
|
1352
1456
|
]);
|
|
1353
1457
|
|
|
1354
1458
|
// ../../shared/protocol/dist/sessions/session-resource.js
|
|
1355
|
-
import { z as
|
|
1459
|
+
import { z as z21 } from "zod";
|
|
1356
1460
|
var SESSION_RESOURCE_MAX_ORIGINAL_BYTES = 499999;
|
|
1357
1461
|
var SESSION_RESOURCE_GZIP_THRESHOLD_BYTES = 20 * 1024;
|
|
1358
1462
|
var SESSION_RESOURCE_MAX_IMAGE_PIXELS = 16 * 1024 * 1024;
|
|
@@ -1366,18 +1470,18 @@ var SESSION_RESOURCE_MEDIA_TYPES = [
|
|
|
1366
1470
|
"text/css",
|
|
1367
1471
|
"text/javascript"
|
|
1368
1472
|
];
|
|
1369
|
-
var SessionResourceReadDataSchema =
|
|
1370
|
-
path:
|
|
1371
|
-
rootRevision:
|
|
1473
|
+
var SessionResourceReadDataSchema = z21.object({
|
|
1474
|
+
path: z21.string().min(1).max(SESSION_DIRECTORY_MAX_PATH_LENGTH).refine(isSafeSessionDirectoryPath),
|
|
1475
|
+
rootRevision: z21.string().regex(/^[A-Za-z0-9_-]{43}$/u)
|
|
1372
1476
|
}).strict();
|
|
1373
|
-
var SessionResourceReadResultDataSchema =
|
|
1477
|
+
var SessionResourceReadResultDataSchema = z21.object({
|
|
1374
1478
|
path: SessionResourceReadDataSchema.shape.path,
|
|
1375
1479
|
rootRevision: SessionResourceReadDataSchema.shape.rootRevision,
|
|
1376
|
-
mediaType:
|
|
1377
|
-
originalByteLength:
|
|
1378
|
-
byteLength:
|
|
1379
|
-
encoding:
|
|
1380
|
-
data:
|
|
1480
|
+
mediaType: z21.enum(SESSION_RESOURCE_MEDIA_TYPES),
|
|
1481
|
+
originalByteLength: z21.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
|
|
1482
|
+
byteLength: z21.number().int().min(0).max(SESSION_RESOURCE_MAX_ORIGINAL_BYTES),
|
|
1483
|
+
encoding: z21.enum(["identity", "gzip"]),
|
|
1484
|
+
data: z21.string().max(SESSION_RESOURCE_MAX_BASE64_LENGTH)
|
|
1381
1485
|
}).strict().superRefine((result, context) => {
|
|
1382
1486
|
const invalid = () => context.addIssue({ code: "custom", message: "Invalid resource content" });
|
|
1383
1487
|
if (result.encoding === "gzip" !== result.originalByteLength >= SESSION_RESOURCE_GZIP_THRESHOLD_BYTES || result.byteLength !== result.originalByteLength || result.mediaType.startsWith("image/") && result.byteLength === 0)
|
|
@@ -1390,115 +1494,115 @@ var SessionResourceReadResultDataSchema = z19.object({
|
|
|
1390
1494
|
});
|
|
1391
1495
|
|
|
1392
1496
|
// ../../shared/protocol/dist/sessions/session-images.js
|
|
1393
|
-
import { z as
|
|
1497
|
+
import { z as z22 } from "zod";
|
|
1394
1498
|
var SESSION_IMAGE_MAX_BYTES = 3 * 1024 * 1024;
|
|
1395
1499
|
var SESSION_IMAGE_MAX_PIXELS = 16 * 1024 * 1024;
|
|
1396
|
-
var SessionImageIdSchema =
|
|
1397
|
-
var SessionImageTransferModeSchema =
|
|
1398
|
-
var DirectUrlSchema =
|
|
1500
|
+
var SessionImageIdSchema = z22.uuid();
|
|
1501
|
+
var SessionImageTransferModeSchema = z22.enum(["direct", "proxy"]);
|
|
1502
|
+
var DirectUrlSchema = z22.string().regex(/^https:\/\/[^/?#@\\\s\x00-\x1f\x7f]+(?:[/?][^#\\\s\x00-\x1f\x7f]*)?$/u).refine((raw) => {
|
|
1399
1503
|
if (!URL.canParse(raw))
|
|
1400
1504
|
return false;
|
|
1401
1505
|
const url = new URL(raw);
|
|
1402
1506
|
return url.protocol === "https:" && url.username === "" && url.password === "" && url.hash === "";
|
|
1403
1507
|
}, "Direct transfers require HTTPS without userinfo, fragments or unsafe characters");
|
|
1404
|
-
var ProxyUrlSchema =
|
|
1405
|
-
var SessionImageTransferHeadersSchema =
|
|
1406
|
-
var SessionImageUploadRequestSchema =
|
|
1508
|
+
var ProxyUrlSchema = z22.string().regex(/^\/api\/v3\/session-images\/[0-9a-f-]+\/content\?[^#\\\s\x00-\x1f\x7f]+$/u);
|
|
1509
|
+
var SessionImageTransferHeadersSchema = z22.record(z22.string().regex(/^(?:content-type|if-none-match|x-ms-blob-type)$/u), z22.string().min(1).max(256).regex(/^[\x20-\x7e]+$/u));
|
|
1510
|
+
var SessionImageUploadRequestSchema = z22.object({
|
|
1407
1511
|
machineId: IdSchema,
|
|
1408
1512
|
sessionId: IdSchema,
|
|
1409
|
-
sizeBytes:
|
|
1513
|
+
sizeBytes: z22.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES)
|
|
1410
1514
|
}).strict();
|
|
1411
|
-
var SessionImageScopeSchema =
|
|
1515
|
+
var SessionImageScopeSchema = z22.object({
|
|
1412
1516
|
machineId: IdSchema,
|
|
1413
1517
|
sessionId: IdSchema
|
|
1414
1518
|
}).strict();
|
|
1415
1519
|
var UploadResultFields = {
|
|
1416
1520
|
imageId: SessionImageIdSchema,
|
|
1417
|
-
uploadExpiresAt:
|
|
1418
|
-
method:
|
|
1419
|
-
contentType:
|
|
1521
|
+
uploadExpiresAt: z22.number().int().positive(),
|
|
1522
|
+
method: z22.literal("PUT"),
|
|
1523
|
+
contentType: z22.literal("image/webp"),
|
|
1420
1524
|
headers: SessionImageTransferHeadersSchema.refine((headers) => headers["content-type"] === "image/webp")
|
|
1421
1525
|
};
|
|
1422
|
-
var SessionImageUploadResultSchema =
|
|
1423
|
-
|
|
1424
|
-
|
|
1526
|
+
var SessionImageUploadResultSchema = z22.discriminatedUnion("mode", [
|
|
1527
|
+
z22.object({ ...UploadResultFields, mode: z22.literal("direct"), uploadUrl: DirectUrlSchema }).strict(),
|
|
1528
|
+
z22.object({ ...UploadResultFields, mode: z22.literal("proxy"), uploadUrl: ProxyUrlSchema }).strict()
|
|
1425
1529
|
]);
|
|
1426
|
-
var SessionImageCommitResultSchema =
|
|
1530
|
+
var SessionImageCommitResultSchema = z22.object({
|
|
1427
1531
|
imageId: SessionImageIdSchema,
|
|
1428
1532
|
machineId: IdSchema,
|
|
1429
1533
|
sessionId: IdSchema,
|
|
1430
|
-
sizeBytes:
|
|
1431
|
-
width:
|
|
1432
|
-
height:
|
|
1433
|
-
sha256:
|
|
1434
|
-
expiresAt:
|
|
1534
|
+
sizeBytes: z22.number().int().min(1).max(SESSION_IMAGE_MAX_BYTES),
|
|
1535
|
+
width: z22.number().int().positive(),
|
|
1536
|
+
height: z22.number().int().positive(),
|
|
1537
|
+
sha256: z22.string().regex(/^[a-f0-9]{64}$/u),
|
|
1538
|
+
expiresAt: z22.number().int().positive()
|
|
1435
1539
|
}).strict();
|
|
1436
1540
|
var DownloadResultFields = {
|
|
1437
1541
|
image: SessionImageCommitResultSchema,
|
|
1438
|
-
downloadExpiresAt:
|
|
1439
|
-
method:
|
|
1542
|
+
downloadExpiresAt: z22.number().int().positive(),
|
|
1543
|
+
method: z22.literal("GET"),
|
|
1440
1544
|
headers: SessionImageTransferHeadersSchema
|
|
1441
1545
|
};
|
|
1442
|
-
var SessionImageDownloadResultSchema =
|
|
1443
|
-
|
|
1444
|
-
|
|
1546
|
+
var SessionImageDownloadResultSchema = z22.discriminatedUnion("mode", [
|
|
1547
|
+
z22.object({ ...DownloadResultFields, mode: z22.literal("direct"), downloadUrl: DirectUrlSchema }).strict(),
|
|
1548
|
+
z22.object({ ...DownloadResultFields, mode: z22.literal("proxy"), downloadUrl: ProxyUrlSchema }).strict()
|
|
1445
1549
|
]);
|
|
1446
|
-
var TimelineImageBlobRequestSchema =
|
|
1447
|
-
sha256:
|
|
1550
|
+
var TimelineImageBlobRequestSchema = z22.object({
|
|
1551
|
+
sha256: z22.string().regex(/^[a-f0-9]{64}$/u)
|
|
1448
1552
|
}).strict();
|
|
1449
|
-
var TimelineImageBlobResultSchema =
|
|
1553
|
+
var TimelineImageBlobResultSchema = z22.object({
|
|
1450
1554
|
sha256: TimelineImageBlobRequestSchema.shape.sha256,
|
|
1451
1555
|
image: SessionImageCommitResultSchema
|
|
1452
1556
|
}).strict();
|
|
1453
1557
|
|
|
1454
1558
|
// ../../shared/protocol/dist/sessions/session-rename.js
|
|
1455
|
-
import { z as
|
|
1559
|
+
import { z as z23 } from "zod";
|
|
1456
1560
|
var SESSION_RENAME_OPERATION = "session.rename";
|
|
1457
1561
|
var SESSION_RENAME_VERSION = 1;
|
|
1458
1562
|
var SESSION_RENAME_CAPABILITY = sessionCommunicationOperationCapability(SESSION_RENAME_OPERATION, SESSION_RENAME_VERSION);
|
|
1459
1563
|
var SESSION_NAME_MAX_LENGTH = 100;
|
|
1460
|
-
var SessionNameSchema =
|
|
1461
|
-
var SessionRenameDataSchema =
|
|
1462
|
-
var SessionRenameResultDataSchema =
|
|
1564
|
+
var SessionNameSchema = z23.string().regex(/^[^\u0000-\u001f\u007f]*$/u).trim().min(1).max(SESSION_NAME_MAX_LENGTH);
|
|
1565
|
+
var SessionRenameDataSchema = z23.object({ name: SessionNameSchema }).strict();
|
|
1566
|
+
var SessionRenameResultDataSchema = z23.object({ name: SessionNameSchema }).strict();
|
|
1463
1567
|
|
|
1464
1568
|
// ../../shared/protocol/dist/sessions/sessions.js
|
|
1465
|
-
import { z as
|
|
1466
|
-
var GroupChatParticipantSchema =
|
|
1569
|
+
import { z as z24 } from "zod";
|
|
1570
|
+
var GroupChatParticipantSchema = z24.object({
|
|
1467
1571
|
sessionId: IdSchema,
|
|
1468
|
-
title:
|
|
1572
|
+
title: z24.string().trim().min(1).max(260)
|
|
1469
1573
|
}).strict();
|
|
1470
|
-
var GroupChatInfoSchema =
|
|
1471
|
-
participants:
|
|
1472
|
-
state:
|
|
1574
|
+
var GroupChatInfoSchema = z24.object({
|
|
1575
|
+
participants: z24.array(GroupChatParticipantSchema).length(2).refine((participants) => new Set(participants.map((participant) => participant.sessionId)).size === 2, "A group requires two different sessions"),
|
|
1576
|
+
state: z24.enum(["ready", "running", "paused", "blocked"])
|
|
1473
1577
|
}).strict();
|
|
1474
|
-
var SessionSummarySchema =
|
|
1578
|
+
var SessionSummarySchema = z24.object({
|
|
1475
1579
|
userId: IdSchema,
|
|
1476
1580
|
sessionId: IdSchema,
|
|
1477
1581
|
machineId: IdSchema,
|
|
1478
|
-
summary:
|
|
1479
|
-
renameSupported:
|
|
1480
|
-
workingDirectory:
|
|
1481
|
-
gitRoot:
|
|
1482
|
-
repository:
|
|
1483
|
-
gitRemoteUrl:
|
|
1484
|
-
branch:
|
|
1485
|
-
isRemote:
|
|
1582
|
+
summary: z24.string().max(4096).optional(),
|
|
1583
|
+
renameSupported: z24.boolean().optional(),
|
|
1584
|
+
workingDirectory: z24.string().max(32768).optional(),
|
|
1585
|
+
gitRoot: z24.string().max(32768).optional(),
|
|
1586
|
+
repository: z24.string().max(1024).optional(),
|
|
1587
|
+
gitRemoteUrl: z24.string().max(32768).optional(),
|
|
1588
|
+
branch: z24.string().max(1024).optional(),
|
|
1589
|
+
isRemote: z24.boolean(),
|
|
1486
1590
|
createdAt: IsoDateSchema,
|
|
1487
1591
|
modifiedAt: IsoDateSchema,
|
|
1488
1592
|
groupChat: GroupChatInfoSchema.optional()
|
|
1489
1593
|
});
|
|
1490
|
-
var SessionsSnapshotSchema =
|
|
1594
|
+
var SessionsSnapshotSchema = z24.object({
|
|
1491
1595
|
userId: IdSchema,
|
|
1492
1596
|
machineId: IdSchema,
|
|
1493
|
-
machineName:
|
|
1494
|
-
platform:
|
|
1597
|
+
machineName: z24.string().trim().min(1).max(120),
|
|
1598
|
+
platform: z24.string().trim().min(1).max(64),
|
|
1495
1599
|
agentRunId: IdSchema,
|
|
1496
|
-
sequence:
|
|
1600
|
+
sequence: z24.number().int().positive(),
|
|
1497
1601
|
generatedAt: IsoDateSchema,
|
|
1498
|
-
complete:
|
|
1499
|
-
totalCount:
|
|
1500
|
-
nextCursor:
|
|
1501
|
-
sessions:
|
|
1602
|
+
complete: z24.boolean(),
|
|
1603
|
+
totalCount: z24.number().int().nonnegative(),
|
|
1604
|
+
nextCursor: z24.string().min(1).max(1024).optional(),
|
|
1605
|
+
sessions: z24.array(SessionSummarySchema)
|
|
1502
1606
|
}).superRefine((snapshot, context) => {
|
|
1503
1607
|
if (snapshot.totalCount < snapshot.sessions.length) {
|
|
1504
1608
|
context.addIssue({
|
|
@@ -1540,47 +1644,47 @@ var SessionsSnapshotSchema = z22.object({
|
|
|
1540
1644
|
sessionIds.add(session.sessionId);
|
|
1541
1645
|
}
|
|
1542
1646
|
});
|
|
1543
|
-
var SessionListRequestSchema =
|
|
1647
|
+
var SessionListRequestSchema = z24.object({
|
|
1544
1648
|
requestId: IdSchema,
|
|
1545
1649
|
machineId: IdSchema,
|
|
1546
|
-
cursor:
|
|
1650
|
+
cursor: z24.string().min(1).max(1024).optional()
|
|
1547
1651
|
});
|
|
1548
|
-
var SessionListResultSchema =
|
|
1549
|
-
|
|
1550
|
-
ok:
|
|
1652
|
+
var SessionListResultSchema = z24.discriminatedUnion("ok", [
|
|
1653
|
+
z24.object({
|
|
1654
|
+
ok: z24.literal(true),
|
|
1551
1655
|
requestId: IdSchema,
|
|
1552
1656
|
machineId: IdSchema,
|
|
1553
1657
|
snapshot: SessionsSnapshotSchema
|
|
1554
1658
|
}),
|
|
1555
|
-
|
|
1556
|
-
ok:
|
|
1659
|
+
z24.object({
|
|
1660
|
+
ok: z24.literal(false),
|
|
1557
1661
|
requestId: IdSchema,
|
|
1558
1662
|
machineId: IdSchema,
|
|
1559
1663
|
error: ProtocolFailureSchema
|
|
1560
1664
|
})
|
|
1561
1665
|
]);
|
|
1562
|
-
var SessionAgentModeSchema =
|
|
1666
|
+
var SessionAgentModeSchema = z24.enum([
|
|
1563
1667
|
"interactive",
|
|
1564
1668
|
"plan",
|
|
1565
1669
|
"autopilot"
|
|
1566
1670
|
]);
|
|
1567
|
-
var AgentConfigurationOptionSchema =
|
|
1671
|
+
var AgentConfigurationOptionSchema = z24.object({
|
|
1568
1672
|
id: IdSchema,
|
|
1569
|
-
name:
|
|
1570
|
-
value:
|
|
1571
|
-
options:
|
|
1572
|
-
value:
|
|
1573
|
-
name:
|
|
1673
|
+
name: z24.string().trim().min(1).max(260),
|
|
1674
|
+
value: z24.string().min(1).max(256),
|
|
1675
|
+
options: z24.array(z24.object({
|
|
1676
|
+
value: z24.string().min(1).max(256),
|
|
1677
|
+
name: z24.string().trim().min(1).max(260)
|
|
1574
1678
|
}).strict()).min(1).max(100)
|
|
1575
1679
|
}).strict();
|
|
1576
|
-
var AgentConfigurationChangeSchema =
|
|
1680
|
+
var AgentConfigurationChangeSchema = z24.object({
|
|
1577
1681
|
id: IdSchema,
|
|
1578
|
-
value:
|
|
1682
|
+
value: z24.string().min(1).max(256)
|
|
1579
1683
|
}).strict();
|
|
1580
|
-
var WorkspaceOptionSchema =
|
|
1684
|
+
var WorkspaceOptionSchema = z24.object({
|
|
1581
1685
|
id: IdSchema,
|
|
1582
|
-
name:
|
|
1583
|
-
path:
|
|
1686
|
+
name: z24.string().trim().min(1).max(260),
|
|
1687
|
+
path: z24.string().trim().min(1).max(32768)
|
|
1584
1688
|
});
|
|
1585
1689
|
var REASONING_EFFORTS = [
|
|
1586
1690
|
"low",
|
|
@@ -1589,113 +1693,113 @@ var REASONING_EFFORTS = [
|
|
|
1589
1693
|
"xhigh",
|
|
1590
1694
|
"max"
|
|
1591
1695
|
];
|
|
1592
|
-
var ReasoningEffortSchema =
|
|
1593
|
-
var CopilotModelOptionSchema =
|
|
1696
|
+
var ReasoningEffortSchema = z24.enum(REASONING_EFFORTS);
|
|
1697
|
+
var CopilotModelOptionSchema = z24.object({
|
|
1594
1698
|
id: IdSchema,
|
|
1595
|
-
name:
|
|
1596
|
-
isDefault:
|
|
1597
|
-
supportedReasoningEfforts:
|
|
1699
|
+
name: z24.string().trim().min(1).max(260),
|
|
1700
|
+
isDefault: z24.boolean(),
|
|
1701
|
+
supportedReasoningEfforts: z24.array(ReasoningEffortSchema).optional(),
|
|
1598
1702
|
defaultReasoningEffort: ReasoningEffortSchema.optional(),
|
|
1599
|
-
creation:
|
|
1703
|
+
creation: z24.object({
|
|
1600
1704
|
agentId: IdSchema,
|
|
1601
|
-
agentName:
|
|
1602
|
-
modelName:
|
|
1603
|
-
agentModes:
|
|
1604
|
-
reasoningEffortConfigurationSupported:
|
|
1605
|
-
isDefault:
|
|
1705
|
+
agentName: z24.string().trim().min(1).max(260),
|
|
1706
|
+
modelName: z24.string().trim().min(1).max(260),
|
|
1707
|
+
agentModes: z24.array(SessionAgentModeSchema).min(1),
|
|
1708
|
+
reasoningEffortConfigurationSupported: z24.boolean(),
|
|
1709
|
+
isDefault: z24.boolean()
|
|
1606
1710
|
}).strict().optional()
|
|
1607
1711
|
});
|
|
1608
|
-
var SessionReasoningEffortSchema =
|
|
1712
|
+
var SessionReasoningEffortSchema = z24.enum([
|
|
1609
1713
|
"default",
|
|
1610
1714
|
...REASONING_EFFORTS
|
|
1611
1715
|
]);
|
|
1612
|
-
var CurrentReasoningEffortSchema =
|
|
1613
|
-
var SessionToolInfoSchema =
|
|
1614
|
-
name:
|
|
1615
|
-
description:
|
|
1616
|
-
deferred:
|
|
1716
|
+
var CurrentReasoningEffortSchema = z24.string().trim().min(1).max(64);
|
|
1717
|
+
var SessionToolInfoSchema = z24.object({
|
|
1718
|
+
name: z24.string().trim().min(1).max(260),
|
|
1719
|
+
description: z24.string().trim().min(1).max(4096).optional(),
|
|
1720
|
+
deferred: z24.boolean().optional()
|
|
1617
1721
|
});
|
|
1618
|
-
var SessionSlashCommandInfoSchema =
|
|
1619
|
-
name:
|
|
1620
|
-
description:
|
|
1621
|
-
kind:
|
|
1722
|
+
var SessionSlashCommandInfoSchema = z24.object({
|
|
1723
|
+
name: z24.string().trim().min(1).max(260),
|
|
1724
|
+
description: z24.string().trim().min(1).max(4096).optional(),
|
|
1725
|
+
kind: z24.enum(["builtin", "skill", "client"])
|
|
1622
1726
|
});
|
|
1623
|
-
var SessionSkillInfoSchema =
|
|
1624
|
-
name:
|
|
1625
|
-
description:
|
|
1626
|
-
source:
|
|
1627
|
-
enabled:
|
|
1628
|
-
userInvocable:
|
|
1629
|
-
commandName:
|
|
1727
|
+
var SessionSkillInfoSchema = z24.object({
|
|
1728
|
+
name: z24.string().trim().min(1).max(260),
|
|
1729
|
+
description: z24.string().trim().min(1).max(4096).optional(),
|
|
1730
|
+
source: z24.string().trim().min(1).max(260),
|
|
1731
|
+
enabled: z24.boolean(),
|
|
1732
|
+
userInvocable: z24.boolean(),
|
|
1733
|
+
commandName: z24.string().trim().min(1).max(260).optional()
|
|
1630
1734
|
});
|
|
1631
|
-
var SessionEnvironmentInfoSchema =
|
|
1632
|
-
tools:
|
|
1633
|
-
slashCommands:
|
|
1634
|
-
skills:
|
|
1735
|
+
var SessionEnvironmentInfoSchema = z24.object({
|
|
1736
|
+
tools: z24.array(SessionToolInfoSchema).max(512),
|
|
1737
|
+
slashCommands: z24.array(SessionSlashCommandInfoSchema).max(512),
|
|
1738
|
+
skills: z24.array(SessionSkillInfoSchema).max(512)
|
|
1635
1739
|
});
|
|
1636
|
-
var SessionOptionsRequestSchema =
|
|
1740
|
+
var SessionOptionsRequestSchema = z24.object({
|
|
1637
1741
|
requestId: IdSchema,
|
|
1638
1742
|
machineId: IdSchema,
|
|
1639
1743
|
sessionId: IdSchema.optional(),
|
|
1640
1744
|
workspaceId: IdSchema.optional(),
|
|
1641
|
-
capabilities:
|
|
1745
|
+
capabilities: z24.array(IdSchema).max(64).optional()
|
|
1642
1746
|
});
|
|
1643
|
-
var SessionOptionsResultSchema =
|
|
1644
|
-
|
|
1645
|
-
ok:
|
|
1747
|
+
var SessionOptionsResultSchema = z24.discriminatedUnion("ok", [
|
|
1748
|
+
z24.object({
|
|
1749
|
+
ok: z24.literal(true),
|
|
1646
1750
|
requestId: IdSchema,
|
|
1647
1751
|
machineId: IdSchema,
|
|
1648
1752
|
sessionId: IdSchema.optional(),
|
|
1649
|
-
workspaces:
|
|
1650
|
-
models:
|
|
1651
|
-
modelRefreshError:
|
|
1652
|
-
agentModes:
|
|
1653
|
-
reasoningEffortConfigurationSupported:
|
|
1654
|
-
fileAttachmentsSupported:
|
|
1655
|
-
worktreeCreationSupported:
|
|
1656
|
-
worktreeBranches:
|
|
1657
|
-
worktreeCurrentBranch:
|
|
1753
|
+
workspaces: z24.array(WorkspaceOptionSchema),
|
|
1754
|
+
models: z24.array(CopilotModelOptionSchema).min(1),
|
|
1755
|
+
modelRefreshError: z24.string().min(1).max(4096).optional(),
|
|
1756
|
+
agentModes: z24.array(SessionAgentModeSchema).min(1),
|
|
1757
|
+
reasoningEffortConfigurationSupported: z24.literal(true).optional(),
|
|
1758
|
+
fileAttachmentsSupported: z24.boolean().optional(),
|
|
1759
|
+
worktreeCreationSupported: z24.literal(true).optional(),
|
|
1760
|
+
worktreeBranches: z24.array(z24.string().min(1).max(1024)).optional(),
|
|
1761
|
+
worktreeCurrentBranch: z24.string().min(1).max(1024).optional(),
|
|
1658
1762
|
currentModelId: IdSchema.optional(),
|
|
1659
1763
|
currentAgentMode: SessionAgentModeSchema.optional(),
|
|
1660
1764
|
currentReasoningEffort: CurrentReasoningEffortSchema.optional(),
|
|
1661
1765
|
environment: SessionEnvironmentInfoSchema.optional(),
|
|
1662
|
-
environmentPending:
|
|
1663
|
-
agentName:
|
|
1664
|
-
configOptions:
|
|
1766
|
+
environmentPending: z24.literal(true).optional(),
|
|
1767
|
+
agentName: z24.string().trim().min(1).max(260).optional(),
|
|
1768
|
+
configOptions: z24.array(AgentConfigurationOptionSchema).max(32).optional()
|
|
1665
1769
|
}),
|
|
1666
|
-
|
|
1667
|
-
ok:
|
|
1770
|
+
z24.object({
|
|
1771
|
+
ok: z24.literal(false),
|
|
1668
1772
|
requestId: IdSchema,
|
|
1669
1773
|
machineId: IdSchema,
|
|
1670
1774
|
sessionId: IdSchema.optional(),
|
|
1671
1775
|
error: ProtocolFailureSchema,
|
|
1672
|
-
failureStage:
|
|
1673
|
-
models:
|
|
1674
|
-
agentModes:
|
|
1675
|
-
reasoningEffortConfigurationSupported:
|
|
1676
|
-
fileAttachmentsSupported:
|
|
1776
|
+
failureStage: z24.enum(["models", "configuration", "workspaces"]).optional(),
|
|
1777
|
+
models: z24.array(CopilotModelOptionSchema).min(1).optional(),
|
|
1778
|
+
agentModes: z24.array(SessionAgentModeSchema).min(1).optional(),
|
|
1779
|
+
reasoningEffortConfigurationSupported: z24.literal(true).optional(),
|
|
1780
|
+
fileAttachmentsSupported: z24.boolean().optional(),
|
|
1677
1781
|
currentModelId: IdSchema.optional(),
|
|
1678
1782
|
currentAgentMode: SessionAgentModeSchema.optional(),
|
|
1679
1783
|
currentReasoningEffort: CurrentReasoningEffortSchema.optional(),
|
|
1680
|
-
agentName:
|
|
1681
|
-
configOptions:
|
|
1784
|
+
agentName: z24.string().trim().min(1).max(260).optional(),
|
|
1785
|
+
configOptions: z24.array(AgentConfigurationOptionSchema).max(32).optional()
|
|
1682
1786
|
})
|
|
1683
1787
|
]);
|
|
1684
|
-
var SessionCreateRequestSchema =
|
|
1788
|
+
var SessionCreateRequestSchema = z24.object({
|
|
1685
1789
|
requestId: IdSchema,
|
|
1686
1790
|
machineId: IdSchema,
|
|
1687
1791
|
workspaceId: IdSchema,
|
|
1688
1792
|
modelId: IdSchema,
|
|
1689
1793
|
agentMode: SessionAgentModeSchema,
|
|
1690
1794
|
reasoningEffort: SessionReasoningEffortSchema.optional(),
|
|
1691
|
-
worktree:
|
|
1692
|
-
branchName:
|
|
1693
|
-
baseBranch:
|
|
1795
|
+
worktree: z24.object({
|
|
1796
|
+
branchName: z24.string().trim().min(1).max(120).optional(),
|
|
1797
|
+
baseBranch: z24.string().trim().min(1).max(1024).optional()
|
|
1694
1798
|
}).strict().optional()
|
|
1695
1799
|
});
|
|
1696
|
-
var SessionCreateResultSchema =
|
|
1697
|
-
|
|
1698
|
-
ok:
|
|
1800
|
+
var SessionCreateResultSchema = z24.discriminatedUnion("ok", [
|
|
1801
|
+
z24.object({
|
|
1802
|
+
ok: z24.literal(true),
|
|
1699
1803
|
requestId: IdSchema,
|
|
1700
1804
|
machineId: IdSchema,
|
|
1701
1805
|
session: SessionSummarySchema,
|
|
@@ -1703,34 +1807,34 @@ var SessionCreateResultSchema = z22.discriminatedUnion("ok", [
|
|
|
1703
1807
|
agentMode: SessionAgentModeSchema,
|
|
1704
1808
|
reasoningEffort: SessionReasoningEffortSchema.optional()
|
|
1705
1809
|
}),
|
|
1706
|
-
|
|
1707
|
-
ok:
|
|
1810
|
+
z24.object({
|
|
1811
|
+
ok: z24.literal(false),
|
|
1708
1812
|
requestId: IdSchema,
|
|
1709
1813
|
machineId: IdSchema,
|
|
1710
1814
|
error: ProtocolFailureSchema
|
|
1711
1815
|
})
|
|
1712
1816
|
]);
|
|
1713
|
-
var SessionDeleteRequestSchema =
|
|
1817
|
+
var SessionDeleteRequestSchema = z24.object({
|
|
1714
1818
|
requestId: IdSchema,
|
|
1715
1819
|
machineId: IdSchema,
|
|
1716
1820
|
sessionId: IdSchema
|
|
1717
1821
|
}).strict();
|
|
1718
|
-
var SessionDeleteResultSchema =
|
|
1719
|
-
|
|
1720
|
-
ok:
|
|
1822
|
+
var SessionDeleteResultSchema = z24.discriminatedUnion("ok", [
|
|
1823
|
+
z24.object({
|
|
1824
|
+
ok: z24.literal(true),
|
|
1721
1825
|
requestId: IdSchema,
|
|
1722
1826
|
machineId: IdSchema,
|
|
1723
1827
|
sessionId: IdSchema
|
|
1724
1828
|
}).strict(),
|
|
1725
|
-
|
|
1726
|
-
ok:
|
|
1829
|
+
z24.object({
|
|
1830
|
+
ok: z24.literal(false),
|
|
1727
1831
|
requestId: IdSchema,
|
|
1728
1832
|
machineId: IdSchema,
|
|
1729
1833
|
sessionId: IdSchema,
|
|
1730
1834
|
error: ProtocolFailureSchema
|
|
1731
1835
|
}).strict()
|
|
1732
1836
|
]);
|
|
1733
|
-
var SessionConfigureRequestSchema =
|
|
1837
|
+
var SessionConfigureRequestSchema = z24.object({
|
|
1734
1838
|
requestId: IdSchema,
|
|
1735
1839
|
machineId: IdSchema,
|
|
1736
1840
|
sessionId: IdSchema,
|
|
@@ -1739,59 +1843,59 @@ var SessionConfigureRequestSchema = z22.object({
|
|
|
1739
1843
|
reasoningEffort: SessionReasoningEffortSchema.optional(),
|
|
1740
1844
|
configOption: AgentConfigurationChangeSchema.optional()
|
|
1741
1845
|
}).refine((request) => request.modelId !== void 0 || request.agentMode !== void 0 || request.reasoningEffort !== void 0 || request.configOption !== void 0, { message: "A modelId, agentMode, reasoningEffort, or configOption change is required" });
|
|
1742
|
-
var SessionConfigureResultSchema =
|
|
1743
|
-
|
|
1744
|
-
ok:
|
|
1846
|
+
var SessionConfigureResultSchema = z24.discriminatedUnion("ok", [
|
|
1847
|
+
z24.object({
|
|
1848
|
+
ok: z24.literal(true),
|
|
1745
1849
|
requestId: IdSchema,
|
|
1746
1850
|
machineId: IdSchema,
|
|
1747
1851
|
sessionId: IdSchema,
|
|
1748
1852
|
modelId: IdSchema.optional(),
|
|
1749
1853
|
agentMode: SessionAgentModeSchema,
|
|
1750
1854
|
reasoningEffort: CurrentReasoningEffortSchema.optional(),
|
|
1751
|
-
configOptions:
|
|
1855
|
+
configOptions: z24.array(AgentConfigurationOptionSchema).max(32).optional()
|
|
1752
1856
|
}),
|
|
1753
|
-
|
|
1754
|
-
ok:
|
|
1857
|
+
z24.object({
|
|
1858
|
+
ok: z24.literal(false),
|
|
1755
1859
|
requestId: IdSchema,
|
|
1756
1860
|
machineId: IdSchema,
|
|
1757
1861
|
sessionId: IdSchema,
|
|
1758
1862
|
error: ProtocolFailureSchema
|
|
1759
1863
|
})
|
|
1760
1864
|
]);
|
|
1761
|
-
var SessionRemoteActionSchema =
|
|
1865
|
+
var SessionRemoteActionSchema = z24.enum([
|
|
1762
1866
|
"status",
|
|
1763
1867
|
"enable",
|
|
1764
1868
|
"disable"
|
|
1765
1869
|
]);
|
|
1766
|
-
var SessionRemoteStateSchema =
|
|
1870
|
+
var SessionRemoteStateSchema = z24.enum([
|
|
1767
1871
|
"off",
|
|
1768
1872
|
"connecting",
|
|
1769
1873
|
"active",
|
|
1770
1874
|
"error"
|
|
1771
1875
|
]);
|
|
1772
|
-
var SessionRemoteRequestSchema =
|
|
1876
|
+
var SessionRemoteRequestSchema = z24.object({
|
|
1773
1877
|
requestId: IdSchema,
|
|
1774
1878
|
machineId: IdSchema,
|
|
1775
1879
|
sessionId: IdSchema,
|
|
1776
1880
|
action: SessionRemoteActionSchema
|
|
1777
1881
|
});
|
|
1778
|
-
var SessionRemoteStatusSchema =
|
|
1882
|
+
var SessionRemoteStatusSchema = z24.object({
|
|
1779
1883
|
state: SessionRemoteStateSchema,
|
|
1780
1884
|
attachedSessionId: IdSchema.optional(),
|
|
1781
|
-
url:
|
|
1782
|
-
steerable:
|
|
1885
|
+
url: z24.url().max(32768).optional(),
|
|
1886
|
+
steerable: z24.boolean(),
|
|
1783
1887
|
error: ProtocolFailureSchema.optional()
|
|
1784
1888
|
});
|
|
1785
|
-
var SessionRemoteResultSchema =
|
|
1786
|
-
|
|
1787
|
-
ok:
|
|
1889
|
+
var SessionRemoteResultSchema = z24.discriminatedUnion("ok", [
|
|
1890
|
+
z24.object({
|
|
1891
|
+
ok: z24.literal(true),
|
|
1788
1892
|
requestId: IdSchema,
|
|
1789
1893
|
machineId: IdSchema,
|
|
1790
1894
|
sessionId: IdSchema,
|
|
1791
1895
|
status: SessionRemoteStatusSchema
|
|
1792
1896
|
}),
|
|
1793
|
-
|
|
1794
|
-
ok:
|
|
1897
|
+
z24.object({
|
|
1898
|
+
ok: z24.literal(false),
|
|
1795
1899
|
requestId: IdSchema,
|
|
1796
1900
|
machineId: IdSchema,
|
|
1797
1901
|
sessionId: IdSchema,
|
|
@@ -1800,34 +1904,34 @@ var SessionRemoteResultSchema = z22.discriminatedUnion("ok", [
|
|
|
1800
1904
|
]);
|
|
1801
1905
|
|
|
1802
1906
|
// ../../shared/protocol/dist/sessions/group-chat.js
|
|
1803
|
-
import { z as
|
|
1907
|
+
import { z as z25 } from "zod";
|
|
1804
1908
|
var GROUP_CHAT_CREATE_OPERATION = "group-chat.create";
|
|
1805
1909
|
var GROUP_CHAT_CREATE_VERSION = 1;
|
|
1806
1910
|
var GROUP_CHAT_CREATE_CAPABILITY = sessionCommunicationOperationCapability(GROUP_CHAT_CREATE_OPERATION, GROUP_CHAT_CREATE_VERSION);
|
|
1807
|
-
var GroupChatCreateDataSchema =
|
|
1911
|
+
var GroupChatCreateDataSchema = z25.object({
|
|
1808
1912
|
peerSessionId: IdSchema
|
|
1809
1913
|
}).strict();
|
|
1810
|
-
var GroupChatCreateResultDataSchema =
|
|
1914
|
+
var GroupChatCreateResultDataSchema = z25.object({
|
|
1811
1915
|
session: SessionSummarySchema.refine((session) => session.groupChat !== void 0, "Group creation must return a virtual group session")
|
|
1812
1916
|
}).strict();
|
|
1813
1917
|
|
|
1814
1918
|
// ../../shared/protocol/dist/sessions/prompts.js
|
|
1815
|
-
import { z as
|
|
1816
|
-
var SessionAvatarPersonaSchema =
|
|
1817
|
-
role:
|
|
1818
|
-
displayName:
|
|
1919
|
+
import { z as z26 } from "zod";
|
|
1920
|
+
var SessionAvatarPersonaSchema = z26.object({
|
|
1921
|
+
role: z26.enum(["designer", "filmmaker", "developer", "secretary", "default"]),
|
|
1922
|
+
displayName: z26.string().trim().min(1).max(40).regex(/^[^\u0000-\u001f\u007f-\u009f]*$/).optional()
|
|
1819
1923
|
}).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" });
|
|
1820
1924
|
var MAX_PROMPT_IMAGE_BYTES = 3 * 1024 * 1024;
|
|
1821
|
-
var SessionPromptRequestSchema =
|
|
1925
|
+
var SessionPromptRequestSchema = z26.object({
|
|
1822
1926
|
requestId: IdSchema,
|
|
1823
1927
|
operationId: IdSchema,
|
|
1824
1928
|
machineId: IdSchema,
|
|
1825
1929
|
sessionId: IdSchema,
|
|
1826
|
-
prompt:
|
|
1827
|
-
attachments:
|
|
1828
|
-
fileAttachments:
|
|
1930
|
+
prompt: z26.string().trim().max(1e5),
|
|
1931
|
+
attachments: z26.array(PromptImageAttachmentSchema).max(4).optional(),
|
|
1932
|
+
fileAttachments: z26.array(PromptFileAttachmentSchema).max(4).optional(),
|
|
1829
1933
|
avatarPersona: SessionAvatarPersonaSchema.optional(),
|
|
1830
|
-
mode:
|
|
1934
|
+
mode: z26.enum(["enqueue", "immediate"]).default("enqueue")
|
|
1831
1935
|
}).strict().superRefine((request, context) => {
|
|
1832
1936
|
if (request.prompt.length === 0 && (request.attachments?.length ?? 0) === 0 && (request.fileAttachments?.length ?? 0) === 0) {
|
|
1833
1937
|
context.addIssue({
|
|
@@ -1853,22 +1957,22 @@ var SessionPromptRequestSchema = z24.object({
|
|
|
1853
1957
|
});
|
|
1854
1958
|
}
|
|
1855
1959
|
});
|
|
1856
|
-
var SessionPromptResultSchema =
|
|
1857
|
-
|
|
1858
|
-
ok:
|
|
1960
|
+
var SessionPromptResultSchema = z26.discriminatedUnion("ok", [
|
|
1961
|
+
z26.object({
|
|
1962
|
+
ok: z26.literal(true),
|
|
1859
1963
|
requestId: IdSchema,
|
|
1860
1964
|
operationId: IdSchema,
|
|
1861
1965
|
machineId: IdSchema,
|
|
1862
1966
|
sessionId: IdSchema,
|
|
1863
1967
|
messageId: IdSchema,
|
|
1864
|
-
mode:
|
|
1865
|
-
deliveryState:
|
|
1968
|
+
mode: z26.enum(["enqueue", "immediate"]),
|
|
1969
|
+
deliveryState: z26.enum(["queued", "processing"]),
|
|
1866
1970
|
// Negotiated lower bound from the native event clock. Exact text and history
|
|
1867
1971
|
// ownership checks still apply; this is not an identity or proof of persistence.
|
|
1868
1972
|
submittedAt: IsoDateSchema.optional()
|
|
1869
1973
|
}),
|
|
1870
|
-
|
|
1871
|
-
ok:
|
|
1974
|
+
z26.object({
|
|
1975
|
+
ok: z26.literal(false),
|
|
1872
1976
|
requestId: IdSchema,
|
|
1873
1977
|
operationId: IdSchema,
|
|
1874
1978
|
machineId: IdSchema,
|
|
@@ -1876,29 +1980,29 @@ var SessionPromptResultSchema = z24.discriminatedUnion("ok", [
|
|
|
1876
1980
|
error: ProtocolFailureSchema
|
|
1877
1981
|
})
|
|
1878
1982
|
]);
|
|
1879
|
-
var SessionActivityUpdateSchema =
|
|
1983
|
+
var SessionActivityUpdateSchema = z26.object({
|
|
1880
1984
|
userId: IdSchema,
|
|
1881
1985
|
machineId: IdSchema,
|
|
1882
1986
|
sessionId: IdSchema,
|
|
1883
|
-
state:
|
|
1987
|
+
state: z26.enum(["working", "idle"]),
|
|
1884
1988
|
occurredAt: IsoDateSchema,
|
|
1885
1989
|
assistantPreview: SessionAssistantPreviewSchema.optional(),
|
|
1886
1990
|
userPreview: SessionUserPreviewSchema.optional()
|
|
1887
1991
|
});
|
|
1888
|
-
var SessionAbortRequestSchema =
|
|
1992
|
+
var SessionAbortRequestSchema = z26.object({
|
|
1889
1993
|
requestId: IdSchema,
|
|
1890
1994
|
machineId: IdSchema,
|
|
1891
1995
|
sessionId: IdSchema
|
|
1892
1996
|
});
|
|
1893
|
-
var SessionAbortResultSchema =
|
|
1894
|
-
|
|
1895
|
-
ok:
|
|
1997
|
+
var SessionAbortResultSchema = z26.discriminatedUnion("ok", [
|
|
1998
|
+
z26.object({
|
|
1999
|
+
ok: z26.literal(true),
|
|
1896
2000
|
requestId: IdSchema,
|
|
1897
2001
|
machineId: IdSchema,
|
|
1898
2002
|
sessionId: IdSchema
|
|
1899
2003
|
}),
|
|
1900
|
-
|
|
1901
|
-
ok:
|
|
2004
|
+
z26.object({
|
|
2005
|
+
ok: z26.literal(false),
|
|
1902
2006
|
requestId: IdSchema,
|
|
1903
2007
|
machineId: IdSchema,
|
|
1904
2008
|
sessionId: IdSchema,
|
|
@@ -1907,12 +2011,12 @@ var SessionAbortResultSchema = z24.discriminatedUnion("ok", [
|
|
|
1907
2011
|
]);
|
|
1908
2012
|
|
|
1909
2013
|
// ../../shared/protocol/dist/sessions/interactions.js
|
|
1910
|
-
import { z as
|
|
1911
|
-
var InteractionFormFieldSchema =
|
|
2014
|
+
import { z as z27 } from "zod";
|
|
2015
|
+
var InteractionFormFieldSchema = z27.object({
|
|
1912
2016
|
id: IdSchema,
|
|
1913
|
-
label:
|
|
1914
|
-
description:
|
|
1915
|
-
inputType:
|
|
2017
|
+
label: z27.string().trim().min(1).max(1024),
|
|
2018
|
+
description: z27.string().max(2048).optional(),
|
|
2019
|
+
inputType: z27.enum([
|
|
1916
2020
|
"text",
|
|
1917
2021
|
"number",
|
|
1918
2022
|
"integer",
|
|
@@ -1920,77 +2024,77 @@ var InteractionFormFieldSchema = z25.object({
|
|
|
1920
2024
|
"select",
|
|
1921
2025
|
"multi-select"
|
|
1922
2026
|
]),
|
|
1923
|
-
required:
|
|
1924
|
-
options:
|
|
1925
|
-
defaultValue:
|
|
1926
|
-
|
|
1927
|
-
|
|
1928
|
-
|
|
1929
|
-
|
|
2027
|
+
required: z27.boolean(),
|
|
2028
|
+
options: z27.array(z27.string().max(1024)).max(100),
|
|
2029
|
+
defaultValue: z27.union([
|
|
2030
|
+
z27.string().max(4096),
|
|
2031
|
+
z27.number().finite(),
|
|
2032
|
+
z27.boolean(),
|
|
2033
|
+
z27.array(z27.string().max(1024)).max(100)
|
|
1930
2034
|
]).optional(),
|
|
1931
|
-
minimum:
|
|
1932
|
-
maximum:
|
|
1933
|
-
minLength:
|
|
1934
|
-
maxLength:
|
|
1935
|
-
minItems:
|
|
1936
|
-
maxItems:
|
|
1937
|
-
format:
|
|
1938
|
-
}).strict();
|
|
1939
|
-
var InteractionPermissionRequestSchema =
|
|
1940
|
-
kind:
|
|
2035
|
+
minimum: z27.number().finite().optional(),
|
|
2036
|
+
maximum: z27.number().finite().optional(),
|
|
2037
|
+
minLength: z27.number().int().nonnegative().max(1e6).optional(),
|
|
2038
|
+
maxLength: z27.number().int().nonnegative().max(1e6).optional(),
|
|
2039
|
+
minItems: z27.number().int().nonnegative().max(100).optional(),
|
|
2040
|
+
maxItems: z27.number().int().nonnegative().max(100).optional(),
|
|
2041
|
+
format: z27.enum(["email", "uri", "date", "date-time"]).optional()
|
|
2042
|
+
}).strict();
|
|
2043
|
+
var InteractionPermissionRequestSchema = z27.object({
|
|
2044
|
+
kind: z27.literal("permission"),
|
|
1941
2045
|
permissionKind: IdSchema,
|
|
1942
|
-
title:
|
|
1943
|
-
description:
|
|
1944
|
-
canApproveSession:
|
|
1945
|
-
canApproveAlways:
|
|
1946
|
-
approvalScope:
|
|
1947
|
-
}).strict();
|
|
1948
|
-
var InteractionUserInputRequestSchema =
|
|
1949
|
-
kind:
|
|
1950
|
-
question:
|
|
1951
|
-
choices:
|
|
1952
|
-
allowFreeform:
|
|
1953
|
-
}).strict();
|
|
1954
|
-
var InteractionElicitationRequestSchema =
|
|
1955
|
-
kind:
|
|
1956
|
-
message:
|
|
1957
|
-
mode:
|
|
1958
|
-
source:
|
|
1959
|
-
url:
|
|
1960
|
-
fields:
|
|
1961
|
-
}).strict();
|
|
1962
|
-
var InteractionMcpOauthRequestSchema =
|
|
1963
|
-
kind:
|
|
1964
|
-
serverName:
|
|
1965
|
-
serverUrl:
|
|
1966
|
-
reason:
|
|
1967
|
-
responseMode:
|
|
1968
|
-
}).strict();
|
|
1969
|
-
var InteractionMcpHeadersRequestSchema =
|
|
1970
|
-
kind:
|
|
1971
|
-
serverName:
|
|
1972
|
-
serverUrl:
|
|
1973
|
-
reason:
|
|
1974
|
-
responseMode:
|
|
1975
|
-
}).strict();
|
|
1976
|
-
var InteractionAutoModeSwitchRequestSchema =
|
|
1977
|
-
kind:
|
|
2046
|
+
title: z27.string().trim().min(1).max(256),
|
|
2047
|
+
description: z27.string().max(4096),
|
|
2048
|
+
canApproveSession: z27.boolean(),
|
|
2049
|
+
canApproveAlways: z27.boolean().optional(),
|
|
2050
|
+
approvalScope: z27.string().trim().min(1).max(4096).optional()
|
|
2051
|
+
}).strict();
|
|
2052
|
+
var InteractionUserInputRequestSchema = z27.object({
|
|
2053
|
+
kind: z27.literal("user_input"),
|
|
2054
|
+
question: z27.string().trim().min(1).max(4096),
|
|
2055
|
+
choices: z27.array(z27.string().max(1024)).max(100),
|
|
2056
|
+
allowFreeform: z27.boolean()
|
|
2057
|
+
}).strict();
|
|
2058
|
+
var InteractionElicitationRequestSchema = z27.object({
|
|
2059
|
+
kind: z27.literal("elicitation"),
|
|
2060
|
+
message: z27.string().trim().min(1).max(4096),
|
|
2061
|
+
mode: z27.enum(["form", "url"]),
|
|
2062
|
+
source: z27.string().trim().min(1).max(256).optional(),
|
|
2063
|
+
url: z27.url().max(32768).optional(),
|
|
2064
|
+
fields: z27.array(InteractionFormFieldSchema).max(100)
|
|
2065
|
+
}).strict();
|
|
2066
|
+
var InteractionMcpOauthRequestSchema = z27.object({
|
|
2067
|
+
kind: z27.literal("mcp_oauth"),
|
|
2068
|
+
serverName: z27.string().trim().min(1).max(256),
|
|
2069
|
+
serverUrl: z27.url().max(32768),
|
|
2070
|
+
reason: z27.enum(["initial", "refresh", "reauth", "upscope"]),
|
|
2071
|
+
responseMode: z27.literal("cancel-only")
|
|
2072
|
+
}).strict();
|
|
2073
|
+
var InteractionMcpHeadersRequestSchema = z27.object({
|
|
2074
|
+
kind: z27.literal("mcp_headers"),
|
|
2075
|
+
serverName: z27.string().trim().min(1).max(256),
|
|
2076
|
+
serverUrl: z27.url().max(32768),
|
|
2077
|
+
reason: z27.string().trim().min(1).max(256),
|
|
2078
|
+
responseMode: z27.literal("none-only")
|
|
2079
|
+
}).strict();
|
|
2080
|
+
var InteractionAutoModeSwitchRequestSchema = z27.object({
|
|
2081
|
+
kind: z27.literal("auto_mode_switch"),
|
|
1978
2082
|
errorCode: IdSchema.optional(),
|
|
1979
|
-
retryAfterSeconds:
|
|
1980
|
-
}).strict();
|
|
1981
|
-
var InteractionSessionLimitsRequestSchema =
|
|
1982
|
-
kind:
|
|
1983
|
-
maxAiCredits:
|
|
1984
|
-
usedAiCredits:
|
|
1985
|
-
}).strict();
|
|
1986
|
-
var InteractionExitPlanRequestSchema =
|
|
1987
|
-
kind:
|
|
1988
|
-
summary:
|
|
1989
|
-
planContent:
|
|
1990
|
-
actions:
|
|
2083
|
+
retryAfterSeconds: z27.number().int().nonnegative().optional()
|
|
2084
|
+
}).strict();
|
|
2085
|
+
var InteractionSessionLimitsRequestSchema = z27.object({
|
|
2086
|
+
kind: z27.literal("session_limits"),
|
|
2087
|
+
maxAiCredits: z27.number().finite().nonnegative(),
|
|
2088
|
+
usedAiCredits: z27.number().finite().nonnegative()
|
|
2089
|
+
}).strict();
|
|
2090
|
+
var InteractionExitPlanRequestSchema = z27.object({
|
|
2091
|
+
kind: z27.literal("exit_plan"),
|
|
2092
|
+
summary: z27.string().max(4096),
|
|
2093
|
+
planContent: z27.string().max(1e5).optional(),
|
|
2094
|
+
actions: z27.array(IdSchema).min(1).max(20),
|
|
1991
2095
|
recommendedAction: IdSchema
|
|
1992
2096
|
}).strict();
|
|
1993
|
-
var InteractionRequestSchema =
|
|
2097
|
+
var InteractionRequestSchema = z27.discriminatedUnion("kind", [
|
|
1994
2098
|
InteractionPermissionRequestSchema,
|
|
1995
2099
|
InteractionUserInputRequestSchema,
|
|
1996
2100
|
InteractionElicitationRequestSchema,
|
|
@@ -2000,81 +2104,81 @@ var InteractionRequestSchema = z25.discriminatedUnion("kind", [
|
|
|
2000
2104
|
InteractionSessionLimitsRequestSchema,
|
|
2001
2105
|
InteractionExitPlanRequestSchema
|
|
2002
2106
|
]);
|
|
2003
|
-
var InteractionPermissionResponseSchema =
|
|
2004
|
-
kind:
|
|
2005
|
-
decision:
|
|
2006
|
-
feedback:
|
|
2007
|
-
}).strict();
|
|
2008
|
-
var InteractionUserInputResponseSchema =
|
|
2009
|
-
kind:
|
|
2010
|
-
answer:
|
|
2011
|
-
wasFreeform:
|
|
2012
|
-
}).strict();
|
|
2013
|
-
var InteractionFieldValueSchema =
|
|
2014
|
-
|
|
2015
|
-
|
|
2016
|
-
|
|
2017
|
-
|
|
2018
|
-
]);
|
|
2019
|
-
var InteractionElicitationResponseSchema =
|
|
2020
|
-
kind:
|
|
2021
|
-
action:
|
|
2022
|
-
values:
|
|
2023
|
-
}).strict();
|
|
2024
|
-
var InteractionMcpOauthResponseSchema =
|
|
2025
|
-
kind:
|
|
2026
|
-
action:
|
|
2027
|
-
}).strict();
|
|
2028
|
-
var InteractionMcpHeadersResponseSchema =
|
|
2029
|
-
kind:
|
|
2030
|
-
action:
|
|
2031
|
-
}).strict();
|
|
2032
|
-
var InteractionAutoModeSwitchResponseSchema =
|
|
2033
|
-
kind:
|
|
2034
|
-
action:
|
|
2035
|
-
}).strict();
|
|
2036
|
-
var InteractionSessionLimitsResponseSchema =
|
|
2037
|
-
kind:
|
|
2038
|
-
action:
|
|
2039
|
-
additionalAiCredits:
|
|
2040
|
-
maxAiCredits:
|
|
2107
|
+
var InteractionPermissionResponseSchema = z27.object({
|
|
2108
|
+
kind: z27.literal("permission"),
|
|
2109
|
+
decision: z27.enum(["approve-once", "approve-for-session", "approve-always", "reject"]),
|
|
2110
|
+
feedback: z27.string().trim().min(1).max(2048).optional()
|
|
2111
|
+
}).strict();
|
|
2112
|
+
var InteractionUserInputResponseSchema = z27.object({
|
|
2113
|
+
kind: z27.literal("user_input"),
|
|
2114
|
+
answer: z27.string().max(1e5),
|
|
2115
|
+
wasFreeform: z27.boolean()
|
|
2116
|
+
}).strict();
|
|
2117
|
+
var InteractionFieldValueSchema = z27.union([
|
|
2118
|
+
z27.string().max(4096),
|
|
2119
|
+
z27.number(),
|
|
2120
|
+
z27.boolean(),
|
|
2121
|
+
z27.array(z27.string().max(1024)).max(100)
|
|
2122
|
+
]);
|
|
2123
|
+
var InteractionElicitationResponseSchema = z27.object({
|
|
2124
|
+
kind: z27.literal("elicitation"),
|
|
2125
|
+
action: z27.enum(["accept", "decline", "cancel"]),
|
|
2126
|
+
values: z27.record(z27.string().max(256), InteractionFieldValueSchema)
|
|
2127
|
+
}).strict();
|
|
2128
|
+
var InteractionMcpOauthResponseSchema = z27.object({
|
|
2129
|
+
kind: z27.literal("mcp_oauth"),
|
|
2130
|
+
action: z27.literal("cancel")
|
|
2131
|
+
}).strict();
|
|
2132
|
+
var InteractionMcpHeadersResponseSchema = z27.object({
|
|
2133
|
+
kind: z27.literal("mcp_headers"),
|
|
2134
|
+
action: z27.literal("none")
|
|
2135
|
+
}).strict();
|
|
2136
|
+
var InteractionAutoModeSwitchResponseSchema = z27.object({
|
|
2137
|
+
kind: z27.literal("auto_mode_switch"),
|
|
2138
|
+
action: z27.enum(["yes", "yes_always", "no"])
|
|
2139
|
+
}).strict();
|
|
2140
|
+
var InteractionSessionLimitsResponseSchema = z27.object({
|
|
2141
|
+
kind: z27.literal("session_limits"),
|
|
2142
|
+
action: z27.enum(["add", "set", "unset", "cancel"]),
|
|
2143
|
+
additionalAiCredits: z27.number().positive().optional(),
|
|
2144
|
+
maxAiCredits: z27.number().positive().optional()
|
|
2041
2145
|
}).strict().superRefine((response, context) => {
|
|
2042
2146
|
if (response.action === "add" && response.additionalAiCredits === void 0) {
|
|
2043
2147
|
context.addIssue({
|
|
2044
|
-
code:
|
|
2148
|
+
code: z27.ZodIssueCode.custom,
|
|
2045
2149
|
path: ["additionalAiCredits"],
|
|
2046
2150
|
message: "additionalAiCredits is required for add"
|
|
2047
2151
|
});
|
|
2048
2152
|
}
|
|
2049
2153
|
if (response.action === "set" && response.maxAiCredits === void 0) {
|
|
2050
2154
|
context.addIssue({
|
|
2051
|
-
code:
|
|
2155
|
+
code: z27.ZodIssueCode.custom,
|
|
2052
2156
|
path: ["maxAiCredits"],
|
|
2053
2157
|
message: "maxAiCredits is required for set"
|
|
2054
2158
|
});
|
|
2055
2159
|
}
|
|
2056
2160
|
if (response.action !== "add" && response.additionalAiCredits !== void 0) {
|
|
2057
2161
|
context.addIssue({
|
|
2058
|
-
code:
|
|
2162
|
+
code: z27.ZodIssueCode.custom,
|
|
2059
2163
|
path: ["additionalAiCredits"],
|
|
2060
2164
|
message: "additionalAiCredits is only valid for add"
|
|
2061
2165
|
});
|
|
2062
2166
|
}
|
|
2063
2167
|
if (response.action !== "set" && response.maxAiCredits !== void 0) {
|
|
2064
2168
|
context.addIssue({
|
|
2065
|
-
code:
|
|
2169
|
+
code: z27.ZodIssueCode.custom,
|
|
2066
2170
|
path: ["maxAiCredits"],
|
|
2067
2171
|
message: "maxAiCredits is only valid for set"
|
|
2068
2172
|
});
|
|
2069
2173
|
}
|
|
2070
2174
|
});
|
|
2071
|
-
var InteractionExitPlanResponseSchema =
|
|
2072
|
-
kind:
|
|
2073
|
-
approved:
|
|
2175
|
+
var InteractionExitPlanResponseSchema = z27.object({
|
|
2176
|
+
kind: z27.literal("exit_plan"),
|
|
2177
|
+
approved: z27.boolean(),
|
|
2074
2178
|
selectedAction: IdSchema.optional(),
|
|
2075
|
-
feedback:
|
|
2179
|
+
feedback: z27.string().trim().min(1).max(4096).optional()
|
|
2076
2180
|
}).strict();
|
|
2077
|
-
var InteractionResponseSchema =
|
|
2181
|
+
var InteractionResponseSchema = z27.discriminatedUnion("kind", [
|
|
2078
2182
|
InteractionPermissionResponseSchema,
|
|
2079
2183
|
InteractionUserInputResponseSchema,
|
|
2080
2184
|
InteractionElicitationResponseSchema,
|
|
@@ -2084,30 +2188,30 @@ var InteractionResponseSchema = z25.discriminatedUnion("kind", [
|
|
|
2084
2188
|
InteractionSessionLimitsResponseSchema,
|
|
2085
2189
|
InteractionExitPlanResponseSchema
|
|
2086
2190
|
]);
|
|
2087
|
-
var InteractionRequestPayloadSchema =
|
|
2191
|
+
var InteractionRequestPayloadSchema = z27.object({
|
|
2088
2192
|
interactionRequestId: IdSchema,
|
|
2089
2193
|
userId: IdSchema,
|
|
2090
2194
|
machineId: IdSchema,
|
|
2091
2195
|
sessionId: IdSchema,
|
|
2092
2196
|
request: InteractionRequestSchema
|
|
2093
2197
|
}).strict();
|
|
2094
|
-
var InteractionRespondRequestSchema =
|
|
2198
|
+
var InteractionRespondRequestSchema = z27.object({
|
|
2095
2199
|
requestId: IdSchema,
|
|
2096
2200
|
interactionRequestId: IdSchema,
|
|
2097
2201
|
machineId: IdSchema,
|
|
2098
2202
|
sessionId: IdSchema,
|
|
2099
2203
|
response: InteractionResponseSchema
|
|
2100
2204
|
}).strict();
|
|
2101
|
-
var InteractionRespondResultSchema =
|
|
2102
|
-
|
|
2103
|
-
ok:
|
|
2205
|
+
var InteractionRespondResultSchema = z27.discriminatedUnion("ok", [
|
|
2206
|
+
z27.object({
|
|
2207
|
+
ok: z27.literal(true),
|
|
2104
2208
|
requestId: IdSchema,
|
|
2105
2209
|
interactionRequestId: IdSchema,
|
|
2106
2210
|
machineId: IdSchema,
|
|
2107
2211
|
sessionId: IdSchema
|
|
2108
2212
|
}).strict(),
|
|
2109
|
-
|
|
2110
|
-
ok:
|
|
2213
|
+
z27.object({
|
|
2214
|
+
ok: z27.literal(false),
|
|
2111
2215
|
requestId: IdSchema,
|
|
2112
2216
|
interactionRequestId: IdSchema,
|
|
2113
2217
|
machineId: IdSchema,
|
|
@@ -2115,31 +2219,31 @@ var InteractionRespondResultSchema = z25.discriminatedUnion("ok", [
|
|
|
2115
2219
|
error: ProtocolFailureSchema
|
|
2116
2220
|
}).strict()
|
|
2117
2221
|
]);
|
|
2118
|
-
var PermissionRequestPayloadSchema =
|
|
2222
|
+
var PermissionRequestPayloadSchema = z27.object({
|
|
2119
2223
|
permissionRequestId: IdSchema,
|
|
2120
2224
|
userId: IdSchema,
|
|
2121
2225
|
machineId: IdSchema,
|
|
2122
2226
|
sessionId: IdSchema,
|
|
2123
|
-
request:
|
|
2227
|
+
request: z27.record(z27.string(), z27.unknown())
|
|
2124
2228
|
});
|
|
2125
|
-
var PermissionRespondRequestSchema =
|
|
2229
|
+
var PermissionRespondRequestSchema = z27.object({
|
|
2126
2230
|
requestId: IdSchema,
|
|
2127
2231
|
permissionRequestId: IdSchema,
|
|
2128
2232
|
machineId: IdSchema,
|
|
2129
2233
|
sessionId: IdSchema,
|
|
2130
|
-
decision:
|
|
2131
|
-
feedback:
|
|
2234
|
+
decision: z27.enum(["approve-once", "reject"]),
|
|
2235
|
+
feedback: z27.string().trim().min(1).max(2048).optional()
|
|
2132
2236
|
});
|
|
2133
|
-
var PermissionRespondResultSchema =
|
|
2134
|
-
|
|
2135
|
-
ok:
|
|
2237
|
+
var PermissionRespondResultSchema = z27.discriminatedUnion("ok", [
|
|
2238
|
+
z27.object({
|
|
2239
|
+
ok: z27.literal(true),
|
|
2136
2240
|
requestId: IdSchema,
|
|
2137
2241
|
permissionRequestId: IdSchema,
|
|
2138
2242
|
machineId: IdSchema,
|
|
2139
2243
|
sessionId: IdSchema
|
|
2140
2244
|
}),
|
|
2141
|
-
|
|
2142
|
-
ok:
|
|
2245
|
+
z27.object({
|
|
2246
|
+
ok: z27.literal(false),
|
|
2143
2247
|
requestId: IdSchema,
|
|
2144
2248
|
permissionRequestId: IdSchema,
|
|
2145
2249
|
machineId: IdSchema,
|
|
@@ -2149,42 +2253,42 @@ var PermissionRespondResultSchema = z25.discriminatedUnion("ok", [
|
|
|
2149
2253
|
]);
|
|
2150
2254
|
|
|
2151
2255
|
// ../../shared/protocol/dist/conversation/timeline-sync.js
|
|
2152
|
-
import { z as
|
|
2256
|
+
import { z as z28 } from "zod";
|
|
2153
2257
|
var TIMELINE_SYNC_MAX_EVENTS = 128;
|
|
2154
2258
|
var TIMELINE_SYNC_MAX_BYTES = 6 * 1024 * 1024;
|
|
2155
2259
|
var TIMELINE_IMAGE_CHUNK_BYTES = 48 * 1024;
|
|
2156
2260
|
var TIMELINE_IMAGE_MAX_BYTES = 3 * 1024 * 1024;
|
|
2157
|
-
var identity =
|
|
2158
|
-
var sequence =
|
|
2159
|
-
var hash =
|
|
2160
|
-
var TimelineWatermarkSchema =
|
|
2261
|
+
var identity = z28.string().min(1).max(256);
|
|
2262
|
+
var sequence = z28.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
|
|
2263
|
+
var hash = z28.string().regex(/^[a-f0-9]{64}$/u);
|
|
2264
|
+
var TimelineWatermarkSchema = z28.object({
|
|
2161
2265
|
epoch: identity,
|
|
2162
2266
|
sequence
|
|
2163
2267
|
}).strict();
|
|
2164
|
-
var TimelineSyncRequestSchema =
|
|
2268
|
+
var TimelineSyncRequestSchema = z28.object({
|
|
2165
2269
|
watermark: TimelineWatermarkSchema.optional(),
|
|
2166
|
-
waitMs:
|
|
2167
|
-
resume:
|
|
2270
|
+
waitMs: z28.number().int().min(0).max(2e4).optional(),
|
|
2271
|
+
resume: z28.boolean().optional()
|
|
2168
2272
|
}).strict();
|
|
2169
|
-
var TimelineTextAppendSchema =
|
|
2273
|
+
var TimelineTextAppendSchema = z28.object({
|
|
2170
2274
|
itemId: identity,
|
|
2171
|
-
baseRevision:
|
|
2172
|
-
revision:
|
|
2173
|
-
appendText:
|
|
2174
|
-
sourceEventIds:
|
|
2175
|
-
sourceMessageIds:
|
|
2176
|
-
sourceInteractionIds:
|
|
2177
|
-
}).strict();
|
|
2178
|
-
var TimelineSyncEventSchema =
|
|
2179
|
-
|
|
2180
|
-
|
|
2181
|
-
|
|
2182
|
-
kind:
|
|
2275
|
+
baseRevision: z28.number().int().positive(),
|
|
2276
|
+
revision: z28.number().int().positive(),
|
|
2277
|
+
appendText: z28.string().min(1).max(5e5),
|
|
2278
|
+
sourceEventIds: z28.array(identity).min(1).max(1e3).optional(),
|
|
2279
|
+
sourceMessageIds: z28.array(identity).min(1).max(1e3).optional(),
|
|
2280
|
+
sourceInteractionIds: z28.array(identity).min(1).max(1e3).optional()
|
|
2281
|
+
}).strict();
|
|
2282
|
+
var TimelineSyncEventSchema = z28.discriminatedUnion("kind", [
|
|
2283
|
+
z28.object({ kind: z28.literal("upsert"), sequence, item: ConversationItemSchema }).strict(),
|
|
2284
|
+
z28.object({ kind: z28.literal("append"), sequence, append: TimelineTextAppendSchema }).strict(),
|
|
2285
|
+
z28.object({
|
|
2286
|
+
kind: z28.literal("step"),
|
|
2183
2287
|
sequence,
|
|
2184
2288
|
upsert: ConversationActivityStepUpsertSchema
|
|
2185
2289
|
}).strict()
|
|
2186
2290
|
]);
|
|
2187
|
-
var TimelineResyncReasonSchema =
|
|
2291
|
+
var TimelineResyncReasonSchema = z28.enum([
|
|
2188
2292
|
"initial",
|
|
2189
2293
|
"epoch-changed",
|
|
2190
2294
|
"evicted",
|
|
@@ -2193,36 +2297,36 @@ var TimelineResyncReasonSchema = z26.enum([
|
|
|
2193
2297
|
"rewind",
|
|
2194
2298
|
"oversized"
|
|
2195
2299
|
]);
|
|
2196
|
-
var TimelineSyncResponseSchema =
|
|
2197
|
-
|
|
2198
|
-
status:
|
|
2300
|
+
var TimelineSyncResponseSchema = z28.discriminatedUnion("status", [
|
|
2301
|
+
z28.object({
|
|
2302
|
+
status: z28.literal("snapshot"),
|
|
2199
2303
|
watermark: TimelineWatermarkSchema,
|
|
2200
2304
|
page: SessionTimelinePageSchema
|
|
2201
2305
|
}).strict(),
|
|
2202
|
-
|
|
2203
|
-
status:
|
|
2306
|
+
z28.object({
|
|
2307
|
+
status: z28.literal("replay"),
|
|
2204
2308
|
watermark: TimelineWatermarkSchema,
|
|
2205
2309
|
afterSequence: sequence,
|
|
2206
|
-
events:
|
|
2207
|
-
hasMore:
|
|
2310
|
+
events: z28.array(TimelineSyncEventSchema).max(TIMELINE_SYNC_MAX_EVENTS),
|
|
2311
|
+
hasMore: z28.boolean()
|
|
2208
2312
|
}).strict(),
|
|
2209
|
-
|
|
2210
|
-
status:
|
|
2313
|
+
z28.object({
|
|
2314
|
+
status: z28.literal("resync"),
|
|
2211
2315
|
epoch: identity,
|
|
2212
2316
|
reason: TimelineResyncReasonSchema
|
|
2213
2317
|
}).strict()
|
|
2214
2318
|
]);
|
|
2215
|
-
var TimelineImageRequestSchema =
|
|
2319
|
+
var TimelineImageRequestSchema = z28.object({
|
|
2216
2320
|
sha256: hash,
|
|
2217
|
-
offset:
|
|
2321
|
+
offset: z28.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1)
|
|
2218
2322
|
}).strict();
|
|
2219
|
-
var TimelineImageChunkSchema =
|
|
2323
|
+
var TimelineImageChunkSchema = z28.object({
|
|
2220
2324
|
sha256: hash,
|
|
2221
|
-
offset:
|
|
2222
|
-
totalBytes:
|
|
2223
|
-
mimeType:
|
|
2224
|
-
data:
|
|
2225
|
-
eof:
|
|
2325
|
+
offset: z28.number().int().min(0).max(TIMELINE_IMAGE_MAX_BYTES - 1),
|
|
2326
|
+
totalBytes: z28.number().int().positive().max(TIMELINE_IMAGE_MAX_BYTES),
|
|
2327
|
+
mimeType: z28.enum(["image/gif", "image/jpeg", "image/png", "image/webp"]),
|
|
2328
|
+
data: z28.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),
|
|
2329
|
+
eof: z28.boolean()
|
|
2226
2330
|
}).strict().superRefine((chunk, context) => {
|
|
2227
2331
|
const padding = chunk.data.endsWith("==") ? 2 : chunk.data.endsWith("=") ? 1 : 0;
|
|
2228
2332
|
const length = chunk.data.length / 4 * 3 - padding;
|
|
@@ -2233,10 +2337,10 @@ var TimelineImageChunkSchema = z26.object({
|
|
|
2233
2337
|
});
|
|
2234
2338
|
|
|
2235
2339
|
// ../../shared/protocol/dist/workbench.js
|
|
2236
|
-
import { z as
|
|
2340
|
+
import { z as z30 } from "zod";
|
|
2237
2341
|
|
|
2238
2342
|
// ../../shared/protocol/dist/schedules.js
|
|
2239
|
-
import { z as
|
|
2343
|
+
import { z as z29 } from "zod";
|
|
2240
2344
|
var SCHEDULE_OPERATIONS = [
|
|
2241
2345
|
"schedule.snapshot",
|
|
2242
2346
|
"schedule.create",
|
|
@@ -2244,90 +2348,90 @@ var SCHEDULE_OPERATIONS = [
|
|
|
2244
2348
|
"schedule.draft.dismiss",
|
|
2245
2349
|
"schedule.resume"
|
|
2246
2350
|
];
|
|
2247
|
-
var Id =
|
|
2248
|
-
var NativeId =
|
|
2249
|
-
var Time =
|
|
2250
|
-
var WorkbenchScheduleRuleSchema =
|
|
2251
|
-
|
|
2252
|
-
|
|
2253
|
-
kind:
|
|
2254
|
-
seconds:
|
|
2255
|
-
recurring:
|
|
2351
|
+
var Id = z29.string().min(1).max(256);
|
|
2352
|
+
var NativeId = z29.number().int().positive().max(Number.MAX_SAFE_INTEGER);
|
|
2353
|
+
var Time = z29.iso.datetime({ offset: true });
|
|
2354
|
+
var WorkbenchScheduleRuleSchema = z29.discriminatedUnion("kind", [
|
|
2355
|
+
z29.object({ kind: z29.literal("once"), at: Time }).strict(),
|
|
2356
|
+
z29.object({
|
|
2357
|
+
kind: z29.literal("interval"),
|
|
2358
|
+
seconds: z29.number().int().min(10).max(86400),
|
|
2359
|
+
recurring: z29.boolean().optional()
|
|
2256
2360
|
}).strict(),
|
|
2257
|
-
|
|
2258
|
-
kind:
|
|
2259
|
-
expression:
|
|
2260
|
-
timezone:
|
|
2361
|
+
z29.object({
|
|
2362
|
+
kind: z29.literal("cron"),
|
|
2363
|
+
expression: z29.string().trim().min(9).max(256).regex(/^\S+(?: +\S+){4}$/),
|
|
2364
|
+
timezone: z29.string().min(1).max(128).regex(/^[A-Za-z0-9_+./-]+$/)
|
|
2261
2365
|
}).strict()
|
|
2262
2366
|
]);
|
|
2263
2367
|
var Content = {
|
|
2264
2368
|
rule: WorkbenchScheduleRuleSchema,
|
|
2265
|
-
prompt:
|
|
2266
|
-
skill:
|
|
2369
|
+
prompt: z29.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."),
|
|
2370
|
+
skill: z29.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.")
|
|
2267
2371
|
};
|
|
2268
|
-
var WorkbenchScheduleProposalSchema =
|
|
2269
|
-
var WorkbenchScheduleDraftSchema =
|
|
2270
|
-
id:
|
|
2372
|
+
var WorkbenchScheduleProposalSchema = z29.object(Content).strict().refine((value) => value.prompt.trim().length > 0 || value.skill !== void 0, { message: "A prompt or skill is required" });
|
|
2373
|
+
var WorkbenchScheduleDraftSchema = z29.object({
|
|
2374
|
+
id: z29.uuid(),
|
|
2271
2375
|
createdAt: Time,
|
|
2272
2376
|
...Content
|
|
2273
2377
|
}).strict();
|
|
2274
|
-
var WorkbenchScheduleEntrySchema =
|
|
2378
|
+
var WorkbenchScheduleEntrySchema = z29.object({
|
|
2275
2379
|
id: NativeId,
|
|
2276
|
-
prompt:
|
|
2277
|
-
displayPrompt:
|
|
2278
|
-
recurring:
|
|
2380
|
+
prompt: z29.string().max(1e5),
|
|
2381
|
+
displayPrompt: z29.string().max(1e5).optional(),
|
|
2382
|
+
recurring: z29.boolean(),
|
|
2279
2383
|
nextRunAt: Time,
|
|
2280
|
-
intervalMs:
|
|
2281
|
-
cron:
|
|
2282
|
-
timezone:
|
|
2384
|
+
intervalMs: z29.number().int().positive().optional(),
|
|
2385
|
+
cron: z29.string().max(256).optional(),
|
|
2386
|
+
timezone: z29.string().max(128).optional(),
|
|
2283
2387
|
at: Time.optional()
|
|
2284
2388
|
}).strict();
|
|
2285
|
-
var WorkbenchScheduleResultSchema =
|
|
2389
|
+
var WorkbenchScheduleResultSchema = z29.object({
|
|
2286
2390
|
id: Id,
|
|
2287
2391
|
scheduleId: NativeId,
|
|
2288
2392
|
triggerEventId: Id,
|
|
2289
2393
|
time: Time,
|
|
2290
|
-
prompt:
|
|
2291
|
-
status:
|
|
2292
|
-
reply:
|
|
2394
|
+
prompt: z29.string().max(16e3),
|
|
2395
|
+
status: z29.enum(["reply", "error", "merged", "pending", "unknown"]),
|
|
2396
|
+
reply: z29.string().max(16e3).optional(),
|
|
2293
2397
|
replyEventId: Id.optional(),
|
|
2294
|
-
error:
|
|
2295
|
-
}).strict();
|
|
2296
|
-
var WorkbenchScheduleSnapshotSchema =
|
|
2297
|
-
state:
|
|
2298
|
-
workingDirectory:
|
|
2299
|
-
timezone:
|
|
2300
|
-
entries:
|
|
2301
|
-
drafts:
|
|
2302
|
-
results:
|
|
2303
|
-
historyTruncated:
|
|
2398
|
+
error: z29.string().max(1024).optional()
|
|
2399
|
+
}).strict();
|
|
2400
|
+
var WorkbenchScheduleSnapshotSchema = z29.object({
|
|
2401
|
+
state: z29.enum(["active", "needs-resume"]),
|
|
2402
|
+
workingDirectory: z29.string().max(32768).optional(),
|
|
2403
|
+
timezone: z29.string().max(128).optional(),
|
|
2404
|
+
entries: z29.array(WorkbenchScheduleEntrySchema).max(256),
|
|
2405
|
+
drafts: z29.array(WorkbenchScheduleDraftSchema).max(100),
|
|
2406
|
+
results: z29.array(WorkbenchScheduleResultSchema).max(100),
|
|
2407
|
+
historyTruncated: z29.boolean(),
|
|
2304
2408
|
sampledAt: Time
|
|
2305
2409
|
}).strict();
|
|
2306
2410
|
var Submission = {
|
|
2307
|
-
operationId:
|
|
2308
|
-
operationCreatedAt:
|
|
2411
|
+
operationId: z29.uuid(),
|
|
2412
|
+
operationCreatedAt: z29.iso.datetime(),
|
|
2309
2413
|
expectedAgentRunId: Id
|
|
2310
2414
|
};
|
|
2311
|
-
var WorkbenchScheduleCreateRequestSchema =
|
|
2415
|
+
var WorkbenchScheduleCreateRequestSchema = z29.object({
|
|
2312
2416
|
...Submission,
|
|
2313
2417
|
...Content,
|
|
2314
|
-
draftId:
|
|
2418
|
+
draftId: z29.uuid().optional()
|
|
2315
2419
|
}).strict().refine((value) => value.prompt.trim().length > 0 || value.skill !== void 0, { message: "A prompt or skill is required" });
|
|
2316
|
-
var WorkbenchScheduleCreateResultSchema =
|
|
2420
|
+
var WorkbenchScheduleCreateResultSchema = z29.object({
|
|
2317
2421
|
snapshot: WorkbenchScheduleSnapshotSchema,
|
|
2318
|
-
verified:
|
|
2422
|
+
verified: z29.boolean()
|
|
2319
2423
|
}).strict();
|
|
2320
|
-
var WorkbenchScheduleDeleteRequestSchema =
|
|
2424
|
+
var WorkbenchScheduleDeleteRequestSchema = z29.object({
|
|
2321
2425
|
...Submission,
|
|
2322
2426
|
id: NativeId
|
|
2323
2427
|
}).strict();
|
|
2324
|
-
var WorkbenchScheduleDeleteResultSchema =
|
|
2428
|
+
var WorkbenchScheduleDeleteResultSchema = z29.object({
|
|
2325
2429
|
snapshot: WorkbenchScheduleSnapshotSchema,
|
|
2326
|
-
removed:
|
|
2430
|
+
removed: z29.boolean()
|
|
2327
2431
|
}).strict();
|
|
2328
|
-
var WorkbenchScheduleDraftDismissRequestSchema =
|
|
2432
|
+
var WorkbenchScheduleDraftDismissRequestSchema = z29.object({
|
|
2329
2433
|
...Submission,
|
|
2330
|
-
draftId:
|
|
2434
|
+
draftId: z29.uuid()
|
|
2331
2435
|
}).strict();
|
|
2332
2436
|
var ScheduleAndroidSchemas = {
|
|
2333
2437
|
WorkbenchScheduleRule: WorkbenchScheduleRuleSchema,
|
|
@@ -2344,10 +2448,10 @@ var ScheduleAndroidSchemas = {
|
|
|
2344
2448
|
};
|
|
2345
2449
|
|
|
2346
2450
|
// ../../shared/protocol/dist/workbench.js
|
|
2347
|
-
var Id2 =
|
|
2348
|
-
var Text =
|
|
2349
|
-
var Count =
|
|
2350
|
-
var Failure =
|
|
2451
|
+
var Id2 = z30.string().trim().min(1).max(256);
|
|
2452
|
+
var Text = z30.string().max(1e5);
|
|
2453
|
+
var Count = z30.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
|
|
2454
|
+
var Failure = z30.object({ code: Id2, message: z30.string().min(1).max(1024) }).strict();
|
|
2351
2455
|
var WORKBENCH_OPERATIONS = [
|
|
2352
2456
|
"operation.get",
|
|
2353
2457
|
"question.ask",
|
|
@@ -2366,104 +2470,104 @@ var WORKBENCH_OPERATIONS = [
|
|
|
2366
2470
|
...SCHEDULE_OPERATIONS
|
|
2367
2471
|
];
|
|
2368
2472
|
var Submission2 = {
|
|
2369
|
-
operationId:
|
|
2370
|
-
operationCreatedAt:
|
|
2473
|
+
operationId: z30.uuid(),
|
|
2474
|
+
operationCreatedAt: z30.iso.datetime(),
|
|
2371
2475
|
expectedAgentRunId: Id2
|
|
2372
2476
|
};
|
|
2373
|
-
var WorkbenchOperationGetSchema =
|
|
2374
|
-
var WorkbenchOperationStatusSchema =
|
|
2375
|
-
operationId:
|
|
2376
|
-
operation:
|
|
2477
|
+
var WorkbenchOperationGetSchema = z30.object({ operationId: z30.uuid() }).strict();
|
|
2478
|
+
var WorkbenchOperationStatusSchema = z30.object({
|
|
2479
|
+
operationId: z30.uuid(),
|
|
2480
|
+
operation: z30.enum(WORKBENCH_OPERATIONS),
|
|
2377
2481
|
agentRunId: Id2,
|
|
2378
|
-
state:
|
|
2379
|
-
result:
|
|
2482
|
+
state: z30.enum(["running", "succeeded", "failed", "uncertain", "result-expired"]),
|
|
2483
|
+
result: z30.record(z30.string(), z30.json()).optional(),
|
|
2380
2484
|
error: Failure.optional()
|
|
2381
2485
|
}).strict().superRefine((value, context) => {
|
|
2382
2486
|
if (value.state === "succeeded" !== (value.result !== void 0) || (value.state === "failed" || value.state === "uncertain") !== (value.error !== void 0)) {
|
|
2383
2487
|
context.addIssue({ code: "custom", message: "Invalid operation state payload" });
|
|
2384
2488
|
}
|
|
2385
2489
|
});
|
|
2386
|
-
var WorkbenchAskRequestSchema =
|
|
2490
|
+
var WorkbenchAskRequestSchema = z30.object({
|
|
2387
2491
|
...Submission2,
|
|
2388
|
-
question:
|
|
2492
|
+
question: z30.string().trim().min(1).max(16e3)
|
|
2389
2493
|
}).strict();
|
|
2390
|
-
var WorkbenchAskResultSchema =
|
|
2391
|
-
var WorkbenchEmptyRequestSchema =
|
|
2392
|
-
var WorkbenchSubmitRequestSchema =
|
|
2393
|
-
var WorkbenchResearchCreateRequestSchema =
|
|
2494
|
+
var WorkbenchAskResultSchema = z30.object({ answer: Text }).strict();
|
|
2495
|
+
var WorkbenchEmptyRequestSchema = z30.object({}).strict();
|
|
2496
|
+
var WorkbenchSubmitRequestSchema = z30.object(Submission2).strict();
|
|
2497
|
+
var WorkbenchResearchCreateRequestSchema = z30.object({
|
|
2394
2498
|
...Submission2,
|
|
2395
|
-
title:
|
|
2396
|
-
question:
|
|
2499
|
+
title: z30.string().trim().min(1).max(120),
|
|
2500
|
+
question: z30.string().trim().min(1).max(16e3),
|
|
2397
2501
|
sourceItemId: Id2.optional(),
|
|
2398
|
-
deferInitialPrompt:
|
|
2502
|
+
deferInitialPrompt: z30.literal(true).optional()
|
|
2399
2503
|
}).strict();
|
|
2400
|
-
var WorkbenchResearchThreadSchema =
|
|
2504
|
+
var WorkbenchResearchThreadSchema = z30.object({
|
|
2401
2505
|
sessionId: Id2,
|
|
2402
2506
|
parentSessionId: Id2,
|
|
2403
|
-
title:
|
|
2404
|
-
createdAt:
|
|
2507
|
+
title: z30.string().min(1).max(120),
|
|
2508
|
+
createdAt: z30.iso.datetime(),
|
|
2405
2509
|
contextAnchor: Id2.optional(),
|
|
2406
|
-
contextTruncated:
|
|
2407
|
-
detached:
|
|
2408
|
-
state:
|
|
2510
|
+
contextTruncated: z30.boolean(),
|
|
2511
|
+
detached: z30.boolean(),
|
|
2512
|
+
state: z30.enum(["creating", "ready", "failed"])
|
|
2409
2513
|
}).strict();
|
|
2410
|
-
var WorkbenchResearchCreateResultSchema =
|
|
2514
|
+
var WorkbenchResearchCreateResultSchema = z30.object({
|
|
2411
2515
|
thread: WorkbenchResearchThreadSchema
|
|
2412
2516
|
}).strict();
|
|
2413
|
-
var WorkbenchResearchListResultSchema =
|
|
2414
|
-
threads:
|
|
2517
|
+
var WorkbenchResearchListResultSchema = z30.object({
|
|
2518
|
+
threads: z30.array(WorkbenchResearchThreadSchema).max(100)
|
|
2415
2519
|
}).strict();
|
|
2416
|
-
var WorkbenchResearchTimelineRequestSchema =
|
|
2520
|
+
var WorkbenchResearchTimelineRequestSchema = z30.object({
|
|
2417
2521
|
cursor: Id2.optional()
|
|
2418
2522
|
}).strict();
|
|
2419
|
-
var WorkbenchResearchSendRequestSchema =
|
|
2523
|
+
var WorkbenchResearchSendRequestSchema = z30.object({
|
|
2420
2524
|
...Submission2,
|
|
2421
|
-
prompt:
|
|
2422
|
-
}).strict();
|
|
2423
|
-
var WorkbenchResearchSendResultSchema =
|
|
2424
|
-
var WorkbenchCompletedResultSchema =
|
|
2425
|
-
var WorkbenchCommandSchema =
|
|
2426
|
-
name:
|
|
2427
|
-
description:
|
|
2428
|
-
argumentHint:
|
|
2429
|
-
kind:
|
|
2430
|
-
allowDuringExecution:
|
|
2431
|
-
supported:
|
|
2432
|
-
reason:
|
|
2433
|
-
}).strict();
|
|
2434
|
-
var WorkbenchCommandListResultSchema =
|
|
2435
|
-
commands:
|
|
2436
|
-
}).strict();
|
|
2437
|
-
var WorkbenchCommandInvokeRequestSchema =
|
|
2525
|
+
prompt: z30.string().trim().min(1).max(16e3)
|
|
2526
|
+
}).strict();
|
|
2527
|
+
var WorkbenchResearchSendResultSchema = z30.object({ messageId: Id2 }).strict();
|
|
2528
|
+
var WorkbenchCompletedResultSchema = z30.object({ completed: z30.boolean() }).strict();
|
|
2529
|
+
var WorkbenchCommandSchema = z30.object({
|
|
2530
|
+
name: z30.string().min(1).max(260),
|
|
2531
|
+
description: z30.string().max(4096),
|
|
2532
|
+
argumentHint: z30.string().max(1024).optional(),
|
|
2533
|
+
kind: z30.enum(["builtin", "skill", "client"]),
|
|
2534
|
+
allowDuringExecution: z30.boolean(),
|
|
2535
|
+
supported: z30.boolean(),
|
|
2536
|
+
reason: z30.string().max(1024).optional()
|
|
2537
|
+
}).strict();
|
|
2538
|
+
var WorkbenchCommandListResultSchema = z30.object({
|
|
2539
|
+
commands: z30.array(WorkbenchCommandSchema).max(512)
|
|
2540
|
+
}).strict();
|
|
2541
|
+
var WorkbenchCommandInvokeRequestSchema = z30.object({
|
|
2438
2542
|
...Submission2,
|
|
2439
|
-
name:
|
|
2440
|
-
input:
|
|
2441
|
-
}).strict();
|
|
2442
|
-
var WorkbenchCommandChoiceSchema =
|
|
2443
|
-
name:
|
|
2444
|
-
label:
|
|
2445
|
-
input:
|
|
2446
|
-
}).strict();
|
|
2447
|
-
var WorkbenchCommandResultSchema =
|
|
2448
|
-
|
|
2449
|
-
|
|
2450
|
-
|
|
2451
|
-
|
|
2452
|
-
kind:
|
|
2453
|
-
choices:
|
|
2543
|
+
name: z30.string().trim().min(1).max(260),
|
|
2544
|
+
input: z30.string().max(16e3)
|
|
2545
|
+
}).strict();
|
|
2546
|
+
var WorkbenchCommandChoiceSchema = z30.object({
|
|
2547
|
+
name: z30.string().min(1).max(260),
|
|
2548
|
+
label: z30.string().min(1).max(1024),
|
|
2549
|
+
input: z30.string().max(16e3)
|
|
2550
|
+
}).strict();
|
|
2551
|
+
var WorkbenchCommandResultSchema = z30.discriminatedUnion("kind", [
|
|
2552
|
+
z30.object({ kind: z30.literal("text"), text: Text }).strict(),
|
|
2553
|
+
z30.object({ kind: z30.literal("completed") }).strict(),
|
|
2554
|
+
z30.object({ kind: z30.literal("sent"), messageId: Id2 }).strict(),
|
|
2555
|
+
z30.object({
|
|
2556
|
+
kind: z30.literal("select-subcommand"),
|
|
2557
|
+
choices: z30.array(WorkbenchCommandChoiceSchema).min(1).max(100)
|
|
2454
2558
|
}).strict()
|
|
2455
2559
|
]);
|
|
2456
|
-
var WorkbenchQueueItemSchema =
|
|
2560
|
+
var WorkbenchQueueItemSchema = z30.object({
|
|
2457
2561
|
id: Id2,
|
|
2458
|
-
kind:
|
|
2459
|
-
texts:
|
|
2460
|
-
actions:
|
|
2562
|
+
kind: z30.string().min(1).max(64),
|
|
2563
|
+
texts: z30.array(z30.string().max(1e5)).min(1).max(100),
|
|
2564
|
+
actions: z30.array(z30.enum(["edit", "remove", "move", "send-now"])).max(4)
|
|
2461
2565
|
}).strict();
|
|
2462
|
-
var WorkbenchQueueSnapshotSchema =
|
|
2566
|
+
var WorkbenchQueueSnapshotSchema = z30.object({
|
|
2463
2567
|
generation: Id2,
|
|
2464
2568
|
revision: Id2,
|
|
2465
|
-
items:
|
|
2466
|
-
steeringMessages:
|
|
2569
|
+
items: z30.array(WorkbenchQueueItemSchema).max(512),
|
|
2570
|
+
steeringMessages: z30.array(z30.string().max(1e5)).max(512)
|
|
2467
2571
|
}).strict();
|
|
2468
2572
|
var QueueMutation = {
|
|
2469
2573
|
...Submission2,
|
|
@@ -2471,48 +2575,48 @@ var QueueMutation = {
|
|
|
2471
2575
|
revision: Id2,
|
|
2472
2576
|
id: Id2
|
|
2473
2577
|
};
|
|
2474
|
-
var WorkbenchQueueMutationRequestSchema =
|
|
2475
|
-
|
|
2476
|
-
|
|
2477
|
-
|
|
2478
|
-
|
|
2479
|
-
]);
|
|
2480
|
-
var WorkbenchQueueMutationResultSchema =
|
|
2481
|
-
changed:
|
|
2578
|
+
var WorkbenchQueueMutationRequestSchema = z30.discriminatedUnion("action", [
|
|
2579
|
+
z30.object({ ...QueueMutation, action: z30.literal("edit"), prompt: z30.string().trim().min(1).max(1e5) }).strict(),
|
|
2580
|
+
z30.object({ ...QueueMutation, action: z30.literal("remove") }).strict(),
|
|
2581
|
+
z30.object({ ...QueueMutation, action: z30.literal("move"), toPosition: z30.number().int().min(0).max(511) }).strict(),
|
|
2582
|
+
z30.object({ ...QueueMutation, action: z30.literal("send-now") }).strict()
|
|
2583
|
+
]);
|
|
2584
|
+
var WorkbenchQueueMutationResultSchema = z30.object({
|
|
2585
|
+
changed: z30.boolean(),
|
|
2482
2586
|
snapshot: WorkbenchQueueSnapshotSchema
|
|
2483
2587
|
}).strict();
|
|
2484
|
-
var WorkbenchTokenMetricSchema =
|
|
2485
|
-
kind:
|
|
2588
|
+
var WorkbenchTokenMetricSchema = z30.object({
|
|
2589
|
+
kind: z30.string().min(1).max(128),
|
|
2486
2590
|
count: Count
|
|
2487
2591
|
}).strict();
|
|
2488
|
-
var WorkbenchModelUsageSchema =
|
|
2592
|
+
var WorkbenchModelUsageSchema = z30.object({
|
|
2489
2593
|
model: Id2,
|
|
2490
2594
|
requests: Count,
|
|
2491
|
-
premiumRequestCost:
|
|
2492
|
-
tokens:
|
|
2595
|
+
premiumRequestCost: z30.number().finite().nonnegative(),
|
|
2596
|
+
tokens: z30.array(WorkbenchTokenMetricSchema).max(32)
|
|
2493
2597
|
}).strict();
|
|
2494
|
-
var WorkbenchContextSchema =
|
|
2598
|
+
var WorkbenchContextSchema = z30.object({
|
|
2495
2599
|
currentTokens: Count,
|
|
2496
2600
|
tokenLimit: Count,
|
|
2497
2601
|
systemTokens: Count.optional(),
|
|
2498
2602
|
conversationTokens: Count.optional(),
|
|
2499
2603
|
toolTokens: Count.optional()
|
|
2500
2604
|
}).strict();
|
|
2501
|
-
var WorkbenchInsightsSchema =
|
|
2502
|
-
sampledAt:
|
|
2605
|
+
var WorkbenchInsightsSchema = z30.object({
|
|
2606
|
+
sampledAt: z30.iso.datetime(),
|
|
2503
2607
|
generation: Id2,
|
|
2504
2608
|
model: Id2.optional(),
|
|
2505
2609
|
totalUserRequests: Count,
|
|
2506
|
-
premiumRequestCost:
|
|
2507
|
-
nanoAiu:
|
|
2508
|
-
tokens:
|
|
2509
|
-
models:
|
|
2610
|
+
premiumRequestCost: z30.number().finite().nonnegative(),
|
|
2611
|
+
nanoAiu: z30.string().regex(/^\d+$/).max(40).optional(),
|
|
2612
|
+
tokens: z30.array(WorkbenchTokenMetricSchema).max(32),
|
|
2613
|
+
models: z30.array(WorkbenchModelUsageSchema).max(100),
|
|
2510
2614
|
context: WorkbenchContextSchema.optional(),
|
|
2511
|
-
canCompact:
|
|
2512
|
-
compactUnavailableReason:
|
|
2615
|
+
canCompact: z30.boolean(),
|
|
2616
|
+
compactUnavailableReason: z30.string().max(1024).optional()
|
|
2513
2617
|
}).strict();
|
|
2514
|
-
var WorkbenchCompactResultSchema =
|
|
2515
|
-
success:
|
|
2618
|
+
var WorkbenchCompactResultSchema = z30.object({
|
|
2619
|
+
success: z30.boolean(),
|
|
2516
2620
|
tokensRemoved: Count,
|
|
2517
2621
|
messagesRemoved: Count
|
|
2518
2622
|
}).strict();
|
|
@@ -2546,8 +2650,110 @@ var WorkbenchAndroidSchemas = {
|
|
|
2546
2650
|
WorkbenchCompactResult: WorkbenchCompactResultSchema
|
|
2547
2651
|
};
|
|
2548
2652
|
|
|
2653
|
+
// ../../shared/protocol/dist/microsoft-todo.js
|
|
2654
|
+
import { z as z31 } from "zod";
|
|
2655
|
+
var MicrosoftTodoOperationSchema = z31.enum([
|
|
2656
|
+
"status",
|
|
2657
|
+
"connect",
|
|
2658
|
+
"disconnect",
|
|
2659
|
+
"list_lists",
|
|
2660
|
+
"get_list",
|
|
2661
|
+
"create_list",
|
|
2662
|
+
"update_list",
|
|
2663
|
+
"delete_list",
|
|
2664
|
+
"list_tasks",
|
|
2665
|
+
"get_task",
|
|
2666
|
+
"create_task",
|
|
2667
|
+
"update_task",
|
|
2668
|
+
"delete_task"
|
|
2669
|
+
]);
|
|
2670
|
+
var MicrosoftTodoIdSchema = z31.string().min(1).max(1024).regex(/^[A-Za-z0-9_/=+-]+$/);
|
|
2671
|
+
var MicrosoftTodoDateTimeSchema = z31.object({
|
|
2672
|
+
dateTime: z31.string().min(1).max(64).regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,7})?$/),
|
|
2673
|
+
timeZone: z31.string().min(1).max(128)
|
|
2674
|
+
}).strict();
|
|
2675
|
+
var MicrosoftTodoTaskInputSchema = z31.object({
|
|
2676
|
+
title: z31.string().trim().min(1).max(1e3).optional(),
|
|
2677
|
+
body: z31.object({
|
|
2678
|
+
content: z31.string().max(16e3),
|
|
2679
|
+
contentType: z31.literal("text")
|
|
2680
|
+
}).strict().optional(),
|
|
2681
|
+
status: z31.enum(["notStarted", "inProgress", "completed", "waitingOnOthers", "deferred"]).optional(),
|
|
2682
|
+
importance: z31.enum(["low", "normal", "high"]).optional(),
|
|
2683
|
+
dueDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
|
|
2684
|
+
reminderDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
|
|
2685
|
+
isReminderOn: z31.boolean().optional()
|
|
2686
|
+
}).strict();
|
|
2687
|
+
var MicrosoftTodoListInputSchema = z31.object({
|
|
2688
|
+
displayName: z31.string().trim().min(1).max(255)
|
|
2689
|
+
}).strict();
|
|
2690
|
+
var MicrosoftTodoRequestSchema = z31.object({
|
|
2691
|
+
operation: MicrosoftTodoOperationSchema,
|
|
2692
|
+
listId: MicrosoftTodoIdSchema.optional(),
|
|
2693
|
+
taskId: MicrosoftTodoIdSchema.optional(),
|
|
2694
|
+
list: MicrosoftTodoListInputSchema.optional(),
|
|
2695
|
+
task: MicrosoftTodoTaskInputSchema.optional(),
|
|
2696
|
+
cursor: z31.string().min(1).max(8192).optional(),
|
|
2697
|
+
etag: z31.string().min(1).max(512).regex(/^[^\r\n]+$/).optional()
|
|
2698
|
+
}).strict();
|
|
2699
|
+
var MicrosoftTodoListSchema = z31.object({
|
|
2700
|
+
id: MicrosoftTodoIdSchema,
|
|
2701
|
+
displayName: z31.string().max(1e3),
|
|
2702
|
+
isOwner: z31.boolean(),
|
|
2703
|
+
isShared: z31.boolean(),
|
|
2704
|
+
wellknownListName: z31.string().max(128),
|
|
2705
|
+
etag: z31.string().max(512).optional()
|
|
2706
|
+
}).strict();
|
|
2707
|
+
var MicrosoftTodoTaskSchema = z31.object({
|
|
2708
|
+
id: MicrosoftTodoIdSchema,
|
|
2709
|
+
title: z31.string().max(1e3),
|
|
2710
|
+
body: z31.object({ content: z31.string().max(16e3), contentType: z31.string().max(32) }).strict(),
|
|
2711
|
+
status: z31.string().max(64),
|
|
2712
|
+
importance: z31.string().max(32),
|
|
2713
|
+
dueDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
|
|
2714
|
+
reminderDateTime: MicrosoftTodoDateTimeSchema.nullable().optional(),
|
|
2715
|
+
isReminderOn: z31.boolean(),
|
|
2716
|
+
lastModifiedDateTime: z31.string().max(64),
|
|
2717
|
+
etag: z31.string().max(512).optional()
|
|
2718
|
+
}).strict();
|
|
2719
|
+
var MicrosoftTodoResultSchema = z31.object({
|
|
2720
|
+
ok: z31.literal(true),
|
|
2721
|
+
enabled: z31.boolean(),
|
|
2722
|
+
connected: z31.boolean(),
|
|
2723
|
+
authorizationUrl: z31.url().optional(),
|
|
2724
|
+
lists: z31.array(MicrosoftTodoListSchema).max(100).optional(),
|
|
2725
|
+
list: MicrosoftTodoListSchema.optional(),
|
|
2726
|
+
tasks: z31.array(MicrosoftTodoTaskSchema).max(100).optional(),
|
|
2727
|
+
task: MicrosoftTodoTaskSchema.optional(),
|
|
2728
|
+
nextCursor: z31.string().max(8192).optional(),
|
|
2729
|
+
deleted: z31.boolean().optional()
|
|
2730
|
+
}).strict();
|
|
2731
|
+
var MicrosoftTodoAndroidSchemas = {
|
|
2732
|
+
MicrosoftTodoDateTime: MicrosoftTodoDateTimeSchema,
|
|
2733
|
+
MicrosoftTodoTaskInput: MicrosoftTodoTaskInputSchema,
|
|
2734
|
+
MicrosoftTodoListInput: MicrosoftTodoListInputSchema,
|
|
2735
|
+
MicrosoftTodoRequest: MicrosoftTodoRequestSchema,
|
|
2736
|
+
MicrosoftTodoList: MicrosoftTodoListSchema,
|
|
2737
|
+
MicrosoftTodoTask: MicrosoftTodoTaskSchema,
|
|
2738
|
+
MicrosoftTodoResult: MicrosoftTodoResultSchema
|
|
2739
|
+
};
|
|
2740
|
+
|
|
2741
|
+
// ../../shared/protocol/dist/relay-features.js
|
|
2742
|
+
import { z as z32 } from "zod";
|
|
2743
|
+
var RelayFeaturesSchema = z32.object({
|
|
2744
|
+
microsoftTodo: z32.boolean(),
|
|
2745
|
+
modelGateway: z32.boolean(),
|
|
2746
|
+
sessionImages: z32.boolean(),
|
|
2747
|
+
webClient: z32.boolean()
|
|
2748
|
+
}).strict();
|
|
2749
|
+
var RelayFeatureAndroidSchemas = { RelayFeatures: RelayFeaturesSchema };
|
|
2750
|
+
|
|
2549
2751
|
// ../../shared/protocol/dist/codegen/android-schemas.js
|
|
2550
2752
|
var AndroidProtocolSchemas = {
|
|
2753
|
+
MobileIdentityProof: MobileIdentityProofSchema,
|
|
2754
|
+
MobileAuthorizationClaim: MobileAuthorizationClaimSchema,
|
|
2755
|
+
MobileAuthorizationPoll: MobileAuthorizationPollSchema,
|
|
2756
|
+
MobileAuthorizationResult: MobileAuthorizationResultSchema,
|
|
2551
2757
|
BrowserOpenUrlParams: BrowserOpenUrlParamsSchema,
|
|
2552
2758
|
BrowserOpenUrlResult: BrowserOpenUrlResultSchema,
|
|
2553
2759
|
TimelineImageBlobRequest: TimelineImageBlobRequestSchema,
|
|
@@ -2559,6 +2765,8 @@ var AndroidProtocolSchemas = {
|
|
|
2559
2765
|
SessionImageDownloadResult: SessionImageDownloadResultSchema,
|
|
2560
2766
|
...WorkbenchAndroidSchemas,
|
|
2561
2767
|
...ScheduleAndroidSchemas,
|
|
2768
|
+
...MicrosoftTodoAndroidSchemas,
|
|
2769
|
+
...RelayFeatureAndroidSchemas,
|
|
2562
2770
|
SessionCommunication: SessionCommunicationSchema,
|
|
2563
2771
|
SessionGitDiffData: SessionGitDiffDataSchema,
|
|
2564
2772
|
SessionGitDiffEntry: SessionGitDiffPartialEntrySchema,
|
|
@@ -2585,6 +2793,9 @@ var AndroidProtocolSchemas = {
|
|
|
2585
2793
|
SecureMessage: SecureMessageSchema,
|
|
2586
2794
|
SecureDeliveryError: SecureDeliveryErrorSchema,
|
|
2587
2795
|
AuthUser: AuthUserSchema,
|
|
2796
|
+
RelayAuthDiscovery: RelayAuthDiscoverySchema,
|
|
2797
|
+
RelayAuthentication: RelayAuthDiscoverySchema.shape.authentication,
|
|
2798
|
+
AadAccountResult: AadAccountResultSchema,
|
|
2588
2799
|
LoginRequest: LoginRequestSchema,
|
|
2589
2800
|
LoginResult: LoginResultSchema,
|
|
2590
2801
|
PcAccountRequest: PcAccountRequestSchema,
|
|
@@ -2663,10 +2874,17 @@ var AndroidProtocolSchemas = {
|
|
|
2663
2874
|
};
|
|
2664
2875
|
|
|
2665
2876
|
export {
|
|
2877
|
+
MobileAuthorizationIdSchema,
|
|
2666
2878
|
AuthUserSchema,
|
|
2879
|
+
AadAccountResultSchema,
|
|
2880
|
+
RELAY_AUTH_DISCOVERY_PATH,
|
|
2881
|
+
RelayAuthenticationSchema,
|
|
2882
|
+
RelayAuthDiscoverySchema,
|
|
2667
2883
|
PcAccountRequestSchema,
|
|
2668
2884
|
PcAccountResultSchema,
|
|
2669
2885
|
PairingStatusRequestSchema,
|
|
2886
|
+
MobileIdentityPublicKeySchema,
|
|
2887
|
+
MobileAuthorizationListResultSchema,
|
|
2670
2888
|
PcEnrollmentIdSchema,
|
|
2671
2889
|
PcEnrollmentStartRequestSchema,
|
|
2672
2890
|
PcEnrollmentVerifierRequestSchema,
|