@moinulmoin/eden-runtime-cloudflare 0.1.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.
Files changed (48) hide show
  1. package/LICENSE +201 -0
  2. package/NOTICE +42 -0
  3. package/dist/artifact-runtime.d.ts +27 -0
  4. package/dist/artifact-runtime.js +14 -0
  5. package/dist/eden-eve-host-worker.mjs +1960 -0
  6. package/dist/eve-host-runtime.d.ts +46 -0
  7. package/dist/eve-host-runtime.js +127 -0
  8. package/dist/eve-host.d.ts +166 -0
  9. package/dist/eve-host.js +495 -0
  10. package/dist/http-host.d.ts +6 -0
  11. package/dist/http-host.js +419 -0
  12. package/dist/index.d.ts +21 -0
  13. package/dist/index.js +7 -0
  14. package/dist/model-adapter-internal.d.ts +12 -0
  15. package/dist/model-adapter-internal.js +172 -0
  16. package/dist/model-adapter.d.ts +9 -0
  17. package/dist/model-adapter.js +56 -0
  18. package/dist/model-contracts.d.ts +92 -0
  19. package/dist/model-contracts.js +2 -0
  20. package/dist/model-normalizers.d.ts +7 -0
  21. package/dist/model-normalizers.js +453 -0
  22. package/dist/session-checkpoint.d.ts +48 -0
  23. package/dist/session-checkpoint.js +300 -0
  24. package/dist/session-identity.d.ts +9 -0
  25. package/dist/session-identity.js +45 -0
  26. package/dist/session-jobs.d.ts +69 -0
  27. package/dist/session-jobs.js +427 -0
  28. package/dist/session-journal.d.ts +154 -0
  29. package/dist/session-journal.js +391 -0
  30. package/dist/session-schema.d.ts +21 -0
  31. package/dist/session-schema.js +247 -0
  32. package/dist/session-state.d.ts +165 -0
  33. package/dist/session-state.js +168 -0
  34. package/dist/session.d.ts +40 -0
  35. package/dist/session.js +792 -0
  36. package/dist/test-execution.d.ts +8 -0
  37. package/dist/test-execution.js +12 -0
  38. package/dist/test-worker.d.ts +12 -0
  39. package/dist/test-worker.js +214 -0
  40. package/dist/tool-harness.d.ts +31 -0
  41. package/dist/tool-harness.js +226 -0
  42. package/dist/turn-runner-storage.d.ts +28 -0
  43. package/dist/turn-runner-storage.js +583 -0
  44. package/dist/turn-runner-types.d.ts +112 -0
  45. package/dist/turn-runner-types.js +21 -0
  46. package/dist/turn-runner.d.ts +6 -0
  47. package/dist/turn-runner.js +370 -0
  48. package/package.json +51 -0
