stitchkit 0.93.0 → 0.94.1

package/dist/agent-runtime/store-driver-contract.d.ts

@@ -0,0 +1,814 @@
+import { z } from 'zod';
+import type { AgentStoreEventEnvelope, AgentStoreEventPage, ReadAgentStoreEventsSchema } from '../durability/events.js';
+import { type AgentMessage, type AgentRun } from './schemas.js';
+import type { AgentRecoverablePage } from './store.js';
+import type { AgentConversationArchive, AgentStoreEventDraft } from './store-events.js';
+import type { AgentConversationPurgeDriver } from './store-purge.js';
+export declare const AgentRuntimeHeadSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    conversationId: z.ZodString;
+    version: z.ZodInt;
+}, z.core.$strip>;
+export declare const AgentStoredRunSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    run: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        conversationId: z.ZodString;
+        inputMessageIds: z.ZodArray<z.ZodString>;
+        assistantMessageId: z.ZodString;
+        state: z.ZodEnum<{
+            abandoned: "abandoned";
+            cancelled: "cancelled";
+            completed: "completed";
+            failed: "failed";
+            interrupt_requested: "interrupt_requested";
+            interrupted: "interrupted";
+            queued: "queued";
+            running: "running";
+            superseded: "superseded";
+        }>;
+        revision: z.ZodInt;
+        queuePriority: z.ZodOptional<z.ZodEnum<{
+            "interrupt-next": "interrupt-next";
+        }>>;
+        executionSequence: z.ZodOptional<z.ZodInt>;
+        ownerId: z.ZodOptional<z.ZodString>;
+        fencingToken: z.ZodOptional<z.ZodInt>;
+        terminalReason: z.ZodOptional<z.ZodEnum<{
+            abandoned: "abandoned";
+            absorbed: "absorbed";
+            cancelled: "cancelled";
+            context_overflow: "context_overflow";
+            interrupted: "interrupted";
+            output_rejected: "output_rejected";
+            policy_stop: "policy_stop";
+            provider_failure: "provider_failure";
+            provider_stop: "provider_stop";
+            runtime_failure: "runtime_failure";
+            shutdown: "shutdown";
+            storage_conflict: "storage_conflict";
+            success: "success";
+            superseded: "superseded";
+            timeout: "timeout";
+        }>>;
+        terminalPolicyName: z.ZodOptional<z.ZodString>;
+        absorbedIntoRunId: z.ZodOptional<z.ZodString>;
+        usage: z.ZodOptional<z.ZodObject<{
+            inputTokens: z.ZodObject<{
+                value: z.ZodOptional<z.ZodInt>;
+                provenance: z.ZodEnum<{
+                    computed: "computed";
+                    estimated: "estimated";
+                    "provider-reported": "provider-reported";
+                    unavailable: "unavailable";
+                }>;
+            }, z.core.$strip>;
+            outputTokens: z.ZodObject<{
+                value: z.ZodOptional<z.ZodInt>;
+                provenance: z.ZodEnum<{
+                    computed: "computed";
+                    estimated: "estimated";
+                    "provider-reported": "provider-reported";
+                    unavailable: "unavailable";
+                }>;
+            }, z.core.$strip>;
+            reasoningTokens: z.ZodOptional<z.ZodObject<{
+                value: z.ZodOptional<z.ZodInt>;
+                provenance: z.ZodEnum<{
+                    computed: "computed";
+                    estimated: "estimated";
+                    "provider-reported": "provider-reported";
+                    unavailable: "unavailable";
+                }>;
+            }, z.core.$strip>>;
+            cacheReadTokens: z.ZodOptional<z.ZodObject<{
+                value: z.ZodOptional<z.ZodInt>;
+                provenance: z.ZodEnum<{
+                    computed: "computed";
+                    estimated: "estimated";
+                    "provider-reported": "provider-reported";
+                    unavailable: "unavailable";
+                }>;
+            }, z.core.$strip>>;
+            cacheWriteTokens: z.ZodOptional<z.ZodObject<{
+                value: z.ZodOptional<z.ZodInt>;
+                provenance: z.ZodEnum<{
+                    computed: "computed";
+                    estimated: "estimated";
+                    "provider-reported": "provider-reported";
+                    unavailable: "unavailable";
+                }>;
+            }, z.core.$strip>>;
+            cost: z.ZodOptional<z.ZodObject<{
+                value: z.ZodOptional<z.ZodNumber>;
+                currency: z.ZodOptional<z.ZodString>;
+                provenance: z.ZodEnum<{
+                    computed: "computed";
+                    estimated: "estimated";
+                    "provider-reported": "provider-reported";
+                    unavailable: "unavailable";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        lastOperation: z.ZodOptional<z.ZodObject<{
+            operationId: z.ZodString;
+            kind: z.ZodEnum<{
+                compaction: "compaction";
+                "model-request": "model-request";
+            }>;
+            phase: z.ZodEnum<{
+                cancelled: "cancelled";
+                completed: "completed";
+                failed: "failed";
+                "first-output": "first-output";
+                started: "started";
+            }>;
+            step: z.ZodOptional<z.ZodInt>;
+            startedAt: z.ZodISODateTime;
+            firstOutputAt: z.ZodOptional<z.ZodISODateTime>;
+            finishedAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strip>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+    terminalAssistant: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        conversationId: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            summary: "summary";
+            system: "system";
+            tool: "tool";
+            user: "user";
+        }>;
+        status: z.ZodEnum<{
+            committed: "committed";
+            completed: "completed";
+            failed: "failed";
+            interrupted: "interrupted";
+            streaming: "streaming";
+            superseded: "superseded";
+        }>;
+        parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reasoning">;
+            text: z.ZodString;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            mediaType: z.ZodString;
+            reference: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"source">;
+            sourceId: z.ZodString;
+            url: z.ZodOptional<z.ZodURL>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-call">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-result">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            outcome: z.ZodEnum<{
+                error: "error";
+                interrupted: "interrupted";
+                success: "success";
+            }>;
+            output: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-approval-request">;
+            approvalId: z.ZodString;
+            callId: z.ZodString;
+            isAutomatic: z.ZodOptional<z.ZodBoolean>;
+            signature: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-approval-response">;
+            approvalId: z.ZodString;
+            approved: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"provider">;
+            envelope: z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"control">;
+            reason: z.ZodEnum<{
+                "run-interrupted": "run-interrupted";
+                "stale-run": "stale-run";
+            }>;
+        }, z.core.$strip>], "type">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const AgentAdmissionReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    conversationId: z.ZodString;
+    idempotencyKey: z.ZodString;
+    input: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        conversationId: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            summary: "summary";
+            system: "system";
+            tool: "tool";
+            user: "user";
+        }>;
+        status: z.ZodEnum<{
+            committed: "committed";
+            completed: "completed";
+            failed: "failed";
+            interrupted: "interrupted";
+            streaming: "streaming";
+            superseded: "superseded";
+        }>;
+        parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reasoning">;
+            text: z.ZodString;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            mediaType: z.ZodString;
+            reference: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"source">;
+            sourceId: z.ZodString;
+            url: z.ZodOptional<z.ZodURL>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-call">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-result">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            outcome: z.ZodEnum<{
+                error: "error";
+                interrupted: "interrupted";
+                success: "success";
+            }>;
+            output: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-approval-request">;
+            approvalId: z.ZodString;
+            callId: z.ZodString;
+            isAutomatic: z.ZodOptional<z.ZodBoolean>;
+            signature: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-approval-response">;
+            approvalId: z.ZodString;
+            approved: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"provider">;
+            envelope: z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"control">;
+            reason: z.ZodEnum<{
+                "run-interrupted": "run-interrupted";
+                "stale-run": "stale-run";
+            }>;
+        }, z.core.$strip>], "type">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+    runId: z.ZodString;
+    assistantMessageId: z.ZodString;
+}, z.core.$strip>;
+export type AgentRuntimeHead = z.infer<typeof AgentRuntimeHeadSchema>;
+export type AgentStoredRun = z.infer<typeof AgentStoredRunSchema>;
+export type AgentAdmissionReceipt = z.infer<typeof AgentAdmissionReceiptSchema>;
+/**
+ * The durable record that a keyed user-instruction seed already happened.
+ *
+ * Kept beside the history rather than derived from it: compaction and `clear`
+ * legitimately remove the seeded messages, and the seed must not return when
+ * they do. `messageIds` lets an archive round trip match an imported seed's
+ * messages without this record.
+ */
+export declare const AgentSeedReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    conversationId: z.ZodString;
+    seedKey: z.ZodString;
+    messageIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type AgentSeedReceipt = z.infer<typeof AgentSeedReceiptSchema>;
+export declare const AgentHistoryMutationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"admit">;
+    input: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        conversationId: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            summary: "summary";
+            system: "system";
+            tool: "tool";
+            user: "user";
+        }>;
+        status: z.ZodEnum<{
+            committed: "committed";
+            completed: "completed";
+            failed: "failed";
+            interrupted: "interrupted";
+            streaming: "streaming";
+            superseded: "superseded";
+        }>;
+        parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reasoning">;
+            text: z.ZodString;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            mediaType: z.ZodString;
+            reference: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"source">;
+            sourceId: z.ZodString;
+            url: z.ZodOptional<z.ZodURL>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-call">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-result">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            outcome: z.ZodEnum<{
+                error: "error";
+                interrupted: "interrupted";
+                success: "success";
+            }>;
+            output: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-approval-request">;
+            approvalId: z.ZodString;
+            callId: z.ZodString;
+            isAutomatic: z.ZodOptional<z.ZodBoolean>;
+            signature: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-approval-response">;
+            approvalId: z.ZodString;
+            approved: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"provider">;
+            envelope: z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"control">;
+            reason: z.ZodEnum<{
+                "run-interrupted": "run-interrupted";
+                "stale-run": "stale-run";
+            }>;
+        }, z.core.$strip>], "type">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"upsert-assistant">;
+    message: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        conversationId: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            summary: "summary";
+            system: "system";
+            tool: "tool";
+            user: "user";
+        }>;
+        status: z.ZodEnum<{
+            committed: "committed";
+            completed: "completed";
+            failed: "failed";
+            interrupted: "interrupted";
+            streaming: "streaming";
+            superseded: "superseded";
+        }>;
+        parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reasoning">;
+            text: z.ZodString;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            mediaType: z.ZodString;
+            reference: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"source">;
+            sourceId: z.ZodString;
+            url: z.ZodOptional<z.ZodURL>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-call">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-result">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            outcome: z.ZodEnum<{
+                error: "error";
+                interrupted: "interrupted";
+                success: "success";
+            }>;
+            output: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-approval-request">;
+            approvalId: z.ZodString;
+            callId: z.ZodString;
+            isAutomatic: z.ZodOptional<z.ZodBoolean>;
+            signature: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-approval-response">;
+            approvalId: z.ZodString;
+            approved: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"provider">;
+            envelope: z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"control">;
+            reason: z.ZodEnum<{
+                "run-interrupted": "run-interrupted";
+                "stale-run": "stale-run";
+            }>;
+        }, z.core.$strip>], "type">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"replace-compacted-range">;
+    replacedMessageIds: z.ZodArray<z.ZodString>;
+    summary: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        conversationId: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            summary: "summary";
+            system: "system";
+            tool: "tool";
+            user: "user";
+        }>;
+        status: z.ZodEnum<{
+            committed: "committed";
+            completed: "completed";
+            failed: "failed";
+            interrupted: "interrupted";
+            streaming: "streaming";
+            superseded: "superseded";
+        }>;
+        parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reasoning">;
+            text: z.ZodString;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            mediaType: z.ZodString;
+            reference: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"source">;
+            sourceId: z.ZodString;
+            url: z.ZodOptional<z.ZodURL>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-call">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-result">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            outcome: z.ZodEnum<{
+                error: "error";
+                interrupted: "interrupted";
+                success: "success";
+            }>;
+            output: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-approval-request">;
+            approvalId: z.ZodString;
+            callId: z.ZodString;
+            isAutomatic: z.ZodOptional<z.ZodBoolean>;
+            signature: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-approval-response">;
+            approvalId: z.ZodString;
+            approved: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"provider">;
+            envelope: z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"control">;
+            reason: z.ZodEnum<{
+                "run-interrupted": "run-interrupted";
+                "stale-run": "stale-run";
+            }>;
+        }, z.core.$strip>], "type">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"seed">;
+    message: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        conversationId: z.ZodString;
+        runId: z.ZodOptional<z.ZodString>;
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            summary: "summary";
+            system: "system";
+            tool: "tool";
+            user: "user";
+        }>;
+        status: z.ZodEnum<{
+            committed: "committed";
+            completed: "completed";
+            failed: "failed";
+            interrupted: "interrupted";
+            streaming: "streaming";
+            superseded: "superseded";
+        }>;
+        parts: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reasoning">;
+            text: z.ZodString;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            mediaType: z.ZodString;
+            reference: z.ZodString;
+            filename: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"source">;
+            sourceId: z.ZodString;
+            url: z.ZodOptional<z.ZodURL>;
+            title: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-call">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            input: z.ZodJSONSchema;
+            provider: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-result">;
+            callId: z.ZodString;
+            toolName: z.ZodString;
+            outcome: z.ZodEnum<{
+                error: "error";
+                interrupted: "interrupted";
+                success: "success";
+            }>;
+            output: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-approval-request">;
+            approvalId: z.ZodString;
+            callId: z.ZodString;
+            isAutomatic: z.ZodOptional<z.ZodBoolean>;
+            signature: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool-approval-response">;
+            approvalId: z.ZodString;
+            approved: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"provider">;
+            envelope: z.ZodObject<{
+                schemaVersion: z.ZodInt;
+                provider: z.ZodString;
+                data: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"control">;
+            reason: z.ZodEnum<{
+                "run-interrupted": "run-interrupted";
+                "stale-run": "stale-run";
+            }>;
+        }, z.core.$strip>], "type">>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+export type AgentHistoryMutation = z.infer<typeof AgentHistoryMutationSchema>;
+export type AgentStoreCompareAndSwapResult = {
+    outcome: 'applied';
+} | {
+    outcome: 'conflict';
+    actualVersion: number;
+};
+export interface AgentRuntimeStoreDriver<TRANSACTION> {
+    conversations?: AgentConversationPurgeDriver<TRANSACTION>;
+    /**
+     * Run one coherent store operation. `read` lets an adapter take a stable
+     * snapshot without reserving its writer slot; absent options retain the
+     * write-safe transaction used by existing adapters.
+     */
+    transaction<RESULT>(work: (transaction: TRANSACTION) => Promise<RESULT>, options?: {
+        access: 'read' | 'write';
+    }): Promise<RESULT>;
+    head: {
+        load(transaction: TRANSACTION, conversationId: string): Promise<AgentRuntimeHead | undefined>;
+        compareAndSwap(transaction: TRANSACTION, input: {
+            conversationId: string;
+            expectedVersion: number;
+            next: AgentRuntimeHead;
+        }): Promise<AgentStoreCompareAndSwapResult>;
+    };
+    runs: {
+        load(transaction: TRANSACTION, input: {
+            conversationId: string;
+            runId: string;
+        }): Promise<AgentStoredRun | undefined>;
+        loadByAssistantMessageId(transaction: TRANSACTION, input: {
+            conversationId: string;
+            assistantMessageId: string;
+        }): Promise<AgentStoredRun | undefined>;
+        loadMany(transaction: TRANSACTION, input: {
+            conversationId: string;
+            runIds: readonly string[];
+        }): Promise<readonly AgentStoredRun[]>;
+        listActive(transaction: TRANSACTION, conversationId: string): Promise<readonly AgentStoredRun[]>;
+        save(transaction: TRANSACTION, record: AgentStoredRun): Promise<void>;
+    };
+    admissions: {
+        load(transaction: TRANSACTION, input: {
+            conversationId: string;
+            idempotencyKey: string;
+        }): Promise<AgentAdmissionReceipt | undefined>;
+        loadByInputMessageId(transaction: TRANSACTION, input: {
+            conversationId: string;
+            inputMessageId: string;
+        }): Promise<AgentAdmissionReceipt | undefined>;
+        create(transaction: TRANSACTION, receipt: AgentAdmissionReceipt): Promise<void>;
+    };
+    seeds: {
+        load(transaction: TRANSACTION, input: {
+            conversationId: string;
+            seedKey: string;
+        }): Promise<AgentSeedReceipt | undefined>;
+        create(transaction: TRANSACTION, receipt: AgentSeedReceipt): Promise<void>;
+    };
+    history: {
+        load(transaction: TRANSACTION, conversationId: string): Promise<readonly AgentMessage[]>;
+        /**
+         * Whether any stored message — active or compacted — already carries this
+         * identity.
+         *
+         * `load` deliberately hides compacted rows, so a seed restored into a
+         * conversation whose receipts were not restored can match a message the
+         * active view does not show. Optional because a driver with no inactive
+         * store has nothing `load` hides; the seed write is idempotent either way.
+         */
+        hasMessage?(transaction: TRANSACTION, input: {
+            conversationId: string;
+            messageId: string;
+        }): Promise<boolean>;
+        apply(transaction: TRANSACTION, mutation: AgentHistoryMutation): Promise<void>;
+    };
+    events: {
+        append(transaction: TRANSACTION, event: AgentStoreEventDraft): Promise<AgentStoreEventEnvelope>;
+        list(transaction: TRANSACTION, input: z.infer<typeof ReadAgentStoreEventsSchema>): Promise<AgentStoreEventPage>;
+    };
+    /** Optional driver-owned durable payloads included in the canonical archive. */
+    archive?: {
+        export(transaction: TRANSACTION, conversationId: string): Promise<Pick<AgentConversationArchive, 'projections' | 'spills'>>;
+        import(transaction: TRANSACTION, archive: AgentConversationArchive): Promise<void>;
+    };
+    scanRecoverable(input: {
+        cursor?: string;
+        limit: number;
+    }): Promise<AgentRecoverablePage>;
+}
+/**
+ * The run states a recovery pass and an active listing must consider.
+ *
+ * Exported because a driver author needs it: `runs.listActive` and
+ * `scanRecoverable` are driver members, so this list crossed the public
+ * boundary as a literal every adapter had to guess and hardcode — the reference
+ * adapter repeats it three times. Adding a run state silently broke every
+ * deployed driver. Same reasoning as `isSpeakableAssistantStatus`, applied to
+ * the enum that a consumer implements against rather than reads.
+ */
+export declare const ACTIVE_AGENT_RUN_STATES: readonly AgentRun['state'][];
+export declare function isActiveRunState(state: AgentRun['state']): boolean;
+export declare function emptyHead(conversationId: string): AgentRuntimeHead;
+//# sourceMappingURL=store-driver-contract.d.ts.map