@dbx-tools/genie 0.3.43 → 0.4.0

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * as chat from "./src/chat.js";
+export * as space from "./src/space.js";
+export { genieChat, genieEventChat } from "./src/chat.js";
+export type { GenieChatOptions } from "./src/chat.js";
+export { getGenieSpace, genieSampleQuestions } from "./src/space.js";
+export type { GetGenieSpaceOptions } from "./src/space.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 chat from "./src/chat.js";
+export * as space from "./src/space.js";
+export { genieChat, genieEventChat } from "./src/chat.js";
+export { getGenieSpace, genieSampleQuestions } from "./src/space.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxPQUFPLEtBQUssSUFBSSxNQUFNLFlBQVksQ0FBQztBQUNuQyxPQUFPLEtBQUssS0FBSyxNQUFNLGFBQWEsQ0FBQztBQUNyQyxPQUFPLEVBQUUsU0FBUyxFQUFFLGNBQWMsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUV2RCxPQUFPLEVBQUUsYUFBYSxFQUFFLG9CQUFvQixFQUFFLE1BQU0sYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIGJ5IHByb2plbiB3YXRjaCAtIERPIE5PVCBFRElULlxuLy8gUmVnZW5lcmF0ZWQgZnJvbSB0aGUgZXhwb3J0aW5nIG1vZHVsZXMgaW4gLi9zcmMuXG4vLyBIYW5kIGVkaXRzIGFyZSBvdmVyd3JpdHRlbiBvbiB0aGUgbmV4dCB3YXRjaDsgdGhpcyBmaWxlIGlzIHJlYWQtb25seS5cblxuZXhwb3J0ICogYXMgY2hhdCBmcm9tIFwiLi9zcmMvY2hhdFwiO1xuZXhwb3J0ICogYXMgc3BhY2UgZnJvbSBcIi4vc3JjL3NwYWNlXCI7XG5leHBvcnQgeyBnZW5pZUNoYXQsIGdlbmllRXZlbnRDaGF0IH0gZnJvbSBcIi4vc3JjL2NoYXRcIjtcbmV4cG9ydCB0eXBlIHsgR2VuaWVDaGF0T3B0aW9ucyB9IGZyb20gXCIuL3NyYy9jaGF0XCI7XG5leHBvcnQgeyBnZXRHZW5pZVNwYWNlLCBnZW5pZVNhbXBsZVF1ZXN0aW9ucyB9IGZyb20gXCIuL3NyYy9zcGFjZVwiO1xuZXhwb3J0IHR5cGUgeyBHZXRHZW5pZVNwYWNlT3B0aW9ucyB9IGZyb20gXCIuL3NyYy9zcGFjZVwiO1xuIl19

