@dbx-tools/shared-genie 0.3.43 → 0.4.0

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * as event from "./src/event.js";
+export * as genieModel from "./src/genie-model.js";
+export { eventDetector, detectStatus, detectAttachmentAdded, detectThinking, detectText, detectQuery, detectStatement, detectRows, detectSuggestedQuestions, eventsFromMessage } from "./src/event.js";
+export { MessageStatusSchema, GenieThoughtSchema, ATTACHMENT_TYPES, GenieQueryAttachmentSchema, GenieAttachmentSchema, GenieMessageSchema, GenieResponseSchema, GenieSpaceSchema, TERMINAL_STATUSES, isTerminalStatus, humanizeStatus, detectAttachmentType, GenieChatLocationSchema, QuestionEventSchema, MessageEventSchema, StatusEventSchema, AttachmentEventSchema, ThinkingEventSchema, TextEventSchema, QueryEventSchema, StatementEventSchema, RowsEventSchema, SuggestedQuestionsEventSchema, ResultEventSchema, GenieChatEventSchema } from "./src/genie-model.js";
+export type { MessageStatus, GenieThoughtType, GenieThought, KnownAttachmentType, AttachmentType, GenieQueryAttachment, GenieAttachment, GenieMessage, GenieResponse, GenieSpace, TerminalStatus, GenieChatLocation, QuestionEvent, MessageEvent, StatusEvent, AttachmentEvent, ThinkingEvent, TextEvent, QueryEvent, StatementEvent, RowsEvent, SuggestedQuestionsEvent, ResultEvent, GenieChatEvent, GenieChatEventType, GenieChatEventFields } from "./src/genie-model.js";

package/lib/index.js

