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