package/lib/src/chat.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Genie chat driver.
+ *
+ * Drives a single turn against a Genie space from one `content` string;
+ * multi-turn conversations are the caller's job (thread the `conversation_id`
+ * returned on each `GenieMessage` back into the next turn's
+ * `options.conversationId`).
+ *
+ * Two layers serve two kinds of consumer. The low-level layer yields every
+ * poll-observed `GenieMessage` (validated against `GenieMessageSchema`,
+ * falling back to the raw snapshot on a schema miss) and owns the messy parts
+ * - cancellation, conversation seeding, distinct-filtering, and SDK quirks
+ * (Waiter stripping); reach for it when you want the raw stream. The
+ * high-level layer wraps it and emits semantic, deduplicated `{ type, payload }`
+ * events (see {@link GenieChatEvent}), always closing a successful turn with a
+ * terminal `result` event carrying the final `GenieMessage`; errors propagate
+ * by throwing, with no `error` variant. Iterating UI / agent code that wants
+ * every message verbatim takes the low-level stream; subscribers reacting to
+ * "Genie is thinking about X" or "Genie produced text Y" take the event layer.
+ *
+ * @module
+ */
+import { WorkspaceClient } from "@databricks/sdk-experimental";
+import { databricks } from "@dbx-tools/appkit";
+import { type GenieChatEvent, type GenieMessage } from "@dbx-tools/shared-genie";
+/** Options accepted by both {@link genieChat} and {@link genieEventChat}. */
+export interface GenieChatOptions {
+    /**
+     * Seed conversation id. When set, this turn appends to the existing
+     * conversation (via `createMessage`) instead of opening a new one. Use it to
+     * thread a multi-turn conversation: read `conversation_id` off the prior
+     * turn's terminal `GenieMessage` (or the `result` event's
+     * `payload.conversation_id`) and pass it into the next call.
+     */
+    conversationId?: string;
+    /**
+     * Explicit `WorkspaceClient`. Defaults to AppKit's per-request
+     * execution-context client when AppKit is installed and we're inside a
+     * request; falls back to a fresh `new WorkspaceClient({})` (env-var auth)
+     * otherwise.
+     */
+    workspaceClient?: WorkspaceClient;
+    /** Poll cadence in milliseconds between successive `getMessage` calls (default 500). */
+    pollIntervalMs?: number;
+    /**
+     * External cancellation. Accepts a WHATWG `AbortSignal` or a fully-built SDK
+     * `Context` (see `databricks.ContextLike`). Aborting it cancels every in-flight
+     * SDK call and the next inter-poll sleep.
+     */
+    context?: databricks.ContextLike;
+}
+/**
+ * One turn against a Genie space, yielded as a stream of `GenieMessage`
+ * snapshots.
+ *
+ * Turn lifecycle:
+ *
+ *   - No `options.conversationId`: open a new conversation via
+ *     `client.genie.startConversation`. The opened conversation id surfaces on
+ *     every yielded `GenieMessage` (`.conversation_id`) so the caller can
+ *     thread it into a follow-up call.
+ *   - With `options.conversationId`: append to that conversation via
+ *     `client.genie.createMessage`.
+ *   - In both cases, after the create/start the driver polls
+ *     `client.genie.getMessage` every `options.pollIntervalMs` (default 500ms)
+ *     until the message reaches a terminal status, then yields the terminal
+ *     snapshot and returns.
+ *
+ * Cancellation: a single internal `AbortController` covers the whole turn.
+ * `options.context` is tied into that controller so an external abort tears
+ * down every in-flight SDK call AND the inter-poll sleep. Breaking out of the
+ * `for await` does the same via the `try / finally`.
+ *
+ * @example
+ * // Single turn.
+ * for await (const m of genieChat(spaceId, "Top 5 stores?")) {
+ *   render(m);
+ * }
+ *
+ * @example
+ * // Multi-turn: caller threads the conversation id.
+ * let conversationId: string | undefined;
+ * for (const question of questions) {
+ *   for await (const m of genieChat(spaceId, question, { conversationId })) {
+ *     conversationId = m.conversation_id ?? conversationId;
+ *     render(m);
+ *   }
+ * }
+ */
+export declare function genieChat(space_id: string, content: string, options?: GenieChatOptions): AsyncGenerator<GenieMessage, void, void>;
+/**
+ * One turn against a Genie space, yielded as a typed {@link GenieChatEvent}
+ * stream. Drives {@link genieChat} underneath and decorates each snapshot with
+ * the derived events the field-level diff produced. Stream order:
+ *
+ *   1. `{ type: "message", message }` - the raw `GenieMessage`, once per poll
+ *      yield.
+ *   2. `{ type: "question", content, message_id, ... }` fires exactly once, on
+ *      the FIRST `message` yield. We read `content` and `message_id` straight
+ *      off the snapshot so every downstream event for this turn shares the same
+ *      `message_id` (the question included) - subscribers can group everything
+ *      for one Genie call under that one key.
+ *   3. Any of `status` / `attachment` / `thinking` / `text` / `query` /
+ *      `statement` / `rows` / `suggested_questions` the diff against the prior
+ *      snapshot produced.
+ *   4. On the terminal snapshot, `{ type: "result", ... }` as the final yield.
+ *
+ * Errors propagate by the generator throwing - there's no `"error"` variant.
+ * Wrap the `for await` in `try/catch` if you need to handle failures.
+ *
+ * @example
+ * for await (const evt of genieEventChat(spaceId, "Top stores?")) {
+ *   switch (evt.type) {
+ *     case "thinking":
+ *       console.log("[thinking]", evt.thought_type, evt.text);
+ *       break;
+ *     case "text":
+ *       console.log("[text]", evt.text);
+ *       break;
+ *     case "result":
+ *       console.log("[done]", evt.status);
+ *       break;
+ *   }
+ * }
+ */
+export declare function genieEventChat(space_id: string, content: string, options?: GenieChatOptions): AsyncGenerator<GenieChatEvent, void, void>;

package/lib/src/chat.js

