@amalgm/chat 0.1.0

package/dist/events/schema.d.ts

@@ -0,0 +1,455 @@
+/**
+ * Canonical amalgm event grammar — engine `chat-core/event-schema.js`
+ * (239 lines) ported byte-exact on zod v4 (engine pins zod ^4.4.3; this
+ * package pins the same major+minor so validation output and issue
+ * messages match).
+ *
+ * The discriminated union over `type` is the product's spine: every native
+ * harness event is normalized into one of these twelve shapes before it
+ * touches the wire, the reducer, or the transcript.
+ */
+import { z } from 'zod';
+/** Engine event-schema.js:17-40 — 21 kinds including the legacy ACP-ish tail. */
+declare const toolKind: z.ZodEnum<{
+    unknown: "unknown";
+    web_search: "web_search";
+    browser: "browser";
+    file_read: "file_read";
+    file_write: "file_write";
+    file_edit: "file_edit";
+    bash: "bash";
+    subagent: "subagent";
+    mcp: "mcp";
+    question: "question";
+    todo: "todo";
+    read: "read";
+    edit: "edit";
+    delete: "delete";
+    move: "move";
+    search: "search";
+    execute: "execute";
+    think: "think";
+    fetch: "fetch";
+    switch_mode: "switch_mode";
+    other: "other";
+}>;
+export declare const usageSnapshot: z.ZodObject<{
+    tokenList: z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        cacheRead: z.ZodNumber;
+        cacheWrite: z.ZodNumber;
+        thought: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strict>;
+    cumulativeTokenList: z.ZodNullable<z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        cacheRead: z.ZodNumber;
+        cacheWrite: z.ZodNumber;
+        thought: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strict>>;
+    previousCumulativeTokenList: z.ZodNullable<z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        cacheRead: z.ZodNumber;
+        cacheWrite: z.ZodNumber;
+        thought: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strict>>;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    cacheReadTokens: z.ZodNumber;
+    cacheWriteTokens: z.ZodNumber;
+    thoughtTokens: z.ZodNumber;
+    inputContextSize: z.ZodNumber;
+    contextUsedTokens: z.ZodNullable<z.ZodNumber>;
+    contextLimit: z.ZodNullable<z.ZodNumber>;
+    usedTokens: z.ZodNullable<z.ZodNumber>;
+    lastUsedTokens: z.ZodNullable<z.ZodNumber>;
+    maxTokens: z.ZodNullable<z.ZodNumber>;
+    totalProcessedTokens: z.ZodNullable<z.ZodNumber>;
+    costUsd: z.ZodNullable<z.ZodNumber>;
+    marketCostUsd: z.ZodNullable<z.ZodNumber>;
+    operation: z.ZodString;
+    billable: z.ZodBoolean;
+    source: z.ZodString;
+    exact: z.ZodBoolean;
+}, z.core.$strict>;
+declare const compactionTrigger: z.ZodEnum<{
+    auto: "auto";
+    manual: "manual";
+    model_triggered: "model_triggered";
+}>;
+export declare const amalgmEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ts: z.ZodNumber;
+    providerSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    raw: z.ZodOptional<z.ZodObject<{
+        source: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    type: z.ZodLiteral<"text.delta">;
+    text: z.ZodString;
+    streamKind: z.ZodOptional<z.ZodLiteral<"text">>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodNumber;
+    providerSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    raw: z.ZodOptional<z.ZodObject<{
+        source: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    type: z.ZodLiteral<"text.boundary">;
+    streamKind: z.ZodOptional<z.ZodLiteral<"text">>;
+    itemId: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodNumber;
+    providerSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    raw: z.ZodOptional<z.ZodObject<{
+        source: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    type: z.ZodLiteral<"reasoning.delta">;
+    text: z.ZodString;
+    streamKind: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"reasoning">, z.ZodLiteral<"plan">]>>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodNumber;
+    providerSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    raw: z.ZodOptional<z.ZodObject<{
+        source: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    type: z.ZodLiteral<"tool.started">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        web_search: "web_search";
+        browser: "browser";
+        file_read: "file_read";
+        file_write: "file_write";
+        file_edit: "file_edit";
+        bash: "bash";
+        subagent: "subagent";
+        mcp: "mcp";
+        question: "question";
+        todo: "todo";
+        read: "read";
+        edit: "edit";
+        delete: "delete";
+        move: "move";
+        search: "search";
+        execute: "execute";
+        think: "think";
+        fetch: "fetch";
+        switch_mode: "switch_mode";
+        other: "other";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+    detail: z.ZodOptional<z.ZodString>;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    timing: z.ZodOptional<z.ZodObject<{
+        startedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        completedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        elapsedMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    data: z.ZodOptional<z.ZodUnknown>;
+    itemType: z.ZodOptional<z.ZodLiteral<"tool">>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodNumber;
+    providerSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    raw: z.ZodOptional<z.ZodObject<{
+        source: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    type: z.ZodLiteral<"tool.updated">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        web_search: "web_search";
+        browser: "browser";
+        file_read: "file_read";
+        file_write: "file_write";
+        file_edit: "file_edit";
+        bash: "bash";
+        subagent: "subagent";
+        mcp: "mcp";
+        question: "question";
+        todo: "todo";
+        read: "read";
+        edit: "edit";
+        delete: "delete";
+        move: "move";
+        search: "search";
+        execute: "execute";
+        think: "think";
+        fetch: "fetch";
+        switch_mode: "switch_mode";
+        other: "other";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+    detail: z.ZodOptional<z.ZodString>;
+    inputDelta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    outputDelta: z.ZodOptional<z.ZodUnknown>;
+    output: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+        details: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    timing: z.ZodOptional<z.ZodObject<{
+        startedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        completedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        elapsedMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    data: z.ZodOptional<z.ZodUnknown>;
+    status: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        in_progress: "in_progress";
+        completed: "completed";
+        failed: "failed";
+    }>>;
+    itemType: z.ZodOptional<z.ZodLiteral<"tool">>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodNumber;
+    providerSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    raw: z.ZodOptional<z.ZodObject<{
+        source: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    type: z.ZodLiteral<"tool.completed">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        web_search: "web_search";
+        browser: "browser";
+        file_read: "file_read";
+        file_write: "file_write";
+        file_edit: "file_edit";
+        bash: "bash";
+        subagent: "subagent";
+        mcp: "mcp";
+        question: "question";
+        todo: "todo";
+        read: "read";
+        edit: "edit";
+        delete: "delete";
+        move: "move";
+        search: "search";
+        execute: "execute";
+        think: "think";
+        fetch: "fetch";
+        switch_mode: "switch_mode";
+        other: "other";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+    detail: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    output: z.ZodOptional<z.ZodUnknown>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+        details: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    timing: z.ZodOptional<z.ZodObject<{
+        startedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        completedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        elapsedMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    data: z.ZodOptional<z.ZodUnknown>;
+    isError: z.ZodBoolean;
+    itemType: z.ZodOptional<z.ZodLiteral<"tool">>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodNumber;
+    providerSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    raw: z.ZodOptional<z.ZodObject<{
+        source: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    type: z.ZodLiteral<"usage.final">;
+    usage: z.ZodObject<{
+        tokenList: z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            thought: z.ZodNumber;
+            total: z.ZodNumber;
+        }, z.core.$strict>;
+        cumulativeTokenList: z.ZodNullable<z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            thought: z.ZodNumber;
+            total: z.ZodNumber;
+        }, z.core.$strict>>;
+        previousCumulativeTokenList: z.ZodNullable<z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            thought: z.ZodNumber;
+            total: z.ZodNumber;
+        }, z.core.$strict>>;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        cacheReadTokens: z.ZodNumber;
+        cacheWriteTokens: z.ZodNumber;
+        thoughtTokens: z.ZodNumber;
+        inputContextSize: z.ZodNumber;
+        contextUsedTokens: z.ZodNullable<z.ZodNumber>;
+        contextLimit: z.ZodNullable<z.ZodNumber>;
+        usedTokens: z.ZodNullable<z.ZodNumber>;
+        lastUsedTokens: z.ZodNullable<z.ZodNumber>;
+        maxTokens: z.ZodNullable<z.ZodNumber>;
+        totalProcessedTokens: z.ZodNullable<z.ZodNumber>;
+        costUsd: z.ZodNullable<z.ZodNumber>;
+        marketCostUsd: z.ZodNullable<z.ZodNumber>;
+        operation: z.ZodString;
+        billable: z.ZodBoolean;
+        source: z.ZodString;
+        exact: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodNumber;
+    providerSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    raw: z.ZodOptional<z.ZodObject<{
+        source: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    type: z.ZodLiteral<"compaction.started">;
+    trigger: z.ZodEnum<{
+        auto: "auto";
+        manual: "manual";
+        model_triggered: "model_triggered";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodNumber;
+    providerSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    raw: z.ZodOptional<z.ZodObject<{
+        source: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    type: z.ZodLiteral<"compaction.finished">;
+    trigger: z.ZodEnum<{
+        auto: "auto";
+        manual: "manual";
+        model_triggered: "model_triggered";
+    }>;
+    preTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    postTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    durationMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodNumber;
+    providerSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    raw: z.ZodOptional<z.ZodObject<{
+        source: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    type: z.ZodLiteral<"warning">;
+    message: z.ZodString;
+    requestedModel: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodNumber;
+    providerSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    raw: z.ZodOptional<z.ZodObject<{
+        source: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    type: z.ZodLiteral<"error">;
+    message: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodNumber;
+    providerSessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    raw: z.ZodOptional<z.ZodObject<{
+        source: z.ZodString;
+        method: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    type: z.ZodLiteral<"done">;
+    stopReason: z.ZodString;
+    usage: z.ZodOptional<z.ZodObject<{
+        tokenList: z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            thought: z.ZodNumber;
+            total: z.ZodNumber;
+        }, z.core.$strict>;
+        cumulativeTokenList: z.ZodNullable<z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            thought: z.ZodNumber;
+            total: z.ZodNumber;
+        }, z.core.$strict>>;
+        previousCumulativeTokenList: z.ZodNullable<z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cacheRead: z.ZodNumber;
+            cacheWrite: z.ZodNumber;
+            thought: z.ZodNumber;
+            total: z.ZodNumber;
+        }, z.core.$strict>>;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        cacheReadTokens: z.ZodNumber;
+        cacheWriteTokens: z.ZodNumber;
+        thoughtTokens: z.ZodNumber;
+        inputContextSize: z.ZodNumber;
+        contextUsedTokens: z.ZodNullable<z.ZodNumber>;
+        contextLimit: z.ZodNullable<z.ZodNumber>;
+        usedTokens: z.ZodNullable<z.ZodNumber>;
+        lastUsedTokens: z.ZodNullable<z.ZodNumber>;
+        maxTokens: z.ZodNullable<z.ZodNumber>;
+        totalProcessedTokens: z.ZodNullable<z.ZodNumber>;
+        costUsd: z.ZodNullable<z.ZodNumber>;
+        marketCostUsd: z.ZodNullable<z.ZodNumber>;
+        operation: z.ZodString;
+        billable: z.ZodBoolean;
+        source: z.ZodString;
+        exact: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "type">;
+export type AmalgmEvent = z.infer<typeof amalgmEventSchema>;
+export type UsageSnapshot = z.infer<typeof usageSnapshot>;
+export type ToolKind = z.infer<typeof toolKind>;
+export type CompactionTrigger = z.infer<typeof compactionTrigger>;
+/**
+ * Additive export (the engine keeps the enum module-private): the tool-kind
+ * vocabulary, exposed because `src/events` owns the grammar's vocabularies.
+ */
+export { toolKind as toolKindSchema };
+/**
+ * Engine event-schema.js:221-228. Returns the parsed event or throws
+ * `Invalid Amalgm event <type>: <path>: <message>[; ...]` — the exact
+ * engine error string.
+ */
+export declare function validateAmalgmEvent(value: unknown): AmalgmEvent;
+/** Engine event-schema.js:230-232. */
+export declare function validateAmalgmEvents(events: unknown[]): AmalgmEvent[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/events/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/events/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,iFAAiF;AACjF,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;EAuBZ,CAAC;AA6BH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsBf,CAAC;AAgGZ,QAAA,MAAM,iBAAiB;;;;EAAgD,CAAC;AAexE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAa5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAChD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE;;;GAGG;AACH,OAAO,EAAE,QAAQ,IAAI,cAAc,EAAE,CAAC;AAMtC;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAO/D;AAED,sCAAsC;AACtC,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,WAAW,EAAE,CAErE"}

package/dist/events/schema.js

@@ -0,0 +1,228 @@
+/**
+ * Canonical amalgm event grammar — engine `chat-core/event-schema.js`
+ * (239 lines) ported byte-exact on zod v4 (engine pins zod ^4.4.3; this
+ * package pins the same major+minor so validation output and issue
+ * messages match).
+ *
+ * The discriminated union over `type` is the product's spine: every native
+ * harness event is normalized into one of these twelve shapes before it
+ * touches the wire, the reducer, or the transcript.
+ */
+import { z } from 'zod';
+const positiveNumber = z.number().finite().positive();
+const nonNegativeNumber = z.number().finite().min(0);
+const nullablePositiveNumber = positiveNumber.nullable();
+const providerSessionId = z.string().nullable().optional();
+const unknownRecord = z.record(z.string(), z.unknown());
+const rawEnvelope = z.object({
+    source: z.string().min(1),
+    method: z.string().min(1).optional(),
+    payload: z.unknown().optional(),
+}).strict();
+/** Engine event-schema.js:17-40 — 21 kinds including the legacy ACP-ish tail. */
+const toolKind = z.enum([
+    'web_search',
+    'browser',
+    'file_read',
+    'file_write',
+    'file_edit',
+    'bash',
+    'subagent',
+    'mcp',
+    'question',
+    'todo',
+    'unknown',
+    // Legacy ACP-ish kinds still emitted by older callers.
+    'read',
+    'edit',
+    'delete',
+    'move',
+    'search',
+    'execute',
+    'think',
+    'fetch',
+    'switch_mode',
+    'other',
+]);
+const toolTiming = z.object({
+    startedAt: z.union([z.string(), z.number()]).optional(),
+    completedAt: z.union([z.string(), z.number()]).optional(),
+    elapsedMs: nonNegativeNumber.optional(),
+}).passthrough();
+const toolError = z.object({
+    message: z.string(),
+    code: z.string().optional(),
+    details: z.unknown().optional(),
+}).passthrough();
+const baseEvent = z.object({
+    ts: z.number().finite(),
+    providerSessionId,
+    raw: rawEnvelope.optional(),
+}).passthrough();
+const tokenList = z.object({
+    input: nonNegativeNumber,
+    output: nonNegativeNumber,
+    cacheRead: nonNegativeNumber,
+    cacheWrite: nonNegativeNumber,
+    thought: nonNegativeNumber,
+    total: nonNegativeNumber,
+}).strict();
+export const usageSnapshot = z.object({
+    tokenList,
+    cumulativeTokenList: tokenList.nullable(),
+    previousCumulativeTokenList: tokenList.nullable(),
+    inputTokens: nonNegativeNumber,
+    outputTokens: nonNegativeNumber,
+    cacheReadTokens: nonNegativeNumber,
+    cacheWriteTokens: nonNegativeNumber,
+    thoughtTokens: nonNegativeNumber,
+    inputContextSize: nonNegativeNumber,
+    contextUsedTokens: nullablePositiveNumber,
+    contextLimit: nullablePositiveNumber,
+    usedTokens: nullablePositiveNumber,
+    lastUsedTokens: nullablePositiveNumber,
+    maxTokens: nullablePositiveNumber,
+    totalProcessedTokens: nullablePositiveNumber,
+    costUsd: z.number().finite().nullable(),
+    marketCostUsd: z.number().finite().nullable(),
+    operation: z.string().min(1),
+    billable: z.boolean(),
+    source: z.string().min(1),
+    exact: z.boolean(),
+}).strict();
+const textDeltaEvent = baseEvent.extend({
+    type: z.literal('text.delta'),
+    text: z.string(),
+    streamKind: z.literal('text').optional(),
+}).strict();
+const textBoundaryEvent = baseEvent.extend({
+    type: z.literal('text.boundary'),
+    streamKind: z.literal('text').optional(),
+    itemId: z.string().optional(),
+    reason: z.string().optional(),
+}).strict();
+const reasoningDeltaEvent = baseEvent.extend({
+    type: z.literal('reasoning.delta'),
+    text: z.string(),
+    streamKind: z.union([z.literal('reasoning'), z.literal('plan')]).optional(),
+}).strict();
+const toolStartedEvent = baseEvent.extend({
+    type: z.literal('tool.started'),
+    toolCallId: z.string(),
+    toolName: z.string().min(1),
+    name: z.string().min(1).optional(),
+    kind: toolKind.optional(),
+    title: z.string().optional(),
+    detail: z.string().optional(),
+    input: unknownRecord,
+    metadata: unknownRecord.optional(),
+    timing: toolTiming.optional(),
+    data: z.unknown().optional(),
+    itemType: z.literal('tool').optional(),
+}).strict();
+const toolUpdatedEvent = baseEvent.extend({
+    type: z.literal('tool.updated'),
+    toolCallId: z.string(),
+    toolName: z.string().optional(),
+    name: z.string().optional(),
+    kind: toolKind.optional(),
+    title: z.string().optional(),
+    detail: z.string().optional(),
+    inputDelta: unknownRecord.optional(),
+    outputDelta: z.unknown().optional(),
+    output: z.unknown().optional(),
+    error: toolError.optional(),
+    metadata: unknownRecord.optional(),
+    timing: toolTiming.optional(),
+    data: z.unknown().optional(),
+    status: z.enum(['in_progress', 'completed', 'failed', 'error']).optional(),
+    itemType: z.literal('tool').optional(),
+}).strict();
+const toolCompletedEvent = baseEvent.extend({
+    type: z.literal('tool.completed'),
+    toolCallId: z.string(),
+    toolName: z.string().optional(),
+    name: z.string().optional(),
+    kind: toolKind.optional(),
+    title: z.string().optional(),
+    detail: z.string().optional(),
+    input: unknownRecord.optional(),
+    output: z.unknown().optional(),
+    result: z.unknown().optional(),
+    error: toolError.optional(),
+    metadata: unknownRecord.optional(),
+    timing: toolTiming.optional(),
+    data: z.unknown().optional(),
+    isError: z.boolean(),
+    itemType: z.literal('tool').optional(),
+}).strict();
+const usageFinalEvent = baseEvent.extend({
+    type: z.literal('usage.final'),
+    usage: usageSnapshot,
+}).strict();
+const warningEvent = baseEvent.extend({
+    type: z.literal('warning'),
+    message: z.string(),
+    requestedModel: z.string().optional(),
+}).strict();
+const errorEvent = baseEvent.extend({
+    type: z.literal('error'),
+    message: z.string(),
+}).strict();
+const doneEvent = baseEvent.extend({
+    type: z.literal('done'),
+    stopReason: z.string(),
+    usage: usageSnapshot.optional(),
+}).strict();
+const compactionTrigger = z.enum(['auto', 'manual', 'model_triggered']);
+const compactionStartedEvent = baseEvent.extend({
+    type: z.literal('compaction.started'),
+    trigger: compactionTrigger,
+}).strict();
+const compactionFinishedEvent = baseEvent.extend({
+    type: z.literal('compaction.finished'),
+    trigger: compactionTrigger,
+    preTokens: nullablePositiveNumber.optional(),
+    postTokens: nullablePositiveNumber.optional(),
+    durationMs: nullablePositiveNumber.optional(),
+}).strict();
+export const amalgmEventSchema = z.discriminatedUnion('type', [
+    textDeltaEvent,
+    textBoundaryEvent,
+    reasoningDeltaEvent,
+    toolStartedEvent,
+    toolUpdatedEvent,
+    toolCompletedEvent,
+    usageFinalEvent,
+    compactionStartedEvent,
+    compactionFinishedEvent,
+    warningEvent,
+    errorEvent,
+    doneEvent,
+]);
+/**
+ * Additive export (the engine keeps the enum module-private): the tool-kind
+ * vocabulary, exposed because `src/events` owns the grammar's vocabularies.
+ */
+export { toolKind as toolKindSchema };
+function formatZodIssue(issue) {
+    return `${issue.path.join('.') || '<event>'}: ${issue.message}`;
+}
+/**
+ * Engine event-schema.js:221-228. Returns the parsed event or throws
+ * `Invalid Amalgm event <type>: <path>: <message>[; ...]` — the exact
+ * engine error string.
+ */
+export function validateAmalgmEvent(value) {
+    const parsed = amalgmEventSchema.safeParse(value);
+    if (parsed.success)
+        return parsed.data;
+    const type = value && typeof value === 'object' ? value.type : typeof value;
+    const details = parsed.error.issues.map(formatZodIssue).join('; ');
+    throw new Error(`Invalid Amalgm event ${String(type || 'unknown')}: ${details}`);
+}
+/** Engine event-schema.js:230-232. */
+export function validateAmalgmEvents(events) {
+    return events.map(validateAmalgmEvent);
+}
+//# sourceMappingURL=schema.js.map