@irogane/kaji 0.2.0-beta.11

package/dist/context-C-YPY-GS.d.ts

@@ -0,0 +1,1538 @@
+import * as z from 'zod';
+import { ErrorObject } from 'ajv/dist/2020.js';
+
+type DeepReadonly<T> = T extends (...args: never[]) => unknown ? T : T extends readonly (infer TItem)[] ? readonly DeepReadonly<TItem>[] : T extends object ? {
+    readonly [TKey in keyof T]: DeepReadonly<T[TKey]>;
+} : T;
+
+/**
+ * Zod schemas for all Kaji events, mirroring
+ * `kaji.infra.events.schemas`. Field names stay snake_case because they are
+ * the shared wire format with the Python SDK.
+ *
+ * `BaseEvent` is `.strict()` to match Pydantic's `extra="forbid"`. The
+ * id/version/timestamp/metadata defaults mirror the Python `default_factory`
+ * fields, so constructing an event needs only its own payload plus session_id.
+ */
+
+declare const SessionCreated: z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"session.created">;
+}, z.core.$strict>;
+declare const AgentTurnFailed: z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"agent.turn.failed">;
+    turn_id: z.ZodString;
+    error: z.ZodString;
+    error_code: z.ZodOptional<z.ZodString>;
+    phase: z.ZodOptional<z.ZodEnum<{
+        queue: "queue";
+        provider_open: "provider_open";
+        provider_stream: "provider_stream";
+        approval: "approval";
+        tool: "tool";
+    }>>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        not_started: "not_started";
+        failed: "failed";
+        unknown: "unknown";
+    }>>;
+}, z.core.$strict>;
+/** Discriminated union over every event, keyed on `type`. */
+declare const KajiEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"session.created">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"session.closed">;
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"user.message">;
+    content: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"user.audio.chunk">;
+    chunk_size_bytes: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"transcript.partial">;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"transcript.final">;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"memory.retrieval.started">;
+    query: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"memory.retrieval.completed">;
+    query: z.ZodString;
+    documents: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"agent.reasoning.started">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"agent.message.delta">;
+    delta: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"agent.message.completed">;
+    content: z.ZodString;
+    tokens: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+    }, z.core.$strict>>>;
+    cost_usd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"agent.turn.exhausted">;
+    max_iterations: z.ZodNumber;
+    pending_tool_calls: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"agent.turn.failed">;
+    turn_id: z.ZodString;
+    error: z.ZodString;
+    error_code: z.ZodOptional<z.ZodString>;
+    phase: z.ZodOptional<z.ZodEnum<{
+        queue: "queue";
+        provider_open: "provider_open";
+        provider_stream: "provider_stream";
+        approval: "approval";
+        tool: "tool";
+    }>>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        not_started: "not_started";
+        failed: "failed";
+        unknown: "unknown";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"tool.call.requested">;
+    turn_id: z.ZodString;
+    tool_name: z.ZodString;
+    tool_args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tool_call_id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"tool.call.started">;
+    turn_id: z.ZodString;
+    tool_name: z.ZodString;
+    tool_call_id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"tool.call.completed">;
+    turn_id: z.ZodString;
+    tool_name: z.ZodString;
+    tool_call_id: z.ZodString;
+    result: z.ZodUnknown;
+    tokens: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+    }, z.core.$strict>>>;
+    cost_usd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"tool.call.failed">;
+    turn_id: z.ZodString;
+    tool_name: z.ZodString;
+    tool_call_id: z.ZodString;
+    error: z.ZodString;
+    error_code: z.ZodOptional<z.ZodString>;
+    error_path: z.ZodOptional<z.ZodString>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        not_started: "not_started";
+        failed: "failed";
+        unknown: "unknown";
+    }>>;
+    reason_code: z.ZodOptional<z.ZodString>;
+    recovery_code: z.ZodOptional<z.ZodString>;
+    doc_url: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"tool.approval.requested">;
+    turn_id: z.ZodString;
+    tool_name: z.ZodString;
+    tool_call_id: z.ZodString;
+    tool_args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    risk: z.ZodEnum<{
+        read: "read";
+        write: "write";
+        external_effect: "external_effect";
+        destructive: "destructive";
+        admin: "admin";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"tool.approval.approved">;
+    turn_id: z.ZodString;
+    tool_name: z.ZodString;
+    tool_call_id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"tool.approval.rejected">;
+    turn_id: z.ZodString;
+    tool_name: z.ZodString;
+    tool_call_id: z.ZodString;
+    error_code: z.ZodEnum<{
+        APPROVAL_REJECTED: "APPROVAL_REJECTED";
+        APPROVAL_TIMEOUT: "APPROVAL_TIMEOUT";
+        TURN_TIMEOUT: "TURN_TIMEOUT";
+        TOOL_CANCELLED: "TOOL_CANCELLED";
+        APPROVAL_UNAVAILABLE: "APPROVAL_UNAVAILABLE";
+    }>;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"workflow.started">;
+    workflow_name: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"workflow.completed">;
+    workflow_name: z.ZodString;
+    result: z.ZodUnknown;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"workflow.failed">;
+    workflow_name: z.ZodString;
+    error: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"cancellation.requested">;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"cancellation.completed">;
+}, z.core.$strict>], "type">;
+/** A validated Kaji event (output type, with defaults applied). */
+type KajiEvent = z.infer<typeof KajiEvent>;
+/** The input type accepted by `KajiEvent.parse` (defaults optional). */
+type KajiEventInput = z.input<typeof KajiEvent>;
+/** Base event fields, useful for typing helpers that touch any event. */
+type BaseEvent = z.infer<typeof SessionCreated>;
+/** An event draft accepted by stores and committers. Drafts never carry sequence. */
+declare const NewKajiEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"session.created">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"session.closed">;
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"user.message">;
+    content: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"user.audio.chunk">;
+    chunk_size_bytes: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"transcript.partial">;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"transcript.final">;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"memory.retrieval.started">;
+    query: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"memory.retrieval.completed">;
+    query: z.ZodString;
+    documents: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"agent.reasoning.started">;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"agent.message.delta">;
+    delta: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"agent.message.completed">;
+    content: z.ZodString;
+    tokens: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+    }, z.core.$strict>>>;
+    cost_usd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"agent.turn.exhausted">;
+    max_iterations: z.ZodNumber;
+    pending_tool_calls: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"agent.turn.failed">;
+    turn_id: z.ZodString;
+    error: z.ZodString;
+    error_code: z.ZodOptional<z.ZodString>;
+    phase: z.ZodOptional<z.ZodEnum<{
+        queue: "queue";
+        provider_open: "provider_open";
+        provider_stream: "provider_stream";
+        approval: "approval";
+        tool: "tool";
+    }>>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        not_started: "not_started";
+        failed: "failed";
+        unknown: "unknown";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"tool.call.requested">;
+    turn_id: z.ZodString;
+    tool_name: z.ZodString;
+    tool_args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    tool_call_id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"tool.call.started">;
+    turn_id: z.ZodString;
+    tool_name: z.ZodString;
+    tool_call_id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"tool.call.completed">;
+    turn_id: z.ZodString;
+    tool_name: z.ZodString;
+    tool_call_id: z.ZodString;
+    result: z.ZodUnknown;
+    tokens: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+    }, z.core.$strict>>>;
+    cost_usd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"tool.call.failed">;
+    turn_id: z.ZodString;
+    tool_name: z.ZodString;
+    tool_call_id: z.ZodString;
+    error: z.ZodString;
+    error_code: z.ZodOptional<z.ZodString>;
+    error_path: z.ZodOptional<z.ZodString>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        not_started: "not_started";
+        failed: "failed";
+        unknown: "unknown";
+    }>>;
+    reason_code: z.ZodOptional<z.ZodString>;
+    recovery_code: z.ZodOptional<z.ZodString>;
+    doc_url: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"tool.approval.requested">;
+    turn_id: z.ZodString;
+    tool_name: z.ZodString;
+    tool_call_id: z.ZodString;
+    tool_args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    risk: z.ZodEnum<{
+        read: "read";
+        write: "write";
+        external_effect: "external_effect";
+        destructive: "destructive";
+        admin: "admin";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"tool.approval.approved">;
+    turn_id: z.ZodString;
+    tool_name: z.ZodString;
+    tool_call_id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"tool.approval.rejected">;
+    turn_id: z.ZodString;
+    tool_name: z.ZodString;
+    tool_call_id: z.ZodString;
+    error_code: z.ZodEnum<{
+        APPROVAL_REJECTED: "APPROVAL_REJECTED";
+        APPROVAL_TIMEOUT: "APPROVAL_TIMEOUT";
+        TURN_TIMEOUT: "TURN_TIMEOUT";
+        TOOL_CANCELLED: "TOOL_CANCELLED";
+        APPROVAL_UNAVAILABLE: "APPROVAL_UNAVAILABLE";
+    }>;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"workflow.started">;
+    workflow_name: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"workflow.completed">;
+    workflow_name: z.ZodString;
+    result: z.ZodUnknown;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"workflow.failed">;
+    workflow_name: z.ZodString;
+    error: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"cancellation.requested">;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodDefault<z.ZodString>;
+    version: z.ZodDefault<z.ZodLiteral<"1.0">>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    session_id: z.ZodString;
+    turn_id: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    type: z.ZodLiteral<"cancellation.completed">;
+}, z.core.$strict>], "type">;
+type NewKajiEvent = KajiEvent;
+/** A persisted event. Stores assign a positive session-local sequence. */
+type StoredKajiEvent = DeepReadonly<KajiEvent & {
+    sequence: number;
+}>;
+declare const StoredKajiEvent: z.ZodPipe<z.ZodObject<{
+    sequence: z.ZodNumber;
+}, z.core.$loose>, z.ZodTransform<{
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "tool.call.failed";
+    readonly turn_id: string;
+    readonly tool_name: string;
+    readonly tool_call_id: string;
+    readonly error: string;
+    readonly error_code?: string | undefined;
+    readonly error_path?: string | undefined;
+    readonly retryable?: boolean | undefined;
+    readonly outcome?: "not_started" | "failed" | "unknown" | undefined;
+    readonly reason_code?: string | undefined;
+    readonly recovery_code?: string | undefined;
+    readonly doc_url?: string | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "session.created";
+    readonly turn_id?: string | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "session.closed";
+    readonly turn_id?: string | undefined;
+    readonly reason?: string | null | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "user.message";
+    readonly content: string;
+    readonly turn_id?: string | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "user.audio.chunk";
+    readonly chunk_size_bytes: number;
+    readonly turn_id?: string | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "transcript.partial";
+    readonly text: string;
+    readonly turn_id?: string | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "transcript.final";
+    readonly text: string;
+    readonly turn_id?: string | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "memory.retrieval.started";
+    readonly query: string;
+    readonly turn_id?: string | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "memory.retrieval.completed";
+    readonly query: string;
+    readonly documents: readonly {
+        readonly [x: string]: unknown;
+    }[];
+    readonly turn_id?: string | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "agent.reasoning.started";
+    readonly turn_id?: string | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "agent.message.delta";
+    readonly delta: string;
+    readonly turn_id?: string | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "agent.message.completed";
+    readonly content: string;
+    readonly turn_id?: string | undefined;
+    readonly tokens?: {
+        readonly input: number;
+        readonly output: number;
+    } | null | undefined;
+    readonly cost_usd?: number | null | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "agent.turn.exhausted";
+    readonly max_iterations: number;
+    readonly pending_tool_calls: readonly {
+        readonly [x: string]: unknown;
+    }[];
+    readonly turn_id?: string | undefined;
+    readonly reason?: string | null | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "agent.turn.failed";
+    readonly turn_id: string;
+    readonly error: string;
+    readonly error_code?: string | undefined;
+    readonly phase?: "queue" | "provider_open" | "provider_stream" | "approval" | "tool" | undefined;
+    readonly retryable?: boolean | undefined;
+    readonly outcome?: "not_started" | "failed" | "unknown" | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "tool.call.requested";
+    readonly turn_id: string;
+    readonly tool_name: string;
+    readonly tool_args: {
+        readonly [x: string]: unknown;
+    };
+    readonly tool_call_id: string;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "tool.call.started";
+    readonly turn_id: string;
+    readonly tool_name: string;
+    readonly tool_call_id: string;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "tool.call.completed";
+    readonly turn_id: string;
+    readonly tool_name: string;
+    readonly tool_call_id: string;
+    readonly result: unknown;
+    readonly tokens?: {
+        readonly input: number;
+        readonly output: number;
+    } | null | undefined;
+    readonly cost_usd?: number | null | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "tool.approval.requested";
+    readonly turn_id: string;
+    readonly tool_name: string;
+    readonly tool_call_id: string;
+    readonly tool_args: {
+        readonly [x: string]: unknown;
+    };
+    readonly risk: "read" | "write" | "external_effect" | "destructive" | "admin";
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "tool.approval.approved";
+    readonly turn_id: string;
+    readonly tool_name: string;
+    readonly tool_call_id: string;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "tool.approval.rejected";
+    readonly turn_id: string;
+    readonly tool_name: string;
+    readonly tool_call_id: string;
+    readonly error_code: "APPROVAL_REJECTED" | "APPROVAL_TIMEOUT" | "TURN_TIMEOUT" | "TOOL_CANCELLED" | "APPROVAL_UNAVAILABLE";
+    readonly reason: string;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "workflow.started";
+    readonly workflow_name: string;
+    readonly turn_id?: string | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "workflow.completed";
+    readonly workflow_name: string;
+    readonly result: unknown;
+    readonly turn_id?: string | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "workflow.failed";
+    readonly workflow_name: string;
+    readonly error: string;
+    readonly turn_id?: string | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "cancellation.requested";
+    readonly reason: string;
+    readonly turn_id?: string | undefined;
+    readonly sequence: number;
+} | {
+    readonly id: string;
+    readonly version: "1.0";
+    readonly timestamp: number;
+    readonly session_id: string;
+    readonly metadata: {
+        readonly [x: string]: unknown;
+    };
+    readonly type: "cancellation.completed";
+    readonly turn_id?: string | undefined;
+    readonly sequence: number;
+}, {
+    [x: string]: unknown;
+    sequence: number;
+}>>;
+/** Validate an untouched new-event mapping before constructor defaults can run. */
+declare function validateNewEvent(value: unknown): NewKajiEvent;
+/** Validate an untouched stored-event mapping before constructor defaults can run. */
+declare function validateStoredEvent(value: unknown): StoredKajiEvent;
+
+/** Dependency-free, low-cardinality observability contracts for the stable runtime. */
+type ProviderFamily = "openai" | "anthropic" | "custom";
+type SpanName = "kaji.turn" | "kaji.provider" | "kaji.tool" | "kaji.integration.auth" | "kaji.integration.request";
+type ProviderStatus = "success" | "error" | "cancelled";
+type TurnOutcome = "completed" | "failed" | "cancelled";
+type ToolMetricOutcome = "acquired" | "completed" | "failed" | "cancelled" | "timeout" | "not_started" | "unknown";
+type JournalStage = "append" | "publish";
+type SubscriberStage = "lag" | "overflow";
+interface MetricLabelsByName {
+    "kaji.turn.queue_wait_ms": Record<never, never>;
+    "kaji.turn.duration_ms": {
+        outcome: TurnOutcome;
+    };
+    "kaji.turn.iterations": {
+        outcome: TurnOutcome;
+    };
+    "kaji.provider.duration_ms": {
+        provider_family: ProviderFamily;
+        status: ProviderStatus;
+    };
+    "kaji.provider.retries": {
+        provider_family: ProviderFamily;
+    };
+    "kaji.replay.input_events": Record<never, never>;
+    "kaji.context.messages": Record<never, never>;
+    "kaji.context.characters": Record<never, never>;
+    "kaji.tool.queue_wait_ms": {
+        outcome: ToolMetricOutcome;
+    };
+    "kaji.tool.active": Record<never, never>;
+    "kaji.tool.duration_ms": {
+        outcome: ToolMetricOutcome;
+        error_code: string;
+    };
+    "kaji.journal.failures": {
+        stage: JournalStage;
+    };
+    "kaji.subscriber.lag_events": Record<never, never>;
+    "kaji.subscriber.overflow": {
+        stage: SubscriberStage;
+    };
+    "kaji.integration.auth_ms": {
+        integration: "github" | "gmail";
+        operation: "token";
+        outcome: ProviderStatus;
+    };
+    "kaji.integration.request_ms": {
+        integration: "github" | "gmail";
+        operation: "read" | "mutation";
+        outcome: ProviderStatus;
+    };
+}
+interface MetricUnitByName {
+    "kaji.turn.queue_wait_ms": "ms";
+    "kaji.turn.duration_ms": "ms";
+    "kaji.turn.iterations": "count";
+    "kaji.provider.duration_ms": "ms";
+    "kaji.provider.retries": "count";
+    "kaji.replay.input_events": "count";
+    "kaji.context.messages": "count";
+    "kaji.context.characters": "count";
+    "kaji.tool.queue_wait_ms": "ms";
+    "kaji.tool.active": "gauge";
+    "kaji.tool.duration_ms": "ms";
+    "kaji.journal.failures": "count";
+    "kaji.subscriber.lag_events": "count";
+    "kaji.subscriber.overflow": "count";
+    "kaji.integration.auth_ms": "ms";
+    "kaji.integration.request_ms": "ms";
+}
+type MetricName = keyof MetricLabelsByName;
+type MetricLabels<TName extends MetricName> = Readonly<MetricLabelsByName[TName]>;
+type MetricMeasurement = {
+    [TName in MetricName]: Readonly<{
+        name: TName;
+        value: number;
+        unit: MetricUnitByName[TName];
+        labels: MetricLabels<TName>;
+    }>;
+}[MetricName];
+interface MetricsSink {
+    record(measurement: MetricMeasurement): void | Promise<void>;
+}
+type TraceAttributeName = "session.id" | "turn.id" | "request.id" | "trace.id" | "tool.call_id" | "provider.family" | "integration.name" | "integration.operation" | "http.status_family";
+type TraceAttributeValue = string;
+type TraceAttributes = Readonly<Partial<Record<TraceAttributeName, TraceAttributeValue>>>;
+interface TraceSpan {
+    setAttribute(name: TraceAttributeName, value: TraceAttributeValue): void;
+    recordError(error: unknown): void;
+    end(): void;
+}
+interface TraceSink {
+    startSpan(name: SpanName, attributes?: TraceAttributes): TraceSpan;
+}
+declare const METRIC_NAMES: readonly MetricName[];
+/** Record a validated measurement. Invalid tuples fail closed; sink failures stay observational. */
+declare function recordMetric<TName extends MetricName>(sink: MetricsSink, name: TName, value: number, labels: MetricLabels<TName>): void;
+declare const NOOP_METRICS: MetricsSink;
+declare const NOOP_TRACE: TraceSink;
+/** Start a span protected from throwing third-party sinks and span handles. */
+declare function startSpan(sink: TraceSink, name: SpanName, attributes?: TraceAttributes): TraceSpan;
+declare function providerFamily(provider: object): ProviderFamily;
+
+/** A single conversation turn in the projected state. */
+interface MessageToolCall {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+}
+interface Message {
+    role: "user" | "assistant" | "tool";
+    content: string;
+    /** Set only for tool messages. */
+    name?: string;
+    /** Set only for tool messages: the id from the originating tool call request. */
+    toolCallId?: string;
+    /** Set only for assistant messages that requested tools. */
+    toolCalls?: MessageToolCall[];
+}
+/** Accumulated token counts across all turns in the session. */
+interface SessionTokens {
+    input: number;
+    output: number;
+}
+declare const APPROVAL_KEY: unique symbol;
+/** Stable value key for the approval security/correlation tuple. */
+type ApprovalKey = string & {
+    readonly [APPROVAL_KEY]: true;
+};
+type ApprovalFailureCode = "APPROVAL_REJECTED" | "APPROVAL_TIMEOUT" | "TURN_TIMEOUT" | "TOOL_CANCELLED" | "APPROVAL_UNAVAILABLE";
+declare function approvalKey(turnId: string, toolCallId: string, toolName: string): ApprovalKey;
+/** A projection of the event log into current session state. */
+interface SessionState {
+    sessionId: string;
+    isActive: boolean;
+    messages: Message[];
+    /**
+     * Correlation triples that emitted TOOL_APPROVAL_REQUESTED but have not yet
+     * been approved or rejected.
+     */
+    pendingApprovals: Set<ApprovalKey>;
+    approvedApprovals: Set<ApprovalKey>;
+    rejectedApprovals: Map<ApprovalKey, ApprovalFailureCode>;
+    /** Total tokens consumed in this session (summed from AGENT_MESSAGE_COMPLETED events). */
+    totalTokens: SessionTokens;
+    /** Estimated total cost in USD for this session. */
+    totalCostUsd: number;
+}
+/** Create an empty projection for incremental application. */
+declare function createSessionState(sessionId: string): SessionState;
+/**
+ * Reconstruct session state from stored events. Sequences must already be
+ * strictly monotonic.
+ *
+ * TOOL_CALL_REQUESTED events are attached to the most recent assistant message
+ * so provider history includes the assistant-side tool call before the matching
+ * role:tool result. OpenAI and Anthropic reject orphan tool-result messages.
+ */
+declare function replaySession(events: readonly StoredKajiEvent[]): SessionState;
+/** Apply one persisted event to an existing session projection in place. */
+declare function applyEvent(state: SessionState, event: StoredKajiEvent): number | null;
+
+type UuidFactory = () => string;
+type IdScope = "event" | "session" | "turn" | "request" | "trace" | "tool_call";
+interface IdFactory {
+    next(scope: IdScope): string;
+}
+interface Clock {
+    nowWallSeconds(): number;
+    /** Monotonic milliseconds, matching `performance.now()`. */
+    nowMonotonic(): number;
+}
+interface TimerHandle {
+    cancel(): void;
+}
+/** Minimal one-shot timer seam used by deadline races. */
+interface TimerScheduler {
+    schedule(delayMs: number, callback: () => void): TimerHandle;
+}
+
+/**
+ * Cancellation token for the agent loop, mirroring the Python
+ * `CancellationToken`. Carries a backing `AbortController` so the same
+ * cancel signal can be plumbed into platform APIs that accept an
+ * `AbortSignal` (the `openai` / `@anthropic-ai/sdk` clients, `fetch`,
+ * `EventTarget` listeners, etc.). The boolean `isCancelled` flag remains
+ * for the polling style the runtime already uses; both fire together.
+ */
+declare class CancellationError extends Error {
+    constructor(message?: string);
+}
+interface CancellationTokenLike {
+    isCancelled: boolean;
+    signal?: AbortSignal;
+    throwIfCancelled?: () => void;
+}
+declare function throwIfCancellationRequested(token?: CancellationTokenLike): void;
+declare class CancellationToken {
+    private readonly controller;
+    /** Whether `cancel()` has been called. */
+    get isCancelled(): boolean;
+    /**
+     * The underlying `AbortSignal`. Pass this directly to APIs that accept
+     * one (the OpenAI / Anthropic SDKs, `fetch`, etc.) so the network call
+     * aborts on cancel instead of just polling out at the next yield point.
+     */
+    get signal(): AbortSignal;
+    cancel(): void;
+    throwIfCancelled(): void;
+}
+
+/** Compiled Draft 2020-12 validation for provider-supplied tool arguments. */
+
+type ToolValidationCode = "INVALID_TOOL_SCHEMA" | "INVALID_TOOL_ARGUMENTS" | "UNCLASSIFIED_TOOL_RISK";
+type ToolExecutionOutcome = "not_started";
+type ToolArgumentValidator = (toolName: string, args: unknown) => Promise<void>;
+declare const TOOL_ARGUMENT_VALIDATOR: unique symbol;
+declare abstract class ToolValidationError extends Error {
+    readonly code: ToolValidationCode;
+    readonly toolName: string;
+    readonly path: string;
+    readonly retryable = false;
+    readonly outcome: ToolExecutionOutcome;
+    protected constructor(code: ToolValidationCode, toolName: string, path: string, message: string);
+    normalized(): {
+        code: ToolValidationCode;
+        path: string;
+        message: string;
+    };
+}
+declare class ToolArgumentValidationError extends ToolValidationError {
+    private constructor();
+    static fromAjv(toolName: string, errors: readonly ErrorObject[]): ToolArgumentValidationError;
+    static nonObject(toolName: string): ToolArgumentValidationError;
+    static parseError(toolName: string): ToolArgumentValidationError;
+    static fromValidationIssue(toolName: string, pathParts: readonly PropertyKey[], keyword: string): ToolArgumentValidationError;
+    static jsonUnsafe(toolName: string, path: string): ToolArgumentValidationError;
+    static oversize(toolName: string): ToolArgumentValidationError;
+    static changedDuringValidation(toolName: string): ToolArgumentValidationError;
+}
+declare class ToolSchemaValidationError extends ToolValidationError {
+    private constructor();
+    static fromAjv(toolName: string, errors: readonly ErrorObject[]): ToolSchemaValidationError;
+    static compilation(toolName: string): ToolSchemaValidationError;
+    static jsonUnsafe(toolName: string, path: string): ToolSchemaValidationError;
+    static invalidRisk(toolName: string): ToolSchemaValidationError;
+}
+/** Compile each tool schema once and validate calls without exposing receipts. */
+declare class ToolSchemaValidator {
+    constructor(specs?: ReadonlyMap<string, ToolSpec>);
+    /** Validate a private clone; Zod parse results are intentionally discarded. */
+    validate(name: string, args: unknown): Promise<void>;
+}
+
+/**
+ * Tool registry for LLM-callable functions, mirroring
+ * `kaji.runtime.tools.registry`. A process-level registry holds specs and
+ * handlers; tools run with a `ToolExecutionContext` and need no infra by default.
+ */
+
+/** A JSON Schema object describing a tool's parameters. */
+type JSONSchema = Readonly<Record<string, unknown>>;
+/** Parameter schema accepted at tool authoring boundaries. */
+type ToolParameters = JSONSchema | z.ZodType;
+/** Risk level for a tool, used by ToolPolicy to gate execution. */
+type ToolRisk = "read" | "write" | "external_effect" | "destructive" | "admin";
+declare class UnclassifiedToolRiskError extends Error {
+    readonly toolName: string;
+    readonly code: "UNCLASSIFIED_TOOL_RISK";
+    readonly retryable = false;
+    readonly outcome: "not_started";
+    constructor(toolName: string);
+}
+/** Definition of a tool exposed to the LLM. */
+interface ToolSpec {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: JSONSchema;
+    readonly catalogName?: string;
+    readonly tags?: readonly string[];
+    readonly enabled?: boolean;
+    /** Risk classification for policy enforcement and approval routing. */
+    readonly risk: ToolRisk;
+    /** Explicit opt-in for bounded overlap with adjacent parallel-safe tools. */
+    readonly parallel_safe?: boolean;
+    /** Per-tool execution deadline. Must be a positive integer when present. */
+    readonly timeout_ms?: number;
+    readonly [TOOL_ARGUMENT_VALIDATOR]?: ToolArgumentValidator;
+}
+/** A tool handler: receives validated args and canonical execution context. */
+type ToolHandler = (args: Record<string, unknown>, context: ToolExecutionContext) => Promise<Record<string, unknown>>;
+/** Metadata attached to a handler by `tool(meta, fn)`. */
+interface ToolMeta {
+    description: string;
+    parameters: ToolParameters;
+    risk: ToolRisk;
+    tags?: string[];
+    enabled?: boolean;
+    parallel_safe?: boolean;
+    timeout_ms?: number;
+}
+interface ListToolSpecsOptions {
+    tags?: string[];
+    enabledOnly?: boolean;
+}
+/**
+ * Build a tool spec from a Zod schema while preserving its complete validation
+ * schema, including nested constraints and references.
+ */
+declare function toolSpecFromSchema(name: string, description: string, schema: z.ZodType, risk: ToolRisk): ToolSpec;
+/**
+ * Scoped tool registry for per-agent or per-tenant isolation.
+ *
+ * The module-level `registerTool`, `listToolSpecs`, and `executeTool`
+ * functions delegate to a single default `ToolRegistry` instance, which is
+ * sufficient for simple setups. Construct your own `ToolRegistry` when you
+ * need multiple isolated registries.
+ *
+ * @example
+ * ```ts
+ * const registry = new ToolRegistry();
+ * registry.register(
+ *   { name: "ping", description: "...", parameters: {}, risk: "read" },
+ *   async (_args, context) => ({ pong: true, principalId: context.principalId }),
+ * );
+ * await registry.execute("ping", {}, {
+ *   principalId: "user-1",
+ *   sessionId: "session-1",
+ *   turnId: "turn-1",
+ *   requestId: "request-1",
+ *   traceId: "trace-1",
+ *   toolCallId: "call-1",
+ *   idempotencyKey: "session-1:call-1",
+ *   signal: new AbortController().signal,
+ *   metadata: {},
+ * });
+ * ```
+ */
+declare class ToolRegistry {
+    private readonly specs;
+    private readonly handlers;
+    private readonly schemaValidator;
+    constructor(schemaValidator?: ToolSchemaValidator);
+    register(spec: ToolSpec, handler: ToolHandler): this;
+    register(name: string, handler: ToolHandler): this;
+    listSpecs(options?: ListToolSpecsOptions): ToolSpec[];
+    execute(toolName: string, toolArgs: Record<string, unknown>, context: ToolExecutionContext): Promise<Record<string, unknown>>;
+    clear(): void;
+}
+/** Thrown when a tool is requested by name but not registered. */
+declare class UnknownToolError extends Error {
+    readonly toolName: string;
+    constructor(toolName: string);
+}
+/** Register a tool handler on the process-default registry. Accepts either a
+ * full ToolSpec + handler, or a pre-tagged handler (from `tool(meta, fn)`)
+ * with just a name string. */
+declare function registerTool(spec: ToolSpec, handler: ToolHandler): void;
+declare function registerTool(name: string, handler: ToolHandler): void;
+/** Return registered tool specs from the process-default registry. */
+declare function listToolSpecs(options?: ListToolSpecsOptions): ToolSpec[];
+/** Execute a registered tool call from the process-default registry. */
+declare function executeTool(toolName: string, toolArgs: Record<string, unknown>, context: ToolExecutionContext): Promise<Record<string, unknown>>;
+
+/**
+ * Provider interface for LLM backends, mirroring
+ * `kaji.runtime.providers.base.ModelProvider`.
+ *
+ * Each provider translates the neutral message + tool format to its own API at
+ * its boundary. The runtime never imports provider-specific types.
+ */
+
+/** A message in the conversation history passed to the provider. */
+interface ProviderMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    /** Set only for tool-result messages. */
+    name?: string;
+    /** Set only for tool-result messages: id from the originating tool call. */
+    tool_call_id?: string;
+    /** Set only for assistant messages that requested tools. */
+    toolCalls?: ToolCall[];
+}
+/** A tool call the model wants to make. */
+interface ToolCall {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+}
+/** A streaming chunk from the provider. */
+interface ModelResponseChunk {
+    delta: string;
+    toolCalls: ToolCall[];
+    /** Token usage, if the provider reported it during streaming. */
+    usage?: TokenUsage;
+    /** Estimated cost in USD, if the model is in the cost table. */
+    costUsd?: number;
+}
+/** Token usage from a provider response. */
+interface TokenUsage {
+    /** Prompt / input tokens consumed. */
+    input: number;
+    /** Completion / output tokens generated. */
+    output: number;
+}
+/** A complete non-streaming response. */
+interface ModelResponse {
+    content: string;
+    toolCalls: ToolCall[];
+    /** Token usage, if the provider reported it. */
+    usage?: TokenUsage;
+    /** Estimated cost in USD, if the model is in the cost table. */
+    costUsd?: number;
+}
+/** Immutable per-call provider response bounds. */
+interface ProviderResponseLimits {
+    readonly textMaxBytes: number;
+    readonly toolArgumentsMaxBytes: number;
+    readonly responseMaxBytes: number;
+    readonly toolCallsMax: number;
+}
+/** Linear-assembly evidence captured for one provider response. */
+interface ProviderResponseDiagnostics {
+    readonly rawFragments: number;
+    readonly toolArgumentJoinOperations: number;
+}
+/** Internal per-call sink used by the runtime without changing stream chunks. */
+interface ProviderResponseDiagnosticsSink {
+    record(diagnostics: Readonly<ProviderResponseDiagnostics>): void;
+}
+/** @internal Attach runtime-owned diagnostics without exposing a public option. */
+declare function withProviderResponseDiagnostics(options: ModelProviderOptions, sink: ProviderResponseDiagnosticsSink): ModelProviderOptions;
+declare const DEFAULT_PROVIDER_RESPONSE_LIMITS: Readonly<ProviderResponseLimits>;
+declare function resolveProviderResponseLimits(limits: Readonly<ProviderResponseLimits> | undefined): Readonly<ProviderResponseLimits>;
+/**
+ * Per-call options that callers may override from the constructor defaults.
+ *
+ * `cancellationToken` is structurally typed: any object with an
+ * `isCancelled` boolean is accepted. Pass a full `CancellationToken`
+ * (which also carries an `AbortSignal` under `.signal`) to let the
+ * provider abort the underlying HTTP call, not just poll out at the next
+ * yield point.
+ */
+interface ModelProviderOptions {
+    temperature?: number;
+    maxTokens?: number;
+    cancellationToken?: CancellationTokenLike;
+    /** Runtime-injected metrics sink. Provider implementations must keep labels low-cardinality. */
+    metricsSink?: MetricsSink;
+    /** Runtime-injected immutable response limits. */
+    responseLimits?: Readonly<ProviderResponseLimits>;
+}
+/** Common interface every LLM provider implements. */
+interface ModelProvider {
+    /**
+     * Custom providers are cooperative cancellation boundaries. Both methods
+     * must observe `options.cancellationToken` while opening and streaming,
+     * stop their underlying request, and let the returned iterator settle when
+     * cancellation is requested. A provider that misses the configured grace
+     * causes a typed contract violation and quarantines that session until a
+     * successful `drainProviders()`. Custom adapters must pass the SDK's
+     * cancellation-contract suite before being described as production-safe.
+     */
+    /** Stable low-cardinality family identifier for observability. */
+    readonly providerFamily?: ProviderFamily;
+    generate(messages: ProviderMessage[], tools: ToolSpec[], options?: ModelProviderOptions): Promise<ModelResponse>;
+    generateStream(messages: ProviderMessage[], tools: ToolSpec[], options?: ModelProviderOptions): AsyncGenerator<ModelResponseChunk>;
+}
+/** Rate-limit retry configuration shared by HTTP-backed providers. */
+interface RetryOptions {
+    /** Maximum retry attempts on 429 rate-limit responses. Defaults to 3. */
+    maxAttempts?: number;
+    /** Base delay in ms before first retry. Doubles each attempt. Defaults to 1000. */
+    baseDelayMs?: number;
+}
+
+/**
+ * Build the provider message list from replayed session state. Mirrors the
+ * message construction in `kaji.runtime.agents.runtime`.
+ */
+
+/** Caller-owned context applied to one agent turn. */
+interface TurnContext {
+    readonly principalId?: string;
+    readonly requestId?: string;
+    readonly traceId?: string;
+    /**
+     * Absolute Unix epoch deadline in milliseconds. An earlier value tightens,
+     * but never extends, the runtime's configured whole-turn maximum.
+     * Use `deadlineAfter()` when starting from a duration.
+     */
+    readonly deadlineAtMs?: number;
+    readonly db?: unknown;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** Fully resolved authorization and correlation context for one tool call. */
+interface ToolExecutionContext {
+    readonly principalId: string;
+    readonly sessionId: string;
+    readonly turnId: string;
+    readonly requestId: string;
+    readonly traceId: string;
+    readonly toolCallId: string;
+    readonly idempotencyKey: string;
+    readonly deadlineMonotonicMs?: number;
+    readonly signal: AbortSignal;
+    readonly db?: unknown;
+    readonly metadata: Readonly<Record<string, unknown>>;
+}
+declare class MissingToolIdentityError extends Error {
+    readonly code: "MISSING_TOOL_IDENTITY";
+    readonly retryable = false;
+    readonly outcome: "not_started";
+    constructor();
+}
+/** Convert a caller duration to an absolute Unix epoch deadline for `TurnContext`. */
+declare function deadlineAfter(timeoutMs: number, clock?: Clock): number;
+interface ContextWindow {
+    maxTurns: number | null;
+    maxCharacters: number | null;
+}
+interface ContextDiagnostics {
+    readonly droppedTurns: number;
+    readonly droppedMessages: number;
+    readonly droppedCharacters: number;
+}
+interface ContextBuildResult {
+    messages: ProviderMessage[];
+    diagnostics: ContextDiagnostics;
+}
+declare const DEFAULT_CONTEXT_WINDOW: Readonly<ContextWindow>;
+declare class ContextWindowOverflowError extends Error {
+    readonly currentTurnCharacters: number;
+    readonly maxCharacters: number;
+    constructor(currentTurnCharacters: number, maxCharacters: number);
+}
+declare class ContextIntegrityError extends Error {
+    constructor(message: string);
+}
+
+export { type ProviderStatus as $, AgentTurnFailed as A, type BaseEvent as B, type ContextWindow as C, DEFAULT_CONTEXT_WINDOW as D, type IdScope as E, type JournalStage as F, type KajiEventInput as G, METRIC_NAMES as H, type IdFactory as I, type JSONSchema as J, KajiEvent as K, type ListToolSpecsOptions as L, type MetricsSink as M, NewKajiEvent as N, type Message as O, type ProviderMessage as P, type MetricLabels as Q, type RetryOptions as R, StoredKajiEvent as S, type ToolRisk as T, type MetricMeasurement as U, type MetricName as V, MissingToolIdentityError as W, NOOP_METRICS as X, NOOP_TRACE as Y, type ProviderFamily as Z, type ProviderResponseLimits as _, type SessionState as a, SessionCreated as a0, type SessionTokens as a1, type SpanName as a2, type SubscriberStage as a3, type TimerHandle as a4, ToolArgumentValidationError as a5, type ToolExecutionOutcome as a6, type ToolMetricOutcome as a7, type ToolParameters as a8, ToolSchemaValidationError as a9, type ProviderResponseDiagnostics as aA, createSessionState as aB, withProviderResponseDiagnostics as aC, ToolSchemaValidator as aa, type ToolValidationCode as ab, ToolValidationError as ac, type TraceAttributeName as ad, type TraceAttributeValue as ae, type TraceAttributes as af, type TraceSpan as ag, type TurnOutcome as ah, UnclassifiedToolRiskError as ai, UnknownToolError as aj, type UuidFactory as ak, applyEvent as al, approvalKey as am, deadlineAfter as an, executeTool as ao, listToolSpecs as ap, providerFamily as aq, recordMetric as ar, registerTool as as, replaySession as at, resolveProviderResponseLimits as au, startSpan as av, throwIfCancellationRequested as aw, toolSpecFromSchema as ax, validateNewEvent as ay, validateStoredEvent as az, type ContextBuildResult as b, type ToolCall as c, type ToolExecutionContext as d, type TimerScheduler as e, type TraceSink as f, type ToolSpec as g, type Clock as h, type ModelProvider as i, type ModelProviderOptions as j, type ModelResponse as k, type ModelResponseChunk as l, type ToolHandler as m, ToolRegistry as n, type ToolMeta as o, type CancellationTokenLike as p, type TurnContext as q, type ContextDiagnostics as r, CancellationToken as s, type TokenUsage as t, type ApprovalFailureCode as u, type ApprovalKey as v, CancellationError as w, ContextIntegrityError as x, ContextWindowOverflowError as y, DEFAULT_PROVIDER_RESPONSE_LIMITS as z };