@byok-sdk/protocol 0.6.0 → 0.7.0
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/dist/agent-egress.d.ts +144 -0
- package/dist/codec.d.ts +24 -0
- package/dist/envelope.d.ts +369 -0
- package/dist/http-api.d.ts +750 -0
- package/dist/index.d.ts +5 -3
- package/dist/index.js +256 -9
- package/dist/index.js.map +1 -1
- package/dist/messages.d.ts +677 -5
- package/dist/version.d.ts +1 -1
- package/package.json +1 -1
|
@@ -0,0 +1,144 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
/** Additive daemon capability names. Server/cloud admission consumes these exactly. */
|
|
3
|
+
export declare const AGENT_EGRESS_POLICY_CAPABILITY: 'agent-egress-policy';
|
|
4
|
+
export declare const AGENT_EGRESS_RELIABLE_ACK_CAPABILITY: 'agent-egress-reliable-ack';
|
|
5
|
+
export declare const AGENT_CONTENT_WORKSPACE_READ_CAPABILITY: 'agent-content-workspace-read';
|
|
6
|
+
export declare const AGENT_CONTENT_TRANSCRIPT_READ_CAPABILITY: 'agent-content-transcript-read';
|
|
7
|
+
export declare const AGENT_CONTENT_ARTIFACT_READ_CAPABILITY: 'agent-content-artifact-read';
|
|
8
|
+
export declare const AgentContentMimeTypeSchema: z.ZodString;
|
|
9
|
+
/** Explicit MIME and byte policy for one independently-authorized content surface. */
|
|
10
|
+
export declare const ContentReadPolicySchema: z.ZodObject<{
|
|
11
|
+
maxBytes: z.ZodNumber;
|
|
12
|
+
allowedMimeTypes: z.ZodArray<z.ZodString>;
|
|
13
|
+
}, z.core.$strict>;
|
|
14
|
+
export type ContentReadPolicy = z.infer<typeof ContentReadPolicySchema>;
|
|
15
|
+
export declare const AgentEgressActivityPolicySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
16
|
+
mode: z.ZodLiteral<"metadata-status">;
|
|
17
|
+
delivery: z.ZodLiteral<"latest-value">;
|
|
18
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
19
|
+
mode: z.ZodLiteral<"contentful-trajectory">;
|
|
20
|
+
delivery: z.ZodLiteral<"latest-value">;
|
|
21
|
+
maxCoalesceMs: z.ZodNumber;
|
|
22
|
+
maxEventBytes: z.ZodNumber;
|
|
23
|
+
}, z.core.$strict>], "mode">;
|
|
24
|
+
export type AgentEgressActivityPolicy = z.infer<typeof AgentEgressActivityPolicySchema>;
|
|
25
|
+
export declare const AgentReliableQuotaPolicySchema: z.ZodObject<{
|
|
26
|
+
maxPendingEventsPerAgent: z.ZodNumber;
|
|
27
|
+
maxPendingBytesPerAgent: z.ZodNumber;
|
|
28
|
+
maxPendingBytesPerTenant: z.ZodNumber;
|
|
29
|
+
}, z.core.$strict>;
|
|
30
|
+
export type AgentReliableQuotaPolicy = z.infer<typeof AgentReliableQuotaPolicySchema>;
|
|
31
|
+
/**
|
|
32
|
+
* The only consumable policy shape for Agent egress. Missing/unknown policy
|
|
33
|
+
* is intentionally not represented as a default: callers must select a
|
|
34
|
+
* revision and all three content surfaces independently.
|
|
35
|
+
*/
|
|
36
|
+
export declare const AgentEgressPolicySchema: z.ZodObject<{
|
|
37
|
+
policyRevision: z.ZodString;
|
|
38
|
+
activity: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
39
|
+
mode: z.ZodLiteral<"metadata-status">;
|
|
40
|
+
delivery: z.ZodLiteral<"latest-value">;
|
|
41
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
42
|
+
mode: z.ZodLiteral<"contentful-trajectory">;
|
|
43
|
+
delivery: z.ZodLiteral<"latest-value">;
|
|
44
|
+
maxCoalesceMs: z.ZodNumber;
|
|
45
|
+
maxEventBytes: z.ZodNumber;
|
|
46
|
+
}, z.core.$strict>], "mode">;
|
|
47
|
+
reliable: z.ZodObject<{
|
|
48
|
+
maxPendingEventsPerAgent: z.ZodNumber;
|
|
49
|
+
maxPendingBytesPerAgent: z.ZodNumber;
|
|
50
|
+
maxPendingBytesPerTenant: z.ZodNumber;
|
|
51
|
+
}, z.core.$strict>;
|
|
52
|
+
transfers: z.ZodObject<{
|
|
53
|
+
workspace: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
|
|
54
|
+
maxBytes: z.ZodNumber;
|
|
55
|
+
allowedMimeTypes: z.ZodArray<z.ZodString>;
|
|
56
|
+
}, z.core.$strict>]>;
|
|
57
|
+
transcript: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
|
|
58
|
+
maxBytes: z.ZodNumber;
|
|
59
|
+
allowedMimeTypes: z.ZodArray<z.ZodString>;
|
|
60
|
+
}, z.core.$strict>]>;
|
|
61
|
+
artifact: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
|
|
62
|
+
maxBytes: z.ZodNumber;
|
|
63
|
+
allowedMimeTypes: z.ZodArray<z.ZodString>;
|
|
64
|
+
}, z.core.$strict>]>;
|
|
65
|
+
}, z.core.$strict>;
|
|
66
|
+
}, z.core.$strict>;
|
|
67
|
+
export type AgentEgressPolicy = z.infer<typeof AgentEgressPolicySchema>;
|
|
68
|
+
/** Delivery stores are semantically distinct; this enum is never a durable boolean. */
|
|
69
|
+
export declare const AgentEgressLaneSchema: z.ZodEnum<{
|
|
70
|
+
"latest-value": "latest-value";
|
|
71
|
+
reliable: "reliable";
|
|
72
|
+
}>;
|
|
73
|
+
export type AgentEgressLane = z.infer<typeof AgentEgressLaneSchema>;
|
|
74
|
+
/** Every refusal/replacement is observable rather than silently degrading to another lane. */
|
|
75
|
+
export declare const AgentEgressDropReasonSchema: z.ZodEnum<{
|
|
76
|
+
ack_mismatch: "ack_mismatch";
|
|
77
|
+
backpressure: "backpressure";
|
|
78
|
+
capability_missing: "capability_missing";
|
|
79
|
+
coalesced: "coalesced";
|
|
80
|
+
disconnected: "disconnected";
|
|
81
|
+
invalid_envelope: "invalid_envelope";
|
|
82
|
+
policy_denied: "policy_denied";
|
|
83
|
+
quota_exceeded: "quota_exceeded";
|
|
84
|
+
sanitizer_rejected: "sanitizer_rejected";
|
|
85
|
+
}>;
|
|
86
|
+
export type AgentEgressDropReason = z.infer<typeof AgentEgressDropReasonSchema>;
|
|
87
|
+
export declare const AgentContentReadSurfaceSchema: z.ZodEnum<{
|
|
88
|
+
artifact: "artifact";
|
|
89
|
+
transcript: "transcript";
|
|
90
|
+
workspace: "workspace";
|
|
91
|
+
}>;
|
|
92
|
+
export type AgentContentReadSurface = z.infer<typeof AgentContentReadSurfaceSchema>;
|
|
93
|
+
/** The product-selected actor is explicit; tenant/device are bound by the authenticated transport. */
|
|
94
|
+
export declare const AgentContentActorKindSchema: z.ZodEnum<{
|
|
95
|
+
agent: "agent";
|
|
96
|
+
system: "system";
|
|
97
|
+
user: "user";
|
|
98
|
+
}>;
|
|
99
|
+
export type AgentContentActorKind = z.infer<typeof AgentContentActorKindSchema>;
|
|
100
|
+
export declare const AgentContentActorSchema: z.ZodObject<{
|
|
101
|
+
kind: z.ZodEnum<{
|
|
102
|
+
agent: "agent";
|
|
103
|
+
system: "system";
|
|
104
|
+
user: "user";
|
|
105
|
+
}>;
|
|
106
|
+
id: z.ZodString;
|
|
107
|
+
}, z.core.$strict>;
|
|
108
|
+
export type AgentContentActor = z.infer<typeof AgentContentActorSchema>;
|
|
109
|
+
/** No byte/text interpretation is inferred from a target name or MIME declaration. */
|
|
110
|
+
export declare const AgentContentDecodeAsSchema: z.ZodEnum<{
|
|
111
|
+
bytes: "bytes";
|
|
112
|
+
utf8: "utf8";
|
|
113
|
+
}>;
|
|
114
|
+
export type AgentContentDecodeAs = z.infer<typeof AgentContentDecodeAsSchema>;
|
|
115
|
+
export declare const AgentContentReadDecisionSchema: z.ZodEnum<{
|
|
116
|
+
allowed: "allowed";
|
|
117
|
+
denied: "denied";
|
|
118
|
+
}>;
|
|
119
|
+
export type AgentContentReadDecision = z.infer<typeof AgentContentReadDecisionSchema>;
|
|
120
|
+
export declare const AgentContentReadDenialReasonSchema: z.ZodEnum<{
|
|
121
|
+
"absolute-target": "absolute-target";
|
|
122
|
+
"byte-limit": "byte-limit";
|
|
123
|
+
"capability-missing": "capability-missing";
|
|
124
|
+
"dot-segment": "dot-segment";
|
|
125
|
+
"identity-mismatch": "identity-mismatch";
|
|
126
|
+
"invalid-request": "invalid-request";
|
|
127
|
+
"mime-not-allowlisted": "mime-not-allowlisted";
|
|
128
|
+
"non-relative-target": "non-relative-target";
|
|
129
|
+
"not-regular-file": "not-regular-file";
|
|
130
|
+
"path-escape": "path-escape";
|
|
131
|
+
"policy-disabled": "policy-disabled";
|
|
132
|
+
"policy-revision-mismatch": "policy-revision-mismatch";
|
|
133
|
+
"root-invalid": "root-invalid";
|
|
134
|
+
"root-not-allowlisted": "root-not-allowlisted";
|
|
135
|
+
"sensitive-name": "sensitive-name";
|
|
136
|
+
symlink: "symlink";
|
|
137
|
+
"target-missing": "target-missing";
|
|
138
|
+
"text-decode-failed": "text-decode-failed";
|
|
139
|
+
"text-not-allowlisted": "text-not-allowlisted";
|
|
140
|
+
}>;
|
|
141
|
+
export type AgentContentReadDenialReason = z.infer<typeof AgentContentReadDenialReasonSchema>;
|
|
142
|
+
/** SHA-256 transport receipt hash, never a content byte projection. */
|
|
143
|
+
export declare const AgentEgressContentHashSchema: z.ZodString;
|
|
144
|
+
export declare const AgentEgressPolicyRevisionSchema: z.ZodString;
|
package/dist/codec.d.ts
CHANGED
|
@@ -34,6 +34,30 @@ interface EnvelopeShapeOptions {
|
|
|
34
34
|
taskId: string;
|
|
35
35
|
seq: number;
|
|
36
36
|
};
|
|
37
|
+
'task.offer_for_agent': {
|
|
38
|
+
taskId: string;
|
|
39
|
+
seq: number;
|
|
40
|
+
};
|
|
41
|
+
'task.offer_for_agent_with_egress': {
|
|
42
|
+
taskId: string;
|
|
43
|
+
seq: number;
|
|
44
|
+
};
|
|
45
|
+
'agent.egress.reliable': {
|
|
46
|
+
taskId?: string;
|
|
47
|
+
seq?: number;
|
|
48
|
+
};
|
|
49
|
+
'agent.egress.ack': {
|
|
50
|
+
taskId?: string;
|
|
51
|
+
seq: number;
|
|
52
|
+
};
|
|
53
|
+
'agent.content.read': {
|
|
54
|
+
taskId?: string;
|
|
55
|
+
seq: number;
|
|
56
|
+
};
|
|
57
|
+
'agent.content.receipt': {
|
|
58
|
+
taskId?: string;
|
|
59
|
+
seq?: number;
|
|
60
|
+
};
|
|
37
61
|
'task.approve': {
|
|
38
62
|
taskId: string;
|
|
39
63
|
seq: number;
|
package/dist/envelope.d.ts
CHANGED
|
@@ -175,6 +175,222 @@ export declare const EnvelopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
175
175
|
}, z.core.$strip>>;
|
|
176
176
|
requiredToolsets: z.ZodArray<z.ZodString>;
|
|
177
177
|
}, z.core.$strict>;
|
|
178
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
179
|
+
v: z.ZodNumber;
|
|
180
|
+
id: z.ZodUUID;
|
|
181
|
+
ts: z.ZodISODateTime;
|
|
182
|
+
type: z.ZodLiteral<"task.offer_for_agent">;
|
|
183
|
+
task_id: z.ZodString;
|
|
184
|
+
session_ref: z.ZodOptional<z.ZodString>;
|
|
185
|
+
seq: z.ZodNumber;
|
|
186
|
+
payload: z.ZodObject<{
|
|
187
|
+
instruction: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
188
|
+
blobRef: z.ZodObject<{
|
|
189
|
+
blobId: z.ZodString;
|
|
190
|
+
contentHash: z.ZodString;
|
|
191
|
+
size: z.ZodNumber;
|
|
192
|
+
contentType: z.ZodString;
|
|
193
|
+
url: z.ZodOptional<z.ZodString>;
|
|
194
|
+
}, z.core.$strip>;
|
|
195
|
+
}, z.core.$strict>]>;
|
|
196
|
+
policy: z.ZodObject<{
|
|
197
|
+
mode: z.ZodEnum<{
|
|
198
|
+
auto: "auto";
|
|
199
|
+
confirm: "confirm";
|
|
200
|
+
plan: "plan";
|
|
201
|
+
readonly: "readonly";
|
|
202
|
+
}>;
|
|
203
|
+
allowTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
204
|
+
denyTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
205
|
+
workspaceRoot: z.ZodOptional<z.ZodString>;
|
|
206
|
+
network: z.ZodOptional<z.ZodBoolean>;
|
|
207
|
+
}, z.core.$strict>;
|
|
208
|
+
agentRef: z.ZodObject<{
|
|
209
|
+
agentId: z.ZodString;
|
|
210
|
+
profileRevision: z.ZodString;
|
|
211
|
+
}, z.core.$strict>;
|
|
212
|
+
requiredToolsets: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
213
|
+
runtime: z.ZodOptional<z.ZodEnum<{
|
|
214
|
+
claude: "claude";
|
|
215
|
+
codex: "codex";
|
|
216
|
+
pi: "pi";
|
|
217
|
+
}>>;
|
|
218
|
+
dispatchSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
219
|
+
lane: z.ZodLiteral<"subscription">;
|
|
220
|
+
runtimeId: z.ZodEnum<{
|
|
221
|
+
claude: "claude";
|
|
222
|
+
codex: "codex";
|
|
223
|
+
}>;
|
|
224
|
+
providerId: z.ZodNull;
|
|
225
|
+
modelId: z.ZodString;
|
|
226
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
227
|
+
lane: z.ZodLiteral<"byok">;
|
|
228
|
+
runtimeId: z.ZodLiteral<"pi">;
|
|
229
|
+
providerId: z.ZodString;
|
|
230
|
+
modelId: z.ZodString;
|
|
231
|
+
}, z.core.$strict>], "lane">>;
|
|
232
|
+
sessionRef: z.ZodOptional<z.ZodString>;
|
|
233
|
+
limits: z.ZodOptional<z.ZodObject<{
|
|
234
|
+
maxDurationMs: z.ZodOptional<z.ZodNumber>;
|
|
235
|
+
maxTokens: z.ZodOptional<z.ZodNumber>;
|
|
236
|
+
}, z.core.$strip>>;
|
|
237
|
+
}, z.core.$strict>;
|
|
238
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
239
|
+
v: z.ZodNumber;
|
|
240
|
+
id: z.ZodUUID;
|
|
241
|
+
ts: z.ZodISODateTime;
|
|
242
|
+
type: z.ZodLiteral<"task.offer_for_agent_with_egress">;
|
|
243
|
+
task_id: z.ZodString;
|
|
244
|
+
session_ref: z.ZodOptional<z.ZodString>;
|
|
245
|
+
seq: z.ZodNumber;
|
|
246
|
+
payload: z.ZodObject<{
|
|
247
|
+
instruction: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
|
|
248
|
+
blobRef: z.ZodObject<{
|
|
249
|
+
blobId: z.ZodString;
|
|
250
|
+
contentHash: z.ZodString;
|
|
251
|
+
size: z.ZodNumber;
|
|
252
|
+
contentType: z.ZodString;
|
|
253
|
+
url: z.ZodOptional<z.ZodString>;
|
|
254
|
+
}, z.core.$strip>;
|
|
255
|
+
}, z.core.$strict>]>;
|
|
256
|
+
policy: z.ZodObject<{
|
|
257
|
+
mode: z.ZodEnum<{
|
|
258
|
+
auto: "auto";
|
|
259
|
+
confirm: "confirm";
|
|
260
|
+
plan: "plan";
|
|
261
|
+
readonly: "readonly";
|
|
262
|
+
}>;
|
|
263
|
+
allowTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
264
|
+
denyTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
265
|
+
workspaceRoot: z.ZodOptional<z.ZodString>;
|
|
266
|
+
network: z.ZodOptional<z.ZodBoolean>;
|
|
267
|
+
}, z.core.$strict>;
|
|
268
|
+
agentRef: z.ZodObject<{
|
|
269
|
+
agentId: z.ZodString;
|
|
270
|
+
profileRevision: z.ZodString;
|
|
271
|
+
}, z.core.$strict>;
|
|
272
|
+
requiredToolsets: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
273
|
+
runtime: z.ZodOptional<z.ZodEnum<{
|
|
274
|
+
claude: "claude";
|
|
275
|
+
codex: "codex";
|
|
276
|
+
pi: "pi";
|
|
277
|
+
}>>;
|
|
278
|
+
dispatchSelection: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
279
|
+
lane: z.ZodLiteral<"subscription">;
|
|
280
|
+
runtimeId: z.ZodEnum<{
|
|
281
|
+
claude: "claude";
|
|
282
|
+
codex: "codex";
|
|
283
|
+
}>;
|
|
284
|
+
providerId: z.ZodNull;
|
|
285
|
+
modelId: z.ZodString;
|
|
286
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
287
|
+
lane: z.ZodLiteral<"byok">;
|
|
288
|
+
runtimeId: z.ZodLiteral<"pi">;
|
|
289
|
+
providerId: z.ZodString;
|
|
290
|
+
modelId: z.ZodString;
|
|
291
|
+
}, z.core.$strict>], "lane">>;
|
|
292
|
+
limits: z.ZodOptional<z.ZodObject<{
|
|
293
|
+
maxDurationMs: z.ZodOptional<z.ZodNumber>;
|
|
294
|
+
maxTokens: z.ZodOptional<z.ZodNumber>;
|
|
295
|
+
}, z.core.$strip>>;
|
|
296
|
+
sessionRef: z.ZodString;
|
|
297
|
+
egressPolicy: z.ZodObject<{
|
|
298
|
+
policyRevision: z.ZodString;
|
|
299
|
+
activity: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
300
|
+
mode: z.ZodLiteral<"metadata-status">;
|
|
301
|
+
delivery: z.ZodLiteral<"latest-value">;
|
|
302
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
303
|
+
mode: z.ZodLiteral<"contentful-trajectory">;
|
|
304
|
+
delivery: z.ZodLiteral<"latest-value">;
|
|
305
|
+
maxCoalesceMs: z.ZodNumber;
|
|
306
|
+
maxEventBytes: z.ZodNumber;
|
|
307
|
+
}, z.core.$strict>], "mode">;
|
|
308
|
+
reliable: z.ZodObject<{
|
|
309
|
+
maxPendingEventsPerAgent: z.ZodNumber;
|
|
310
|
+
maxPendingBytesPerAgent: z.ZodNumber;
|
|
311
|
+
maxPendingBytesPerTenant: z.ZodNumber;
|
|
312
|
+
}, z.core.$strict>;
|
|
313
|
+
transfers: z.ZodObject<{
|
|
314
|
+
workspace: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
|
|
315
|
+
maxBytes: z.ZodNumber;
|
|
316
|
+
allowedMimeTypes: z.ZodArray<z.ZodString>;
|
|
317
|
+
}, z.core.$strict>]>;
|
|
318
|
+
transcript: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
|
|
319
|
+
maxBytes: z.ZodNumber;
|
|
320
|
+
allowedMimeTypes: z.ZodArray<z.ZodString>;
|
|
321
|
+
}, z.core.$strict>]>;
|
|
322
|
+
artifact: z.ZodUnion<readonly [z.ZodLiteral<"disabled">, z.ZodObject<{
|
|
323
|
+
maxBytes: z.ZodNumber;
|
|
324
|
+
allowedMimeTypes: z.ZodArray<z.ZodString>;
|
|
325
|
+
}, z.core.$strict>]>;
|
|
326
|
+
}, z.core.$strict>;
|
|
327
|
+
}, z.core.$strict>;
|
|
328
|
+
}, z.core.$strict>;
|
|
329
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
330
|
+
v: z.ZodNumber;
|
|
331
|
+
id: z.ZodUUID;
|
|
332
|
+
ts: z.ZodISODateTime;
|
|
333
|
+
type: z.ZodLiteral<"agent.egress.ack">;
|
|
334
|
+
task_id: z.ZodOptional<z.ZodString>;
|
|
335
|
+
session_ref: z.ZodOptional<z.ZodString>;
|
|
336
|
+
seq: z.ZodNumber;
|
|
337
|
+
payload: z.ZodObject<{
|
|
338
|
+
agentRef: z.ZodObject<{
|
|
339
|
+
agentId: z.ZodString;
|
|
340
|
+
profileRevision: z.ZodString;
|
|
341
|
+
}, z.core.$strict>;
|
|
342
|
+
sessionRef: z.ZodString;
|
|
343
|
+
policyRevision: z.ZodString;
|
|
344
|
+
eventId: z.ZodUUID;
|
|
345
|
+
cursor: z.ZodNumber;
|
|
346
|
+
receiptId: z.ZodUUID;
|
|
347
|
+
}, z.core.$strict>;
|
|
348
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
349
|
+
v: z.ZodNumber;
|
|
350
|
+
id: z.ZodUUID;
|
|
351
|
+
ts: z.ZodISODateTime;
|
|
352
|
+
type: z.ZodLiteral<"agent.content.read">;
|
|
353
|
+
task_id: z.ZodOptional<z.ZodString>;
|
|
354
|
+
session_ref: z.ZodOptional<z.ZodString>;
|
|
355
|
+
seq: z.ZodNumber;
|
|
356
|
+
payload: z.ZodObject<{
|
|
357
|
+
requestId: z.ZodUUID;
|
|
358
|
+
surface: z.ZodEnum<{
|
|
359
|
+
artifact: "artifact";
|
|
360
|
+
transcript: "transcript";
|
|
361
|
+
workspace: "workspace";
|
|
362
|
+
}>;
|
|
363
|
+
actor: z.ZodObject<{
|
|
364
|
+
kind: z.ZodEnum<{
|
|
365
|
+
agent: "agent";
|
|
366
|
+
system: "system";
|
|
367
|
+
user: "user";
|
|
368
|
+
}>;
|
|
369
|
+
id: z.ZodString;
|
|
370
|
+
}, z.core.$strict>;
|
|
371
|
+
agentRef: z.ZodObject<{
|
|
372
|
+
agentId: z.ZodString;
|
|
373
|
+
profileRevision: z.ZodString;
|
|
374
|
+
}, z.core.$strict>;
|
|
375
|
+
sessionRef: z.ZodString;
|
|
376
|
+
runtime: z.ZodEnum<{
|
|
377
|
+
claude: "claude";
|
|
378
|
+
codex: "codex";
|
|
379
|
+
pi: "pi";
|
|
380
|
+
}>;
|
|
381
|
+
cwd: z.ZodString;
|
|
382
|
+
policyRevision: z.ZodString;
|
|
383
|
+
target: z.ZodString;
|
|
384
|
+
mimeType: z.ZodString;
|
|
385
|
+
decodeAs: z.ZodEnum<{
|
|
386
|
+
bytes: "bytes";
|
|
387
|
+
utf8: "utf8";
|
|
388
|
+
}>;
|
|
389
|
+
policy: z.ZodObject<{
|
|
390
|
+
maxBytes: z.ZodNumber;
|
|
391
|
+
allowedMimeTypes: z.ZodArray<z.ZodString>;
|
|
392
|
+
}, z.core.$strict>;
|
|
393
|
+
}, z.core.$strict>;
|
|
178
394
|
}, z.core.$strip>, z.ZodObject<{
|
|
179
395
|
v: z.ZodNumber;
|
|
180
396
|
id: z.ZodUUID;
|
|
@@ -231,6 +447,10 @@ export declare const EnvelopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
231
447
|
payload: z.ZodObject<{
|
|
232
448
|
deviceId: z.ZodString;
|
|
233
449
|
agentId: z.ZodOptional<z.ZodString>;
|
|
450
|
+
agentRef: z.ZodOptional<z.ZodObject<{
|
|
451
|
+
agentId: z.ZodString;
|
|
452
|
+
profileRevision: z.ZodString;
|
|
453
|
+
}, z.core.$strict>>;
|
|
234
454
|
runtime: z.ZodOptional<z.ZodEnum<{
|
|
235
455
|
claude: "claude";
|
|
236
456
|
codex: "codex";
|
|
@@ -264,6 +484,10 @@ export declare const EnvelopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
264
484
|
payload: z.ZodObject<{
|
|
265
485
|
reason: z.ZodString;
|
|
266
486
|
retryable: z.ZodOptional<z.ZodBoolean>;
|
|
487
|
+
agentRef: z.ZodOptional<z.ZodObject<{
|
|
488
|
+
agentId: z.ZodString;
|
|
489
|
+
profileRevision: z.ZodString;
|
|
490
|
+
}, z.core.$strict>>;
|
|
267
491
|
}, z.core.$strip>;
|
|
268
492
|
}, z.core.$strip>, z.ZodObject<{
|
|
269
493
|
v: z.ZodNumber;
|
|
@@ -377,6 +601,10 @@ export declare const EnvelopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
377
601
|
clientVersion: z.ZodString;
|
|
378
602
|
reportedAt: z.ZodISODateTime;
|
|
379
603
|
}, z.core.$strip>>;
|
|
604
|
+
agentRef: z.ZodOptional<z.ZodObject<{
|
|
605
|
+
agentId: z.ZodString;
|
|
606
|
+
profileRevision: z.ZodString;
|
|
607
|
+
}, z.core.$strict>>;
|
|
380
608
|
}, z.core.$strip>;
|
|
381
609
|
}, z.core.$strip>, z.ZodObject<{
|
|
382
610
|
v: z.ZodNumber;
|
|
@@ -403,6 +631,10 @@ export declare const EnvelopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
403
631
|
clientVersion: z.ZodString;
|
|
404
632
|
reportedAt: z.ZodISODateTime;
|
|
405
633
|
}, z.core.$strip>>;
|
|
634
|
+
agentRef: z.ZodOptional<z.ZodObject<{
|
|
635
|
+
agentId: z.ZodString;
|
|
636
|
+
profileRevision: z.ZodString;
|
|
637
|
+
}, z.core.$strict>>;
|
|
406
638
|
}, z.core.$strip>;
|
|
407
639
|
}, z.core.$strip>, z.ZodObject<{
|
|
408
640
|
v: z.ZodNumber;
|
|
@@ -428,6 +660,10 @@ export declare const EnvelopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
428
660
|
clientVersion: z.ZodString;
|
|
429
661
|
reportedAt: z.ZodISODateTime;
|
|
430
662
|
}, z.core.$strip>>;
|
|
663
|
+
agentRef: z.ZodOptional<z.ZodObject<{
|
|
664
|
+
agentId: z.ZodString;
|
|
665
|
+
profileRevision: z.ZodString;
|
|
666
|
+
}, z.core.$strict>>;
|
|
431
667
|
}, z.core.$strip>;
|
|
432
668
|
}, z.core.$strip>, z.ZodObject<{
|
|
433
669
|
v: z.ZodNumber;
|
|
@@ -448,6 +684,139 @@ export declare const EnvelopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
448
684
|
}>;
|
|
449
685
|
at: z.ZodISODateTime;
|
|
450
686
|
}, z.core.$strip>;
|
|
687
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
688
|
+
v: z.ZodNumber;
|
|
689
|
+
id: z.ZodUUID;
|
|
690
|
+
ts: z.ZodISODateTime;
|
|
691
|
+
type: z.ZodLiteral<"agent.egress.reliable">;
|
|
692
|
+
task_id: z.ZodOptional<z.ZodString>;
|
|
693
|
+
session_ref: z.ZodOptional<z.ZodString>;
|
|
694
|
+
seq: z.ZodOptional<z.ZodNumber>;
|
|
695
|
+
payload: z.ZodObject<{
|
|
696
|
+
agentRef: z.ZodObject<{
|
|
697
|
+
agentId: z.ZodString;
|
|
698
|
+
profileRevision: z.ZodString;
|
|
699
|
+
}, z.core.$strict>;
|
|
700
|
+
sessionRef: z.ZodString;
|
|
701
|
+
policyRevision: z.ZodString;
|
|
702
|
+
eventId: z.ZodUUID;
|
|
703
|
+
cursor: z.ZodNumber;
|
|
704
|
+
payload: z.ZodJSONSchema;
|
|
705
|
+
contentHash: z.ZodString;
|
|
706
|
+
byteCount: z.ZodNumber;
|
|
707
|
+
}, z.core.$strict>;
|
|
708
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
709
|
+
v: z.ZodNumber;
|
|
710
|
+
id: z.ZodUUID;
|
|
711
|
+
ts: z.ZodISODateTime;
|
|
712
|
+
type: z.ZodLiteral<"agent.content.receipt">;
|
|
713
|
+
task_id: z.ZodOptional<z.ZodString>;
|
|
714
|
+
session_ref: z.ZodOptional<z.ZodString>;
|
|
715
|
+
seq: z.ZodOptional<z.ZodNumber>;
|
|
716
|
+
payload: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
717
|
+
requestId: z.ZodUUID;
|
|
718
|
+
eventId: z.ZodUUID;
|
|
719
|
+
cursor: z.ZodNumber;
|
|
720
|
+
surface: z.ZodEnum<{
|
|
721
|
+
artifact: "artifact";
|
|
722
|
+
transcript: "transcript";
|
|
723
|
+
workspace: "workspace";
|
|
724
|
+
}>;
|
|
725
|
+
actor: z.ZodObject<{
|
|
726
|
+
kind: z.ZodEnum<{
|
|
727
|
+
agent: "agent";
|
|
728
|
+
system: "system";
|
|
729
|
+
user: "user";
|
|
730
|
+
}>;
|
|
731
|
+
id: z.ZodString;
|
|
732
|
+
}, z.core.$strict>;
|
|
733
|
+
agentRef: z.ZodObject<{
|
|
734
|
+
agentId: z.ZodString;
|
|
735
|
+
profileRevision: z.ZodString;
|
|
736
|
+
}, z.core.$strict>;
|
|
737
|
+
sessionRef: z.ZodString;
|
|
738
|
+
runtime: z.ZodEnum<{
|
|
739
|
+
claude: "claude";
|
|
740
|
+
codex: "codex";
|
|
741
|
+
pi: "pi";
|
|
742
|
+
}>;
|
|
743
|
+
cwd: z.ZodString;
|
|
744
|
+
policyRevision: z.ZodString;
|
|
745
|
+
target: z.ZodString;
|
|
746
|
+
mimeType: z.ZodString;
|
|
747
|
+
decodeAs: z.ZodEnum<{
|
|
748
|
+
bytes: "bytes";
|
|
749
|
+
utf8: "utf8";
|
|
750
|
+
}>;
|
|
751
|
+
decision: z.ZodLiteral<"allowed">;
|
|
752
|
+
byteCount: z.ZodNumber;
|
|
753
|
+
contentHash: z.ZodString;
|
|
754
|
+
blobRef: z.ZodObject<{
|
|
755
|
+
blobId: z.ZodString;
|
|
756
|
+
contentHash: z.ZodString;
|
|
757
|
+
size: z.ZodNumber;
|
|
758
|
+
contentType: z.ZodString;
|
|
759
|
+
url: z.ZodOptional<z.ZodString>;
|
|
760
|
+
}, z.core.$strip>;
|
|
761
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
762
|
+
requestId: z.ZodUUID;
|
|
763
|
+
eventId: z.ZodUUID;
|
|
764
|
+
cursor: z.ZodNumber;
|
|
765
|
+
surface: z.ZodEnum<{
|
|
766
|
+
artifact: "artifact";
|
|
767
|
+
transcript: "transcript";
|
|
768
|
+
workspace: "workspace";
|
|
769
|
+
}>;
|
|
770
|
+
actor: z.ZodObject<{
|
|
771
|
+
kind: z.ZodEnum<{
|
|
772
|
+
agent: "agent";
|
|
773
|
+
system: "system";
|
|
774
|
+
user: "user";
|
|
775
|
+
}>;
|
|
776
|
+
id: z.ZodString;
|
|
777
|
+
}, z.core.$strict>;
|
|
778
|
+
agentRef: z.ZodObject<{
|
|
779
|
+
agentId: z.ZodString;
|
|
780
|
+
profileRevision: z.ZodString;
|
|
781
|
+
}, z.core.$strict>;
|
|
782
|
+
sessionRef: z.ZodString;
|
|
783
|
+
runtime: z.ZodEnum<{
|
|
784
|
+
claude: "claude";
|
|
785
|
+
codex: "codex";
|
|
786
|
+
pi: "pi";
|
|
787
|
+
}>;
|
|
788
|
+
cwd: z.ZodString;
|
|
789
|
+
policyRevision: z.ZodString;
|
|
790
|
+
target: z.ZodString;
|
|
791
|
+
mimeType: z.ZodString;
|
|
792
|
+
decodeAs: z.ZodEnum<{
|
|
793
|
+
bytes: "bytes";
|
|
794
|
+
utf8: "utf8";
|
|
795
|
+
}>;
|
|
796
|
+
decision: z.ZodLiteral<"denied">;
|
|
797
|
+
byteCount: z.ZodLiteral<0>;
|
|
798
|
+
reason: z.ZodEnum<{
|
|
799
|
+
"absolute-target": "absolute-target";
|
|
800
|
+
"byte-limit": "byte-limit";
|
|
801
|
+
"capability-missing": "capability-missing";
|
|
802
|
+
"dot-segment": "dot-segment";
|
|
803
|
+
"identity-mismatch": "identity-mismatch";
|
|
804
|
+
"invalid-request": "invalid-request";
|
|
805
|
+
"mime-not-allowlisted": "mime-not-allowlisted";
|
|
806
|
+
"non-relative-target": "non-relative-target";
|
|
807
|
+
"not-regular-file": "not-regular-file";
|
|
808
|
+
"path-escape": "path-escape";
|
|
809
|
+
"policy-disabled": "policy-disabled";
|
|
810
|
+
"policy-revision-mismatch": "policy-revision-mismatch";
|
|
811
|
+
"root-invalid": "root-invalid";
|
|
812
|
+
"root-not-allowlisted": "root-not-allowlisted";
|
|
813
|
+
"sensitive-name": "sensitive-name";
|
|
814
|
+
symlink: "symlink";
|
|
815
|
+
"target-missing": "target-missing";
|
|
816
|
+
"text-decode-failed": "text-decode-failed";
|
|
817
|
+
"text-not-allowlisted": "text-not-allowlisted";
|
|
818
|
+
}>;
|
|
819
|
+
}, z.core.$strict>], "decision">;
|
|
451
820
|
}, z.core.$strip>], "type">;
|
|
452
821
|
export type Envelope = z.infer<typeof EnvelopeSchema>;
|
|
453
822
|
/** `true` for every message type the server sends to the daemon (envelope `seq` is required for these). */
|