@@ -0,0 +1,8 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+export * as event from "./src/event.js";
+export * as genieModel from "./src/genie-model.js";
+export { eventDetector, detectStatus, detectAttachmentAdded, detectThinking, detectText, detectQuery, detectStatement, detectRows, detectSuggestedQuestions, eventsFromMessage } from "./src/event.js";
+export { MessageStatusSchema, GenieThoughtSchema, ATTACHMENT_TYPES, GenieQueryAttachmentSchema, GenieAttachmentSchema, GenieMessageSchema, GenieResponseSchema, GenieSpaceSchema, TERMINAL_STATUSES, isTerminalStatus, humanizeStatus, detectAttachmentType, GenieChatLocationSchema, QuestionEventSchema, MessageEventSchema, StatusEventSchema, AttachmentEventSchema, ThinkingEventSchema, TextEventSchema, QueryEventSchema, StatementEventSchema, RowsEventSchema, SuggestedQuestionsEventSchema, ResultEventSchema, GenieChatEventSchema } from "./src/genie-model.js";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/event.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Pure event-detection for `genieEventChat`. Given two
+ * `GenieMessage` snapshots (current + prior) and the surrounding
+ * `space_id`, derive the semantic deltas (status transitions, new
+ * attachments, new thoughts, SQL emission, warehouse submission,
+ * row-count progress, follow-up suggestions, text deltas) and
+ * yield them as typed {@link GenieChatEvent}s.
+ *
+ * Detectors are built through a single typed factory that ties
+ * each event's name to its scope (whole-message vs per-attachment)
+ * and payload shape, so a misnamed event or a payload that doesn't
+ * match its event fails to compile. An orchestrator walks the
+ * snapshot diff and yields every detector that fires in a stable
+ * order (status first, then per-attachment field deltas) so a
+ * subscriber that logs events as they arrive sees a sensible
+ * sequence.
+ *
+ * The module is intentionally pure: no `EventEmitter`, no `this`,
+ * no I/O, no module-level mutable state. The `message` and
+ * `result` events are NOT derived here - they belong to the chat
+ * lifecycle layer (the `genieEventChat` driver) because they track
+ * per-yield / per-turn-completion semantics rather than a
+ * field-level snapshot diff.
+ *
+ * @module
+ */
+import { type GenieAttachment, type GenieChatEvent, type GenieChatEventFields, type GenieChatEventType, type GenieChatLocation, type GenieMessage } from "./genie-model.js";
+/**
+ * What a single detector call returns: zero (`undefined`), one
+ * (fields object), or many (`fields[]`) events of the same type.
+ * Each result is the variant's payload fields **without** the
+ * `type` discriminator - the orchestrator stamps `type` when it
+ * yields the event.
+ */
+type DetectorResult<T extends GenieChatEventType> = GenieChatEventFields<T> | GenieChatEventFields<T>[] | undefined;
+/**
+ * Where in the wire shape a given event is derived from. Drives
+ * which arguments `detect` receives. `"message"` events watch
+ * `GenieMessage` itself; `"attachment"` events watch one slot of
+ * `message.attachments[]`. `"lifecycle"` events (`message`,
+ * `result`) are emitted by the chat driver directly and can't be
+ * built with {@link eventDetector} - they have no diff signature.
+ */
+interface DetectorScope {
+    status: "message";
+    attachment: "attachment";
+    thinking: "attachment";
+    text: "attachment";
+    query: "attachment";
+    statement: "attachment";
+    rows: "attachment";
+    suggested_questions: "attachment";
+    question: "lifecycle";
+    message: "lifecycle";
+    result: "lifecycle";
+}
+/**
+ * `detect` callback signature for a given event type. Resolved
+ * from {@link DetectorScope}: `"message"` events get the top-level
+ * snapshot triple, `"attachment"` events get the per-slot quad,
+ * `"lifecycle"` events resolve to `never` (no diff-based detector
+ * exists for them).
+ */
+type DetectFn<T extends GenieChatEventType> = DetectorScope[T] extends "message" ? (current: GenieMessage, previous: GenieMessage | undefined, space_id: string) => DetectorResult<T> : DetectorScope[T] extends "attachment" ? (current: GenieAttachment, previous: GenieAttachment | undefined, location: GenieChatLocation, index: number) => DetectorResult<T> : never;
+/**
+ * Typed detector for one event in the {@link GenieChatEvent}
+ * union. The `type` field is the event name; `detect`'s signature
+ * is picked from {@link DetectorScope} based on `T`.
+ */
+interface EventDetector<T extends GenieChatEventType> {
+    readonly type: T;
+    detect: DetectFn<T>;
+}
+/**
+ * Build an {@link EventDetector}. Pass the event name as the
+ * literal first arg and the matching `detect` callback as the
+ * second. TS infers `T` from the literal, narrows `detect`'s
+ * signature accordingly, and types the return as
+ * `EventDetector<T>`.
+ *
+ * Build-time guarantees:
+ *
+ *   - `eventDetector("status2", ...)` fails - the name isn't in
+ *     {@link GenieChatEvent}.
+ *   - `eventDetector("status", attachmentArgsCallback)` fails -
+ *     `"status"` is message-scoped, so `detect` must take
+ *     `(GenieMessage, GenieMessage | undefined, string)`.
+ *   - Returning a `ThinkingEvent`-shaped fields object from a
+ *     `"status"` detector fails - the return type is constrained
+ *     to `DetectorResult<"status">`.
+ *
+ * Lifecycle event names (`"message"`, `"result"`) resolve `detect`
+ * to `never` and won't compile, which is intentional: those have
+ * no diff signature and are emitted directly by the chat driver.
+ */
+export declare function eventDetector<T extends GenieChatEventType>(type: T, detect: DetectFn<T>): EventDetector<T>;
+/** Top-level `message.status` transitioned. */
+export declare const detectStatus: EventDetector<"status">;
+/** First time we see an attachment slot. */
+export declare const detectAttachmentAdded: EventDetector<"attachment">;
+/**
+ * One emit per new `(thought_type, content)` tuple on a query
+ * attachment. Value-based set diff: Genie can mutate existing
+ * thought slots in place (e.g. re-typing index 0 from
+ * `DATA_SOURCING` to `DESCRIPTION` while re-appending the
+ * original at index 1), so positional / append-only diff would
+ * miss re-types and double-count re-orders.
+ */
+export declare const detectThinking: EventDetector<"thinking">;
+/** Text-attachment `content` appeared or changed. */
+export declare const detectText: EventDetector<"text">;
+/** SQL transitioned undefined -> string, or changed. */
+export declare const detectQuery: EventDetector<"query">;
+/** Warehouse-statement id assigned. */
+export declare const detectStatement: EventDetector<"statement">;
+/**
+ * `row_count` changed - fires on every transition including the
+ * initial `undefined -> 0` and the post-execution `0 -> N`.
+ * Carries the statement id when available for correlation.
+ */
+export declare const detectRows: EventDetector<"rows">;
+/**
+ * Follow-up suggested-questions array appeared or changed.
+ * Compares structurally so a length-preserving content rewrite still fires.
+ */
+export declare const detectSuggestedQuestions: EventDetector<"suggested_questions">;
+/**
+ * Walk the diff between `current` and `previous` and yield every
+ * derived event the snapshot produced. Detector order mirrors
+ * Genie's wire ordering (status first, then per-attachment field
+ * deltas) so a subscriber that simply logs events as they arrive
+ * sees them in a sensible sequence.
+ *
+ * Caller responsibilities (not handled here):
+ *
+ *   - Yield `{ type: "message", message: current }` BEFORE
+ *     calling this, once per poll yield.
+ *   - Yield `{ type: "result", ... }` AFTER calling this when
+ *     `isTerminalStatus(current.status)` - per-turn lifecycle,
+ *     not a per-snapshot field diff.
+ *   - Decide what counts as a "fresh turn" and pass `undefined`
+ *     for `previous` on turn boundaries, so anonymous-attachment
+ *     state from a prior turn doesn't bleed in.
+ *
+ * Sync generator: the diff is pure CPU work, no awaits. Use
+ * `yield*` from an async generator to splice the events into a
+ * stream.
+ */
+export declare function eventsFromMessage(current: GenieMessage, previous: GenieMessage | undefined, space_id: string): Generator<GenieChatEvent, void, void>;
+export {};