@@ -0,0 +1,274 @@
+/**
+ * Genie chat driver.
+ *
+ * Drives a single turn against a Genie space from one `content` string;
+ * multi-turn conversations are the caller's job (thread the `conversation_id`
+ * returned on each `GenieMessage` back into the next turn's
+ * `options.conversationId`).
+ *
+ * Two layers serve two kinds of consumer. The low-level layer yields every
+ * poll-observed `GenieMessage` (validated against `GenieMessageSchema`,
+ * falling back to the raw snapshot on a schema miss) and owns the messy parts
+ * - cancellation, conversation seeding, distinct-filtering, and SDK quirks
+ * (Waiter stripping); reach for it when you want the raw stream. The
+ * high-level layer wraps it and emits semantic, deduplicated `{ type, payload }`
+ * events (see {@link GenieChatEvent}), always closing a successful turn with a
+ * terminal `result` event carrying the final `GenieMessage`; errors propagate
+ * by throwing, with no `error` variant. Iterating UI / agent code that wants
+ * every message verbatim takes the low-level stream; subscribers reacting to
+ * "Genie is thinking about X" or "Genie produced text Y" take the event layer.
+ *
+ * @module
+ */
+import { WorkspaceClient } from "@databricks/sdk-experimental";
+import { databricks } from "@dbx-tools/appkit";
+import { async, log } from "@dbx-tools/shared-core";
+import { event, genieModel } from "@dbx-tools/shared-genie";
+const logger = log.logger("genie/chat");
+/**
+ * Validate a polled wire snapshot against {@link GenieMessageSchema}
+ * and return the schema-normalized message. Genie's wire occasionally ships a
+ * shape the (SDK-derived) schema doesn't model exactly - e.g. an early poll
+ * that omits the SDK-required `message_id` - so a miss degrades to the raw
+ * snapshot rather than throwing, keeping a single odd poll from aborting the
+ * whole turn.
+ */
+function validateMessage(raw) {
+    const result = genieModel.GenieMessageSchema.safeParse(raw);
+    if (result.success)
+        return result.data;
+    logger.debug("wire-message:schema-miss", {
+        message_id: raw.message_id ?? raw.id,
+        issues: result.error.issues.length,
+    });
+    return raw;
+}
+/* ----------------------- low-level: genieChat ----------------------- */
+/**
+ * One turn against a Genie space, yielded as a stream of `GenieMessage`
+ * snapshots.
+ *
+ * Turn lifecycle:
+ *
+ *   - No `options.conversationId`: open a new conversation via
+ *     `client.genie.startConversation`. The opened conversation id surfaces on
+ *     every yielded `GenieMessage` (`.conversation_id`) so the caller can
+ *     thread it into a follow-up call.
+ *   - With `options.conversationId`: append to that conversation via
+ *     `client.genie.createMessage`.
+ *   - In both cases, after the create/start the driver polls
+ *     `client.genie.getMessage` every `options.pollIntervalMs` (default 500ms)
+ *     until the message reaches a terminal status, then yields the terminal
+ *     snapshot and returns.
+ *
+ * Cancellation: a single internal `AbortController` covers the whole turn.
+ * `options.context` is tied into that controller so an external abort tears
+ * down every in-flight SDK call AND the inter-poll sleep. Breaking out of the
+ * `for await` does the same via the `try / finally`.
+ *
+ * @example
+ * // Single turn.
+ * for await (const m of genieChat(spaceId, "Top 5 stores?")) {
+ *   render(m);
+ * }
+ *
+ * @example
+ * // Multi-turn: caller threads the conversation id.
+ * let conversationId: string | undefined;
+ * for (const question of questions) {
+ *   for await (const m of genieChat(spaceId, question, { conversationId })) {
+ *     conversationId = m.conversation_id ?? conversationId;
+ *     render(m);
+ *   }
+ * }
+ */
+export async function* genieChat(space_id, content, options) {
+    const controller = new AbortController();
+    try {
+        const client = await getWorkspaceClient(options);
+        // Build the SDK Context ONCE. Building it inside the poll producer would
+        // re-attach an abort listener to `options.context` on every poll iteration
+        // (via `databricks.toContext` -> `async.tieAbortSignal`), eventually tripping
+        // Node's `MaxListenersExceededWarning`.
+        const ctx = databricks.toContext(controller, options?.context);
+        let conversationId = options?.conversationId;
+        let messageId;
+        const pollProducer = async (pollCtx) => {
+            if (!conversationId) {
+                // First poll: open the conversation. Refuse to retry: if
+                // `startConversation` returned a response without a `conversation_id`,
+                // retrying would just open conversation after conversation.
+                if (pollCtx.attempt > 0) {
+                    throw new Error("Genie did not return a conversation id; refusing to retry");
+                }
+                const startResponse = await client.genie.startConversation({ space_id, content }, ctx);
+                conversationId = startResponse.conversation_id;
+                messageId = startResponse.message_id;
+                return startResponse.message;
+            }
+            if (!messageId) {
+                // First poll of a follow-up turn: append to the seeded conversation.
+                // `client.genie.createMessage` returns a `Waiter<GenieMessage>`
+                // (`{ ...message, wait: async () => ... }`). Strip `wait` here so
+                // downstream serializers (e.g. yaml.stringify) don't choke on the
+                // AsyncFunction value.
+                const { wait: _wait, ...createResponse } = await client.genie.createMessage({ space_id, conversation_id: conversationId, content }, ctx);
+                messageId = createResponse.message_id;
+                return createResponse;
+            }
+            // Subsequent polls: re-fetch the current message until its status becomes
+            // terminal.
+            return client.genie.getMessage({
+                space_id,
+                conversation_id: conversationId,
+                message_id: messageId,
+            }, ctx);
+        };
+        yield* async.poll(async (pollCtx) => validateMessage(await pollProducer(pollCtx)), {
+            intervalMs: options?.pollIntervalMs ?? 500,
+            // Skip yielding identical consecutive snapshots; Genie often returns
+            // the exact same payload twice during quiet periods. `poll` does a deep
+            // equal on the previous yield.
+            filter: "distinct",
+            // Stop after the terminal message is yielded. `poll` checks the
+            // predicate AFTER yielding, so the terminal message still reaches the
+            // consumer.
+            predicate: (m) => !genieModel.isTerminalStatus(m.status),
+            // Wake the inter-poll sleep on abort so a `for await` break (or
+            // external abort) tears down promptly instead of waiting out the
+            // interval.
+            signal: controller.signal,
+        });
+    }
+    finally {
+        // Cancels any still-pending SDK call and the inter-poll sleep whether we're
+        // unwinding from a normal return, a consumer break, or a thrown error.
+        // Idempotent.
+        controller.abort();
+    }
+}
+/* ---------------------- high-level: genieEventChat ------------------ */
+/**
+ * One turn against a Genie space, yielded as a typed {@link GenieChatEvent}
+ * stream. Drives {@link genieChat} underneath and decorates each snapshot with
+ * the derived events the field-level diff produced. Stream order:
+ *
+ *   1. `{ type: "message", message }` - the raw `GenieMessage`, once per poll
+ *      yield.
+ *   2. `{ type: "question", content, message_id, ... }` fires exactly once, on
+ *      the FIRST `message` yield. We read `content` and `message_id` straight
+ *      off the snapshot so every downstream event for this turn shares the same
+ *      `message_id` (the question included) - subscribers can group everything
+ *      for one Genie call under that one key.
+ *   3. Any of `status` / `attachment` / `thinking` / `text` / `query` /
+ *      `statement` / `rows` / `suggested_questions` the diff against the prior
+ *      snapshot produced.
+ *   4. On the terminal snapshot, `{ type: "result", ... }` as the final yield.
+ *
+ * Errors propagate by the generator throwing - there's no `"error"` variant.
+ * Wrap the `for await` in `try/catch` if you need to handle failures.
+ *
+ * @example
+ * for await (const evt of genieEventChat(spaceId, "Top stores?")) {
+ *   switch (evt.type) {
+ *     case "thinking":
+ *       console.log("[thinking]", evt.thought_type, evt.text);
+ *       break;
+ *     case "text":
+ *       console.log("[text]", evt.text);
+ *       break;
+ *     case "result":
+ *       console.log("[done]", evt.status);
+ *       break;
+ *   }
+ * }
+ */
+export async function* genieEventChat(space_id, content, options) {
+    // Diff source for the current turn. Always `undefined` on the first snapshot
+    // so the initial status / attachments emit fresh; updated to the most recent
+    // snapshot after each yield.
+    let previous;
+    // The `question` event is deferred to the first `message` yield so it can
+    // carry the assigned `message_id` (subscribers use it as the grouping key for
+    // every event in this turn). The first snapshot is the earliest point that id
+    // exists.
+    let questionEmitted = false;
+    for await (const rawMessage of genieChat(space_id, content, options)) {
+        // Normalize `message_id` from the legacy `id` field when Genie's wire
+        // response only populates one of them. The SDK schema marks both as
+        // required, but in practice the `startConversation` / `createMessage` inner
+        // `message` payload sometimes ships only `id` while the new `message_id`
+        // field lands undefined. Every downstream event detector keys grouping off
+        // `message_id`; the fallback keeps one Genie turn's events from splitting
+        // across an anon group + the real-id group when subscribers bucket by
+        // `message_id`.
+        const message = rawMessage.message_id
+            ? rawMessage
+            : { ...rawMessage, message_id: rawMessage.id };
+        yield {
+            type: "message",
+            space_id: message.space_id,
+            message_id: message.message_id,
+            message,
+        };
+        if (!questionEmitted) {
+            yield {
+                type: "question",
+                space_id: message.space_id,
+                ...(message.conversation_id ? { conversation_id: message.conversation_id } : {}),
+                ...(message.message_id ? { message_id: message.message_id } : {}),
+                content: message.content,
+            };
+            questionEmitted = true;
+        }
+        yield* event.eventsFromMessage(message, previous, message.space_id);
+        const status = message.status;
+        if (genieModel.isTerminalStatus(status)) {
+            yield {
+                type: "result",
+                space_id: message.space_id,
+                conversation_id: message.conversation_id,
+                message_id: message.message_id,
+                status,
+                message,
+            };
+        }
+        previous = message;
+    }
+}
+/* ---------------------- workspace client helper --------------------- */
+/**
+ * Resolve a `WorkspaceClient` in this preference order:
+ *
+ *   1. Caller-supplied `options.workspaceClient`.
+ *   2. AppKit's per-request execution-context client, when AppKit is installed
+ *      AND we're inside a request scope.
+ *   3. Fresh `new WorkspaceClient({})` (env-var auth via
+ *      `DATABRICKS_CONFIG_PROFILE` / `DATABRICKS_HOST` / `DATABRICKS_TOKEN`).
+ *
+ * AppKit is loaded lazily so this package stays usable in non-AppKit
+ * environments.
+ */
+async function getWorkspaceClient(options) {
+    if (options?.workspaceClient)
+        return options.workspaceClient;
+    const appkit = await getAppKit();
+    if (appkit) {
+        try {
+            return appkit.getExecutionContext().client;
+        }
+        catch {
+            // Not inside an AppKit request context; fall through to env.
+        }
+    }
+    return new WorkspaceClient({});
+}
+async function getAppKit() {
+    try {
+        return await import("@databricks/appkit");
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chat.js","sourceRoot":"","sources":["../../src/chat.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Genie chat driver.\n *\n * Drives a single turn against a Genie space from one `content` string;\n * multi-turn conversations are the caller's job (thread the `conversation_id`\n * returned on each `GenieMessage` back into the next turn's\n * `options.conversationId`).\n *\n * Two layers serve two kinds of consumer. The low-level layer yields every\n * poll-observed `GenieMessage` (validated against `GenieMessageSchema`,\n * falling back to the raw snapshot on a schema miss) and owns the messy parts\n * - cancellation, conversation seeding, distinct-filtering, and SDK quirks\n * (Waiter stripping); reach for it when you want the raw stream. The\n * high-level layer wraps it and emits semantic, deduplicated `{ type, payload }`\n * events (see {@link GenieChatEvent}), always closing a successful turn with a\n * terminal `result` event carrying the final `GenieMessage`; errors propagate\n * by throwing, with no `error` variant. Iterating UI / agent code that wants\n * every message verbatim takes the low-level stream; subscribers reacting to\n * \"Genie is thinking about X\" or \"Genie produced text Y\" take the event layer.\n *\n * @module\n */\n\nimport { WorkspaceClient } from \"@databricks/sdk-experimental\";\nimport { databricks } from \"@dbx-tools/appkit\";\nimport { async, log, type PollContext } from \"@dbx-tools/shared-core\";\nimport { event, genieModel, type GenieChatEvent, type GenieMessage } from \"@dbx-tools/shared-genie\";\n\nconst logger = log.logger(\"genie/chat\");\n\n/**\n * Validate a polled wire snapshot against {@link GenieMessageSchema}\n * and return the schema-normalized message. Genie's wire occasionally ships a\n * shape the (SDK-derived) schema doesn't model exactly - e.g. an early poll\n * that omits the SDK-required `message_id` - so a miss degrades to the raw\n * snapshot rather than throwing, keeping a single odd poll from aborting the\n * whole turn.\n */\nfunction validateMessage(raw: GenieMessage): GenieMessage {\n  const result = genieModel.GenieMessageSchema.safeParse(raw);\n  if (result.success) return result.data;\n  logger.debug(\"wire-message:schema-miss\", {\n    message_id: raw.message_id ?? raw.id,\n    issues: result.error.issues.length,\n  });\n  return raw;\n}\n\n/* -------------------------- shared options -------------------------- */\n\n/** Options accepted by both {@link genieChat} and {@link genieEventChat}. */\nexport interface GenieChatOptions {\n  /**\n   * Seed conversation id. When set, this turn appends to the existing\n   * conversation (via `createMessage`) instead of opening a new one. Use it to\n   * thread a multi-turn conversation: read `conversation_id` off the prior\n   * turn's terminal `GenieMessage` (or the `result` event's\n   * `payload.conversation_id`) and pass it into the next call.\n   */\n  conversationId?: string;\n  /**\n   * Explicit `WorkspaceClient`. Defaults to AppKit's per-request\n   * execution-context client when AppKit is installed and we're inside a\n   * request; falls back to a fresh `new WorkspaceClient({})` (env-var auth)\n   * otherwise.\n   */\n  workspaceClient?: WorkspaceClient;\n  /** Poll cadence in milliseconds between successive `getMessage` calls (default 500). */\n  pollIntervalMs?: number;\n  /**\n   * External cancellation. Accepts a WHATWG `AbortSignal` or a fully-built SDK\n   * `Context` (see `databricks.ContextLike`). Aborting it cancels every in-flight\n   * SDK call and the next inter-poll sleep.\n   */\n  context?: databricks.ContextLike;\n}\n\n/* ----------------------- low-level: genieChat ----------------------- */\n\n/**\n * One turn against a Genie space, yielded as a stream of `GenieMessage`\n * snapshots.\n *\n * Turn lifecycle:\n *\n *   - No `options.conversationId`: open a new conversation via\n *     `client.genie.startConversation`. The opened conversation id surfaces on\n *     every yielded `GenieMessage` (`.conversation_id`) so the caller can\n *     thread it into a follow-up call.\n *   - With `options.conversationId`: append to that conversation via\n *     `client.genie.createMessage`.\n *   - In both cases, after the create/start the driver polls\n *     `client.genie.getMessage` every `options.pollIntervalMs` (default 500ms)\n *     until the message reaches a terminal status, then yields the terminal\n *     snapshot and returns.\n *\n * Cancellation: a single internal `AbortController` covers the whole turn.\n * `options.context` is tied into that controller so an external abort tears\n * down every in-flight SDK call AND the inter-poll sleep. Breaking out of the\n * `for await` does the same via the `try / finally`.\n *\n * @example\n * // Single turn.\n * for await (const m of genieChat(spaceId, \"Top 5 stores?\")) {\n *   render(m);\n * }\n *\n * @example\n * // Multi-turn: caller threads the conversation id.\n * let conversationId: string | undefined;\n * for (const question of questions) {\n *   for await (const m of genieChat(spaceId, question, { conversationId })) {\n *     conversationId = m.conversation_id ?? conversationId;\n *     render(m);\n *   }\n * }\n */\nexport async function* genieChat(\n  space_id: string,\n  content: string,\n  options?: GenieChatOptions,\n): AsyncGenerator<GenieMessage, void, void> {\n  const controller = new AbortController();\n  try {\n    const client = await getWorkspaceClient(options);\n    // Build the SDK Context ONCE. Building it inside the poll producer would\n    // re-attach an abort listener to `options.context` on every poll iteration\n    // (via `databricks.toContext` -> `async.tieAbortSignal`), eventually tripping\n    // Node's `MaxListenersExceededWarning`.\n    const ctx = databricks.toContext(controller, options?.context);\n    let conversationId = options?.conversationId;\n    let messageId: string | undefined;\n\n    const pollProducer = async (pollCtx: PollContext<GenieMessage>): Promise<GenieMessage> => {\n      if (!conversationId) {\n        // First poll: open the conversation. Refuse to retry: if\n        // `startConversation` returned a response without a `conversation_id`,\n        // retrying would just open conversation after conversation.\n        if (pollCtx.attempt > 0) {\n          throw new Error(\"Genie did not return a conversation id; refusing to retry\");\n        }\n        const startResponse = await client.genie.startConversation({ space_id, content }, ctx);\n        conversationId = startResponse.conversation_id;\n        messageId = startResponse.message_id;\n        return startResponse.message!;\n      }\n      if (!messageId) {\n        // First poll of a follow-up turn: append to the seeded conversation.\n        // `client.genie.createMessage` returns a `Waiter<GenieMessage>`\n        // (`{ ...message, wait: async () => ... }`). Strip `wait` here so\n        // downstream serializers (e.g. yaml.stringify) don't choke on the\n        // AsyncFunction value.\n        const { wait: _wait, ...createResponse } = await client.genie.createMessage(\n          { space_id, conversation_id: conversationId, content },\n          ctx,\n        );\n        messageId = createResponse.message_id;\n        return createResponse;\n      }\n      // Subsequent polls: re-fetch the current message until its status becomes\n      // terminal.\n      return client.genie.getMessage(\n        {\n          space_id,\n          conversation_id: conversationId,\n          message_id: messageId,\n        },\n        ctx,\n      );\n    };\n\n    yield* async.poll(\n      async (pollCtx: PollContext<GenieMessage>) => validateMessage(await pollProducer(pollCtx)),\n      {\n        intervalMs: options?.pollIntervalMs ?? 500,\n        // Skip yielding identical consecutive snapshots; Genie often returns\n        // the exact same payload twice during quiet periods. `poll` does a deep\n        // equal on the previous yield.\n        filter: \"distinct\",\n        // Stop after the terminal message is yielded. `poll` checks the\n        // predicate AFTER yielding, so the terminal message still reaches the\n        // consumer.\n        predicate: (m) => !genieModel.isTerminalStatus(m.status),\n        // Wake the inter-poll sleep on abort so a `for await` break (or\n        // external abort) tears down promptly instead of waiting out the\n        // interval.\n        signal: controller.signal,\n      },\n    );\n  } finally {\n    // Cancels any still-pending SDK call and the inter-poll sleep whether we're\n    // unwinding from a normal return, a consumer break, or a thrown error.\n    // Idempotent.\n    controller.abort();\n  }\n}\n\n/* ---------------------- high-level: genieEventChat ------------------ */\n\n/**\n * One turn against a Genie space, yielded as a typed {@link GenieChatEvent}\n * stream. Drives {@link genieChat} underneath and decorates each snapshot with\n * the derived events the field-level diff produced. Stream order:\n *\n *   1. `{ type: \"message\", message }` - the raw `GenieMessage`, once per poll\n *      yield.\n *   2. `{ type: \"question\", content, message_id, ... }` fires exactly once, on\n *      the FIRST `message` yield. We read `content` and `message_id` straight\n *      off the snapshot so every downstream event for this turn shares the same\n *      `message_id` (the question included) - subscribers can group everything\n *      for one Genie call under that one key.\n *   3. Any of `status` / `attachment` / `thinking` / `text` / `query` /\n *      `statement` / `rows` / `suggested_questions` the diff against the prior\n *      snapshot produced.\n *   4. On the terminal snapshot, `{ type: \"result\", ... }` as the final yield.\n *\n * Errors propagate by the generator throwing - there's no `\"error\"` variant.\n * Wrap the `for await` in `try/catch` if you need to handle failures.\n *\n * @example\n * for await (const evt of genieEventChat(spaceId, \"Top stores?\")) {\n *   switch (evt.type) {\n *     case \"thinking\":\n *       console.log(\"[thinking]\", evt.thought_type, evt.text);\n *       break;\n *     case \"text\":\n *       console.log(\"[text]\", evt.text);\n *       break;\n *     case \"result\":\n *       console.log(\"[done]\", evt.status);\n *       break;\n *   }\n * }\n */\nexport async function* genieEventChat(\n  space_id: string,\n  content: string,\n  options?: GenieChatOptions,\n): AsyncGenerator<GenieChatEvent, void, void> {\n  // Diff source for the current turn. Always `undefined` on the first snapshot\n  // so the initial status / attachments emit fresh; updated to the most recent\n  // snapshot after each yield.\n  let previous: GenieMessage | undefined;\n  // The `question` event is deferred to the first `message` yield so it can\n  // carry the assigned `message_id` (subscribers use it as the grouping key for\n  // every event in this turn). The first snapshot is the earliest point that id\n  // exists.\n  let questionEmitted = false;\n  for await (const rawMessage of genieChat(space_id, content, options)) {\n    // Normalize `message_id` from the legacy `id` field when Genie's wire\n    // response only populates one of them. The SDK schema marks both as\n    // required, but in practice the `startConversation` / `createMessage` inner\n    // `message` payload sometimes ships only `id` while the new `message_id`\n    // field lands undefined. Every downstream event detector keys grouping off\n    // `message_id`; the fallback keeps one Genie turn's events from splitting\n    // across an anon group + the real-id group when subscribers bucket by\n    // `message_id`.\n    const message: GenieMessage = rawMessage.message_id\n      ? rawMessage\n      : { ...rawMessage, message_id: rawMessage.id };\n    yield {\n      type: \"message\",\n      space_id: message.space_id,\n      message_id: message.message_id,\n      message,\n    };\n    if (!questionEmitted) {\n      yield {\n        type: \"question\",\n        space_id: message.space_id,\n        ...(message.conversation_id ? { conversation_id: message.conversation_id } : {}),\n        ...(message.message_id ? { message_id: message.message_id } : {}),\n        content: message.content,\n      };\n      questionEmitted = true;\n    }\n    yield* event.eventsFromMessage(message, previous, message.space_id);\n    const status = message.status;\n    if (genieModel.isTerminalStatus(status)) {\n      yield {\n        type: \"result\",\n        space_id: message.space_id,\n        conversation_id: message.conversation_id,\n        message_id: message.message_id,\n        status,\n        message,\n      };\n    }\n    previous = message;\n  }\n}\n\n/* ---------------------- workspace client helper --------------------- */\n\n/**\n * Resolve a `WorkspaceClient` in this preference order:\n *\n *   1. Caller-supplied `options.workspaceClient`.\n *   2. AppKit's per-request execution-context client, when AppKit is installed\n *      AND we're inside a request scope.\n *   3. Fresh `new WorkspaceClient({})` (env-var auth via\n *      `DATABRICKS_CONFIG_PROFILE` / `DATABRICKS_HOST` / `DATABRICKS_TOKEN`).\n *\n * AppKit is loaded lazily so this package stays usable in non-AppKit\n * environments.\n */\nasync function getWorkspaceClient(options?: GenieChatOptions): Promise<WorkspaceClient> {\n  if (options?.workspaceClient) return options.workspaceClient;\n  const appkit = await getAppKit();\n  if (appkit) {\n    try {\n      return appkit.getExecutionContext().client;\n    } catch {\n      // Not inside an AppKit request context; fall through to env.\n    }\n  }\n  return new WorkspaceClient({});\n}\n\nasync function getAppKit() {\n  try {\n    return await import(\"@databricks/appkit\");\n  } catch {\n    return undefined;\n  }\n}\n"]}

