stitchkit 0.85.1 → 0.86.0

package/dist/agent-runtime/store-events.d.ts

@@ -0,0 +1,829 @@
+import { z } from 'zod';
+export declare const AgentStoreEventKindSchema: z.ZodEnum<{
+    "child/spawned": "child/spawned";
+    "child/state": "child/state";
+    "provider/message": "provider/message";
+    "provider/request": "provider/request";
+    "retry/scheduled": "retry/scheduled";
+    "retry/started": "retry/started";
+    "runtime/baseline": "runtime/baseline";
+    "runtime/transition": "runtime/transition";
+    "sandbox/probed": "sandbox/probed";
+    "schedule/cancelled": "schedule/cancelled";
+    "schedule/failed": "schedule/failed";
+    "schedule/fired": "schedule/fired";
+    "schedule/late": "schedule/late";
+    "schedule/set": "schedule/set";
+    "spill/created": "spill/created";
+    "spill/deleted": "spill/deleted";
+    "state/set": "state/set";
+}>;
+export type AgentStoreEventKind = z.infer<typeof AgentStoreEventKindSchema>;
+export declare const AgentStoreTransitionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"accept">;
+    input: z.ZodObject<{
+        idempotencyKey: z.ZodString;
+        expectedVersion: z.ZodOptional<z.ZodInt>;
+        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>;
+        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>;
+        coalesceIntoRunId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"acquire">;
+    input: z.ZodObject<{
+        conversationId: z.ZodString;
+        runId: z.ZodString;
+        expectedRevision: z.ZodInt;
+        ownerId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"checkpoint">;
+    input: z.ZodObject<{
+        conversationId: z.ZodString;
+        runId: z.ZodString;
+        expectedRevision: z.ZodInt;
+        ownerId: z.ZodString;
+        fencingToken: z.ZodOptional<z.ZodInt>;
+        assistant: 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>;
+        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>>;
+    }, z.core.$strip>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"operation">;
+    input: z.ZodObject<{
+        conversationId: z.ZodString;
+        runId: z.ZodString;
+        expectedRevision: z.ZodInt;
+        ownerId: z.ZodString;
+        fencingToken: z.ZodOptional<z.ZodInt>;
+        operation: 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>;
+    }, z.core.$strip>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"interrupt">;
+    input: z.ZodObject<{
+        conversationId: z.ZodString;
+        runId: z.ZodString;
+        expectedRevision: z.ZodInt;
+    }, z.core.$strip>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"recover">;
+    input: z.ZodObject<{
+        conversationId: z.ZodString;
+        runId: z.ZodString;
+        expectedRevision: z.ZodInt;
+        action: z.ZodEnum<{
+            abandon: "abandon";
+            requeue: "requeue";
+        }>;
+        replaySafe: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"terminal">;
+    input: z.ZodObject<{
+        conversationId: z.ZodString;
+        runId: z.ZodString;
+        expectedRevision: z.ZodInt;
+        ownerId: z.ZodString;
+        fencingToken: z.ZodOptional<z.ZodInt>;
+        assistant: 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>;
+        reason: 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";
+        }>;
+        policyName: 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>>;
+        absorb: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            inputMessageIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"compact">;
+    input: z.ZodObject<{
+        conversationId: z.ZodString;
+        expectedVersion: z.ZodInt;
+        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.core.$strict>], "type">;
+export type AgentStoreTransition = z.infer<typeof AgentStoreTransitionSchema>;
+export declare const AgentStoreEventEnvelopeSchema: z.ZodObject<{
+    schemaVersion: z.ZodInt;
+    eventId: z.ZodString;
+    conversationId: z.ZodString;
+    seq: z.ZodInt;
+    kind: z.ZodString;
+    occurredAt: z.ZodISODateTime;
+    payload: z.ZodJSONSchema;
+    ignorable: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>;
+export type AgentStoreEventEnvelope = z.infer<typeof AgentStoreEventEnvelopeSchema>;
+export declare const AppendAgentStoreEventSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    kind: z.ZodEnum<{
+        "child/spawned": "child/spawned";
+        "child/state": "child/state";
+        "provider/message": "provider/message";
+        "provider/request": "provider/request";
+        "retry/scheduled": "retry/scheduled";
+        "retry/started": "retry/started";
+        "runtime/baseline": "runtime/baseline";
+        "runtime/transition": "runtime/transition";
+        "sandbox/probed": "sandbox/probed";
+        "schedule/cancelled": "schedule/cancelled";
+        "schedule/failed": "schedule/failed";
+        "schedule/fired": "schedule/fired";
+        "schedule/late": "schedule/late";
+        "schedule/set": "schedule/set";
+        "spill/created": "spill/created";
+        "spill/deleted": "spill/deleted";
+        "state/set": "state/set";
+    }>;
+    occurredAt: z.ZodOptional<z.ZodISODateTime>;
+    payload: z.ZodJSONSchema;
+    ignorable: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>;
+export type AppendAgentStoreEvent = z.infer<typeof AppendAgentStoreEventSchema>;
+export declare const ReadAgentStoreEventsSchema: z.ZodObject<{
+    conversationId: z.ZodString;
+    fromSeq: z.ZodOptional<z.ZodInt>;
+    toSeq: z.ZodOptional<z.ZodInt>;
+    limit: z.ZodDefault<z.ZodInt>;
+}, z.core.$strict>;
+export type ReadAgentStoreEvents = z.infer<typeof ReadAgentStoreEventsSchema>;
+export declare const AgentStoreEventPageSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodInt;
+        eventId: z.ZodString;
+        conversationId: z.ZodString;
+        seq: z.ZodInt;
+        kind: z.ZodString;
+        occurredAt: z.ZodISODateTime;
+        payload: z.ZodJSONSchema;
+        ignorable: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+    nextSeq: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>;
+export type AgentStoreEventPage = z.infer<typeof AgentStoreEventPageSchema>;
+export type AgentStoreEventDraft = Omit<AgentStoreEventEnvelope, 'seq'>;
+export interface AgentStoreEventDecodeAccepted {
+    outcome: 'accepted';
+    event: AgentStoreEventEnvelope;
+}
+export interface AgentStoreEventDecodeIgnored {
+    outcome: 'ignored';
+    eventId: string;
+    conversationId: string;
+    seq: number;
+    schemaVersion: number;
+    kind: string;
+}
+export type AgentStoreEventDecodeResult = AgentStoreEventDecodeAccepted | AgentStoreEventDecodeIgnored;
+/**
+ * Validate one event without silently widening the vocabulary.
+ *
+ * `ignorable` applies to an unknown kind or envelope version as a whole. It
+ * never turns an extra field in a known envelope into accepted data.
+ */
+export declare function decodeAgentStoreEvent(value: unknown): AgentStoreEventDecodeResult;
+export declare function agentStoreEventDraft(input: AppendAgentStoreEvent): AgentStoreEventDraft;
+/** Stable UTF-8 JSON used by archives, digests and byte-for-byte round trips. */
+export declare function canonicalAgentJson(value: unknown): string;
+export declare const AgentConversationArchiveSchema: z.ZodObject<{
+    format: z.ZodLiteral<"stitchkit.agent-conversation">;
+    formatVersion: z.ZodLiteral<1>;
+    conversationId: z.ZodString;
+    events: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodInt;
+        eventId: z.ZodString;
+        conversationId: z.ZodString;
+        seq: z.ZodInt;
+        kind: z.ZodString;
+        occurredAt: z.ZodISODateTime;
+        payload: z.ZodJSONSchema;
+        ignorable: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+    projections: z.ZodDefault<z.ZodArray<z.ZodJSONSchema>>;
+    spills: z.ZodDefault<z.ZodArray<z.ZodJSONSchema>>;
+}, z.core.$strict>;
+export type AgentConversationArchive = z.infer<typeof AgentConversationArchiveSchema>;
+export declare function encodeAgentConversationArchive(archive: AgentConversationArchive): Uint8Array;
+export declare function decodeAgentConversationArchive(bytes: Uint8Array): AgentConversationArchive;
+//# sourceMappingURL=store-events.d.ts.map