@@ -0,0 +1,583 @@
1
+ import { commitSessionTransaction, MAX_JOURNAL_EVENTS_PER_PAGE, readJournalEventsPage, readLatestJournalCursor, } from "./session-journal.js";
2
+ import { MAX_BOUNDED_TURN_ATTEMPTS, finalResponseStepId, modelProjectionKey, modelToolStepId, now, } from "./turn-runner-types.js";
3
+ function readTurn(sql, sessionId, turnId) {
4
+ return sql
5
+ .exec(`SELECT turn_id, status, error_id
6
+ FROM turns
7
+ WHERE session_id = ? AND turn_id = ?`, sessionId, turnId)
8
+ .toArray()[0];
9
+ }
10
+ function readAssistantMessage(sql, sessionId, turnId) {
11
+ return sql
12
+ .exec(`SELECT message_id, role, content, completed_at
13
+ FROM messages
14
+ WHERE session_id = ? AND turn_id = ? AND role = 'assistant'
15
+ ORDER BY created_at DESC, message_id DESC
16
+ LIMIT 1`, sessionId, turnId)
17
+ .toArray()[0];
18
+ }
19
+ function readStep(sql, sessionId, stepId) {
20
+ return sql
21
+ .exec(`SELECT step_id, turn_id, logical_key, phase, status, attempt_count,
22
+ error_id
23
+ FROM steps
24
+ WHERE session_id = ? AND step_id = ?`, sessionId, stepId)
25
+ .toArray()[0];
26
+ }
27
+ function readError(sql, sessionId, errorId) {
28
+ if (errorId === null)
29
+ return undefined;
30
+ return sql
31
+ .exec(`SELECT error_id, code, message, retryable
32
+ FROM errors
33
+ WHERE session_id = ? AND error_id = ?`, sessionId, errorId)
34
+ .toArray()[0];
35
+ }
36
+ function storedFailureForStep(sql, sessionId, step) {
37
+ const error = readError(sql, sessionId, step.error_id);
38
+ if (error !== undefined) {
39
+ return {
40
+ code: error.code,
41
+ message: error.message,
42
+ retryable: error.retryable === 1,
43
+ stepId: step.step_id,
44
+ };
45
+ }
46
+ return {
47
+ code: "turn_runner_invalid",
48
+ message: "Turn step failed.",
49
+ retryable: false,
50
+ stepId: step.step_id,
51
+ };
52
+ }
53
+ export function readProjection(sql, sessionId, key) {
54
+ const row = sql
55
+ .exec(`SELECT projection_json
56
+ FROM projections
57
+ WHERE session_id = ? AND projection_key = ?`, sessionId, key)
58
+ .toArray()[0];
59
+ if (row === undefined)
60
+ return undefined;
61
+ try {
62
+ return JSON.parse(row.projection_json);
63
+ }
64
+ catch {
65
+ return undefined;
66
+ }
67
+ }
68
+ export async function deliverNewEvents(storage, sessionId, cursor, onEvent) {
69
+ if (onEvent === undefined) {
70
+ return readLatestJournalCursor(storage.sql, sessionId);
71
+ }
72
+ let deliveredCursor = cursor;
73
+ while (true) {
74
+ const events = readJournalEventsPage(storage.sql, sessionId, deliveredCursor);
75
+ if (events.length === 0)
76
+ break;
77
+ for (const event of events) {
78
+ try {
79
+ await onEvent(event);
80
+ }
81
+ catch {
82
+ // Delivery is best-effort transport work. Stop at the first failed
83
+ // callback so the next delivery attempt replays this event in order,
84
+ // while the canonical turn continues from its committed SQLite state.
85
+ return deliveredCursor;
86
+ }
87
+ deliveredCursor = event.streamIndex;
88
+ }
89
+ if (events.length < MAX_JOURNAL_EVENTS_PER_PAGE)
90
+ break;
91
+ }
92
+ return deliveredCursor;
93
+ }
94
+ export function beginTurn(storage, request) {
95
+ return commitSessionTransaction(storage, request.sessionId, (journal) => {
96
+ const finalStepId = finalResponseStepId(request.turnId);
97
+ const turn = readTurn(storage.sql, request.sessionId, request.turnId);
98
+ if (turn?.status === "completed") {
99
+ const assistant = readAssistantMessage(storage.sql, request.sessionId, request.turnId);
100
+ if (assistant?.completed_at !== null && assistant !== undefined) {
101
+ return {
102
+ status: "completed",
103
+ messageId: assistant.message_id,
104
+ content: assistant.content,
105
+ };
106
+ }
107
+ return {
108
+ status: "failed",
109
+ failure: {
110
+ code: "turn_runner_invalid",
111
+ message: "Completed turn has no final message.",
112
+ retryable: false,
113
+ stepId: finalStepId,
114
+ },
115
+ };
116
+ }
117
+ if (turn?.status === "failed") {
118
+ const stored = readError(storage.sql, request.sessionId, turn.error_id);
119
+ if (stored !== undefined && stored.retryable === 0) {
120
+ return {
121
+ status: "failed",
122
+ failure: {
123
+ code: stored.code,
124
+ message: stored.message,
125
+ retryable: false,
126
+ ...(stored.error_id.includes(finalStepId)
127
+ ? { stepId: finalStepId }
128
+ : {}),
129
+ },
130
+ };
131
+ }
132
+ journal.updateTurn({
133
+ turnId: request.turnId,
134
+ status: "running",
135
+ startedAt: now(),
136
+ failedAt: null,
137
+ errorId: null,
138
+ });
139
+ journal.setSessionStatus("running");
140
+ return { status: "continue" };
141
+ }
142
+ if (turn !== undefined) {
143
+ journal.updateTurn({
144
+ turnId: request.turnId,
145
+ status: "running",
146
+ startedAt: now(),
147
+ });
148
+ journal.setSessionStatus("running");
149
+ return { status: "continue" };
150
+ }
151
+ const timestamp = now();
152
+ const hasSessionStarted = storage.sql
153
+ .exec(`SELECT EXISTS (
154
+ SELECT 1 FROM events
155
+ WHERE session_id = ? AND type = 'session.started'
156
+ ) AS present`, request.sessionId)
157
+ .toArray()[0]?.present === 1;
158
+ if (!hasSessionStarted) {
159
+ const version = storage.sql
160
+ .exec(`SELECT runtime_version, agent_bundle_version, manifest_version,
161
+ protocol_version, artifact_schema_version
162
+ FROM session_meta
163
+ WHERE session_id = ?`, request.sessionId)
164
+ .toArray()[0];
165
+ if (version === undefined) {
166
+ throw new Error("Turn session is not initialized");
167
+ }
168
+ journal.appendEvent({
169
+ type: "session.started",
170
+ data: {
171
+ sessionId: request.sessionId,
172
+ status: "new",
173
+ versions: {
174
+ runtime: version.runtime_version,
175
+ agentBundle: version.agent_bundle_version,
176
+ manifest: version.manifest_version,
177
+ protocol: version.protocol_version,
178
+ schema: version.artifact_schema_version,
179
+ },
180
+ },
181
+ committedAt: timestamp,
182
+ });
183
+ }
184
+ journal.insertTurn({
185
+ turnId: request.turnId,
186
+ status: "running",
187
+ acceptedAt: timestamp,
188
+ startedAt: timestamp,
189
+ });
190
+ journal.insertMessage({
191
+ messageId: request.messageId,
192
+ turnId: request.turnId,
193
+ role: "user",
194
+ content: request.message,
195
+ createdAt: timestamp,
196
+ });
197
+ journal.setSessionStatus("running", timestamp);
198
+ journal.appendEvent({
199
+ type: "turn.started",
200
+ turnId: request.turnId,
201
+ data: { turnId: request.turnId },
202
+ committedAt: timestamp,
203
+ });
204
+ journal.appendEvent({
205
+ type: "message.received",
206
+ turnId: request.turnId,
207
+ data: { messageId: request.messageId, role: "user" },
208
+ committedAt: timestamp,
209
+ });
210
+ return { status: "continue" };
211
+ });
212
+ }
213
+ export function ensureModelToolStep(storage, request) {
214
+ commitSessionTransaction(storage, request.sessionId, (journal) => {
215
+ const stepId = modelToolStepId(request.turnId);
216
+ const existing = readStep(storage.sql, request.sessionId, stepId);
217
+ if (existing !== undefined)
218
+ return;
219
+ const timestamp = now();
220
+ journal.insertStep({
221
+ stepId,
222
+ turnId: request.turnId,
223
+ logicalKey: "tool:bounded-turn",
224
+ phase: "model-tool",
225
+ status: "running",
226
+ attemptCount: 0,
227
+ createdAt: timestamp,
228
+ updatedAt: timestamp,
229
+ });
230
+ journal.appendEvent({
231
+ type: "step.started",
232
+ turnId: request.turnId,
233
+ stepId,
234
+ data: { stepId, phase: "model-tool" },
235
+ committedAt: timestamp,
236
+ });
237
+ });
238
+ }
239
+ export function prepareModelAttempt(storage, request) {
240
+ const stored = readProjection(storage.sql, request.sessionId, modelProjectionKey(request.turnId));
241
+ if (stored !== undefined) {
242
+ return { status: "replayed", result: stored };
243
+ }
244
+ return commitSessionTransaction(storage, request.sessionId, (journal) => {
245
+ const stepId = modelToolStepId(request.turnId);
246
+ const step = readStep(storage.sql, request.sessionId, stepId);
247
+ if (step === undefined) {
248
+ throw new Error("Model/tool step is missing");
249
+ }
250
+ if (step.status === "failed") {
251
+ return {
252
+ status: "failed",
253
+ failure: storedFailureForStep(storage.sql, request.sessionId, step),
254
+ };
255
+ }
256
+ if (step.attempt_count >= MAX_BOUNDED_TURN_ATTEMPTS) {
257
+ return {
258
+ status: "failed",
259
+ failure: {
260
+ code: "model_call_failed",
261
+ message: "Model call retry limit reached.",
262
+ retryable: false,
263
+ stepId,
264
+ },
265
+ };
266
+ }
267
+ const timestamp = now();
268
+ const attemptCount = step.attempt_count + 1;
269
+ journal.updateStep({
270
+ stepId,
271
+ status: "running",
272
+ attemptCount,
273
+ errorId: null,
274
+ updatedAt: timestamp,
275
+ });
276
+ return { status: "execute", attemptCount };
277
+ });
278
+ }
279
+ export function commitModelProjection(storage, request, attemptCount, result) {
280
+ return commitSessionTransaction(storage, request.sessionId, (journal) => {
281
+ const stepId = modelToolStepId(request.turnId);
282
+ const step = readStep(storage.sql, request.sessionId, stepId);
283
+ if (step === undefined ||
284
+ step.status !== "running" ||
285
+ step.attempt_count !== attemptCount) {
286
+ return (readProjection(storage.sql, request.sessionId, modelProjectionKey(request.turnId)) !== undefined);
287
+ }
288
+ journal.upsertProjection(modelProjectionKey(request.turnId), result);
289
+ return true;
290
+ });
291
+ }
292
+ export function recordStepFailure(storage, request, stepId, input) {
293
+ return commitSessionTransaction(storage, request.sessionId, (journal) => {
294
+ const step = readStep(storage.sql, request.sessionId, stepId);
295
+ if (step === undefined) {
296
+ throw new Error("Failed step is missing");
297
+ }
298
+ if (step.status === "failed") {
299
+ return {
300
+ failure: storedFailureForStep(storage.sql, request.sessionId, step),
301
+ stepWasAlreadyFailed: true,
302
+ };
303
+ }
304
+ if (step.status === "completed") {
305
+ return {
306
+ failure: input,
307
+ stepWasAlreadyFailed: true,
308
+ };
309
+ }
310
+ const retryable = input.retryable && step.attempt_count < MAX_BOUNDED_TURN_ATTEMPTS;
311
+ const status = retryable ? "retryable" : "failed";
312
+ const timestamp = now();
313
+ const errorId = `err_${stepId}_${step.attempt_count}`;
314
+ const persisted = {
315
+ ...input,
316
+ retryable,
317
+ stepId,
318
+ };
319
+ journal.updateStep({
320
+ stepId,
321
+ status,
322
+ errorId,
323
+ updatedAt: timestamp,
324
+ ...(status === "failed" ? { completedAt: timestamp } : {}),
325
+ });
326
+ journal.recordError({
327
+ errorId,
328
+ turnId: request.turnId,
329
+ stepId,
330
+ code: persisted.code,
331
+ message: persisted.message,
332
+ retryable: persisted.retryable,
333
+ createdAt: timestamp,
334
+ });
335
+ journal.appendEvent({
336
+ type: "step.failed",
337
+ turnId: request.turnId,
338
+ stepId,
339
+ data: {
340
+ stepId,
341
+ code: persisted.code,
342
+ message: persisted.message,
343
+ retryable: persisted.retryable,
344
+ },
345
+ committedAt: timestamp,
346
+ });
347
+ return { failure: persisted, stepWasAlreadyFailed: false };
348
+ });
349
+ }
350
+ export function recordTurnFailure(storage, request, input) {
351
+ commitSessionTransaction(storage, request.sessionId, (journal) => {
352
+ const turn = readTurn(storage.sql, request.sessionId, request.turnId);
353
+ if (turn === undefined) {
354
+ throw new Error("Failed turn is missing");
355
+ }
356
+ if (turn.status === "completed")
357
+ return;
358
+ if (turn.status === "failed" && turn.error_id !== null)
359
+ return;
360
+ const timestamp = now();
361
+ const errorId = turn.error_id ??
362
+ `err_turn_${request.turnId}_${readLatestJournalCursor(storage.sql, request.sessionId) + 1}`;
363
+ if (turn.error_id === null) {
364
+ journal.recordError({
365
+ errorId,
366
+ turnId: request.turnId,
367
+ ...(input.stepId === undefined ? {} : { stepId: input.stepId }),
368
+ code: input.code,
369
+ message: input.message,
370
+ retryable: input.retryable,
371
+ createdAt: timestamp,
372
+ });
373
+ }
374
+ journal.updateTurn({
375
+ turnId: request.turnId,
376
+ status: "failed",
377
+ failedAt: timestamp,
378
+ errorId,
379
+ });
380
+ journal.setSessionStatus("failed", timestamp);
381
+ journal.appendEvent({
382
+ type: "turn.failed",
383
+ turnId: request.turnId,
384
+ data: {
385
+ turnId: request.turnId,
386
+ code: input.code,
387
+ message: input.message,
388
+ retryable: input.retryable,
389
+ },
390
+ committedAt: timestamp,
391
+ });
392
+ journal.appendEvent({
393
+ type: "session.failed",
394
+ data: {
395
+ code: input.code,
396
+ message: input.message,
397
+ retryable: input.retryable,
398
+ },
399
+ committedAt: timestamp,
400
+ });
401
+ });
402
+ }
403
+ export function completeModelToolStep(storage, request) {
404
+ commitSessionTransaction(storage, request.sessionId, (journal) => {
405
+ const stepId = modelToolStepId(request.turnId);
406
+ const alreadyCompleted = storage.sql
407
+ .exec(`SELECT EXISTS (
408
+ SELECT 1 FROM events
409
+ WHERE session_id = ? AND step_id = ? AND type = 'step.completed'
410
+ ) AS present`, request.sessionId, stepId)
411
+ .toArray()[0]?.present === 1;
412
+ if (alreadyCompleted)
413
+ return;
414
+ const step = readStep(storage.sql, request.sessionId, stepId);
415
+ if (step?.status !== "completed") {
416
+ throw new Error("Model/tool step did not complete");
417
+ }
418
+ journal.appendEvent({
419
+ type: "step.completed",
420
+ turnId: request.turnId,
421
+ stepId,
422
+ data: { stepId, phase: "model-tool" },
423
+ committedAt: now(),
424
+ });
425
+ });
426
+ }
427
+ export function persistToolMessage(storage, request, call, output) {
428
+ commitSessionTransaction(storage, request.sessionId, (journal) => {
429
+ const messageId = `msg_tool_${encodeURIComponent(request.turnId)}_${encodeURIComponent(call.callId)}`;
430
+ const existing = storage.sql
431
+ .exec(`SELECT message_id
432
+ FROM messages
433
+ WHERE session_id = ? AND message_id = ?`, request.sessionId, messageId)
434
+ .toArray()[0];
435
+ if (existing !== undefined)
436
+ return;
437
+ const timestamp = now();
438
+ journal.insertMessage({
439
+ messageId,
440
+ turnId: request.turnId,
441
+ role: "tool",
442
+ content: JSON.stringify(output),
443
+ createdAt: timestamp,
444
+ completedAt: timestamp,
445
+ });
446
+ });
447
+ }
448
+ export function prepareFinalStep(storage, request) {
449
+ return commitSessionTransaction(storage, request.sessionId, (journal) => {
450
+ const stepId = finalResponseStepId(request.turnId);
451
+ const existing = readStep(storage.sql, request.sessionId, stepId);
452
+ if (existing?.status === "failed") {
453
+ return {
454
+ status: "failed",
455
+ failure: storedFailureForStep(storage.sql, request.sessionId, existing),
456
+ };
457
+ }
458
+ const timestamp = now();
459
+ if (existing === undefined) {
460
+ journal.insertStep({
461
+ stepId,
462
+ turnId: request.turnId,
463
+ logicalKey: "final-response",
464
+ phase: "final-response",
465
+ status: "running",
466
+ attemptCount: 1,
467
+ createdAt: timestamp,
468
+ updatedAt: timestamp,
469
+ });
470
+ journal.appendEvent({
471
+ type: "step.started",
472
+ turnId: request.turnId,
473
+ stepId,
474
+ data: { stepId, phase: "final-response" },
475
+ committedAt: timestamp,
476
+ });
477
+ return { status: "execute", attemptCount: 1 };
478
+ }
479
+ if (existing.status === "completed") {
480
+ const assistant = readAssistantMessage(storage.sql, request.sessionId, request.turnId);
481
+ if (assistant?.completed_at !== null && assistant !== undefined) {
482
+ throw new Error("Final response was already committed");
483
+ }
484
+ }
485
+ if (existing.attempt_count >= MAX_BOUNDED_TURN_ATTEMPTS) {
486
+ return {
487
+ status: "failed",
488
+ failure: {
489
+ code: "final_response_failed",
490
+ message: "Final response retry limit reached.",
491
+ retryable: false,
492
+ stepId,
493
+ },
494
+ };
495
+ }
496
+ const attemptCount = existing.attempt_count + 1;
497
+ journal.updateStep({
498
+ stepId,
499
+ status: "running",
500
+ attemptCount,
501
+ errorId: null,
502
+ updatedAt: timestamp,
503
+ completedAt: null,
504
+ });
505
+ return { status: "execute", attemptCount };
506
+ });
507
+ }
508
+ export function commitFinalResponse(storage, request, content, attemptCount) {
509
+ commitSessionTransaction(storage, request.sessionId, (journal) => {
510
+ const stepId = finalResponseStepId(request.turnId);
511
+ const finalStep = readStep(storage.sql, request.sessionId, stepId);
512
+ if (finalStep === undefined ||
513
+ finalStep.status !== "running" ||
514
+ finalStep.attempt_count !== attemptCount) {
515
+ const assistant = readAssistantMessage(storage.sql, request.sessionId, request.turnId);
516
+ if (assistant?.completed_at !== null && assistant !== undefined)
517
+ return;
518
+ throw new Error("Final response checkpoint is stale");
519
+ }
520
+ const timestamp = now();
521
+ const assistant = readAssistantMessage(storage.sql, request.sessionId, request.turnId);
522
+ if (assistant === undefined) {
523
+ journal.insertMessage({
524
+ messageId: request.messageId,
525
+ turnId: request.turnId,
526
+ role: "assistant",
527
+ content,
528
+ createdAt: timestamp,
529
+ completedAt: timestamp,
530
+ });
531
+ }
532
+ else {
533
+ journal.updateMessage({
534
+ messageId: assistant.message_id,
535
+ content,
536
+ completedAt: timestamp,
537
+ });
538
+ }
539
+ journal.upsertProjection(`turn:${request.turnId}:final-response`, content, timestamp);
540
+ journal.updateStep({
541
+ stepId,
542
+ status: "completed",
543
+ attemptCount,
544
+ updatedAt: timestamp,
545
+ completedAt: timestamp,
546
+ });
547
+ journal.updateTurn({
548
+ turnId: request.turnId,
549
+ status: "completed",
550
+ completedAt: timestamp,
551
+ failedAt: null,
552
+ errorId: null,
553
+ });
554
+ journal.setSessionStatus("waiting", timestamp);
555
+ const messageId = assistant?.message_id ?? request.messageId;
556
+ journal.appendEvent({
557
+ type: "message.completed",
558
+ turnId: request.turnId,
559
+ stepId,
560
+ data: { messageId, role: "assistant", content },
561
+ committedAt: timestamp,
562
+ });
563
+ journal.appendEvent({
564
+ type: "step.completed",
565
+ turnId: request.turnId,
566
+ stepId,
567
+ data: { stepId, phase: "final-response" },
568
+ committedAt: timestamp,
569
+ });
570
+ journal.appendEvent({
571
+ type: "turn.completed",
572
+ turnId: request.turnId,
573
+ data: { turnId: request.turnId },
574
+ committedAt: timestamp,
575
+ });
576
+ journal.appendEvent({
577
+ type: "session.waiting",
578
+ data: { status: "waiting" },
579
+ committedAt: timestamp,
580
+ });
581
+ });
582
+ }
583
+ //# sourceMappingURL=turn-runner-storage.js.map
@@ -0,0 +1,112 @@
1
+ import type { EdenEvent, EdenEventType, EdenJsonValue, EdenModelOptions, EdenToolDefinition } from "@moinulmoin/eden-definitions";
2
+ import type { EdenModelAdapter, EdenModelResult } from "./model-adapter.js";
3
+ export declare const MAX_BOUNDED_TURN_ATTEMPTS = 3;
4
+ export type EdenTurnFailureCode = "turn_runner_invalid" | "model_call_aborted" | "model_call_failed" | "model_result_invalid" | "tool_input_invalid" | "tool_output_invalid" | "tool_execution_failed" | "final_response_invalid" | "final_response_failed";
5
+ export interface EdenTurnFailure {
6
+ readonly code: EdenTurnFailureCode;
7
+ readonly message: string;
8
+ readonly retryable: boolean;
9
+ readonly sessionId: string;
10
+ readonly turnId: string;
11
+ readonly stepId?: string;
12
+ }
13
+ export type EdenBoundedTurnResult = {
14
+ readonly status: "completed";
15
+ readonly sessionId: string;
16
+ readonly turnId: string;
17
+ readonly messageId: string;
18
+ readonly content: string;
19
+ } | {
20
+ readonly status: "failed";
21
+ readonly sessionId: string;
22
+ readonly turnId: string;
23
+ readonly error: EdenTurnFailure;
24
+ };
25
+ export interface EdenBoundedTurnRequest<TInput, TOutput extends EdenJsonValue = EdenJsonValue> {
26
+ readonly sessionId: string;
27
+ readonly turnId: string;
28
+ readonly messageId: string;
29
+ readonly message: string;
30
+ readonly systemPrompt?: string;
31
+ readonly model: EdenModelAdapter;
32
+ readonly modelId?: string;
33
+ readonly modelOptions?: EdenModelOptions;
34
+ readonly toolName: string;
35
+ readonly tool: EdenToolDefinition<TInput, TOutput>;
36
+ readonly toolInputSchema: EdenJsonValue;
37
+ readonly bundleIdentity: string;
38
+ readonly signal?: AbortSignal;
39
+ readonly onEvent?: (event: EdenEvent<EdenEventType>) => void | Promise<void>;
40
+ }
41
+ export interface TurnIdentity {
42
+ readonly sessionId: string;
43
+ readonly turnId: string;
44
+ }
45
+ export interface TurnMessageIdentity extends TurnIdentity {
46
+ readonly messageId: string;
47
+ }
48
+ export interface StoredFailure {
49
+ readonly code: EdenTurnFailureCode;
50
+ readonly message: string;
51
+ readonly retryable: boolean;
52
+ readonly stepId?: string;
53
+ }
54
+ export type BeginTurnResult = {
55
+ readonly status: "continue";
56
+ } | {
57
+ readonly status: "completed";
58
+ readonly messageId: string;
59
+ readonly content: string;
60
+ } | {
61
+ readonly status: "failed";
62
+ readonly failure: StoredFailure;
63
+ };
64
+ export type StepPreparation = {
65
+ readonly status: "execute";
66
+ readonly attemptCount: number;
67
+ } | {
68
+ readonly status: "replayed";
69
+ readonly result: EdenModelResult;
70
+ } | {
71
+ readonly status: "failed";
72
+ readonly failure: StoredFailure;
73
+ };
74
+ export interface SqlRow {
75
+ readonly [key: string]: string | number | null;
76
+ }
77
+ export interface TurnRow extends SqlRow {
78
+ readonly turn_id: string;
79
+ readonly status: "accepted" | "running" | "completed" | "failed";
80
+ readonly error_id: string | null;
81
+ }
82
+ export interface MessageRow extends SqlRow {
83
+ readonly message_id: string;
84
+ readonly role: "user" | "assistant" | "tool";
85
+ readonly content: string;
86
+ readonly completed_at: string | null;
87
+ }
88
+ export interface StepRow extends SqlRow {
89
+ readonly step_id: string;
90
+ readonly turn_id: string;
91
+ readonly logical_key: string;
92
+ readonly phase: "model-tool" | "final-response";
93
+ readonly status: "pending" | "running" | "completed" | "retryable" | "failed";
94
+ readonly attempt_count: number;
95
+ readonly error_id: string | null;
96
+ }
97
+ export interface ErrorRow extends SqlRow {
98
+ readonly error_id: string;
99
+ readonly code: string;
100
+ readonly message: string;
101
+ readonly retryable: number;
102
+ }
103
+ export interface ProjectionRow extends SqlRow {
104
+ readonly projection_json: string;
105
+ }
106
+ export declare function modelToolStepId(turnId: string): string;
107
+ export declare function finalResponseStepId(turnId: string): string;
108
+ export declare function modelProjectionKey(turnId: string): string;
109
+ export declare function assistantMessageId(turnId: string): string;
110
+ export declare function now(): string;
111
+ export declare function bytes(value: string): number;
112
+ //# sourceMappingURL=turn-runner-types.d.ts.map