package/lib/src/space.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Genie space metadata helpers.
+ *
+ * Fetches a Genie space's definition (including the opt-in `serialized_space`
+ * blob) and extracts the curated starter questions an author configured on the
+ * space. The typed SDK `client.genie.getSpace` only returns the
+ * directory-listing surface (`title` / `description` / `warehouse_id`); the
+ * sample questions live inside `serialized_space`, which the REST API returns
+ * only when `include_serialized_space=true`. We hit that endpoint through the
+ * workspace client's raw `apiClient` since the typed request shape has no flag
+ * for it.
+ *
+ * @module
+ */
+import { WorkspaceClient } from "@databricks/sdk-experimental";
+import { databricks } from "@dbx-tools/appkit";
+import { type GenieSpace } from "@dbx-tools/shared-genie";
+/** Options for {@link getGenieSpace}. */
+export interface GetGenieSpaceOptions {
+    /**
+     * Explicit `WorkspaceClient`. Defaults to a fresh `new WorkspaceClient({})`
+     * (env-var auth). Server callers should pass their OBO-scoped client so the
+     * lookup runs as the user.
+     */
+    workspaceClient?: WorkspaceClient;
+    /**
+     * Request the `serialized_space` blob (catalogs, tables, sample questions,
+     * prompts). Defaults to `true` - the only reason to skip it is when the
+     * caller just needs title / description and wants the smaller payload.
+     */
+    serialized?: boolean;
+    /**
+     * External cancellation. Accepts a WHATWG `AbortSignal` or a fully-built SDK
+     * `Context` (see `databricks.ContextLike`).
+     */
+    context?: databricks.ContextLike;
+}
+/**
+ * Fetch a Genie space by id, optionally including its serialized definition.
+ * Hits `GET /api/2.0/genie/spaces/<id>` with `include_serialized_space=true`
+ * through the raw `apiClient`, then validates the response against
+ * {@link GenieSpaceSchema} (unknown fields like `etag` /
+ * `parent_path` are stripped).
+ */
+export declare function getGenieSpace(spaceId: string, options?: GetGenieSpaceOptions): Promise<GenieSpace>;
+/**
+ * Extract the curated starter questions an author configured on a Genie space.
+ * Reads `serialized_space -> config.sample_questions[*].question`. Returns `[]`
+ * when the space carries no serialized blob, the blob is unparseable, or no
+ * sample questions are configured - so a missing or misconfigured space
+ * degrades to "no suggestions" rather than throwing. Order is preserved (the
+ * author's ordering) and duplicates are dropped.
+ */
+export declare function genieSampleQuestions(space: GenieSpace): string[];