package/lib/src/event.js

@@ -0,0 +1,248 @@
+/**
+ * Pure event-detection for `genieEventChat`. Given two
+ * `GenieMessage` snapshots (current + prior) and the surrounding
+ * `space_id`, derive the semantic deltas (status transitions, new
+ * attachments, new thoughts, SQL emission, warehouse submission,
+ * row-count progress, follow-up suggestions, text deltas) and
+ * yield them as typed {@link GenieChatEvent}s.
+ *
+ * Detectors are built through a single typed factory that ties
+ * each event's name to its scope (whole-message vs per-attachment)
+ * and payload shape, so a misnamed event or a payload that doesn't
+ * match its event fails to compile. An orchestrator walks the
+ * snapshot diff and yields every detector that fires in a stable
+ * order (status first, then per-attachment field deltas) so a
+ * subscriber that logs events as they arrive sees a sensible
+ * sequence.
+ *
+ * The module is intentionally pure: no `EventEmitter`, no `this`,
+ * no I/O, no module-level mutable state. The `message` and
+ * `result` events are NOT derived here - they belong to the chat
+ * lifecycle layer (the `genieEventChat` driver) because they track
+ * per-yield / per-turn-completion semantics rather than a
+ * field-level snapshot diff.
+ *
+ * @module
+ */
+import { object } from "@dbx-tools/shared-core";
+import { detectAttachmentType, } from "./genie-model.js";
+/* ----------------------- detector factory ----------------------- */
+/**
+ * Build an {@link EventDetector}. Pass the event name as the
+ * literal first arg and the matching `detect` callback as the
+ * second. TS infers `T` from the literal, narrows `detect`'s
+ * signature accordingly, and types the return as
+ * `EventDetector<T>`.
+ *
+ * Build-time guarantees:
+ *
+ *   - `eventDetector("status2", ...)` fails - the name isn't in
+ *     {@link GenieChatEvent}.
+ *   - `eventDetector("status", attachmentArgsCallback)` fails -
+ *     `"status"` is message-scoped, so `detect` must take
+ *     `(GenieMessage, GenieMessage | undefined, string)`.
+ *   - Returning a `ThinkingEvent`-shaped fields object from a
+ *     `"status"` detector fails - the return type is constrained
+ *     to `DetectorResult<"status">`.
+ *
+ * Lifecycle event names (`"message"`, `"result"`) resolve `detect`
+ * to `never` and won't compile, which is intentional: those have
+ * no diff signature and are emitted directly by the chat driver.
+ */
+export function eventDetector(type, detect) {
+    return { type, detect };
+}
+/* ---------------------------- detectors ---------------------------- */
+/** Top-level `message.status` transitioned. */
+export const detectStatus = eventDetector("status", (current, previous, space_id) => {
+    if (!current.status || current.status === previous?.status)
+        return;
+    return {
+        status: current.status,
+        previous_status: previous?.status,
+        space_id,
+        conversation_id: current.conversation_id,
+        message_id: current.message_id,
+    };
+});
+/** First time we see an attachment slot. */
+export const detectAttachmentAdded = eventDetector("attachment", (current, previous, location, index) => {
+    if (previous)
+        return;
+    return {
+        ...location,
+        index,
+        attachment_type: detectAttachmentType(current),
+    };
+});
+/**
+ * One emit per new `(thought_type, content)` tuple on a query
+ * attachment. Value-based set diff: Genie can mutate existing
+ * thought slots in place (e.g. re-typing index 0 from
+ * `DATA_SOURCING` to `DESCRIPTION` while re-appending the
+ * original at index 1), so positional / append-only diff would
+ * miss re-types and double-count re-orders.
+ */
+export const detectThinking = eventDetector("thinking", (current, previous, location) => {
+    const currThoughts = current.query?.thoughts ?? [];
+    if (currThoughts.length === 0)
+        return;
+    const seen = new Set((previous?.query?.thoughts ?? []).map(thoughtKey));
+    const out = [];
+    for (const t of currThoughts) {
+        const key = thoughtKey(t);
+        if (seen.has(key))
+            continue;
+        // Defensive: dedupe within a single snapshot in case Genie
+        // ever ships the same thought twice in one `thoughts[]`.
+        seen.add(key);
+        out.push({ ...location, text: t.content, thought_type: t.thought_type });
+    }
+    return out;
+});
+/** Text-attachment `content` appeared or changed. */
+export const detectText = eventDetector("text", (current, previous, location) => {
+    const curr = current.text?.content;
+    const prev = previous?.text?.content;
+    if (curr === undefined || curr === prev)
+        return;
+    return { ...location, text: curr };
+});
+/** SQL transitioned undefined -> string, or changed. */
+export const detectQuery = eventDetector("query", (current, previous, location) => {
+    const curr = current.query?.query;
+    const prev = previous?.query?.query;
+    if (!curr || curr === prev)
+        return;
+    return {
+        ...location,
+        sql: curr,
+        title: current.query?.title,
+        description: current.query?.description,
+    };
+});
+/** Warehouse-statement id assigned. */
+export const detectStatement = eventDetector("statement", (current, previous, location) => {
+    const curr = current.query?.statement_id;
+    const prev = previous?.query?.statement_id;
+    if (!curr || curr === prev)
+        return;
+    return { ...location, statement_id: curr };
+});
+/**
+ * `row_count` changed - fires on every transition including the
+ * initial `undefined -> 0` and the post-execution `0 -> N`.
+ * Carries the statement id when available for correlation.
+ */
+export const detectRows = eventDetector("rows", (current, previous, location) => {
+    const curr = current.query?.query_result_metadata?.row_count;
+    const prev = previous?.query?.query_result_metadata?.row_count;
+    if (curr === undefined || curr === prev)
+        return;
+    return {
+        ...location,
+        row_count: curr,
+        previous_row_count: prev,
+        statement_id: current.query?.statement_id ?? previous?.query?.statement_id,
+    };
+});
+/**
+ * Follow-up suggested-questions array appeared or changed.
+ * Compares structurally so a length-preserving content rewrite still fires.
+ */
+export const detectSuggestedQuestions = eventDetector("suggested_questions", (current, previous, location) => {
+    const curr = current.suggested_questions?.questions;
+    const prev = previous?.suggested_questions?.questions;
+    if (!curr || curr.length === 0)
+        return;
+    if (object.deepEqual(curr, prev))
+        return;
+    return { ...location, questions: curr };
+});
+/* --------------------------- orchestrator --------------------------- */
+/**
+ * Walk the diff between `current` and `previous` and yield every
+ * derived event the snapshot produced. Detector order mirrors
+ * Genie's wire ordering (status first, then per-attachment field
+ * deltas) so a subscriber that simply logs events as they arrive
+ * sees them in a sensible sequence.
+ *
+ * Caller responsibilities (not handled here):
+ *
+ *   - Yield `{ type: "message", message: current }` BEFORE
+ *     calling this, once per poll yield.
+ *   - Yield `{ type: "result", ... }` AFTER calling this when
+ *     `isTerminalStatus(current.status)` - per-turn lifecycle,
+ *     not a per-snapshot field diff.
+ *   - Decide what counts as a "fresh turn" and pass `undefined`
+ *     for `previous` on turn boundaries, so anonymous-attachment
+ *     state from a prior turn doesn't bleed in.
+ *
+ * Sync generator: the diff is pure CPU work, no awaits. Use
+ * `yield*` from an async generator to splice the events into a
+ * stream.
+ */
+export function* eventsFromMessage(current, previous, space_id) {
+    // Stamp `type` onto each detector result and yield it. Returning
+    // a typed generator keeps the `yield*` callsite tidy. The double
+    // cast (`unknown` -> `GenieChatEvent`) is needed because the
+    // generic merge `{type: T} & GenieChatEventFields<T>` doesn't
+    // structurally narrow back to a discriminated-union member -
+    // each detector's runtime output is shaped correctly by
+    // construction, so the cast is sound.
+    function* emit(detector, result) {
+        if (result === undefined)
+            return;
+        if (Array.isArray(result)) {
+            for (const fields of result) {
+                yield { type: detector.type, ...fields };
+            }
+        }
+        else {
+            yield { type: detector.type, ...result };
+        }
+    }
+    // Message-scoped detectors run once per snapshot.
+    yield* emit(detectStatus, detectStatus.detect(current, previous, space_id));
+    // Per-attachment detectors run once per attachment slot.
+    const currAtts = current.attachments ?? [];
+    const prevAtts = previous?.attachments ?? [];
+    for (let i = 0; i < currAtts.length; i++) {
+        const curr = currAtts[i];
+        const prev = matchPrevAttachment(curr, prevAtts, i);
+        const location = {
+            space_id,
+            conversation_id: current.conversation_id,
+            message_id: current.message_id,
+            attachment_id: curr.attachment_id,
+        };
+        yield* emit(detectAttachmentAdded, detectAttachmentAdded.detect(curr, prev, location, i));
+        yield* emit(detectThinking, detectThinking.detect(curr, prev, location, i));
+        yield* emit(detectText, detectText.detect(curr, prev, location, i));
+        yield* emit(detectQuery, detectQuery.detect(curr, prev, location, i));
+        yield* emit(detectStatement, detectStatement.detect(curr, prev, location, i));
+        yield* emit(detectRows, detectRows.detect(curr, prev, location, i));
+        yield* emit(detectSuggestedQuestions, detectSuggestedQuestions.detect(curr, prev, location, i));
+    }
+}
+/* ----------------------------- helpers ----------------------------- */
+/**
+ * Find the prior version of `curr` in `prevAtts`. Attachments
+ * with ids match by id (Genie keeps ids stable across polls);
+ * anonymous attachments (Genie's main-answer text doesn't get
+ * one) match positionally against an anonymous prev at the same
+ * index, so they don't accidentally bind to an id'd predecessor
+ * that happened to share the slot.
+ */
+function matchPrevAttachment(curr, prevAtts, i) {
+    if (curr.attachment_id) {
+        return prevAtts.find((a) => a.attachment_id === curr.attachment_id);
+    }
+    const p = prevAtts[i];
+    return p && !p.attachment_id ? p : undefined;
+}
+/** Stable key for {@link detectThinking}'s value-based set diff. */
+function thoughtKey(t) {
+    return `${t.thought_type}|${t.content}`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event.js","sourceRoot":"","sources":["../../src/event.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pure event-detection for `genieEventChat`. Given two\n * `GenieMessage` snapshots (current + prior) and the surrounding\n * `space_id`, derive the semantic deltas (status transitions, new\n * attachments, new thoughts, SQL emission, warehouse submission,\n * row-count progress, follow-up suggestions, text deltas) and\n * yield them as typed {@link GenieChatEvent}s.\n *\n * Detectors are built through a single typed factory that ties\n * each event's name to its scope (whole-message vs per-attachment)\n * and payload shape, so a misnamed event or a payload that doesn't\n * match its event fails to compile. An orchestrator walks the\n * snapshot diff and yields every detector that fires in a stable\n * order (status first, then per-attachment field deltas) so a\n * subscriber that logs events as they arrive sees a sensible\n * sequence.\n *\n * The module is intentionally pure: no `EventEmitter`, no `this`,\n * no I/O, no module-level mutable state. The `message` and\n * `result` events are NOT derived here - they belong to the chat\n * lifecycle layer (the `genieEventChat` driver) because they track\n * per-yield / per-turn-completion semantics rather than a\n * field-level snapshot diff.\n *\n * @module\n */\n\nimport { object } from \"@dbx-tools/shared-core\";\n\nimport {\n  detectAttachmentType,\n  type GenieAttachment,\n  type GenieChatEvent,\n  type GenieChatEventFields,\n  type GenieChatEventType,\n  type GenieChatLocation,\n  type GenieMessage,\n  type GenieThought,\n} from \"./genie-model\";\n\n/* ----------------------------- contract ---------------------------- */\n\n/**\n * What a single detector call returns: zero (`undefined`), one\n * (fields object), or many (`fields[]`) events of the same type.\n * Each result is the variant's payload fields **without** the\n * `type` discriminator - the orchestrator stamps `type` when it\n * yields the event.\n */\ntype DetectorResult<T extends GenieChatEventType> =\n  GenieChatEventFields<T> | GenieChatEventFields<T>[] | undefined;\n\n/**\n * Where in the wire shape a given event is derived from. Drives\n * which arguments `detect` receives. `\"message\"` events watch\n * `GenieMessage` itself; `\"attachment\"` events watch one slot of\n * `message.attachments[]`. `\"lifecycle\"` events (`message`,\n * `result`) are emitted by the chat driver directly and can't be\n * built with {@link eventDetector} - they have no diff signature.\n */\ninterface DetectorScope {\n  // Message-scoped: top-level field diff on `GenieMessage`.\n  status: \"message\";\n  // Per-attachment: field diff on one `GenieAttachment` slot.\n  attachment: \"attachment\";\n  thinking: \"attachment\";\n  text: \"attachment\";\n  query: \"attachment\";\n  statement: \"attachment\";\n  rows: \"attachment\";\n  suggested_questions: \"attachment\";\n  // Lifecycle: not derived via diff, handled by the chat driver.\n  question: \"lifecycle\";\n  message: \"lifecycle\";\n  result: \"lifecycle\";\n}\n\n/**\n * `detect` callback signature for a given event type. Resolved\n * from {@link DetectorScope}: `\"message\"` events get the top-level\n * snapshot triple, `\"attachment\"` events get the per-slot quad,\n * `\"lifecycle\"` events resolve to `never` (no diff-based detector\n * exists for them).\n */\ntype DetectFn<T extends GenieChatEventType> = DetectorScope[T] extends \"message\"\n  ? (\n      current: GenieMessage,\n      previous: GenieMessage | undefined,\n      space_id: string,\n    ) => DetectorResult<T>\n  : DetectorScope[T] extends \"attachment\"\n    ? (\n        current: GenieAttachment,\n        previous: GenieAttachment | undefined,\n        location: GenieChatLocation,\n        index: number,\n      ) => DetectorResult<T>\n    : never;\n\n/**\n * Typed detector for one event in the {@link GenieChatEvent}\n * union. The `type` field is the event name; `detect`'s signature\n * is picked from {@link DetectorScope} based on `T`.\n */\ninterface EventDetector<T extends GenieChatEventType> {\n  readonly type: T;\n  detect: DetectFn<T>;\n}\n\n/* ----------------------- detector factory ----------------------- */\n\n/**\n * Build an {@link EventDetector}. Pass the event name as the\n * literal first arg and the matching `detect` callback as the\n * second. TS infers `T` from the literal, narrows `detect`'s\n * signature accordingly, and types the return as\n * `EventDetector<T>`.\n *\n * Build-time guarantees:\n *\n *   - `eventDetector(\"status2\", ...)` fails - the name isn't in\n *     {@link GenieChatEvent}.\n *   - `eventDetector(\"status\", attachmentArgsCallback)` fails -\n *     `\"status\"` is message-scoped, so `detect` must take\n *     `(GenieMessage, GenieMessage | undefined, string)`.\n *   - Returning a `ThinkingEvent`-shaped fields object from a\n *     `\"status\"` detector fails - the return type is constrained\n *     to `DetectorResult<\"status\">`.\n *\n * Lifecycle event names (`\"message\"`, `\"result\"`) resolve `detect`\n * to `never` and won't compile, which is intentional: those have\n * no diff signature and are emitted directly by the chat driver.\n */\nexport function eventDetector<T extends GenieChatEventType>(\n  type: T,\n  detect: DetectFn<T>,\n): EventDetector<T> {\n  return { type, detect };\n}\n\n/* ---------------------------- detectors ---------------------------- */\n\n/** Top-level `message.status` transitioned. */\nexport const detectStatus = eventDetector(\"status\", (current, previous, space_id) => {\n  if (!current.status || current.status === previous?.status) return;\n  return {\n    status: current.status,\n    previous_status: previous?.status,\n    space_id,\n    conversation_id: current.conversation_id,\n    message_id: current.message_id,\n  };\n});\n\n/** First time we see an attachment slot. */\nexport const detectAttachmentAdded = eventDetector(\n  \"attachment\",\n  (current, previous, location, index) => {\n    if (previous) return;\n    return {\n      ...location,\n      index,\n      attachment_type: detectAttachmentType(current),\n    };\n  },\n);\n\n/**\n * One emit per new `(thought_type, content)` tuple on a query\n * attachment. Value-based set diff: Genie can mutate existing\n * thought slots in place (e.g. re-typing index 0 from\n * `DATA_SOURCING` to `DESCRIPTION` while re-appending the\n * original at index 1), so positional / append-only diff would\n * miss re-types and double-count re-orders.\n */\nexport const detectThinking = eventDetector(\"thinking\", (current, previous, location) => {\n  const currThoughts = current.query?.thoughts ?? [];\n  if (currThoughts.length === 0) return;\n  const seen = new Set((previous?.query?.thoughts ?? []).map(thoughtKey));\n  const out: GenieChatEventFields<\"thinking\">[] = [];\n  for (const t of currThoughts) {\n    const key = thoughtKey(t);\n    if (seen.has(key)) continue;\n    // Defensive: dedupe within a single snapshot in case Genie\n    // ever ships the same thought twice in one `thoughts[]`.\n    seen.add(key);\n    out.push({ ...location, text: t.content, thought_type: t.thought_type });\n  }\n  return out;\n});\n\n/** Text-attachment `content` appeared or changed. */\nexport const detectText = eventDetector(\"text\", (current, previous, location) => {\n  const curr = current.text?.content;\n  const prev = previous?.text?.content;\n  if (curr === undefined || curr === prev) return;\n  return { ...location, text: curr };\n});\n\n/** SQL transitioned undefined -> string, or changed. */\nexport const detectQuery = eventDetector(\"query\", (current, previous, location) => {\n  const curr = current.query?.query;\n  const prev = previous?.query?.query;\n  if (!curr || curr === prev) return;\n  return {\n    ...location,\n    sql: curr,\n    title: current.query?.title,\n    description: current.query?.description,\n  };\n});\n\n/** Warehouse-statement id assigned. */\nexport const detectStatement = eventDetector(\"statement\", (current, previous, location) => {\n  const curr = current.query?.statement_id;\n  const prev = previous?.query?.statement_id;\n  if (!curr || curr === prev) return;\n  return { ...location, statement_id: curr };\n});\n\n/**\n * `row_count` changed - fires on every transition including the\n * initial `undefined -> 0` and the post-execution `0 -> N`.\n * Carries the statement id when available for correlation.\n */\nexport const detectRows = eventDetector(\"rows\", (current, previous, location) => {\n  const curr = current.query?.query_result_metadata?.row_count;\n  const prev = previous?.query?.query_result_metadata?.row_count;\n  if (curr === undefined || curr === prev) return;\n  return {\n    ...location,\n    row_count: curr,\n    previous_row_count: prev,\n    statement_id: current.query?.statement_id ?? previous?.query?.statement_id,\n  };\n});\n\n/**\n * Follow-up suggested-questions array appeared or changed.\n * Compares structurally so a length-preserving content rewrite still fires.\n */\nexport const detectSuggestedQuestions = eventDetector(\n  \"suggested_questions\",\n  (current, previous, location) => {\n    const curr = current.suggested_questions?.questions;\n    const prev = previous?.suggested_questions?.questions;\n    if (!curr || curr.length === 0) return;\n    if (object.deepEqual(curr, prev)) return;\n    return { ...location, questions: curr };\n  },\n);\n\n/* --------------------------- orchestrator --------------------------- */\n\n/**\n * Walk the diff between `current` and `previous` and yield every\n * derived event the snapshot produced. Detector order mirrors\n * Genie's wire ordering (status first, then per-attachment field\n * deltas) so a subscriber that simply logs events as they arrive\n * sees them in a sensible sequence.\n *\n * Caller responsibilities (not handled here):\n *\n *   - Yield `{ type: \"message\", message: current }` BEFORE\n *     calling this, once per poll yield.\n *   - Yield `{ type: \"result\", ... }` AFTER calling this when\n *     `isTerminalStatus(current.status)` - per-turn lifecycle,\n *     not a per-snapshot field diff.\n *   - Decide what counts as a \"fresh turn\" and pass `undefined`\n *     for `previous` on turn boundaries, so anonymous-attachment\n *     state from a prior turn doesn't bleed in.\n *\n * Sync generator: the diff is pure CPU work, no awaits. Use\n * `yield*` from an async generator to splice the events into a\n * stream.\n */\nexport function* eventsFromMessage(\n  current: GenieMessage,\n  previous: GenieMessage | undefined,\n  space_id: string,\n): Generator<GenieChatEvent, void, void> {\n  // Stamp `type` onto each detector result and yield it. Returning\n  // a typed generator keeps the `yield*` callsite tidy. The double\n  // cast (`unknown` -> `GenieChatEvent`) is needed because the\n  // generic merge `{type: T} & GenieChatEventFields<T>` doesn't\n  // structurally narrow back to a discriminated-union member -\n  // each detector's runtime output is shaped correctly by\n  // construction, so the cast is sound.\n  function* emit<T extends GenieChatEventType>(\n    detector: EventDetector<T>,\n    result: DetectorResult<T>,\n  ): Generator<GenieChatEvent, void, void> {\n    if (result === undefined) return;\n    if (Array.isArray(result)) {\n      for (const fields of result) {\n        yield { type: detector.type, ...fields } as unknown as GenieChatEvent;\n      }\n    } else {\n      yield { type: detector.type, ...result } as unknown as GenieChatEvent;\n    }\n  }\n\n  // Message-scoped detectors run once per snapshot.\n  yield* emit(detectStatus, detectStatus.detect(current, previous, space_id));\n\n  // Per-attachment detectors run once per attachment slot.\n  const currAtts = current.attachments ?? [];\n  const prevAtts = previous?.attachments ?? [];\n  for (let i = 0; i < currAtts.length; i++) {\n    const curr = currAtts[i]!;\n    const prev = matchPrevAttachment(curr, prevAtts, i);\n    const location: GenieChatLocation = {\n      space_id,\n      conversation_id: current.conversation_id,\n      message_id: current.message_id,\n      attachment_id: curr.attachment_id,\n    };\n    yield* emit(detectAttachmentAdded, detectAttachmentAdded.detect(curr, prev, location, i));\n    yield* emit(detectThinking, detectThinking.detect(curr, prev, location, i));\n    yield* emit(detectText, detectText.detect(curr, prev, location, i));\n    yield* emit(detectQuery, detectQuery.detect(curr, prev, location, i));\n    yield* emit(detectStatement, detectStatement.detect(curr, prev, location, i));\n    yield* emit(detectRows, detectRows.detect(curr, prev, location, i));\n    yield* emit(detectSuggestedQuestions, detectSuggestedQuestions.detect(curr, prev, location, i));\n  }\n}\n\n/* ----------------------------- helpers ----------------------------- */\n\n/**\n * Find the prior version of `curr` in `prevAtts`. Attachments\n * with ids match by id (Genie keeps ids stable across polls);\n * anonymous attachments (Genie's main-answer text doesn't get\n * one) match positionally against an anonymous prev at the same\n * index, so they don't accidentally bind to an id'd predecessor\n * that happened to share the slot.\n */\nfunction matchPrevAttachment(\n  curr: GenieAttachment,\n  prevAtts: GenieAttachment[],\n  i: number,\n): GenieAttachment | undefined {\n  if (curr.attachment_id) {\n    return prevAtts.find((a) => a.attachment_id === curr.attachment_id);\n  }\n  const p = prevAtts[i];\n  return p && !p.attachment_id ? p : undefined;\n}\n\n/** Stable key for {@link detectThinking}'s value-based set diff. */\nfunction thoughtKey(t: GenieThought): string {\n  return `${t.thought_type}|${t.content}`;\n}\n"]}