@tangle-network/agent-app 0.60.53 → 0.60.55
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/assistant/index.js +5 -5
- package/dist/chat-react/index.js +1 -1
- package/dist/chat-routes/index.js +9 -9
- package/dist/chat-store/index.js +2 -2
- package/dist/{chunk-WKD4E52F.js → chunk-2YLSWZ5W.js} +4 -4
- package/dist/chunk-6DOQ6T2O.js +227 -0
- package/dist/chunk-6DOQ6T2O.js.map +1 -0
- package/dist/{chunk-EE7SZFS2.js → chunk-6LPQRKH7.js} +2 -2
- package/dist/{chunk-P2CGXXOJ.js → chunk-CZ7KLS7N.js} +12 -12
- package/dist/{chunk-X4OMULP5.js → chunk-JGZ7WEPL.js} +18 -6
- package/dist/chunk-JGZ7WEPL.js.map +1 -0
- package/dist/object-store/index.js +11 -213
- package/dist/object-store/index.js.map +1 -1
- package/dist/public-consultation/index.js +6 -6
- package/dist/stream/index.js +17 -17
- package/dist/stream/turn-buffer.d.ts +12 -1
- package/dist/teams/invitations-api.js +3 -3
- package/dist/turn-stream/index.js +5 -2
- package/dist/turn-stream/index.js.map +1 -1
- package/dist/web-react/index.js +8 -8
- package/dist/workspace-export/checksum.d.ts +15 -0
- package/dist/workspace-export/d1.d.ts +56 -0
- package/dist/workspace-export/engine.d.ts +51 -0
- package/dist/workspace-export/index.d.ts +16 -0
- package/dist/workspace-export/index.js +1438 -0
- package/dist/workspace-export/index.js.map +1 -0
- package/dist/workspace-export/react.d.ts +16 -0
- package/dist/workspace-export/react.js +158 -0
- package/dist/workspace-export/react.js.map +1 -0
- package/dist/workspace-export/routes.d.ts +53 -0
- package/dist/workspace-export/secrets.d.ts +41 -0
- package/dist/workspace-export/sources.d.ts +59 -0
- package/dist/workspace-export/storage.d.ts +59 -0
- package/dist/workspace-export/tar.d.ts +14 -0
- package/dist/workspace-export/types.d.ts +136 -0
- package/dist/workspace-export/zip.d.ts +26 -0
- package/package.json +11 -1
- package/dist/chunk-X4OMULP5.js.map +0 -1
- /package/dist/{chunk-WKD4E52F.js.map → chunk-2YLSWZ5W.js.map} +0 -0
- /package/dist/{chunk-EE7SZFS2.js.map → chunk-6LPQRKH7.js.map} +0 -0
- /package/dist/{chunk-P2CGXXOJ.js.map → chunk-CZ7KLS7N.js.map} +0 -0
package/dist/assistant/index.js
CHANGED
|
@@ -1,10 +1,11 @@
|
|
|
1
1
|
import {
|
|
2
2
|
chatToolCallPart
|
|
3
|
-
} from "../chunk-
|
|
3
|
+
} from "../chunk-6LPQRKH7.js";
|
|
4
4
|
import "../chunk-FAU5FIFD.js";
|
|
5
5
|
import "../chunk-3HUFJ5LO.js";
|
|
6
6
|
import "../chunk-FBVLEGEG.js";
|
|
7
7
|
import "../chunk-Y6PRDUFJ.js";
|
|
8
|
+
import "../chunk-GEYACSFW.js";
|
|
8
9
|
import {
|
|
9
10
|
ChatComposer
|
|
10
11
|
} from "../chunk-EQ6CGOZK.js";
|
|
@@ -17,20 +18,19 @@ import {
|
|
|
17
18
|
} from "../chunk-HG4OONJA.js";
|
|
18
19
|
import "../chunk-E4AY62T2.js";
|
|
19
20
|
import "../chunk-SJWIZT7B.js";
|
|
20
|
-
import "../chunk-
|
|
21
|
+
import "../chunk-MLG6XKPV.js";
|
|
21
22
|
import {
|
|
22
23
|
AsyncView
|
|
23
24
|
} from "../chunk-LSUELMHY.js";
|
|
24
25
|
import "../chunk-FQYAJYPW.js";
|
|
25
26
|
import "../chunk-ZMU54CBG.js";
|
|
26
|
-
import "../chunk-MLG6XKPV.js";
|
|
27
27
|
import "../chunk-MCYJON3F.js";
|
|
28
28
|
import "../chunk-B7CL7ENS.js";
|
|
29
29
|
import "../chunk-PV33JZKV.js";
|
|
30
30
|
import "../chunk-7YA4QNTU.js";
|
|
31
|
-
import "../chunk-
|
|
32
|
-
import "../chunk-6E7LKHYV.js";
|
|
31
|
+
import "../chunk-2YLSWZ5W.js";
|
|
33
32
|
import "../chunk-ZVEEWGDK.js";
|
|
33
|
+
import "../chunk-6E7LKHYV.js";
|
|
34
34
|
import "../chunk-TXD5HXLE.js";
|
|
35
35
|
import "../chunk-ZGUXI5SI.js";
|
|
36
36
|
import "../chunk-6VQCFJWP.js";
|
package/dist/chat-react/index.js
CHANGED
|
@@ -6,8 +6,8 @@ import "../chunk-L7MB2LLM.js";
|
|
|
6
6
|
import "../chunk-NJDQ2JCP.js";
|
|
7
7
|
import "../chunk-HG4OONJA.js";
|
|
8
8
|
import "../chunk-SJWIZT7B.js";
|
|
9
|
-
import "../chunk-ZMU54CBG.js";
|
|
10
9
|
import "../chunk-MLG6XKPV.js";
|
|
10
|
+
import "../chunk-ZMU54CBG.js";
|
|
11
11
|
import "../chunk-MCYJON3F.js";
|
|
12
12
|
import "../chunk-7YA4QNTU.js";
|
|
13
13
|
import "../chunk-6E7LKHYV.js";
|
|
@@ -65,22 +65,17 @@ import {
|
|
|
65
65
|
rowIdOf,
|
|
66
66
|
storeSupportsDraftPersistence,
|
|
67
67
|
streamChatRouteAsSandboxEvents
|
|
68
|
-
} from "../chunk-
|
|
68
|
+
} from "../chunk-CZ7KLS7N.js";
|
|
69
69
|
import "../chunk-Q7WEEN7P.js";
|
|
70
70
|
import "../chunk-UTAIRVOK.js";
|
|
71
71
|
import "../chunk-RN4WPTBH.js";
|
|
72
72
|
import "../chunk-3NCPXNBZ.js";
|
|
73
|
-
import "../chunk-YXYQ6MJL.js";
|
|
74
|
-
import "../chunk-YG66IHDU.js";
|
|
75
|
-
import {
|
|
76
|
-
coalesceDeltas,
|
|
77
|
-
createBufferedTurnTap
|
|
78
|
-
} from "../chunk-X4OMULP5.js";
|
|
79
73
|
import {
|
|
80
74
|
attachmentInputToPart,
|
|
81
75
|
attachmentKindForMime,
|
|
82
76
|
toChatMessageParts
|
|
83
|
-
} from "../chunk-
|
|
77
|
+
} from "../chunk-2YLSWZ5W.js";
|
|
78
|
+
import "../chunk-ZVEEWGDK.js";
|
|
84
79
|
import {
|
|
85
80
|
ChatTurnInputError,
|
|
86
81
|
DISPATCH_MAX_MEDIA_PARTS,
|
|
@@ -112,10 +107,11 @@ import {
|
|
|
112
107
|
turnResponseEventFor,
|
|
113
108
|
validateSandboxMentionPath
|
|
114
109
|
} from "../chunk-6E7LKHYV.js";
|
|
115
|
-
import "../chunk-ZVEEWGDK.js";
|
|
116
110
|
import {
|
|
117
111
|
isWorkspaceFileExportable
|
|
118
112
|
} from "../chunk-TXD5HXLE.js";
|
|
113
|
+
import "../chunk-YXYQ6MJL.js";
|
|
114
|
+
import "../chunk-YG66IHDU.js";
|
|
119
115
|
import {
|
|
120
116
|
asRecord,
|
|
121
117
|
asString,
|
|
@@ -145,6 +141,10 @@ import {
|
|
|
145
141
|
planFollowUpTurnId,
|
|
146
142
|
planToPersistedPart
|
|
147
143
|
} from "../chunk-LQYIBL3G.js";
|
|
144
|
+
import {
|
|
145
|
+
coalesceDeltas,
|
|
146
|
+
createBufferedTurnTap
|
|
147
|
+
} from "../chunk-JGZ7WEPL.js";
|
|
148
148
|
|
|
149
149
|
// src/chat-routes/model-failover-stream.ts
|
|
150
150
|
var TERMINAL_FAILURE_TYPES = /* @__PURE__ */ new Set(["error", "session.run.failed"]);
|
package/dist/chat-store/index.js
CHANGED
|
@@ -14,9 +14,9 @@ import {
|
|
|
14
14
|
mentionInputToPart,
|
|
15
15
|
mentionPartsFromMessageParts,
|
|
16
16
|
toChatMessageParts
|
|
17
|
-
} from "../chunk-
|
|
18
|
-
import "../chunk-6E7LKHYV.js";
|
|
17
|
+
} from "../chunk-2YLSWZ5W.js";
|
|
19
18
|
import "../chunk-ZVEEWGDK.js";
|
|
19
|
+
import "../chunk-6E7LKHYV.js";
|
|
20
20
|
import "../chunk-TXD5HXLE.js";
|
|
21
21
|
import {
|
|
22
22
|
attachmentPartKey
|
|
@@ -1,9 +1,9 @@
|
|
|
1
|
-
import {
|
|
2
|
-
mentionKindForPath
|
|
3
|
-
} from "./chunk-6E7LKHYV.js";
|
|
4
1
|
import {
|
|
5
2
|
persistedPartToWorkProduct
|
|
6
3
|
} from "./chunk-ZVEEWGDK.js";
|
|
4
|
+
import {
|
|
5
|
+
mentionKindForPath
|
|
6
|
+
} from "./chunk-6E7LKHYV.js";
|
|
7
7
|
import {
|
|
8
8
|
persistedPartToInteraction
|
|
9
9
|
} from "./chunk-6VQCFJWP.js";
|
|
@@ -135,4 +135,4 @@ export {
|
|
|
135
135
|
buildAttachmentPromptBlock,
|
|
136
136
|
historyContentWithAttachments
|
|
137
137
|
};
|
|
138
|
-
//# sourceMappingURL=chunk-
|
|
138
|
+
//# sourceMappingURL=chunk-2YLSWZ5W.js.map
|
|
@@ -0,0 +1,227 @@
|
|
|
1
|
+
import {
|
|
2
|
+
constantTimeEqual,
|
|
3
|
+
hmacSha256Base64Url
|
|
4
|
+
} from "./chunk-S5SRJJQG.js";
|
|
5
|
+
|
|
6
|
+
// src/object-store/index.ts
|
|
7
|
+
function createR2ObjectStore({ bucket }) {
|
|
8
|
+
return {
|
|
9
|
+
async put(key, body, opts) {
|
|
10
|
+
const options = opts?.contentType ? { httpMetadata: { contentType: opts.contentType } } : void 0;
|
|
11
|
+
const fixedLengthStream = globalThis.FixedLengthStream;
|
|
12
|
+
const value = body instanceof ReadableStream && opts?.contentLength !== void 0 && fixedLengthStream ? body.pipeThrough(new fixedLengthStream(opts.contentLength)) : body;
|
|
13
|
+
await bucket.put(key, value, options);
|
|
14
|
+
},
|
|
15
|
+
async get(key) {
|
|
16
|
+
const obj = await bucket.get(key);
|
|
17
|
+
if (!obj) return null;
|
|
18
|
+
return {
|
|
19
|
+
stream: () => obj.body,
|
|
20
|
+
size: obj.size,
|
|
21
|
+
contentType: obj.httpMetadata?.contentType
|
|
22
|
+
};
|
|
23
|
+
},
|
|
24
|
+
async head(key) {
|
|
25
|
+
const obj = await bucket.head(key);
|
|
26
|
+
if (!obj) return null;
|
|
27
|
+
return { size: obj.size, contentType: obj.httpMetadata?.contentType };
|
|
28
|
+
},
|
|
29
|
+
async delete(key) {
|
|
30
|
+
await bucket.delete(key);
|
|
31
|
+
}
|
|
32
|
+
};
|
|
33
|
+
}
|
|
34
|
+
var DEFAULT_MAX_OBJECT_UPLOAD_BYTES = 25 * 1024 * 1024;
|
|
35
|
+
var MAX_WORKERS_OBJECT_UPLOAD_BYTES = 1e8;
|
|
36
|
+
function uploadError(status, code, message) {
|
|
37
|
+
return Response.json({ error: { code, message } }, { status });
|
|
38
|
+
}
|
|
39
|
+
function createObjectUploadRoute({
|
|
40
|
+
store,
|
|
41
|
+
authorize,
|
|
42
|
+
maxBytes = DEFAULT_MAX_OBJECT_UPLOAD_BYTES
|
|
43
|
+
}) {
|
|
44
|
+
if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > MAX_WORKERS_OBJECT_UPLOAD_BYTES) {
|
|
45
|
+
throw new Error("object-store: maxBytes must fit the Cloudflare Workers request limit");
|
|
46
|
+
}
|
|
47
|
+
return async (request) => {
|
|
48
|
+
if (request.method !== "PUT") {
|
|
49
|
+
return new Response("Method not allowed", { status: 405, headers: { Allow: "PUT" } });
|
|
50
|
+
}
|
|
51
|
+
let auth;
|
|
52
|
+
try {
|
|
53
|
+
auth = await authorize({ request });
|
|
54
|
+
} catch {
|
|
55
|
+
return uploadError(503, "authorization_unavailable", "Upload authorization unavailable");
|
|
56
|
+
}
|
|
57
|
+
if (!auth.ok) return auth.response;
|
|
58
|
+
const filename = new URL(request.url).searchParams.get("filename");
|
|
59
|
+
if (!filename || filename.length > 255 || !request.body) {
|
|
60
|
+
return uploadError(400, "invalid_upload", "A filename and file body are required");
|
|
61
|
+
}
|
|
62
|
+
const contentType = request.headers.get("Content-Type") || "application/octet-stream";
|
|
63
|
+
if (contentType.toLowerCase().startsWith("multipart/form-data")) {
|
|
64
|
+
return uploadError(415, "raw_body_required", "Send one raw file body");
|
|
65
|
+
}
|
|
66
|
+
const browserLength = request.headers.get("X-Upload-Length");
|
|
67
|
+
const transportLength = request.headers.get("Content-Length");
|
|
68
|
+
if (browserLength !== null && transportLength !== null && browserLength !== transportLength) {
|
|
69
|
+
return uploadError(400, "invalid_length", "Conflicting upload lengths");
|
|
70
|
+
}
|
|
71
|
+
const lengthHeader = browserLength ?? transportLength;
|
|
72
|
+
if (lengthHeader === null) {
|
|
73
|
+
return uploadError(411, "length_required", "X-Upload-Length is required");
|
|
74
|
+
}
|
|
75
|
+
if (!/^[1-9]\d*$/.test(lengthHeader)) {
|
|
76
|
+
return uploadError(400, "invalid_length", "Invalid Content-Length");
|
|
77
|
+
}
|
|
78
|
+
const declaredLength = Number(lengthHeader);
|
|
79
|
+
if (!Number.isSafeInteger(declaredLength)) {
|
|
80
|
+
return uploadError(400, "invalid_length", "Invalid Content-Length");
|
|
81
|
+
}
|
|
82
|
+
if (declaredLength > maxBytes) {
|
|
83
|
+
return uploadError(413, "upload_too_large", "File exceeds upload limit");
|
|
84
|
+
}
|
|
85
|
+
let key;
|
|
86
|
+
try {
|
|
87
|
+
key = objectKey({
|
|
88
|
+
operatorId: auth.operatorId,
|
|
89
|
+
customerId: auth.customerId,
|
|
90
|
+
uploadId: crypto.randomUUID(),
|
|
91
|
+
filename
|
|
92
|
+
});
|
|
93
|
+
} catch {
|
|
94
|
+
return uploadError(503, "invalid_owner_scope", "Upload owner scope unavailable");
|
|
95
|
+
}
|
|
96
|
+
let size = 0;
|
|
97
|
+
let exceeded = false;
|
|
98
|
+
let bodyComplete = false;
|
|
99
|
+
const boundedBody = request.body.pipeThrough(new TransformStream({
|
|
100
|
+
transform(chunk, controller) {
|
|
101
|
+
if (size + chunk.byteLength > maxBytes) {
|
|
102
|
+
exceeded = true;
|
|
103
|
+
throw new Error("object-store: upload exceeded byte limit");
|
|
104
|
+
}
|
|
105
|
+
size += chunk.byteLength;
|
|
106
|
+
controller.enqueue(chunk);
|
|
107
|
+
},
|
|
108
|
+
flush() {
|
|
109
|
+
bodyComplete = true;
|
|
110
|
+
}
|
|
111
|
+
}));
|
|
112
|
+
try {
|
|
113
|
+
await store.put(key, boundedBody, { contentType, contentLength: declaredLength });
|
|
114
|
+
const stored = await store.head(key);
|
|
115
|
+
if (bodyComplete && size > 0 && stored?.size === size && size === declaredLength) {
|
|
116
|
+
return Response.json({ key, size, contentType }, { status: 201 });
|
|
117
|
+
}
|
|
118
|
+
} catch {
|
|
119
|
+
}
|
|
120
|
+
try {
|
|
121
|
+
await store.delete(key);
|
|
122
|
+
} catch {
|
|
123
|
+
return uploadError(503, "upload_cleanup_failed", "Upload cleanup failed");
|
|
124
|
+
}
|
|
125
|
+
if (exceeded) return uploadError(413, "upload_too_large", "File exceeds upload limit");
|
|
126
|
+
if (size > declaredLength || bodyComplete && size !== declaredLength) {
|
|
127
|
+
return uploadError(400, "invalid_length", "Upload length does not match file body");
|
|
128
|
+
}
|
|
129
|
+
return uploadError(503, "upload_storage_failed", "Upload could not be stored");
|
|
130
|
+
};
|
|
131
|
+
}
|
|
132
|
+
function assertSafeKeySegment(s) {
|
|
133
|
+
if (s.length === 0) throw new Error("object-store: empty key segment");
|
|
134
|
+
if (s.includes("..")) throw new Error(`object-store: unsafe key segment (contains "..") \u2014 ${s}`);
|
|
135
|
+
if (s.includes("/")) throw new Error(`object-store: unsafe key segment (contains "/") \u2014 ${s}`);
|
|
136
|
+
if (s.includes("\\")) throw new Error(`object-store: unsafe key segment (backslash) \u2014 ${s}`);
|
|
137
|
+
return s;
|
|
138
|
+
}
|
|
139
|
+
function sanitizeFilename(filename) {
|
|
140
|
+
const leaf = filename.split(/[/\\]/).pop() ?? "";
|
|
141
|
+
const cleaned = leaf.replace(/[^A-Za-z0-9._-]/g, "_").replace(/^\.+/, "");
|
|
142
|
+
return cleaned.length > 0 ? cleaned : "file";
|
|
143
|
+
}
|
|
144
|
+
function objectKey({ operatorId, customerId, uploadId, filename }) {
|
|
145
|
+
const operator = assertSafeKeySegment(operatorId);
|
|
146
|
+
const customer = customerId == null ? "_unattributed" : assertSafeKeySegment(customerId);
|
|
147
|
+
const upload = assertSafeKeySegment(uploadId);
|
|
148
|
+
return `${operator}/${customer}/${upload}-${sanitizeFilename(filename)}`;
|
|
149
|
+
}
|
|
150
|
+
function canonicalizeObjectKey(raw) {
|
|
151
|
+
let decoded;
|
|
152
|
+
try {
|
|
153
|
+
decoded = decodeURIComponent(raw);
|
|
154
|
+
} catch {
|
|
155
|
+
throw new Error("object-store: malformed key encoding");
|
|
156
|
+
}
|
|
157
|
+
for (const segment of decoded.split("/")) assertSafeKeySegment(segment);
|
|
158
|
+
return decoded;
|
|
159
|
+
}
|
|
160
|
+
function signingMessage(canonicalKey, exp) {
|
|
161
|
+
return JSON.stringify({ v: 1, exp, key: canonicalKey });
|
|
162
|
+
}
|
|
163
|
+
async function signObjectUrl({ key, exp, secret }) {
|
|
164
|
+
if (!secret) throw new Error("object-store: signObjectUrl requires a non-empty secret (fail-closed)");
|
|
165
|
+
const canonical = canonicalizeObjectKey(key);
|
|
166
|
+
const sig = await hmacSha256Base64Url(signingMessage(canonical, exp), secret);
|
|
167
|
+
const params = new URLSearchParams({ key: canonical, exp: String(exp), sig });
|
|
168
|
+
return `?${params.toString()}`;
|
|
169
|
+
}
|
|
170
|
+
async function verifyObjectUrl(request, { secret }) {
|
|
171
|
+
if (!secret) return { ok: false };
|
|
172
|
+
const url = new URL(request.url);
|
|
173
|
+
const rawKey = url.searchParams.get("key");
|
|
174
|
+
const expRaw = url.searchParams.get("exp");
|
|
175
|
+
const sig = url.searchParams.get("sig");
|
|
176
|
+
if (!rawKey || !expRaw || !sig) return { ok: false };
|
|
177
|
+
let key;
|
|
178
|
+
try {
|
|
179
|
+
key = canonicalizeObjectKey(rawKey);
|
|
180
|
+
} catch {
|
|
181
|
+
return { ok: false };
|
|
182
|
+
}
|
|
183
|
+
const exp = Number(expRaw);
|
|
184
|
+
if (!Number.isFinite(exp)) return { ok: false };
|
|
185
|
+
const expected = await hmacSha256Base64Url(signingMessage(key, exp), secret);
|
|
186
|
+
if (!constantTimeEqual(expected, sig)) return { ok: false };
|
|
187
|
+
if (Date.now() > exp) return { ok: false };
|
|
188
|
+
return { ok: true, key };
|
|
189
|
+
}
|
|
190
|
+
function createProxiedArtifactRoute({
|
|
191
|
+
store,
|
|
192
|
+
secret
|
|
193
|
+
}) {
|
|
194
|
+
return async (request) => {
|
|
195
|
+
const rawKey = new URL(request.url).searchParams.get("key");
|
|
196
|
+
if (!rawKey) return new Response("Missing key", { status: 400 });
|
|
197
|
+
try {
|
|
198
|
+
canonicalizeObjectKey(rawKey);
|
|
199
|
+
} catch {
|
|
200
|
+
return new Response("Malformed key", { status: 400 });
|
|
201
|
+
}
|
|
202
|
+
const verified = await verifyObjectUrl(request, { secret });
|
|
203
|
+
if (!verified.ok) return new Response("Forbidden", { status: 403 });
|
|
204
|
+
const obj = await store.get(verified.key);
|
|
205
|
+
if (!obj) return new Response("Not found", { status: 404 });
|
|
206
|
+
const headers = {
|
|
207
|
+
"Content-Type": "application/octet-stream",
|
|
208
|
+
"Content-Disposition": "attachment",
|
|
209
|
+
"X-Content-Type-Options": "nosniff"
|
|
210
|
+
};
|
|
211
|
+
if (Number.isFinite(obj.size) && obj.size >= 0) headers["Content-Length"] = String(obj.size);
|
|
212
|
+
return new Response(obj.stream(), { status: 200, headers });
|
|
213
|
+
};
|
|
214
|
+
}
|
|
215
|
+
|
|
216
|
+
export {
|
|
217
|
+
createR2ObjectStore,
|
|
218
|
+
DEFAULT_MAX_OBJECT_UPLOAD_BYTES,
|
|
219
|
+
MAX_WORKERS_OBJECT_UPLOAD_BYTES,
|
|
220
|
+
createObjectUploadRoute,
|
|
221
|
+
assertSafeKeySegment,
|
|
222
|
+
objectKey,
|
|
223
|
+
signObjectUrl,
|
|
224
|
+
verifyObjectUrl,
|
|
225
|
+
createProxiedArtifactRoute
|
|
226
|
+
};
|
|
227
|
+
//# sourceMappingURL=chunk-6DOQ6T2O.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"sources":["../src/object-store/index.ts"],"sourcesContent":["/**\n * `/object-store` — a portable, secure object store for durable large\n * attachments (uploaded PDFs, images, exports) that are too big to ride a chat\n * turn body or live in KV.\n *\n * SECURITY POSTURE (this module guards a legal privilege wall). Every object key\n * carries an operator segment and a customer segment, and access is by a\n * short-lived HMAC-signed URL whose signature covers the EXACT key (operator +\n * customer + upload id + filename) AND the expiry. A tampered key, a swapped\n * customer segment, or a replayed-after-expiry URL all fail the signature or the\n * expiry check and are refused. The signing secret is a PARAMETER on every call\n * — this module reads NOTHING global (no `process.env`, no ambient config); if a\n * product forgets to bind the secret, {@link verifyObjectUrl} fails closed and\n * {@link signObjectUrl} throws rather than minting an unsigned URL.\n *\n * PURE MECHANISM behind two seams: an {@link ObjectStore} port (the R2 impl maps\n * 1:1 to a bucket held behind the structural {@link R2LikeBucket} — so\n * `@cloudflare/workers-types` never leaks into this package's public `.d.ts`)\n * and the signing `secret`. Reads and writes STREAM: {@link createR2ObjectStore}\n * returns the R2 object's `.body` stream directly and never calls\n * `.text()`/`.arrayBuffer()`, so a 15 MB PDF flows through the worker without\n * buffering the whole file into the isolate's heap.\n *\n * RECONCILIATION with the sandbox `storage` seam (`../sandbox` →\n * `SandboxRuntimeConfig.storage`): that is BYOS3/R2 *snapshot* storage — it\n * checkpoints and restores a sandbox box's filesystem for durable session\n * execution. This is a DIFFERENT concern: a content-addressed store for\n * user-facing attachments gated by a signed-URL privilege wall. They are not\n * interchangeable and must not be merged: one persists agent runtime state, the\n * other serves per-operator/per-customer documents to browsers. Do not route\n * artifact downloads through the snapshot bucket, or vice versa.\n */\n\nimport { constantTimeEqual, hmacSha256Base64Url } from '../crypto/web-token'\n\n// ── The store port + R2 impl ────────────────────────────────────────────────\n\n/** Options for a single {@link ObjectStore.put}. Both fields are optional; a\n * store that needs a fixed content length (e.g. R2 with a `ReadableStream`\n * body) uses `contentLength` when present. */\nexport interface PutObjectOptions {\n /** MIME type recorded with the object (returned by `get`/`head`). Advisory:\n * the proxied download route always serves `application/octet-stream`. */\n contentType?: string\n /** Byte length of `body`, when known. The R2 adapter wraps a stream in the\n * Workers `FixedLengthStream` when this is supplied. */\n contentLength?: number\n}\n\n/** A retrieved object. `stream()` is the ONLY way to read the bytes — there is\n * deliberately no `text()`/`arrayBuffer()`, so a large object never buffers\n * into the isolate heap. */\nexport interface ObjectBody {\n /** The object's bytes as a `ReadableStream` (backed by R2's `.body`). */\n stream(): ReadableStream\n /** Size in bytes. */\n size: number\n /** Recorded MIME type, if any. */\n contentType?: string\n}\n\n/**\n * Portable object-store port. `get`/`head` return `null` on a miss and NEVER\n * throw for a missing key (a miss is a normal control-flow outcome, not an\n * error); `delete` is idempotent.\n */\nexport interface ObjectStore {\n put(key: string, body: ReadableStream | Uint8Array, opts?: PutObjectOptions): Promise<void>\n /** `null` on a miss — never throws for a missing key. */\n get(key: string): Promise<ObjectBody | null>\n /** `null` on a miss — never throws for a missing key. */\n head(key: string): Promise<{ size: number; contentType?: string } | null>\n delete(key: string): Promise<void>\n}\n\n/** Head/metadata shape of a stored object (structural match of R2's `R2Object`). */\nexport interface R2LikeObjectHead {\n size: number\n httpMetadata?: { contentType?: string }\n}\n\n/** Body shape of a retrieved object (structural match of R2's `R2ObjectBody`).\n * `body` is the streamed content — the impl reads this, never `.text()`. */\nexport interface R2LikeObjectBody extends R2LikeObjectHead {\n body: ReadableStream\n}\n\n/**\n * The minimal slice of Cloudflare's `R2Bucket` this module calls. A real\n * `R2Bucket` satisfies it structurally, so the consumer passes its binding\n * without this package ever importing `@cloudflare/workers-types` (which would\n * otherwise leak into the public `.d.ts`).\n */\nexport interface R2LikeBucket {\n put(\n key: string,\n value: ReadableStream | Uint8Array | ArrayBuffer,\n options?: { httpMetadata?: { contentType?: string } },\n ): Promise<unknown>\n get(key: string): Promise<R2LikeObjectBody | null>\n head(key: string): Promise<R2LikeObjectHead | null>\n delete(key: string): Promise<void>\n}\n\n/**\n * Map the {@link ObjectStore} port onto an R2 bucket 1:1. `get` STREAMS: it\n * returns the R2 object's `.body` behind `ObjectBody.stream()` and never calls\n * `.text()`/`.arrayBuffer()`, so a large file flows through the worker rather\n * than buffering into the isolate.\n */\nexport function createR2ObjectStore({ bucket }: { bucket: R2LikeBucket }): ObjectStore {\n return {\n async put(key, body, opts) {\n const options = opts?.contentType ? { httpMetadata: { contentType: opts.contentType } } : undefined\n const fixedLengthStream = (globalThis as typeof globalThis & {\n FixedLengthStream?: new (length: number) => TransformStream<Uint8Array, Uint8Array>\n }).FixedLengthStream\n const value = body instanceof ReadableStream && opts?.contentLength !== undefined && fixedLengthStream\n ? body.pipeThrough(new fixedLengthStream(opts.contentLength))\n : body\n await bucket.put(key, value, options)\n },\n async get(key) {\n const obj = await bucket.get(key)\n if (!obj) return null\n return {\n stream: () => obj.body,\n size: obj.size,\n contentType: obj.httpMetadata?.contentType,\n }\n },\n async head(key) {\n const obj = await bucket.head(key)\n if (!obj) return null\n return { size: obj.size, contentType: obj.httpMetadata?.contentType }\n },\n async delete(key) {\n await bucket.delete(key)\n },\n }\n}\n\n/** Default ceiling for a single raw-body object upload. Consumers may opt into\n * a higher ceiling only after proving their deployed request path and store. */\nexport const DEFAULT_MAX_OBJECT_UPLOAD_BYTES = 25 * 1024 * 1024\n\n/** The minimum Cloudflare zone request-body ceiling is 100 MB decimal.\n * Larger route limits cannot work reliably through a Workers ingress. */\nexport const MAX_WORKERS_OBJECT_UPLOAD_BYTES = 100_000_000\n\nexport type ObjectUploadAuthorization =\n | { ok: true; operatorId: string; customerId?: string }\n | { ok: false; response: Response }\n\nexport interface CreateObjectUploadRouteOptions {\n store: ObjectStore\n /** Resolve identity and upload permission from authenticated server context.\n * Never return an operator or customer chosen by the request body. */\n authorize(args: { request: Request }): Promise<ObjectUploadAuthorization>\n maxBytes?: number\n}\n\nfunction uploadError(status: number, code: string, message: string): Response {\n return Response.json({ error: { code, message } }, { status })\n}\n\n/**\n * Create a PUT handler for one raw file body. The filename is the `filename`\n * query parameter; the bytes are `request.body`, never multipart form data.\n * `X-Upload-Length` carries the browser File.size; `Content-Length` works for\n * non-browser callers. A declared length lets R2 receive a fixed-length stream.\n * The route checks actual bytes and rejects conflicting declared lengths.\n * The server supplies owner scope, and a fresh upload id prevents cleanup from\n * deleting an earlier object. The returned key can be stored in product data;\n * reads still require a separately signed URL.\n */\nexport function createObjectUploadRoute({\n store,\n authorize,\n maxBytes = DEFAULT_MAX_OBJECT_UPLOAD_BYTES,\n}: CreateObjectUploadRouteOptions): (request: Request) => Promise<Response> {\n if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > MAX_WORKERS_OBJECT_UPLOAD_BYTES) {\n throw new Error('object-store: maxBytes must fit the Cloudflare Workers request limit')\n }\n\n return async (request) => {\n if (request.method !== 'PUT') {\n return new Response('Method not allowed', { status: 405, headers: { Allow: 'PUT' } })\n }\n\n let auth: ObjectUploadAuthorization\n try {\n auth = await authorize({ request })\n } catch {\n return uploadError(503, 'authorization_unavailable', 'Upload authorization unavailable')\n }\n if (!auth.ok) return auth.response\n\n const filename = new URL(request.url).searchParams.get('filename')\n if (!filename || filename.length > 255 || !request.body) {\n return uploadError(400, 'invalid_upload', 'A filename and file body are required')\n }\n\n const contentType = request.headers.get('Content-Type') || 'application/octet-stream'\n if (contentType.toLowerCase().startsWith('multipart/form-data')) {\n return uploadError(415, 'raw_body_required', 'Send one raw file body')\n }\n\n const browserLength = request.headers.get('X-Upload-Length')\n const transportLength = request.headers.get('Content-Length')\n if (browserLength !== null && transportLength !== null && browserLength !== transportLength) {\n return uploadError(400, 'invalid_length', 'Conflicting upload lengths')\n }\n const lengthHeader = browserLength ?? transportLength\n if (lengthHeader === null) {\n return uploadError(411, 'length_required', 'X-Upload-Length is required')\n }\n if (!/^[1-9]\\d*$/.test(lengthHeader)) {\n return uploadError(400, 'invalid_length', 'Invalid Content-Length')\n }\n const declaredLength = Number(lengthHeader)\n if (!Number.isSafeInteger(declaredLength)) {\n return uploadError(400, 'invalid_length', 'Invalid Content-Length')\n }\n if (declaredLength > maxBytes) {\n return uploadError(413, 'upload_too_large', 'File exceeds upload limit')\n }\n\n let key: string\n try {\n key = objectKey({\n operatorId: auth.operatorId,\n customerId: auth.customerId,\n uploadId: crypto.randomUUID(),\n filename,\n })\n } catch {\n return uploadError(503, 'invalid_owner_scope', 'Upload owner scope unavailable')\n }\n\n let size = 0\n let exceeded = false\n let bodyComplete = false\n const boundedBody = request.body.pipeThrough(new TransformStream<Uint8Array, Uint8Array>({\n transform(chunk, controller) {\n if (size + chunk.byteLength > maxBytes) {\n exceeded = true\n throw new Error('object-store: upload exceeded byte limit')\n }\n size += chunk.byteLength\n controller.enqueue(chunk)\n },\n flush() {\n bodyComplete = true\n },\n }))\n\n try {\n await store.put(key, boundedBody, { contentType, contentLength: declaredLength })\n const stored = await store.head(key)\n if (bodyComplete && size > 0 && stored?.size === size && size === declaredLength) {\n return Response.json({ key, size, contentType }, { status: 201 })\n }\n } catch {\n // A backend may have committed bytes before rejecting the stream.\n }\n\n try {\n await store.delete(key)\n } catch {\n return uploadError(503, 'upload_cleanup_failed', 'Upload cleanup failed')\n }\n if (exceeded) return uploadError(413, 'upload_too_large', 'File exceeds upload limit')\n if (size > declaredLength || (bodyComplete && size !== declaredLength)) {\n return uploadError(400, 'invalid_length', 'Upload length does not match file body')\n }\n return uploadError(503, 'upload_storage_failed', 'Upload could not be stored')\n }\n}\n\n// ── Key construction + safety ───────────────────────────────────────────────\n\n/**\n * Assert a single object-key path SEGMENT (an operator id, customer id, or\n * upload id) is safe to interpolate into a key, and return it. Throws on the\n * traversal / injection shapes: `..` anywhere, ANY `/` (a segment must be a\n * single path component — a leading, interior, or trailing slash all widen the\n * key by injecting extra levels), a backslash, or an empty segment. Consumers\n * should call this on caller-supplied identifiers BEFORE any `get`/`put` so an\n * attacker-controlled id can never widen the key beyond its own operator+\n * customer prefix.\n */\nexport function assertSafeKeySegment(s: string): string {\n if (s.length === 0) throw new Error('object-store: empty key segment')\n if (s.includes('..')) throw new Error(`object-store: unsafe key segment (contains \"..\") — ${s}`)\n // Reject ANY '/' — leading, interior, or trailing. A key segment is a single\n // path component; an interior slash (`a/b`) would silently add a key level and\n // widen the operator/customer prefix, so it is refused just like a leading one.\n if (s.includes('/')) throw new Error(`object-store: unsafe key segment (contains \"/\") — ${s}`)\n if (s.includes('\\\\')) throw new Error(`object-store: unsafe key segment (backslash) — ${s}`)\n return s\n}\n\n/** Strip a filename down to a safe leaf: drop any path, keep only\n * `[A-Za-z0-9._-]`, and remove leading dots so a `..`/`.hidden`/dot-only name\n * can neither traverse nor vanish. Never returns an empty string. */\nfunction sanitizeFilename(filename: string): string {\n const leaf = filename.split(/[/\\\\]/).pop() ?? ''\n const cleaned = leaf.replace(/[^A-Za-z0-9._-]/g, '_').replace(/^\\.+/, '')\n return cleaned.length > 0 ? cleaned : 'file'\n}\n\n/** Inputs to {@link objectKey}. `customerId` is optional — an unattributed\n * upload lands under the reserved `_unattributed` customer segment. */\nexport interface ObjectKeyParts {\n operatorId: string\n /** Optional — omitted/undefined groups the upload under `_unattributed`. */\n customerId?: string\n uploadId: string\n filename: string\n}\n\n/**\n * Build the canonical object key: `operator/customer/upload-filename`. The\n * operator, customer, and upload segments are asserted safe (throwing on\n * traversal); the filename is sanitized to a safe leaf. The customer segment\n * falls back to `_unattributed` when no customer is attributed. Because a signed\n * URL binds the EXACT key, the operator and customer segments are part of the\n * privilege wall — a caller cannot later swap them without breaking the\n * signature.\n */\nexport function objectKey({ operatorId, customerId, uploadId, filename }: ObjectKeyParts): string {\n const operator = assertSafeKeySegment(operatorId)\n const customer = customerId == null ? '_unattributed' : assertSafeKeySegment(customerId)\n const upload = assertSafeKeySegment(uploadId)\n return `${operator}/${customer}/${upload}-${sanitizeFilename(filename)}`\n}\n\n/**\n * Decode a key ONCE and assert every `/`-delimited segment is safe. Slash- and\n * percent-encoded forms of the same key canonicalize identically (`a/b` and\n * `a%2Fb` both → `a/b`), so a signature binds the key's MEANING, not its\n * on-the-wire spelling. Throws on malformed percent-encoding or an unsafe\n * segment. Our own keys never contain `%`, so the single decode is idempotent.\n */\nfunction canonicalizeObjectKey(raw: string): string {\n let decoded: string\n try {\n decoded = decodeURIComponent(raw)\n } catch {\n throw new Error('object-store: malformed key encoding')\n }\n for (const segment of decoded.split('/')) assertSafeKeySegment(segment)\n return decoded\n}\n\n// ── Signed URLs ─────────────────────────────────────────────────────────────\n\n/** The exact string the signature covers: a versioned JSON of the canonical key\n * and the expiry. JSON escaping makes it delimiter-injection-proof (a key\n * cannot forge the `exp` field). Both sign and verify build it identically. */\nfunction signingMessage(canonicalKey: string, exp: number): string {\n return JSON.stringify({ v: 1, exp, key: canonicalKey })\n}\n\n/** Arguments to {@link signObjectUrl}. */\nexport interface SignObjectUrlArgs {\n /** The exact object key to authorize (from {@link objectKey}). */\n key: string\n /** Absolute expiry in epoch MILLISECONDS (e.g. `Date.now() + 5 * 60_000` for a\n * ~5-minute TTL — the recommended default; keep it short). */\n exp: number\n /** HMAC signing secret. Must be non-empty — signing fails closed otherwise. */\n secret: string\n}\n\n/**\n * Mint a signed query string (`?key=…&exp=…&sig=…`) authorizing a download of\n * `key` until `exp`. The product appends it to its artifact route path\n * (`` `/artifacts${await signObjectUrl(...)}` ``); {@link createProxiedArtifactRoute}\n * / {@link verifyObjectUrl} read it straight off the request URL, so the route's\n * own mount path never matters.\n *\n * FAIL-CLOSED: throws if `secret` is empty (never mints an unsigned URL) and if\n * `key` is unsafe (traversal). Async because the HMAC primitive is WebCrypto.\n *\n * TTL: `exp` is caller-supplied on purpose (the caller knows the sensitivity);\n * keep it SHORT — ~5 minutes is the recommended default for a privilege-walled\n * document.\n */\nexport async function signObjectUrl({ key, exp, secret }: SignObjectUrlArgs): Promise<string> {\n if (!secret) throw new Error('object-store: signObjectUrl requires a non-empty secret (fail-closed)')\n const canonical = canonicalizeObjectKey(key)\n const sig = await hmacSha256Base64Url(signingMessage(canonical, exp), secret)\n const params = new URLSearchParams({ key: canonical, exp: String(exp), sig })\n return `?${params.toString()}`\n}\n\n/** Result of {@link verifyObjectUrl}: the canonical key on success, nothing\n * distinguishing on failure (so a rejection leaks no detail). */\nexport type VerifyObjectUrlResult = { ok: true; key: string } | { ok: false }\n\n/**\n * Verify a signed download request. Reads `key`/`exp`/`sig` off the request URL,\n * canonicalizes the key identically to the signer, recomputes the HMAC and\n * constant-time-compares it, and checks the expiry. Returns the canonical key on\n * success.\n *\n * FAIL-CLOSED everywhere: an empty `secret`, a missing/ malformed parameter, a\n * non-finite expiry, a signature mismatch, or an expired URL all return\n * `{ ok: false }` — and the mismatch path uses a constant-time compare so a\n * near-correct signature is not distinguishable by timing. Async because the\n * HMAC primitive is WebCrypto.\n */\nexport async function verifyObjectUrl(\n request: Request,\n { secret }: { secret: string },\n): Promise<VerifyObjectUrlResult> {\n if (!secret) return { ok: false }\n const url = new URL(request.url)\n const rawKey = url.searchParams.get('key')\n const expRaw = url.searchParams.get('exp')\n const sig = url.searchParams.get('sig')\n if (!rawKey || !expRaw || !sig) return { ok: false }\n\n let key: string\n try {\n key = canonicalizeObjectKey(rawKey)\n } catch {\n return { ok: false }\n }\n\n const exp = Number(expRaw)\n if (!Number.isFinite(exp)) return { ok: false }\n\n const expected = await hmacSha256Base64Url(signingMessage(key, exp), secret)\n if (!constantTimeEqual(expected, sig)) return { ok: false }\n // Signature is valid; enforce expiry last so the constant-time compare always\n // runs (an expired-but-otherwise-valid URL is refused just the same).\n if (Date.now() > exp) return { ok: false }\n return { ok: true, key }\n}\n\n// ── Proxied download route ──────────────────────────────────────────────────\n\n/**\n * Build a download handler that verifies a signed request and STREAMS the object\n * back with a conservative, non-executable content type. Status contract:\n *\n * - `400` — the `key` is missing or malformed (bad encoding / traversal). This\n * is an unauthenticated client error and leaks NOTHING about object existence.\n * - `403` — the signature is missing, wrong, or expired.\n * - `404` — the signature was valid but no object exists at that key (existence\n * is only ever revealed to a validly-signed request).\n * - `200` — streams the bytes with `Content-Disposition: attachment`,\n * `Content-Type: application/octet-stream`, and `X-Content-Type-Options:\n * nosniff`, so the worker never serves active/inline content.\n */\nexport function createProxiedArtifactRoute({\n store,\n secret,\n}: {\n store: ObjectStore\n secret: string\n}): (request: Request) => Promise<Response> {\n return async (request) => {\n // 1. Malformed/missing key → 400, decided BEFORE auth so it leaks no\n // existence signal (a malformed key can never carry a valid signature).\n const rawKey = new URL(request.url).searchParams.get('key')\n if (!rawKey) return new Response('Missing key', { status: 400 })\n try {\n canonicalizeObjectKey(rawKey)\n } catch {\n return new Response('Malformed key', { status: 400 })\n }\n\n // 2. Bad / expired signature → 403.\n const verified = await verifyObjectUrl(request, { secret })\n if (!verified.ok) return new Response('Forbidden', { status: 403 })\n\n // 3. Fetch by the VERIFIED canonical key. Miss → 404 (only reachable behind\n // a valid signature). Hit → stream with a conservative content type.\n const obj = await store.get(verified.key)\n if (!obj) return new Response('Not found', { status: 404 })\n\n const headers: Record<string, string> = {\n 'Content-Type': 'application/octet-stream',\n 'Content-Disposition': 'attachment',\n 'X-Content-Type-Options': 'nosniff',\n }\n if (Number.isFinite(obj.size) && obj.size >= 0) headers['Content-Length'] = String(obj.size)\n return new Response(obj.stream(), { status: 200, headers })\n }\n}\n"],"mappings":"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","names":[]}
|
|
@@ -50,7 +50,7 @@ import {
|
|
|
50
50
|
} from "./chunk-B7CL7ENS.js";
|
|
51
51
|
import {
|
|
52
52
|
attachmentPartsFromMessageParts
|
|
53
|
-
} from "./chunk-
|
|
53
|
+
} from "./chunk-2YLSWZ5W.js";
|
|
54
54
|
import {
|
|
55
55
|
TURN_PHASE_EVENT,
|
|
56
56
|
isTurnPhaseEvent,
|
|
@@ -8939,4 +8939,4 @@ export {
|
|
|
8939
8939
|
useThinkingSeconds,
|
|
8940
8940
|
ChatMessages
|
|
8941
8941
|
};
|
|
8942
|
-
//# sourceMappingURL=chunk-
|
|
8942
|
+
//# sourceMappingURL=chunk-6LPQRKH7.js.map
|
|
@@ -4,20 +4,10 @@ import {
|
|
|
4
4
|
import {
|
|
5
5
|
parseJsonObjectBody
|
|
6
6
|
} from "./chunk-3NCPXNBZ.js";
|
|
7
|
-
import {
|
|
8
|
-
normalizeClientTurnId,
|
|
9
|
-
resolveChatTurn
|
|
10
|
-
} from "./chunk-YG66IHDU.js";
|
|
11
|
-
import {
|
|
12
|
-
coalesceDeltas,
|
|
13
|
-
createBufferedTurnTap,
|
|
14
|
-
replayTurnEvents,
|
|
15
|
-
stampReplaySeq
|
|
16
|
-
} from "./chunk-X4OMULP5.js";
|
|
17
7
|
import {
|
|
18
8
|
mentionInputToPart,
|
|
19
9
|
toChatMessageParts
|
|
20
|
-
} from "./chunk-
|
|
10
|
+
} from "./chunk-2YLSWZ5W.js";
|
|
21
11
|
import {
|
|
22
12
|
ChatTurnInputError,
|
|
23
13
|
TURN_PROGRESS_FIRST,
|
|
@@ -30,6 +20,16 @@ import {
|
|
|
30
20
|
parseFileMentions,
|
|
31
21
|
turnResponseEventFor
|
|
32
22
|
} from "./chunk-6E7LKHYV.js";
|
|
23
|
+
import {
|
|
24
|
+
normalizeClientTurnId,
|
|
25
|
+
resolveChatTurn
|
|
26
|
+
} from "./chunk-YG66IHDU.js";
|
|
27
|
+
import {
|
|
28
|
+
coalesceDeltas,
|
|
29
|
+
createBufferedTurnTap,
|
|
30
|
+
replayTurnEvents,
|
|
31
|
+
stampReplaySeq
|
|
32
|
+
} from "./chunk-JGZ7WEPL.js";
|
|
33
33
|
|
|
34
34
|
// src/chat-routes/draft-persistence.ts
|
|
35
35
|
var CONTENT_EVENT_TYPES = /* @__PURE__ */ new Set([
|
|
@@ -1177,4 +1177,4 @@ export {
|
|
|
1177
1177
|
createChatTurnRoutes,
|
|
1178
1178
|
streamChatRouteAsSandboxEvents
|
|
1179
1179
|
};
|
|
1180
|
-
//# sourceMappingURL=chunk-
|
|
1180
|
+
//# sourceMappingURL=chunk-CZ7KLS7N.js.map
|
|
@@ -318,10 +318,17 @@ function createD1TurnEventStore(db, options = {}) {
|
|
|
318
318
|
const { results } = await db.prepare("SELECT seq, event FROM turn_events WHERE turnId = ? AND seq > ? ORDER BY seq ASC").bind(turnId, fromSeq).all();
|
|
319
319
|
return results;
|
|
320
320
|
},
|
|
321
|
-
async setStatus(turnId, status, scopeId) {
|
|
321
|
+
async setStatus(turnId, status, scopeId, options2 = {}) {
|
|
322
|
+
const at = new Date(now()).toISOString();
|
|
323
|
+
if (options2.onlyIfRunningBefore !== void 0) {
|
|
324
|
+
await db.prepare(
|
|
325
|
+
`UPDATE turn_status SET status = ?, scopeId = COALESCE(?, scopeId)${options2.preserveUpdatedAt ? "" : ", updatedAt = ?"} WHERE turnId = ? AND status = 'running' AND updatedAt < ?`
|
|
326
|
+
).bind(...[status, scopeId ?? null, ...options2.preserveUpdatedAt ? [] : [at], turnId, new Date(options2.onlyIfRunningBefore).toISOString()]).run();
|
|
327
|
+
return;
|
|
328
|
+
}
|
|
322
329
|
await db.prepare(
|
|
323
|
-
|
|
324
|
-
).bind(turnId, status, scopeId ?? null,
|
|
330
|
+
`INSERT INTO turn_status (turnId, status, scopeId, updatedAt) VALUES (?, ?, ?, ?) ON CONFLICT(turnId) DO UPDATE SET status = excluded.status, scopeId = COALESCE(excluded.scopeId, turn_status.scopeId)${options2.preserveUpdatedAt ? "" : ", updatedAt = excluded.updatedAt"}`
|
|
331
|
+
).bind(turnId, status, scopeId ?? null, at).run();
|
|
325
332
|
},
|
|
326
333
|
async getStatus(turnId) {
|
|
327
334
|
const row = await db.prepare("SELECT status FROM turn_status WHERE turnId = ?").bind(turnId).first();
|
|
@@ -376,11 +383,16 @@ function createMemoryTurnEventStore(options = {}) {
|
|
|
376
383
|
async read(turnId, fromSeq) {
|
|
377
384
|
return (events.get(turnId) ?? []).filter((e) => e.seq > fromSeq);
|
|
378
385
|
},
|
|
379
|
-
async setStatus(turnId, s, scopeId) {
|
|
386
|
+
async setStatus(turnId, s, scopeId, options2 = {}) {
|
|
387
|
+
if (options2.onlyIfRunningBefore !== void 0) {
|
|
388
|
+
const stale = status.get(turnId) === "running" && (updatedAt.get(turnId) ?? Number.POSITIVE_INFINITY) < options2.onlyIfRunningBefore;
|
|
389
|
+
if (!stale) return;
|
|
390
|
+
}
|
|
391
|
+
const existed = status.has(turnId);
|
|
380
392
|
status.set(turnId, s);
|
|
381
393
|
if (scopeId) scopes.set(turnId, scopeId);
|
|
382
394
|
if (!order.includes(turnId)) order.push(turnId);
|
|
383
|
-
updatedAt.set(turnId, now());
|
|
395
|
+
if (!(options2.preserveUpdatedAt && existed)) updatedAt.set(turnId, now());
|
|
384
396
|
},
|
|
385
397
|
async getStatus(turnId) {
|
|
386
398
|
return status.get(turnId) ?? null;
|
|
@@ -445,4 +457,4 @@ export {
|
|
|
445
457
|
createD1TurnEventStore,
|
|
446
458
|
createMemoryTurnEventStore
|
|
447
459
|
};
|
|
448
|
-
//# sourceMappingURL=chunk-
|
|
460
|
+
//# sourceMappingURL=chunk-JGZ7WEPL.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"sources":["../src/stream/turn-buffer.ts"],"sourcesContent":["/**\n * Resumable chat turns — the router-path answer to \"streams resume on\n * disconnect\" (issue #27). A turn's loop events are teed into a store as they\n * stream; the turn keeps running under `ctx.waitUntil` when the client drops;\n * a reconnecting client replays the buffered tail by sequence number and\n * keeps following until the turn completes.\n *\n * POST /chat/stream → pumpBufferedTurn(...) + live NDJSON\n * GET /chat/stream/:turnId → replayTurnEvents({ fromSeq }) → NDJSON\n *\n * Storage is a structural seam ({@link TurnEventStore}); a D1 implementation\n * ships here because that's what Cloudflare products have (KV is unsuitable:\n * eventually consistent cross-isolate). Per-token deltas would mean hundreds\n * of rows per turn, so consecutive text/reasoning deltas are coalesced within\n * a flush window before they are persisted — replay yields slightly chunkier\n * deltas with identical concatenation.\n */\n\nexport type TurnStatus = 'running' | 'complete' | 'error'\n\n/** A running row is a renewable lease, not permanent truth. If the process\n * driving a turn dies before writing a terminal status, reconnect discovery\n * must eventually stop returning that abandoned row. */\nexport const DEFAULT_RUNNING_TURN_LEASE_MS = 5 * 60_000\n\n/** Keep a healthy turn's lease comfortably ahead of expiry without turning\n * per-token streaming into status-write traffic. */\nexport const DEFAULT_RUNNING_TURN_RENEW_INTERVAL_MS = 30_000\n\n/** Represent a buffered turn event with a sequence number and serialized event data */\nexport interface BufferedTurnEvent {\n seq: number\n /** The serialized event line (JSON string, no trailing newline). */\n event: string\n}\n\n/** Manage and query turn events and their lifecycle statuses within a scoped event store */\nexport interface TurnEventStore {\n /**\n * Append rows while the turn is live. Implementations must ignore rows that\n * arrive after `setStatus` publishes `complete` or `error`; the terminal\n * status is the replay fence for a detached live projection.\n */\n append(turnId: string, events: BufferedTurnEvent[]): Promise<void>\n read(turnId: string, fromSeq: number): Promise<BufferedTurnEvent[]>\n /** Record turn lifecycle. `scopeId` (a thread/session id) is optional and lets\n * {@link TurnEventStore.listRunning} rediscover this turn after a client reload\n * loses the turnId; stores that don't track scope ignore it. */\n setStatus(turnId: string, status: TurnStatus, scopeId?: string, options?: TurnStatusWriteOptions): Promise<void>\n getStatus(turnId: string): Promise<TurnStatus | null>\n /** Unexpired running turnIds for a scope, newest first — so a reloaded client\n * (clientRunId lost) can find and resume the in-flight turn without reviving\n * a row abandoned by a dead process. Optional: a store records it only if\n * `setStatus` was given a `scopeId`. */\n listRunning?(scopeId: string): Promise<string[]>\n /** Remove one turn's buffered events and keep its status, so a genuine\n * re-stream after a crash starts at seq 0 without interleaving orphaned\n * rows. `runDetachedTurn` requires it to recover a `running` turn. */\n resetEvents?(turnId: string): Promise<void>\n /** Explicitly remove one turn's events and status. Optional so existing\n * custom stores remain source-compatible; the built-in D1 and memory stores\n * provide it. */\n deleteTurn?(turnId: string): Promise<void>\n /** Remove terminal turns whose status was updated before `before` (Unix\n * milliseconds or a Date). Running turns are never eligible. */\n pruneTerminalTurns?(before: number | Date): Promise<number>\n}\n\n/**\n * Settling a stream nothing produces any more. A sweep that ends an orphaned\n * stream must not move it in time, since reports place a stream by its update\n * time, and must not end one whose producer came back meanwhile.\n */\nexport interface TurnStatusWriteOptions {\n /** Keep the row's update time; a new row still takes the current time. */\n preserveUpdatedAt?: boolean\n /** Write only when the row is still `running` and was last updated before this time (Unix ms). */\n onlyIfRunningBefore?: number\n}\n\n/** Configure running-turn lease evaluation. The clock is injectable so store\n * contract tests do not sleep. Keep the default in production unless a\n * deployment also tunes the buffer's renewal interval. */\nexport interface TurnEventStoreOptions {\n runningTurnLeaseMs?: number\n now?: () => number\n}\n\n// ── coalescing ────────────────────────────────────────────────────────────\n\ntype AnyRecord = Record<string, unknown>\n\nfunction deltaTypeOf(ev: unknown): 'text' | 'reasoning' | null {\n const e = ev as AnyRecord | null\n if (!e || typeof e !== 'object') return null\n const inner = (e.kind === 'event' ? (e.event as AnyRecord | undefined) : e) as AnyRecord | undefined\n if (!inner || typeof inner !== 'object') return null\n if ((inner.type === 'text' || inner.type === 'reasoning') && typeof inner.text === 'string') {\n return inner.type\n }\n return null\n}\n\nfunction innerOf(ev: unknown): AnyRecord | null {\n const e = ev as AnyRecord | null\n if (!e || typeof e !== 'object') return null\n const inner = (e.kind === 'event' ? e.event : e) as AnyRecord | undefined\n return inner && typeof inner === 'object' ? inner : null\n}\n\n/**\n * The key of a live-state event whose latest value supersedes earlier ones:\n * the model-processing heartbeat, and a harness's raw update of a text or\n * reasoning part (it carries the part's whole state, keyed by part id). Null\n * for every other event.\n */\nfunction liveStateKeyOf(ev: unknown): string | null {\n const inner = innerOf(ev)\n if (!inner) return null\n if (inner.type === 'model-processing') return 'model-processing'\n if (inner.type !== 'raw') return null\n const raw = (inner.data as AnyRecord | undefined)?.event as AnyRecord | undefined\n const part = raw?.part as AnyRecord | undefined\n if ((raw?.type === 'text' || raw?.type === 'reasoning') && typeof part?.id === 'string') return `raw:${part.id}`\n return null\n}\n\n/** Whether an event only projects live progress, so it may wait for the flush window and be coalesced. */\nexport function isLiveProgressEvent(ev: unknown): boolean {\n return deltaTypeOf(ev) !== null || liveStateKeyOf(ev) !== null\n}\n\n/**\n * Merge text and reasoning deltas of the same type into one event, across the\n * live-state events a harness interleaves with them, and keep only the latest\n * of each live-state event. A reasoning model streams three events per token\n * (its raw part update, a model-processing heartbeat and the delta); merging\n * only adjacent deltas wrote all three as rows (2026-10-10: 1.63 M rows in a\n * day, 59,659 in one turn). Any other event is a boundary nothing merges\n * across. Concatenation-preserving: replaying the coalesced stream produces\n * the same accumulated text, and the latest state of every part.\n */\nexport function coalesceDeltas(events: unknown[]): unknown[] {\n const out: unknown[] = []\n let run: { type: 'text' | 'reasoning'; index: number } | null = null\n let stateSlots = new Map<string, number>()\n for (const ev of events) {\n const type = deltaTypeOf(ev)\n if (type) {\n if (run && run.type === type) {\n const merged = JSON.parse(JSON.stringify(out[run.index])) as AnyRecord\n innerOf(merged)!.text = String(innerOf(out[run.index])!.text) + String(innerOf(ev)!.text)\n out[run.index] = merged\n } else {\n out.push(ev)\n run = { type, index: out.length - 1 }\n }\n continue\n }\n const key = liveStateKeyOf(ev)\n if (key) {\n const slot = stateSlots.get(key)\n if (slot === undefined) {\n out.push(ev)\n stateSlots.set(key, out.length - 1)\n } else {\n out[slot] = ev\n }\n continue\n }\n out.push(ev)\n run = null\n stateSlots = new Map()\n }\n return out\n}\n\nfunction asPartUpdate(ev: unknown): { partId: unknown; delta: unknown } | null {\n const e = ev as AnyRecord | null\n if (!e || typeof e !== 'object' || e.type !== 'message.part.updated') return null\n const data = e.data as AnyRecord | undefined\n if (!data || typeof data !== 'object') return null\n const part = data.part as AnyRecord | undefined\n const partId = part?.id ?? data.partId ?? part?.partId ?? null\n return { partId, delta: data.delta }\n}\n\n/**\n * Coalesce consecutive `message.part.updated` deltas for the SAME part into one\n * event. agent-runtime products stream `ChatStreamEvent` NDJSON\n * (`{type:'message.part.updated', data:{part, delta}}`); pumped through the\n * buffer with the default tool-loop coalescer, every per-token delta persists as\n * its own row because that coalescer never recognizes the shape. Pass this as\n * {@link PumpBufferedTurnOptions.coalesce} instead.\n *\n * Concatenation-preserving for BOTH consumer styles: the merged event keeps the\n * LATEST event's `data.part` (already the cumulative accumulation) and sets\n * `data.delta` to the concatenation of the merged deltas, so a client that\n * appends `delta` and one that reads the cumulative `part` both reconstruct the\n * identical final text.\n */\nexport function coalesceChatStreamEvents(events: unknown[]): unknown[] {\n const out: unknown[] = []\n for (const ev of events) {\n const cur = asPartUpdate(ev)\n const prevEv = out[out.length - 1]\n const prev = prevEv ? asPartUpdate(prevEv) : null\n if (cur && prev && cur.partId != null && cur.partId === prev.partId) {\n // Base the merged row on the latest event (its `part` is the most complete\n // accumulation); carry forward the summed delta.\n const merged = JSON.parse(JSON.stringify(ev)) as AnyRecord\n ;(merged.data as AnyRecord).delta = String(prev.delta ?? '') + String(cur.delta ?? '')\n out[out.length - 1] = merged\n continue\n }\n out.push(ev)\n }\n return out\n}\n\n// ── buffering core (the tap) ────────────────────────────────────────────────\n\n/** Define options for buffering and flushing turn events with optional live client delivery and event coalescing */\nexport interface BufferedTurnOptions {\n store: TurnEventStore\n turnId: string\n /** Deliver one serialized line to the live client. Throwing here (client\n * disconnected) does NOT stop buffering — events keep persisting. */\n write?: (line: string) => Promise<void> | void\n /** Flush buffered events to the store at most this often. Default 400ms. */\n flushIntervalMs?: number\n /** Flush window once a durable owner has taken the turn ({@link BufferedTurnTap.detach}). Live-progress events\n * wait for it; any other event flushes at once, after them. Default 2000ms. */\n detachedFlushIntervalMs?: number\n /** Per-flush coalescer. Default {@link coalesceDeltas} (tool-loop text/reasoning\n * deltas). agent-runtime products streaming `ChatStreamEvent` pass\n * {@link coalesceChatStreamEvents} so per-token deltas don't each persist as a\n * row. Must be concatenation-preserving. */\n coalesce?: (events: unknown[]) => unknown[]\n /** Optional scope (thread/session id) recorded with the turn status, so\n * {@link TurnEventStore.listRunning} can find this turn after a reload. */\n scopeId?: string\n /** How often to renew the running-turn lease while a producer is alive.\n * The timer is backed up by event-driven renewal when a runtime freezes\n * unreferenced timers during remote I/O. Default\n * {@link DEFAULT_RUNNING_TURN_RENEW_INTERVAL_MS}. */\n runningTurnRenewIntervalMs?: number\n}\n\n/** A push-driven buffer for a turn whose producer the caller does NOT own. */\nexport interface BufferedTurnTap {\n /** Buffer one event: persist (coalesced, on the flush window) + best-effort\n * live-deliver. Wire to a push source's per-event hook (e.g. agent-runtime\n * `handleChatTurn`'s `hooks.onEvent`). Marks the turn 'running' on first call. */\n onEvent(raw: unknown): Promise<void>\n /** Settle the turn: final flush + set status. Call after the producer resolves\n * ('complete') or rejects ('error'). 'error' flushes what was produced first. */\n done(status?: Extract<TurnStatus, 'complete' | 'error'>): Promise<void>\n /**\n * Give terminal-status ownership to an external durable runner. Stops this\n * tap's running-lease renewal and flushes its current projection, but keeps\n * `onEvent` available as an append-only live-observation path. After the\n * handoff, an event that is not live progress (a marker, interaction, tool\n * event, error or terminal event) flushes before `onEvent` returns, so a\n * durable owner cannot publish terminal status ahead of it; live progress\n * (deltas, heartbeats, raw part updates) is coalesced over\n * `detachedFlushIntervalMs`. Call it again when observation ends to flush any\n * final event.\n *\n * A caller MUST have registered that durable owner before detaching: this\n * method intentionally writes no replacement status.\n */\n detach(): Promise<void>\n}\n\n/**\n * The buffering core. Sequence-numbers every event, delivers it to `write`\n * (best-effort — a disconnected client never stops buffering), and flushes to\n * the store in coalesced batches. Drives both transports:\n *\n * • {@link pumpBufferedTurn} — when you OWN an `AsyncIterable` producer.\n * • this tap (`onEvent`/`done`) — when the producer owns iteration and only\n * hands you a push callback (agent-runtime `handleChatTurn`'s `hooks.onEvent`\n * + the finished body). Durability stays here in the shell; the engine needs\n * no `TurnEventStore` seam.\n */\n/** Serialized characters of pending events that force a flush before the window ends. */\nconst MAX_PENDING_CHARS = 64 * 1024\n\nexport function createBufferedTurnTap(opts: BufferedTurnOptions): BufferedTurnTap {\n const flushIntervalMs = opts.flushIntervalMs ?? 400\n const detachedFlushIntervalMs = opts.detachedFlushIntervalMs ?? 2000\n let pendingChars = 0\n const coalesce = opts.coalesce ?? coalesceDeltas\n const startedAt = Date.now()\n let seq = 0\n let clientGone = false\n let pending: unknown[] = []\n let lastFlush = Date.now()\n let started = false\n let settled = false\n let detached = false\n let renewalTimer: ReturnType<typeof setTimeout> | undefined\n let renewal: Promise<void> = Promise.resolve()\n let lastRenewedAt = 0\n const runningTurnRenewIntervalMs = Math.max(\n 1,\n opts.runningTurnRenewIntervalMs ?? DEFAULT_RUNNING_TURN_RENEW_INTERVAL_MS,\n )\n\n function clearRenewalTimer(): void {\n if (renewalTimer !== undefined) clearTimeout(renewalTimer)\n renewalTimer = undefined\n }\n\n function scheduleRenewal(): void {\n if (settled || detached || !opts.scopeId) return\n clearRenewalTimer()\n const elapsedMs = Math.max(0, Date.now() - lastRenewedAt)\n const delayMs = Math.max(1, runningTurnRenewIntervalMs - elapsedMs)\n renewalTimer = setTimeout(() => {\n renewalTimer = undefined\n void renewLease()\n }, delayMs)\n // A deliberately abandoned tap in a Node test must not keep the process\n // alive until the production renewal interval elapses.\n if (typeof renewalTimer === 'object' && 'unref' in renewalTimer) {\n renewalTimer.unref()\n }\n }\n\n async function renewLease(): Promise<void> {\n if (settled || detached || !opts.scopeId) return\n clearRenewalTimer()\n lastRenewedAt = Date.now()\n renewal = renewal\n .then(() => opts.store.setStatus(opts.turnId, 'running', opts.scopeId))\n .catch(() => {})\n await renewal\n scheduleRenewal()\n }\n\n async function flush(): Promise<void> {\n if (pending.length === 0) return\n const batch = coalesce(pending)\n pending = []\n pendingChars = 0\n const rows = batch.map((ev) => ({ seq: ++seq, event: JSON.stringify(ev) }))\n await opts.store.append(opts.turnId, rows)\n lastFlush = Date.now()\n }\n\n async function ensureStarted(): Promise<void> {\n if (started) return\n started = true\n // An external durable owner may have detached before the first observed\n // event. It owns status from that point, so this tap must never resurrect\n // its running lease.\n if (detached) return\n await opts.store.setStatus(opts.turnId, 'running', opts.scopeId)\n lastRenewedAt = Date.now()\n scheduleRenewal()\n }\n\n return {\n async onEvent(raw) {\n await ensureStarted()\n // Cloudflare may freeze an unreferenced timer while a producer is\n // awaiting remote I/O. A real event (including the route heartbeat)\n // therefore also renews any lease whose interval has elapsed.\n if (\n !detached &&\n opts.scopeId &&\n Date.now() - lastRenewedAt >= runningTurnRenewIntervalMs\n ) {\n await renewLease()\n }\n // Stamp ms-since-turn-start so any stored turn is replayable AND traceable\n // (see ../trace) from the same buffered rows.\n const ev = raw && typeof raw === 'object' ? { ...(raw as Record<string, unknown>), _t: Date.now() - startedAt } : raw\n const line = JSON.stringify(ev)\n pending.push(ev)\n pendingChars += line?.length ?? 0\n if (!clientGone && opts.write) {\n try {\n // Live delivery carries a provisional ordering hint, not the persisted\n // seq (coalescing changes seq assignment); clients resume with the\n // seqs from replay, or 0 for \"everything\".\n await opts.write(line)\n } catch {\n clientGone = true\n }\n }\n // Once detached, a turn marker, interaction, tool event, error or terminal event persists at once (with the\n // progress before it), and live progress waits for the window, so a reasoning model's per-token events do\n // not each become a row. An external owner's terminal status can fence at most the last window of progress.\n const due = detached\n ? !isLiveProgressEvent(ev) || Date.now() - lastFlush >= detachedFlushIntervalMs\n : Date.now() - lastFlush >= flushIntervalMs\n if (due || pendingChars >= MAX_PENDING_CHARS) await flush()\n },\n async done(status = 'complete') {\n await ensureStarted()\n if (detached) {\n await flush()\n return\n }\n settled = true\n clearRenewalTimer()\n await renewal\n if (status === 'error') {\n await flush().catch(() => {})\n await opts.store.setStatus(opts.turnId, 'error', opts.scopeId).catch(() => {})\n return\n }\n await flush()\n await opts.store.setStatus(opts.turnId, 'complete', opts.scopeId)\n },\n async detach() {\n detached = true\n clearRenewalTimer()\n // A renewal already queued before detach may be writing `running`. Wait\n // for it before returning so the durable owner can safely publish a\n // terminal status after the awaited handoff.\n await renewal\n await flush()\n },\n }\n}\n\n// ── pump (producer side) ──────────────────────────────────────────────────\n\n/** Define options to pump data from an asynchronous iterable source with buffered turn control */\nexport interface PumpBufferedTurnOptions extends BufferedTurnOptions {\n source: AsyncIterable<unknown>\n}\n\n/**\n * Drive a turn to completion regardless of the live client, when you OWN the\n * producer as an `AsyncIterable`. A thin driver over {@link createBufferedTurnTap}.\n * Returns a promise that resolves when the turn finishes — hand it to\n * `ctx.waitUntil` so a disconnect can't kill the turn. Never rejects on\n * client-write failure; a source error marks the turn 'error' (after flushing\n * what was produced) and rethrows.\n */\nexport async function pumpBufferedTurn(opts: PumpBufferedTurnOptions): Promise<void> {\n const tap = createBufferedTurnTap(opts)\n try {\n for await (const raw of opts.source) await tap.onEvent(raw)\n await tap.done('complete')\n } catch (err) {\n await tap.done('error')\n throw err\n }\n}\n\n// ── replay (consumer side) ────────────────────────────────────────────────\n\n/** Define options for replaying turn events with control over sequence, polling, and timeout */\nexport interface ReplayTurnEventsOptions {\n store: TurnEventStore\n turnId: string\n /** Replay strictly after this sequence number (0 = from the beginning). */\n fromSeq?: number\n /** Poll cadence while the turn is still running. Default 500ms. */\n pollMs?: number\n /** Give up following a 'running' turn after this long. Default 120s. */\n timeoutMs?: number\n}\n\n/**\n * Yield buffered events after `fromSeq`, then keep polling while the turn is\n * still 'running' until it completes, errors, or times out. Terminates with a\n * final `{seq: -1, event: '{\"type\":\"turn_status\",...}'}` marker so clients\n * know why the replay ended.\n */\nexport async function* replayTurnEvents(opts: ReplayTurnEventsOptions): AsyncGenerator<BufferedTurnEvent> {\n const pollMs = opts.pollMs ?? 500\n const timeoutMs = opts.timeoutMs ?? 120_000\n let cursor = opts.fromSeq ?? 0\n const deadline = Date.now() + timeoutMs\n\n for (;;) {\n const batch = await opts.store.read(opts.turnId, cursor)\n for (const row of batch) {\n cursor = Math.max(cursor, row.seq)\n yield row\n }\n const status = await opts.store.getStatus(opts.turnId)\n if (status !== 'running') {\n // Writers flush before publishing terminal status; include rows committed after the first read.\n yield* await opts.store.read(opts.turnId, cursor)\n yield { seq: -1, event: JSON.stringify({ type: 'turn_status', status: status ?? 'unknown' }) }\n return\n }\n if (Date.now() >= deadline) {\n yield { seq: -1, event: JSON.stringify({ type: 'turn_status', status: 'timeout' }) }\n return\n }\n await new Promise((r) => setTimeout(r, pollMs))\n }\n}\n\n/**\n * Serialize a replayed row for the wire, stamping the buffer ordinal ONTO the\n * line so a reconnecting client can continue from `?fromSeq=<lastSeq>`.\n *\n * The seq lives on the {@link BufferedTurnEvent} row wrapper, not inside the\n * serialized event — `flush()` builds `{seq: ++seq, event: JSON.stringify(ev)}`.\n * A route that enqueues `row.event` alone therefore emits lines with no seq at\n * all, and every client cursor silently pins to 0: each reconnect refetches the\n * whole turn and re-applies every delta onto already-rendered state. This\n * restores the contract `web-react/chat-stream` already documents (\"replayed\n * lines carry an extra `seq` — transparently ignored\").\n *\n * The `{seq: -1}` `turn_status` sentinel is passed through unstamped: it is a\n * terminator, not a cursor position, and stamping it would move a client's\n * cursor to -1.\n *\n * Fail-soft by construction — a line that is not a JSON object passes through\n * verbatim. A stamping bug must degrade to today's behaviour, never break a\n * replay.\n */\nexport function stampReplaySeq(row: BufferedTurnEvent): string {\n if (row.seq <= 0) return row.event\n const line = row.event\n // Cheap splice instead of parse+stringify: these rows are already canonical\n // JSON objects from `JSON.stringify`, and replay is a hot per-event path.\n if (line.charCodeAt(0) !== 0x7b /* { */) return line\n const rest = line.slice(1)\n return rest.trimStart().startsWith('}')\n ? `{\"seq\":${row.seq}${rest}`\n : `{\"seq\":${row.seq},${rest}`\n}\n\n// ── D1 store ──────────────────────────────────────────────────────────────\n\n/** A bound D1 statement used by the turn store. */\nexport interface D1BoundForTurns {\n run(): Promise<unknown>\n all<T = Record<string, unknown>>(): Promise<{ results: T[] }>\n first<T = Record<string, unknown>>(): Promise<T | null>\n}\n\n/** Minimal structural D1 contract (Cloudflare `D1Database` satisfies it). */\nexport interface D1LikeForTurns {\n prepare(sql: string): {\n bind(...values: unknown[]): D1BoundForTurns\n }\n /** D1's only atomic primitive. Retention refuses a driver without it rather\n * than deleting events and status in separate, reorderable requests. */\n batch?(statements: D1BoundForTurns[]): Promise<unknown[]>\n}\n\nfunction normalizeTurnCutoff(before: number | Date): { milliseconds: number; iso: string } {\n const milliseconds = before instanceof Date ? before.getTime() : before\n if (!Number.isFinite(milliseconds)) {\n throw new RangeError('turn retention cutoff must be a finite Unix-millisecond timestamp or a valid Date')\n }\n const date = new Date(milliseconds)\n if (!Number.isFinite(date.getTime())) {\n throw new RangeError('turn retention cutoff is outside the supported Date range')\n }\n return { milliseconds, iso: date.toISOString() }\n}\n\nasync function runAtomicTurnBatch(\n db: D1LikeForTurns,\n statements: D1BoundForTurns[],\n): Promise<unknown[]> {\n if (typeof db.batch !== 'function') {\n throw new Error('turn retention requires D1 batch() for atomic deletion')\n }\n return db.batch(statements)\n}\n\nfunction changesFromD1Result(result: unknown): number {\n if (!result || typeof result !== 'object') return 0\n const meta = (result as { meta?: unknown }).meta\n if (meta && typeof meta === 'object') {\n const changes = (meta as { changes?: unknown }).changes\n if (typeof changes === 'number' && Number.isFinite(changes)) return changes\n }\n const changes = (result as { changes?: unknown }).changes\n return typeof changes === 'number' && Number.isFinite(changes) ? changes : 0\n}\n\n/** Schema for the D1 store — append to the product's migrations. */\nexport const TURN_EVENTS_MIGRATION_SQL = `\nCREATE TABLE IF NOT EXISTS turn_events (\n turnId TEXT NOT NULL,\n seq INTEGER NOT NULL,\n event TEXT NOT NULL,\n PRIMARY KEY (turnId, seq)\n);\nCREATE TABLE IF NOT EXISTS turn_status (\n turnId TEXT PRIMARY KEY,\n status TEXT NOT NULL,\n scopeId TEXT,\n updatedAt TEXT NOT NULL\n);\nCREATE INDEX IF NOT EXISTS idx_turn_status_scope ON turn_status (scopeId, status);\nCREATE INDEX IF NOT EXISTS idx_turn_status_retention ON turn_status (status, updatedAt);\n`\n\n/** For deployments whose `turn_status` table predates `scopeId`/`listRunning` —\n * run once to add the column (the CREATE above already includes it for new\n * deployments). SQLite ignores a duplicate-add error if already applied. */\nexport const TURN_STATUS_SCOPE_MIGRATION_SQL = `ALTER TABLE turn_status ADD COLUMN scopeId TEXT;`\n\n/** Run once before using `createD1PlanFollowUpGate`: it adds the lease column\n * the gate fences its claims on. Stores that never take follow-up claims do\n * not need it, so the base turn tables leave it out. */\nexport const TURN_STATUS_LEASE_MIGRATION_SQL = 'ALTER TABLE turn_status ADD COLUMN leaseToken TEXT;'\n\n/** For deployments that already have the turn tables, add the index used by\n * terminal-turn retention without rerunning the table migration. */\nexport const TURN_STATUS_RETENTION_MIGRATION_SQL = 'CREATE INDEX IF NOT EXISTS idx_turn_status_retention ON turn_status (status, updatedAt);'\n\n/** Resolve a TurnEventStore that appends and reads turn events using a D1-like database interface */\n/** 100 D1 variables per statement, three per row. */\nconst D1_APPEND_CHUNK = 33\n\nexport function createD1TurnEventStore(\n db: D1LikeForTurns,\n options: TurnEventStoreOptions = {},\n): TurnEventStore {\n const now = options.now ?? Date.now\n const runningTurnLeaseMs = Math.max(\n 1,\n options.runningTurnLeaseMs ?? DEFAULT_RUNNING_TURN_LEASE_MS,\n )\n return {\n async append(turnId, events) {\n if (!events.length) return\n // One multi-row insert per flush window keeps write volume bounded, but\n // D1 caps a statement at 100 bound variables, so a burst of more than 33\n // events (a subagent finishing, a long tool result) failed the whole\n // flush with `D1_ERROR: too many SQL variables` and killed the turn.\n // Rows are appended in order across chunks; a partial failure leaves a\n // prefix, which the ordered `seq` column already tolerates on replay.\n for (let start = 0; start < events.length; start += D1_APPEND_CHUNK) {\n const chunk = events.slice(start, start + D1_APPEND_CHUNK)\n const placeholders = chunk.map(() => '(?, ?, ?)').join(', ')\n const values = chunk.flatMap((e) => [turnId, e.seq, e.event])\n await db\n .prepare(\n `WITH pending(turnId, seq, event) AS (VALUES ${placeholders})\n INSERT OR IGNORE INTO turn_events (turnId, seq, event)\n SELECT pending.turnId, pending.seq, pending.event\n FROM pending\n WHERE NOT EXISTS (\n SELECT 1 FROM turn_status\n WHERE turn_status.turnId = pending.turnId\n AND turn_status.status IN ('complete', 'error')\n )`,\n )\n .bind(...values)\n .run()\n }\n },\n async read(turnId, fromSeq) {\n const { results } = await db\n .prepare('SELECT seq, event FROM turn_events WHERE turnId = ? AND seq > ? ORDER BY seq ASC')\n .bind(turnId, fromSeq)\n .all<{ seq: number; event: string }>()\n return results\n },\n async setStatus(turnId, status, scopeId, options = {}) {\n const at = new Date(now()).toISOString()\n if (options.onlyIfRunningBefore !== undefined) {\n // A guarded write never creates a row: it settles one that exists, is running and is stale.\n await db\n .prepare(\n `UPDATE turn_status SET status = ?, scopeId = COALESCE(?, scopeId)${options.preserveUpdatedAt ? '' : ', updatedAt = ?'} WHERE turnId = ? AND status = 'running' AND updatedAt < ?`,\n )\n .bind(...[status, scopeId ?? null, ...(options.preserveUpdatedAt ? [] : [at]), turnId, new Date(options.onlyIfRunningBefore).toISOString()])\n .run()\n return\n }\n // COALESCE preserves a scopeId set on the initial 'running' write when a\n // later 'complete'/'error' write passes none.\n await db\n .prepare(\n `INSERT INTO turn_status (turnId, status, scopeId, updatedAt) VALUES (?, ?, ?, ?) ON CONFLICT(turnId) DO UPDATE SET status = excluded.status, scopeId = COALESCE(excluded.scopeId, turn_status.scopeId)${options.preserveUpdatedAt ? '' : ', updatedAt = excluded.updatedAt'}`,\n )\n .bind(turnId, status, scopeId ?? null, at)\n .run()\n },\n async getStatus(turnId) {\n const row = await db.prepare('SELECT status FROM turn_status WHERE turnId = ?').bind(turnId).first<{ status: TurnStatus }>()\n return row?.status ?? null\n },\n async listRunning(scopeId) {\n const { results } = await db\n .prepare(\n \"SELECT turnId FROM turn_status WHERE scopeId = ? AND status = 'running' AND updatedAt >= ? ORDER BY updatedAt DESC, rowid DESC\",\n )\n .bind(scopeId, new Date(now() - runningTurnLeaseMs).toISOString())\n .all<{ turnId: string }>()\n return results.map((r) => r.turnId)\n },\n async resetEvents(turnId) {\n await db.prepare('DELETE FROM turn_events WHERE turnId = ?').bind(turnId).run()\n },\n async deleteTurn(turnId) {\n await runAtomicTurnBatch(db, [\n db.prepare('DELETE FROM turn_events WHERE turnId = ?').bind(turnId),\n db.prepare('DELETE FROM turn_status WHERE turnId = ?').bind(turnId),\n ])\n },\n async pruneTerminalTurns(before) {\n const cutoff = normalizeTurnCutoff(before)\n const terminalBefore = \"status IN ('complete', 'error') AND updatedAt < ?\"\n const results = await runAtomicTurnBatch(db, [\n db\n .prepare(\n `DELETE FROM turn_events WHERE turnId IN (SELECT turnId FROM turn_status WHERE ${terminalBefore})`,\n )\n .bind(cutoff.iso),\n db.prepare(`DELETE FROM turn_status WHERE ${terminalBefore}`).bind(cutoff.iso),\n ])\n return changesFromD1Result(results[1])\n },\n }\n}\n\n/** In-memory store for tests and keyless local dev. */\nexport function createMemoryTurnEventStore(\n options: TurnEventStoreOptions = {},\n): TurnEventStore {\n const events = new Map<string, BufferedTurnEvent[]>()\n const status = new Map<string, TurnStatus>()\n const scopes = new Map<string, string>()\n const order: string[] = []\n const updatedAt = new Map<string, number>()\n const now = options.now ?? Date.now\n const runningTurnLeaseMs = Math.max(\n 1,\n options.runningTurnLeaseMs ?? DEFAULT_RUNNING_TURN_LEASE_MS,\n )\n return {\n async append(turnId, rows) {\n if (status.get(turnId) === 'complete' || status.get(turnId) === 'error') return\n const list = events.get(turnId) ?? []\n list.push(...rows)\n events.set(turnId, list)\n },\n async read(turnId, fromSeq) {\n return (events.get(turnId) ?? []).filter((e) => e.seq > fromSeq)\n },\n async setStatus(turnId, s, scopeId, options = {}) {\n if (options.onlyIfRunningBefore !== undefined) {\n const stale = status.get(turnId) === 'running' && (updatedAt.get(turnId) ?? Number.POSITIVE_INFINITY) < options.onlyIfRunningBefore\n if (!stale) return\n }\n const existed = status.has(turnId)\n status.set(turnId, s)\n if (scopeId) scopes.set(turnId, scopeId)\n if (!order.includes(turnId)) order.push(turnId)\n if (!(options.preserveUpdatedAt && existed)) updatedAt.set(turnId, now())\n },\n async getStatus(turnId) {\n return status.get(turnId) ?? null\n },\n async listRunning(scopeId) {\n const cutoff = now() - runningTurnLeaseMs\n return order\n .filter(\n (turnId) =>\n status.get(turnId) === 'running' &&\n scopes.get(turnId) === scopeId &&\n (updatedAt.get(turnId) ?? Number.NEGATIVE_INFINITY) >= cutoff,\n )\n .sort((left, right) => {\n const updatedDelta = (updatedAt.get(right) ?? 0) - (updatedAt.get(left) ?? 0)\n return updatedDelta || order.indexOf(right) - order.indexOf(left)\n })\n },\n async resetEvents(turnId) {\n events.delete(turnId)\n },\n async deleteTurn(turnId) {\n events.delete(turnId)\n status.delete(turnId)\n scopes.delete(turnId)\n updatedAt.delete(turnId)\n const index = order.indexOf(turnId)\n if (index >= 0) order.splice(index, 1)\n },\n async pruneTerminalTurns(before) {\n const cutoff = normalizeTurnCutoff(before).milliseconds\n const removable = order.filter((turnId) => {\n const s = status.get(turnId)\n return (s === 'complete' || s === 'error') && (updatedAt.get(turnId) ?? Number.POSITIVE_INFINITY) < cutoff\n })\n for (const turnId of removable) {\n events.delete(turnId)\n status.delete(turnId)\n scopes.delete(turnId)\n updatedAt.delete(turnId)\n }\n if (removable.length) {\n const removed = new Set(removable)\n for (let i = order.length - 1; i >= 0; i--) {\n if (removed.has(order[i]!)) order.splice(i, 1)\n }\n }\n return removable.length\n },\n }\n}\n"],"mappings":"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","names":["changes","options"]}
|