package/lib/src/space.js

@@ -0,0 +1,69 @@
+/**
+ * Genie space metadata helpers.
+ *
+ * Fetches a Genie space's definition (including the opt-in `serialized_space`
+ * blob) and extracts the curated starter questions an author configured on the
+ * space. The typed SDK `client.genie.getSpace` only returns the
+ * directory-listing surface (`title` / `description` / `warehouse_id`); the
+ * sample questions live inside `serialized_space`, which the REST API returns
+ * only when `include_serialized_space=true`. We hit that endpoint through the
+ * workspace client's raw `apiClient` since the typed request shape has no flag
+ * for it.
+ *
+ * @module
+ */
+import { WorkspaceClient } from "@databricks/sdk-experimental";
+import { databricks } from "@dbx-tools/appkit";
+import { json, log, object, string } from "@dbx-tools/shared-core";
+import { genieModel } from "@dbx-tools/shared-genie";
+const logger = log.logger("genie/space");
+/**
+ * Fetch a Genie space by id, optionally including its serialized definition.
+ * Hits `GET /api/2.0/genie/spaces/<id>` with `include_serialized_space=true`
+ * through the raw `apiClient`, then validates the response against
+ * {@link GenieSpaceSchema} (unknown fields like `etag` /
+ * `parent_path` are stripped).
+ */
+export async function getGenieSpace(spaceId, options) {
+    const client = options?.workspaceClient ?? new WorkspaceClient({});
+    const serialized = options?.serialized !== false;
+    const ctx = options?.context ? databricks.toContext(options.context) : undefined;
+    const raw = await client.apiClient.request({
+        path: `/api/2.0/genie/spaces/${encodeURIComponent(spaceId)}`,
+        method: "GET",
+        query: serialized ? { include_serialized_space: true } : {},
+        headers: new Headers(),
+        raw: false,
+    }, ctx);
+    return genieModel.GenieSpaceSchema.parse(raw);
+}
+/**
+ * Extract the curated starter questions an author configured on a Genie space.
+ * Reads `serialized_space -> config.sample_questions[*].question`. Returns `[]`
+ * when the space carries no serialized blob, the blob is unparseable, or no
+ * sample questions are configured - so a missing or misconfigured space
+ * degrades to "no suggestions" rather than throwing. Order is preserved (the
+ * author's ordering) and duplicates are dropped.
+ */
+export function genieSampleQuestions(space) {
+    const serialized = space.serialized_space;
+    if (!serialized)
+        return [];
+    const parsed = json.parse(serialized);
+    if (parsed === undefined) {
+        logger.warn("serialized-space:parse-error", { spaceId: space.space_id });
+        return [];
+    }
+    const sampleQuestions = parsed?.config
+        ?.sample_questions;
+    if (!Array.isArray(sampleQuestions))
+        return [];
+    return [
+        ...object
+            .sequence(sampleQuestions)
+            .map((entry) => string.firstNonEmpty(entry?.question))
+            .nonNull()
+            .distinct(),
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/chat.ts","../src/space.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -16,25 +16,29 @@
   },
   "dependencies": {
     "@databricks/sdk-experimental": "^0.17.0",
-    "@dbx-tools/appkit": "0.3.43",
-    "@dbx-tools/shared-genie": "0.3.43",
-    "@dbx-tools/shared-core": "0.3.43"
+    "@dbx-tools/appkit": "0.4.0",
+    "@dbx-tools/shared-core": "0.4.0",
+    "@dbx-tools/shared-genie": "0.4.0"
   },
-  "main": "index.ts",
+  "main": "./lib/index.js",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.43",
-  "types": "index.ts",
+  "version": "0.4.0",
+  "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
-    ".": "./index.ts",
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "index.ts",
-    "src"
+    "src",
+    "lib"
   ],
   "peerDependenciesMeta": {
     "@databricks/appkit": {