@dbx-tools/genie 0.6.211 → 0.6.213

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -13,9 +13,14 @@ Pure Genie schemas and event detector helpers live in
 
 Key features:
 
+- Streams the Genie Agent Mode API by default, including reasoning, SQL calls,
+  query output, and the synthesized answer.
 - Starts new Genie conversations or continues an existing `conversationId`.
-- Polls Databricks Genie until terminal status while filtering unchanged
-  snapshots.
+- Projects Agent Mode response items onto the existing `GenieMessage` snapshot
+  and semantic-event contracts.
+- Retains the Conversation API polling driver behind `agentMode: false` and as
+  an automatic pre-stream fallback for `FEATURE_DISABLED` or preview-toggle
+  errors.
 - Converts raw Genie messages into semantic events for thinking text, generated
   SQL, row counts, final results, and errors.
 - Preserves AppKit OBO auth when called during an AppKit request, but also works
@@ -82,10 +87,13 @@ for await (const message of chat.genieChat(spaceId, "Top stores by revenue?")) {
 }
 ```
 
-`chat.genieChat()` starts a conversation or appends to an existing one, polls
-`client.genie.getMessage`, filters identical consecutive payloads, and stops
-after a terminal status. Use it when you want to run your own diffing or persist
-the raw Genie wire shape.
+`chat.genieChat()` starts an Agent Mode response or continues an existing
+conversation, projects SSE output into `GenieMessage` snapshots, filters
+identical consecutive payloads, and stops after a terminal response. Set
+`agentMode: false` to force the legacy start/create/get-message polling flow.
+Use it when you want to run your own diffing or persist the normalized wire
+shape. Agent Mode returns query output inline as Markdown; use polling when a
+consumer specifically requires the legacy `statement_id`.
 
 ## Continue A Conversation
 
@@ -126,8 +134,8 @@ Client resolution order:
 2. AppKit execution-context client, when present;
 3. `createWorkspaceClient()` using AppKit's normal Databricks auth chain.
 
-Pass `options.context` as an `AbortSignal` or SDK context to cancel SDK calls and
-the polling sleep.
+Pass `options.context` as an `AbortSignal` or SDK context to cancel the Agent
+Mode stream, SDK calls, and any polling fallback sleep.
 
 ## Read Space Metadata And Starter Questions
 
@@ -155,14 +163,18 @@ thrown.
 `chat.GenieChatOptions` is shared by both drivers:
 
 - `conversationId` - append to an existing Genie conversation.
+- `agentMode` - use Agent Mode SSE, default `true`; `false` forces polling.
+- `enableVisualization` - request Agent Mode visualization generation.
 - `workspaceClient` - explicit Databricks SDK client.
-- `pollIntervalMs` - polling cadence, default `500`.
+- `pollIntervalMs` - legacy fallback polling cadence, default `500`.
 - `context` - SDK `Context` or `AbortSignal` for cancellation.
 
 ## Modules
 
 - `chat` - `genieChat()` raw snapshot stream and `genieEventChat()` typed event
   stream.
+- `agentMode` - `genieAgentModeChat()`, availability classification, and Agent
+  Mode transport options.
 - `space` - `getGenieSpace()` and `genieSampleQuestions()`.
 
 The AppKit-Mastra package builds its Genie tools on top of this driver; see

package/index.ts

@@ -3,8 +3,10 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/genie";
-export const PACKAGE_VERSION = "0.6.211";
+export const PACKAGE_VERSION = "0.6.213";
+export * as agentMode from "./src/agent-mode.ts";
 export * as chat from "./src/chat.ts";
 export * as space from "./src/space.ts";
+export type { GenieAgentModeOptions } from "./src/agent-mode.ts";
 export type { GenieChatOptions } from "./src/chat.ts";
 export type { GetGenieSpaceOptions } from "./src/space.ts";

package/lib/index.d.ts

@@ -1,6 +1,8 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/genie";
-export declare const PACKAGE_VERSION = "0.6.211";
+export declare const PACKAGE_VERSION = "0.6.213";
+export * as agentMode from "./src/agent-mode.ts";
 export * as chat from "./src/chat.ts";
 export * as space from "./src/space.ts";
+export type { GenieAgentModeOptions } from "./src/agent-mode.ts";
 export type { GenieChatOptions } from "./src/chat.ts";
 export type { GetGenieSpaceOptions } from "./src/space.ts";

package/lib/index.js

@@ -2,7 +2,8 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/genie";
-export const PACKAGE_VERSION = "0.6.211";
+export const PACKAGE_VERSION = "0.6.213";
+export * as agentMode from "./src/agent-mode.js";
 export * as chat from "./src/chat.js";
 export * as space from "./src/space.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxrQkFBa0IsQ0FBQztBQUNyRCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsU0FBUyxDQUFDO0FBQ3pDLE9BQU8sS0FBSyxJQUFJLE1BQU0sZUFBZSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxLQUFLLE1BQU0sZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBHRU5FUkFURUQgYnkgcHJvamVuIHdhdGNoIC0gRE8gTk9UIEVESVQuXG4vLyBSZWdlbmVyYXRlZCBmcm9tIHRoZSBleHBvcnRpbmcgbW9kdWxlcyBpbiAuL3NyYy5cbi8vIEhhbmQgZWRpdHMgYXJlIG92ZXJ3cml0dGVuIG9uIHRoZSBuZXh0IHdhdGNoOyB0aGlzIGZpbGUgaXMgcmVhZC1vbmx5LlxuXG5leHBvcnQgY29uc3QgUEFDS0FHRV9JREVOVElGSUVSID0gXCJAZGJ4LXRvb2xzL2dlbmllXCI7XG5leHBvcnQgY29uc3QgUEFDS0FHRV9WRVJTSU9OID0gXCIwLjYuMjExXCI7XG5leHBvcnQgKiBhcyBjaGF0IGZyb20gXCIuL3NyYy9jaGF0LnRzXCI7XG5leHBvcnQgKiBhcyBzcGFjZSBmcm9tIFwiLi9zcmMvc3BhY2UudHNcIjtcbmV4cG9ydCB0eXBlIHsgR2VuaWVDaGF0T3B0aW9ucyB9IGZyb20gXCIuL3NyYy9jaGF0LnRzXCI7XG5leHBvcnQgdHlwZSB7IEdldEdlbmllU3BhY2VPcHRpb25zIH0gZnJvbSBcIi4vc3JjL3NwYWNlLnRzXCI7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxrQkFBa0IsQ0FBQztBQUNyRCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsU0FBUyxDQUFDO0FBQ3pDLE9BQU8sS0FBSyxTQUFTLE1BQU0scUJBQXFCLENBQUM7QUFDakQsT0FBTyxLQUFLLElBQUksTUFBTSxlQUFlLENBQUM7QUFDdEMsT0FBTyxLQUFLLEtBQUssTUFBTSxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdFTkVSQVRFRCBieSBwcm9qZW4gd2F0Y2ggLSBETyBOT1QgRURJVC5cbi8vIFJlZ2VuZXJhdGVkIGZyb20gdGhlIGV4cG9ydGluZyBtb2R1bGVzIGluIC4vc3JjLlxuLy8gSGFuZCBlZGl0cyBhcmUgb3ZlcndyaXR0ZW4gb24gdGhlIG5leHQgd2F0Y2g7IHRoaXMgZmlsZSBpcyByZWFkLW9ubHkuXG5cbmV4cG9ydCBjb25zdCBQQUNLQUdFX0lERU5USUZJRVIgPSBcIkBkYngtdG9vbHMvZ2VuaWVcIjtcbmV4cG9ydCBjb25zdCBQQUNLQUdFX1ZFUlNJT04gPSBcIjAuNi4yMTNcIjtcbmV4cG9ydCAqIGFzIGFnZW50TW9kZSBmcm9tIFwiLi9zcmMvYWdlbnQtbW9kZS50c1wiO1xuZXhwb3J0ICogYXMgY2hhdCBmcm9tIFwiLi9zcmMvY2hhdC50c1wiO1xuZXhwb3J0ICogYXMgc3BhY2UgZnJvbSBcIi4vc3JjL3NwYWNlLnRzXCI7XG5leHBvcnQgdHlwZSB7IEdlbmllQWdlbnRNb2RlT3B0aW9ucyB9IGZyb20gXCIuL3NyYy9hZ2VudC1tb2RlLnRzXCI7XG5leHBvcnQgdHlwZSB7IEdlbmllQ2hhdE9wdGlvbnMgfSBmcm9tIFwiLi9zcmMvY2hhdC50c1wiO1xuZXhwb3J0IHR5cGUgeyBHZXRHZW5pZVNwYWNlT3B0aW9ucyB9IGZyb20gXCIuL3NyYy9zcGFjZS50c1wiO1xuIl19

package/lib/src/agent-mode.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Genie Agent Mode SSE transport.
+ *
+ * Streams the Responses-shaped Agent Mode API and projects its reasoning, SQL,
+ * query output, and final answer items onto the existing `GenieMessage`
+ * contract so callers can keep one semantic event pipeline across Agent Mode
+ * and the legacy polling API.
+ *
+ * @module
+ */
+import type { WorkspaceClient } from "@databricks/appkit";
+import { databricks } from "@dbx-tools/appkit";
+import { type GenieMessage } from "@dbx-tools/shared-genie";
+/** Inputs for one Agent Mode response stream. */
+export interface GenieAgentModeOptions {
+    conversationId?: string;
+    enableVisualization?: boolean;
+    context?: databricks.ContextLike;
+}
+/** Stream one Agent Mode response as `GenieMessage` snapshots. */
+export declare function genieAgentModeChat(client: WorkspaceClient, agentId: string, content: string, options?: GenieAgentModeOptions): AsyncGenerator<GenieMessage, void, void>;
+/** Return whether Agent Mode is disabled or its preview toggle is unavailable. */
+export declare function isAgentModeUnavailable(value: unknown): boolean;

package/lib/src/agent-mode.js

@@ -0,0 +1,141 @@
+/**
+ * Genie Agent Mode SSE transport.
+ *
+ * Streams the Responses-shaped Agent Mode API and projects its reasoning, SQL,
+ * query output, and final answer items onto the existing `GenieMessage`
+ * contract so callers can keep one semantic event pipeline across Agent Mode
+ * and the legacy polling API.
+ *
+ * @module
+ */
+import { databricks } from "@dbx-tools/appkit";
+import { error, json, log, object } from "@dbx-tools/shared-core";
+import { agentMode as agentModeWire, } from "@dbx-tools/shared-genie";
+const logger = log.logger("genie/agent-mode");
+const CANCEL_TIMEOUT_MS = 5_000;
+/** Stream one Agent Mode response as `GenieMessage` snapshots. */
+export async function* genieAgentModeChat(client, agentId, content, options = {}) {
+    const ownedController = options.context ? undefined : new AbortController();
+    const projection = new agentModeWire.GenieAgentModeProjection(agentId, content);
+    try {
+        const context = options.context
+            ? databricks.toContext(options.context)
+            : databricks.toContext(ownedController);
+        const response = await client.apiClient.request({
+            path: `/api/2.0/genie/agents/${encodeURIComponent(agentId)}/responses`,
+            method: "POST",
+            headers: new Headers({
+                accept: "text/event-stream",
+                "content-type": "application/json",
+            }),
+            raw: true,
+            payload: {
+                input: [
+                    {
+                        type: "message",
+                        role: "user",
+                        content: [{ type: "input_text", text: content }],
+                    },
+                ],
+                ...(options.conversationId ? { conversation_id: options.conversationId } : {}),
+                ...(options.enableVisualization ? { enable_viz: true } : {}),
+            },
+        }, context);
+        const stream = object.isRecord(response) ? response.contents : undefined;
+        if (!isReadableStream(stream)) {
+            throw new TypeError("Genie Agent Mode did not return an SSE stream");
+        }
+        let previous;
+        for await (const event of parseSse(stream)) {
+            const message = projection.apply(event);
+            if (!message)
+                continue;
+            if (!object.deepEqual(message, previous)) {
+                yield message;
+                previous = message;
+            }
+        }
+        if (!projection.terminal) {
+            throw new Error("Genie Agent Mode stream ended before a terminal response");
+        }
+    }
+    finally {
+        ownedController?.abort();
+        if (!projection.terminal && projection.responseId && projection.conversationId) {
+            await cancelResponse(client, agentId, projection.conversationId, projection.responseId);
+        }
+    }
+}
+/** Return whether Agent Mode is disabled or its preview toggle is unavailable. */
+export function isAgentModeUnavailable(value) {
+    const context = error.errorContext(value);
+    return context.hasMessage("feature", "disabled") || context.hasMessage("preview", "toggle");
+}
+function isReadableStream(value) {
+    return object.isRecord(value) && typeof value.getReader === "function";
+}
+async function cancelResponse(client, agentId, conversationId, responseId) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), CANCEL_TIMEOUT_MS);
+    try {
+        await client.apiClient.request({
+            path: `/api/2.0/genie/agents/${encodeURIComponent(agentId)}/conversations/${encodeURIComponent(conversationId)}/responses/${encodeURIComponent(responseId)}/cancel`,
+            method: "POST",
+            headers: new Headers({
+                accept: "application/json",
+                "content-type": "application/json",
+            }),
+            raw: false,
+        }, databricks.toContext(controller));
+    }
+    catch (err) {
+        logger.debug("response:cancel-failed", {
+            agentId,
+            conversationId,
+            responseId,
+            error: error.errorMessage(err),
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function* parseSse(stream) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            buffer += decoder.decode(value, { stream: !done });
+            const frames = buffer.split(/\r?\n\r?\n/);
+            buffer = frames.pop() ?? "";
+            for (const frame of frames) {
+                const event = parseSseFrame(frame);
+                if (event)
+                    yield event;
+            }
+            if (done) {
+                const event = parseSseFrame(buffer);
+                if (event)
+                    yield event;
+                break;
+            }
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}
+function parseSseFrame(frame) {
+    const data = frame
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trimStart())
+        .join("\n");
+    if (!data || data === "[DONE]")
+        return undefined;
+    return agentModeWire.GenieAgentModeEventSchema.parse(json.parse(data));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agent-mode.js","sourceRoot":"","sources":["../../src/agent-mode.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Genie Agent Mode SSE transport.\n *\n * Streams the Responses-shaped Agent Mode API and projects its reasoning, SQL,\n * query output, and final answer items onto the existing `GenieMessage`\n * contract so callers can keep one semantic event pipeline across Agent Mode\n * and the legacy polling API.\n *\n * @module\n */\n\nimport type { WorkspaceClient } from \"@databricks/appkit\";\nimport { databricks } from \"@dbx-tools/appkit\";\nimport { error, json, log, object } from \"@dbx-tools/shared-core\";\nimport {\n  agentMode as agentModeWire,\n  type GenieAgentModeEvent,\n  type GenieMessage,\n} from \"@dbx-tools/shared-genie\";\n\nconst logger = log.logger(\"genie/agent-mode\");\nconst CANCEL_TIMEOUT_MS = 5_000;\n\n/** Inputs for one Agent Mode response stream. */\nexport interface GenieAgentModeOptions {\n  conversationId?: string;\n  enableVisualization?: boolean;\n  context?: databricks.ContextLike;\n}\n\n/** Stream one Agent Mode response as `GenieMessage` snapshots. */\nexport async function* genieAgentModeChat(\n  client: WorkspaceClient,\n  agentId: string,\n  content: string,\n  options: GenieAgentModeOptions = {},\n): AsyncGenerator<GenieMessage, void, void> {\n  const ownedController = options.context ? undefined : new AbortController();\n  const projection = new agentModeWire.GenieAgentModeProjection(agentId, content);\n  try {\n    const context = options.context\n      ? databricks.toContext(options.context)\n      : databricks.toContext(ownedController!);\n    const response = await client.apiClient.request(\n      {\n        path: `/api/2.0/genie/agents/${encodeURIComponent(agentId)}/responses`,\n        method: \"POST\",\n        headers: new Headers({\n          accept: \"text/event-stream\",\n          \"content-type\": \"application/json\",\n        }),\n        raw: true,\n        payload: {\n          input: [\n            {\n              type: \"message\",\n              role: \"user\",\n              content: [{ type: \"input_text\", text: content }],\n            },\n          ],\n          ...(options.conversationId ? { conversation_id: options.conversationId } : {}),\n          ...(options.enableVisualization ? { enable_viz: true } : {}),\n        },\n      },\n      context,\n    );\n    const stream = object.isRecord(response) ? response.contents : undefined;\n    if (!isReadableStream(stream)) {\n      throw new TypeError(\"Genie Agent Mode did not return an SSE stream\");\n    }\n\n    let previous: GenieMessage | undefined;\n    for await (const event of parseSse(stream)) {\n      const message = projection.apply(event);\n      if (!message) continue;\n      if (!object.deepEqual(message, previous)) {\n        yield message;\n        previous = message;\n      }\n    }\n    if (!projection.terminal) {\n      throw new Error(\"Genie Agent Mode stream ended before a terminal response\");\n    }\n  } finally {\n    ownedController?.abort();\n    if (!projection.terminal && projection.responseId && projection.conversationId) {\n      await cancelResponse(client, agentId, projection.conversationId, projection.responseId);\n    }\n  }\n}\n\n/** Return whether Agent Mode is disabled or its preview toggle is unavailable. */\nexport function isAgentModeUnavailable(value: unknown): boolean {\n  const context = error.errorContext(value);\n  return context.hasMessage(\"feature\", \"disabled\") || context.hasMessage(\"preview\", \"toggle\");\n}\n\nfunction isReadableStream(value: unknown): value is ReadableStream<Uint8Array> {\n  return object.isRecord(value) && typeof value.getReader === \"function\";\n}\n\nasync function cancelResponse(\n  client: WorkspaceClient,\n  agentId: string,\n  conversationId: string,\n  responseId: string,\n): Promise<void> {\n  const controller = new AbortController();\n  const timeout = setTimeout(() => controller.abort(), CANCEL_TIMEOUT_MS);\n  try {\n    await client.apiClient.request(\n      {\n        path: `/api/2.0/genie/agents/${encodeURIComponent(agentId)}/conversations/${encodeURIComponent(conversationId)}/responses/${encodeURIComponent(responseId)}/cancel`,\n        method: \"POST\",\n        headers: new Headers({\n          accept: \"application/json\",\n          \"content-type\": \"application/json\",\n        }),\n        raw: false,\n      },\n      databricks.toContext(controller),\n    );\n  } catch (err) {\n    logger.debug(\"response:cancel-failed\", {\n      agentId,\n      conversationId,\n      responseId,\n      error: error.errorMessage(err),\n    });\n  } finally {\n    clearTimeout(timeout);\n  }\n}\n\nasync function* parseSse(\n  stream: ReadableStream<Uint8Array>,\n): AsyncGenerator<GenieAgentModeEvent, void, void> {\n  const reader = stream.getReader();\n  const decoder = new TextDecoder();\n  let buffer = \"\";\n  try {\n    while (true) {\n      const { done, value } = await reader.read();\n      buffer += decoder.decode(value, { stream: !done });\n      const frames = buffer.split(/\\r?\\n\\r?\\n/);\n      buffer = frames.pop() ?? \"\";\n      for (const frame of frames) {\n        const event = parseSseFrame(frame);\n        if (event) yield event;\n      }\n      if (done) {\n        const event = parseSseFrame(buffer);\n        if (event) yield event;\n        break;\n      }\n    }\n  } finally {\n    await reader.cancel().catch(() => undefined);\n    reader.releaseLock();\n  }\n}\n\nfunction parseSseFrame(frame: string): GenieAgentModeEvent | undefined {\n  const data = frame\n    .split(/\\r?\\n/)\n    .filter((line) => line.startsWith(\"data:\"))\n    .map((line) => line.slice(5).trimStart())\n    .join(\"\\n\");\n  if (!data || data === \"[DONE]\") return undefined;\n  return agentModeWire.GenieAgentModeEventSchema.parse(json.parse(data));\n}\n"]}

package/lib/src/chat.d.ts

@@ -6,11 +6,15 @@
  * returned on each `GenieMessage` back into the next turn's
  * `options.conversationId`).
  *
+ * Agent Mode SSE is the default transport. Its Responses-style reasoning, SQL,
+ * query output, and final answer items are projected into `GenieMessage`
+ * snapshots; `agentMode: false` retains the Conversation API polling path.
+ *
  * 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
+ * observed `GenieMessage` (validated against `GenieMessageSchema`, falling back
+ * to the raw snapshot on a schema miss) and owns cancellation, conversation
+ * seeding, distinct-filtering, and SDK quirks; 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
@@ -26,11 +30,16 @@ 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.
+     * Use the streaming Genie Agent Mode API. Defaults to `true`; set `false` to
+     * force the legacy start/create/get-message polling flow.
+     */
+    agentMode?: boolean;
+    /** Ask Agent Mode to generate visualizations when appropriate. */
+    enableVisualization?: boolean;
+    /**
+     * Continue an existing conversation. Agent Mode sends it as
+     * `conversation_id`; legacy polling passes it to `createMessage`. Read the id
+     * from the prior turn's terminal `GenieMessage` or `result` event.
      */
     conversationId?: string;
     /**
@@ -40,12 +49,12 @@ export interface GenieChatOptions {
      * otherwise.
      */
     workspaceClient?: WorkspaceClient;
-    /** Poll cadence in milliseconds between successive `getMessage` calls (default 500). */
+    /** Legacy fallback cadence between successive `getMessage` calls (default 500ms). */
     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.
+     * Agent Mode stream, SDK call, and the next inter-poll sleep.
      */
     context?: databricks.ContextLike;
 }
@@ -55,21 +64,19 @@ export interface GenieChatOptions {
  *
  * 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.
+ *   - Agent Mode (default): POST one Responses-style message to
+ *     `/api/2.0/genie/agents/{id}/responses` and yield projected snapshots from
+ *     its SSE events.
+ *   - Legacy polling (`agentMode: false`): start/create a Conversation API
+ *     message and poll `getMessage` until terminal.
+ *   - A pre-stream `FEATURE_DISABLED` or preview-toggle response falls back to
+ *     legacy polling automatically.
  *
  * 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`.
+ * down the Agent Mode SSE connection, SDK calls, and any inter-poll sleep.
+ * Breaking out of the `for await` also invokes the Agent Mode server-side
+ * cancel endpoint before the generator closes.
  *
  * @example
  * // Single turn.

package/lib/src/chat.js

@@ -6,11 +6,15 @@
  * returned on each `GenieMessage` back into the next turn's
  * `options.conversationId`).
  *
+ * Agent Mode SSE is the default transport. Its Responses-style reasoning, SQL,
+ * query output, and final answer items are projected into `GenieMessage`
+ * snapshots; `agentMode: false` retains the Conversation API polling path.
+ *
  * 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
+ * observed `GenieMessage` (validated against `GenieMessageSchema`, falling back
+ * to the raw snapshot on a schema miss) and owns cancellation, conversation
+ * seeding, distinct-filtering, and SDK quirks; 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
@@ -22,8 +26,9 @@
  */
 import { createWorkspaceClient, getExecutionContext, } from "@databricks/appkit";
 import { databricks } from "@dbx-tools/appkit";
-import { async, log } from "@dbx-tools/shared-core";
+import { async, error, log } from "@dbx-tools/shared-core";
 import { event, genieModel } from "@dbx-tools/shared-genie";
+import { genieAgentModeChat, isAgentModeUnavailable } from "./agent-mode.js";
 const logger = log.logger("genie/chat");
 /**
  * Validate a polled wire snapshot against {@link GenieMessageSchema}
@@ -50,21 +55,19 @@ function validateMessage(raw) {
  *
  * 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.
+ *   - Agent Mode (default): POST one Responses-style message to
+ *     `/api/2.0/genie/agents/{id}/responses` and yield projected snapshots from
+ *     its SSE events.
+ *   - Legacy polling (`agentMode: false`): start/create a Conversation API
+ *     message and poll `getMessage` until terminal.
+ *   - A pre-stream `FEATURE_DISABLED` or preview-toggle response falls back to
+ *     legacy polling automatically.
  *
  * 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`.
+ * down the Agent Mode SSE connection, SDK calls, and any inter-poll sleep.
+ * Breaking out of the `for await` also invokes the Agent Mode server-side
+ * cancel endpoint before the generator closes.
  *
  * @example
  * // Single turn.
@@ -91,6 +94,28 @@ export async function* genieChat(space_id, content, options) {
         // (via `databricks.toContext` -> `async.tieAbortSignal`), eventually tripping
         // Node's `MaxListenersExceededWarning`.
         const ctx = databricks.toContext(controller, options?.context);
+        if (options?.agentMode !== false) {
+            let yielded = false;
+            try {
+                for await (const message of genieAgentModeChat(client, space_id, content, {
+                    ...(options?.conversationId ? { conversationId: options.conversationId } : {}),
+                    ...(options?.enableVisualization ? { enableVisualization: true } : {}),
+                    context: ctx,
+                })) {
+                    yielded = true;
+                    yield validateMessage(message);
+                }
+                return;
+            }
+            catch (err) {
+                if (yielded || !isAgentModeUnavailable(err))
+                    throw err;
+                logger.warn("agent-mode:unavailable, falling back to polling", {
+                    space_id,
+                    error: error.errorMessage(err),
+                });
+            }
+        }
         let conversationId = options?.conversationId;
         let messageId;
         const pollProducer = async (pollCtx) => {
@@ -257,4 +282,4 @@ async function getWorkspaceClient(options) {
     }
     return createWorkspaceClient();
 }
-//# 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 {\n  createWorkspaceClient,\n  getExecutionContext,\n  type WorkspaceClient,\n} from \"@databricks/appkit\";\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 `createWorkspaceClient()` (default 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 inside a request scope.\n *   3. Fresh `createWorkspaceClient()` (env-var auth via\n *      `DATABRICKS_CONFIG_PROFILE` / `DATABRICKS_HOST` / `DATABRICKS_TOKEN`).\n *\n */\nasync function getWorkspaceClient(options?: GenieChatOptions): Promise<WorkspaceClient> {\n  if (options?.workspaceClient) return options.workspaceClient;\n  try {\n    return getExecutionContext().client;\n  } catch {\n    // Not inside an AppKit request context; fall through to default auth.\n  }\n  return createWorkspaceClient();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chat.js","sourceRoot":"","sources":["../../src/chat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EACL,qBAAqB,EACrB,mBAAmB,GAEpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAoB,MAAM,wBAAwB,CAAC;AAC7E,OAAO,EAAE,KAAK,EAAE,UAAU,EAA0C,MAAM,yBAAyB,CAAC;AAEpG,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAE7E,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;AAExC;;;;;;;GAOG;AACH,SAAS,eAAe,CAAC,GAAiB;IACxC,MAAM,MAAM,GAAG,UAAU,CAAC,kBAAkB,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAC5D,IAAI,MAAM,CAAC,OAAO;QAAE,OAAO,MAAM,CAAC,IAAI,CAAC;IACvC,MAAM,CAAC,KAAK,CAAC,0BAA0B,EAAE;QACvC,UAAU,EAAE,GAAG,CAAC,UAAU,IAAI,GAAG,CAAC,EAAE;QACpC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM;KACnC,CAAC,CAAC;IACH,OAAO,GAAG,CAAC;AACb,CAAC;AAoCD,0EAA0E;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,SAAS,CAC9B,QAAgB,EAChB,OAAe,EACf,OAA0B;IAE1B,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;IACzC,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,kBAAkB,CAAC,OAAO,CAAC,CAAC;QACjD,yEAAyE;QACzE,2EAA2E;QAC3E,8EAA8E;QAC9E,wCAAwC;QACxC,MAAM,GAAG,GAAG,UAAU,CAAC,SAAS,CAAC,UAAU,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QAC/D,IAAI,OAAO,EAAE,SAAS,KAAK,KAAK,EAAE,CAAC;YACjC,IAAI,OAAO,GAAG,KAAK,CAAC;YACpB,IAAI,CAAC;gBACH,IAAI,KAAK,EAAE,MAAM,OAAO,IAAI,kBAAkB,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE;oBACxE,GAAG,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;oBAC9E,GAAG,CAAC,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAAE,mBAAmB,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;oBACtE,OAAO,EAAE,GAAG;iBACb,CAAC,EAAE,CAAC;oBACH,OAAO,GAAG,IAAI,CAAC;oBACf,MAAM,eAAe,CAAC,OAAO,CAAC,CAAC;gBACjC,CAAC;gBACD,OAAO;YACT,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,OAAO,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC;oBAAE,MAAM,GAAG,CAAC;gBACvD,MAAM,CAAC,IAAI,CAAC,iDAAiD,EAAE;oBAC7D,QAAQ;oBACR,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC;iBAC/B,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QACD,IAAI,cAAc,GAAG,OAAO,EAAE,cAAc,CAAC;QAC7C,IAAI,SAA6B,CAAC;QAElC,MAAM,YAAY,GAAG,KAAK,EAAE,OAAkC,EAAyB,EAAE;YACvF,IAAI,CAAC,cAAc,EAAE,CAAC;gBACpB,yDAAyD;gBACzD,uEAAuE;gBACvE,4DAA4D;gBAC5D,IAAI,OAAO,CAAC,OAAO,GAAG,CAAC,EAAE,CAAC;oBACxB,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;gBAC/E,CAAC;gBACD,MAAM,aAAa,GAAG,MAAM,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,GAAG,CAAC,CAAC;gBACvF,cAAc,GAAG,aAAa,CAAC,eAAe,CAAC;gBAC/C,SAAS,GAAG,aAAa,CAAC,UAAU,CAAC;gBACrC,OAAO,aAAa,CAAC,OAAQ,CAAC;YAChC,CAAC;YACD,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,qEAAqE;gBACrE,gEAAgE;gBAChE,kEAAkE;gBAClE,kEAAkE;gBAClE,uBAAuB;gBACvB,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,cAAc,EAAE,GAAG,MAAM,MAAM,CAAC,KAAK,CAAC,aAAa,CACzE,EAAE,QAAQ,EAAE,eAAe,EAAE,cAAc,EAAE,OAAO,EAAE,EACtD,GAAG,CACJ,CAAC;gBACF,SAAS,GAAG,cAAc,CAAC,UAAU,CAAC;gBACtC,OAAO,cAAc,CAAC;YACxB,CAAC;YACD,0EAA0E;YAC1E,YAAY;YACZ,OAAO,MAAM,CAAC,KAAK,CAAC,UAAU,CAC5B;gBACE,QAAQ;gBACR,eAAe,EAAE,cAAc;gBAC/B,UAAU,EAAE,SAAS;aACtB,EACD,GAAG,CACJ,CAAC;QACJ,CAAC,CAAC;QAEF,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,CACf,KAAK,EAAE,OAAkC,EAAE,EAAE,CAAC,eAAe,CAAC,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC,EAC1F;YACE,UAAU,EAAE,OAAO,EAAE,cAAc,IAAI,GAAG;YAC1C,qEAAqE;YACrE,wEAAwE;YACxE,+BAA+B;YAC/B,MAAM,EAAE,UAAU;YAClB,gEAAgE;YAChE,sEAAsE;YACtE,YAAY;YACZ,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,CAAC,MAAM,CAAC;YACxD,gEAAgE;YAChE,iEAAiE;YACjE,YAAY;YACZ,MAAM,EAAE,UAAU,CAAC,MAAM;SAC1B,CACF,CAAC;IACJ,CAAC;YAAS,CAAC;QACT,4EAA4E;QAC5E,uEAAuE;QACvE,cAAc;QACd,UAAU,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;AACH,CAAC;AAED,0EAA0E;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,cAAc,CACnC,QAAgB,EAChB,OAAe,EACf,OAA0B;IAE1B,6EAA6E;IAC7E,6EAA6E;IAC7E,6BAA6B;IAC7B,IAAI,QAAkC,CAAC;IACvC,0EAA0E;IAC1E,8EAA8E;IAC9E,8EAA8E;IAC9E,UAAU;IACV,IAAI,eAAe,GAAG,KAAK,CAAC;IAC5B,IAAI,KAAK,EAAE,MAAM,UAAU,IAAI,SAAS,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;QACrE,sEAAsE;QACtE,oEAAoE;QACpE,4EAA4E;QAC5E,yEAAyE;QACzE,2EAA2E;QAC3E,0EAA0E;QAC1E,sEAAsE;QACtE,gBAAgB;QAChB,MAAM,OAAO,GAAiB,UAAU,CAAC,UAAU;YACjD,CAAC,CAAC,UAAU;YACZ,CAAC,CAAC,EAAE,GAAG,UAAU,EAAE,UAAU,EAAE,UAAU,CAAC,EAAE,EAAE,CAAC;QACjD,MAAM;YACJ,IAAI,EAAE,SAAS;YACf,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,OAAO;SACR,CAAC;QACF,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,MAAM;gBACJ,IAAI,EAAE,UAAU;gBAChB,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,GAAG,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,eAAe,EAAE,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAChF,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACjE,OAAO,EAAE,OAAO,CAAC,OAAO;aACzB,CAAC;YACF,eAAe,GAAG,IAAI,CAAC;QACzB,CAAC;QACD,KAAK,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;QACpE,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC9B,IAAI,UAAU,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAAE,CAAC;YACxC,MAAM;gBACJ,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,eAAe,EAAE,OAAO,CAAC,eAAe;gBACxC,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,MAAM;gBACN,OAAO;aACR,CAAC;QACJ,CAAC;QACD,QAAQ,GAAG,OAAO,CAAC;IACrB,CAAC;AACH,CAAC;AAED,0EAA0E;AAE1E;;;;;;;;GAQG;AACH,KAAK,UAAU,kBAAkB,CAAC,OAA0B;IAC1D,IAAI,OAAO,EAAE,eAAe;QAAE,OAAO,OAAO,CAAC,eAAe,CAAC;IAC7D,IAAI,CAAC;QACH,OAAO,mBAAmB,EAAE,CAAC,MAAM,CAAC;IACtC,CAAC;IAAC,MAAM,CAAC;QACP,sEAAsE;IACxE,CAAC;IACD,OAAO,qBAAqB,EAAE,CAAC;AACjC,CAAC","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 * Agent Mode SSE is the default transport. Its Responses-style reasoning, SQL,\n * query output, and final answer items are projected into `GenieMessage`\n * snapshots; `agentMode: false` retains the Conversation API polling path.\n *\n * Two layers serve two kinds of consumer. The low-level layer yields every\n * observed `GenieMessage` (validated against `GenieMessageSchema`, falling back\n * to the raw snapshot on a schema miss) and owns cancellation, conversation\n * seeding, distinct-filtering, and SDK quirks; reach for it when you want the\n * 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 {\n  createWorkspaceClient,\n  getExecutionContext,\n  type WorkspaceClient,\n} from \"@databricks/appkit\";\nimport { databricks } from \"@dbx-tools/appkit\";\nimport { async, error, log, type PollContext } from \"@dbx-tools/shared-core\";\nimport { event, genieModel, type GenieChatEvent, type GenieMessage } from \"@dbx-tools/shared-genie\";\n\nimport { genieAgentModeChat, isAgentModeUnavailable } from \"./agent-mode.ts\";\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   * Use the streaming Genie Agent Mode API. Defaults to `true`; set `false` to\n   * force the legacy start/create/get-message polling flow.\n   */\n  agentMode?: boolean;\n  /** Ask Agent Mode to generate visualizations when appropriate. */\n  enableVisualization?: boolean;\n  /**\n   * Continue an existing conversation. Agent Mode sends it as\n   * `conversation_id`; legacy polling passes it to `createMessage`. Read the id\n   * from the prior turn's terminal `GenieMessage` or `result` event.\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 `createWorkspaceClient()` (default auth)\n   * otherwise.\n   */\n  workspaceClient?: WorkspaceClient;\n  /** Legacy fallback cadence between successive `getMessage` calls (default 500ms). */\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   * Agent Mode stream, 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 *   - Agent Mode (default): POST one Responses-style message to\n *     `/api/2.0/genie/agents/{id}/responses` and yield projected snapshots from\n *     its SSE events.\n *   - Legacy polling (`agentMode: false`): start/create a Conversation API\n *     message and poll `getMessage` until terminal.\n *   - A pre-stream `FEATURE_DISABLED` or preview-toggle response falls back to\n *     legacy polling automatically.\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 the Agent Mode SSE connection, SDK calls, and any inter-poll sleep.\n * Breaking out of the `for await` also invokes the Agent Mode server-side\n * cancel endpoint before the generator closes.\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    if (options?.agentMode !== false) {\n      let yielded = false;\n      try {\n        for await (const message of genieAgentModeChat(client, space_id, content, {\n          ...(options?.conversationId ? { conversationId: options.conversationId } : {}),\n          ...(options?.enableVisualization ? { enableVisualization: true } : {}),\n          context: ctx,\n        })) {\n          yielded = true;\n          yield validateMessage(message);\n        }\n        return;\n      } catch (err) {\n        if (yielded || !isAgentModeUnavailable(err)) throw err;\n        logger.warn(\"agent-mode:unavailable, falling back to polling\", {\n          space_id,\n          error: error.errorMessage(err),\n        });\n      }\n    }\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 inside a request scope.\n *   3. Fresh `createWorkspaceClient()` (env-var auth via\n *      `DATABRICKS_CONFIG_PROFILE` / `DATABRICKS_HOST` / `DATABRICKS_TOKEN`).\n *\n */\nasync function getWorkspaceClient(options?: GenieChatOptions): Promise<WorkspaceClient> {\n  if (options?.workspaceClient) return options.workspaceClient;\n  try {\n    return getExecutionContext().client;\n  } catch {\n    // Not inside an AppKit request context; fall through to default auth.\n  }\n  return createWorkspaceClient();\n}\n"]}

package/lib/tsconfig.tsbuildinfo

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

package/package.json

@@ -1,5 +1,6 @@
 {
   "name": "@dbx-tools/genie",
+  "description": "Server-side Databricks Genie chat drivers",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/reggie-db/dbx-tools.git",
@@ -24,12 +25,12 @@
   },
   "dependencies": {
     "@databricks/appkit": "^0.60.0",
-    "@dbx-tools/appkit": "0.6.211",
-    "@dbx-tools/shared-core": "0.6.211",
-    "@dbx-tools/shared-genie": "0.6.211"
+    "@dbx-tools/appkit": "0.6.213",
+    "@dbx-tools/shared-core": "0.6.213",
+    "@dbx-tools/shared-genie": "0.6.213"
   },
   "main": "./lib/index.js",
-  "license": "UNLICENSED",
+  "license": "Apache-2.0",
   "publishConfig": {
     "access": "public",
     "main": "./lib/index.js",
@@ -42,7 +43,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.211",
+  "version": "0.6.213",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/agent-mode.ts

@@ -0,0 +1,171 @@
+/**
+ * Genie Agent Mode SSE transport.
+ *
+ * Streams the Responses-shaped Agent Mode API and projects its reasoning, SQL,
+ * query output, and final answer items onto the existing `GenieMessage`
+ * contract so callers can keep one semantic event pipeline across Agent Mode
+ * and the legacy polling API.
+ *
+ * @module
+ */
+
+import type { WorkspaceClient } from "@databricks/appkit";
+import { databricks } from "@dbx-tools/appkit";
+import { error, json, log, object } from "@dbx-tools/shared-core";
+import {
+  agentMode as agentModeWire,
+  type GenieAgentModeEvent,
+  type GenieMessage,
+} from "@dbx-tools/shared-genie";
+
+const logger = log.logger("genie/agent-mode");
+const CANCEL_TIMEOUT_MS = 5_000;
+
+/** Inputs for one Agent Mode response stream. */
+export interface GenieAgentModeOptions {
+  conversationId?: string;
+  enableVisualization?: boolean;
+  context?: databricks.ContextLike;
+}
+
+/** Stream one Agent Mode response as `GenieMessage` snapshots. */
+export async function* genieAgentModeChat(
+  client: WorkspaceClient,
+  agentId: string,
+  content: string,
+  options: GenieAgentModeOptions = {},
+): AsyncGenerator<GenieMessage, void, void> {
+  const ownedController = options.context ? undefined : new AbortController();
+  const projection = new agentModeWire.GenieAgentModeProjection(agentId, content);
+  try {
+    const context = options.context
+      ? databricks.toContext(options.context)
+      : databricks.toContext(ownedController!);
+    const response = await client.apiClient.request(
+      {
+        path: `/api/2.0/genie/agents/${encodeURIComponent(agentId)}/responses`,
+        method: "POST",
+        headers: new Headers({
+          accept: "text/event-stream",
+          "content-type": "application/json",
+        }),
+        raw: true,
+        payload: {
+          input: [
+            {
+              type: "message",
+              role: "user",
+              content: [{ type: "input_text", text: content }],
+            },
+          ],
+          ...(options.conversationId ? { conversation_id: options.conversationId } : {}),
+          ...(options.enableVisualization ? { enable_viz: true } : {}),
+        },
+      },
+      context,
+    );
+    const stream = object.isRecord(response) ? response.contents : undefined;
+    if (!isReadableStream(stream)) {
+      throw new TypeError("Genie Agent Mode did not return an SSE stream");
+    }
+
+    let previous: GenieMessage | undefined;
+    for await (const event of parseSse(stream)) {
+      const message = projection.apply(event);
+      if (!message) continue;
+      if (!object.deepEqual(message, previous)) {
+        yield message;
+        previous = message;
+      }
+    }
+    if (!projection.terminal) {
+      throw new Error("Genie Agent Mode stream ended before a terminal response");
+    }
+  } finally {
+    ownedController?.abort();
+    if (!projection.terminal && projection.responseId && projection.conversationId) {
+      await cancelResponse(client, agentId, projection.conversationId, projection.responseId);
+    }
+  }
+}
+
+/** Return whether Agent Mode is disabled or its preview toggle is unavailable. */
+export function isAgentModeUnavailable(value: unknown): boolean {
+  const context = error.errorContext(value);
+  return context.hasMessage("feature", "disabled") || context.hasMessage("preview", "toggle");
+}
+
+function isReadableStream(value: unknown): value is ReadableStream<Uint8Array> {
+  return object.isRecord(value) && typeof value.getReader === "function";
+}
+
+async function cancelResponse(
+  client: WorkspaceClient,
+  agentId: string,
+  conversationId: string,
+  responseId: string,
+): Promise<void> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), CANCEL_TIMEOUT_MS);
+  try {
+    await client.apiClient.request(
+      {
+        path: `/api/2.0/genie/agents/${encodeURIComponent(agentId)}/conversations/${encodeURIComponent(conversationId)}/responses/${encodeURIComponent(responseId)}/cancel`,
+        method: "POST",
+        headers: new Headers({
+          accept: "application/json",
+          "content-type": "application/json",
+        }),
+        raw: false,
+      },
+      databricks.toContext(controller),
+    );
+  } catch (err) {
+    logger.debug("response:cancel-failed", {
+      agentId,
+      conversationId,
+      responseId,
+      error: error.errorMessage(err),
+    });
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+async function* parseSse(
+  stream: ReadableStream<Uint8Array>,
+): AsyncGenerator<GenieAgentModeEvent, void, void> {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      buffer += decoder.decode(value, { stream: !done });
+      const frames = buffer.split(/\r?\n\r?\n/);
+      buffer = frames.pop() ?? "";
+      for (const frame of frames) {
+        const event = parseSseFrame(frame);
+        if (event) yield event;
+      }
+      if (done) {
+        const event = parseSseFrame(buffer);
+        if (event) yield event;
+        break;
+      }
+    }
+  } finally {
+    await reader.cancel().catch(() => undefined);
+    reader.releaseLock();
+  }
+}
+
+function parseSseFrame(frame: string): GenieAgentModeEvent | undefined {
+  const data = frame
+    .split(/\r?\n/)
+    .filter((line) => line.startsWith("data:"))
+    .map((line) => line.slice(5).trimStart())
+    .join("\n");
+  if (!data || data === "[DONE]") return undefined;
+  return agentModeWire.GenieAgentModeEventSchema.parse(json.parse(data));
+}

package/src/chat.ts

@@ -6,11 +6,15 @@
  * returned on each `GenieMessage` back into the next turn's
  * `options.conversationId`).
  *
+ * Agent Mode SSE is the default transport. Its Responses-style reasoning, SQL,
+ * query output, and final answer items are projected into `GenieMessage`
+ * snapshots; `agentMode: false` retains the Conversation API polling path.
+ *
  * 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
+ * observed `GenieMessage` (validated against `GenieMessageSchema`, falling back
+ * to the raw snapshot on a schema miss) and owns cancellation, conversation
+ * seeding, distinct-filtering, and SDK quirks; 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
@@ -27,9 +31,11 @@ import {
   type WorkspaceClient,
 } from "@databricks/appkit";
 import { databricks } from "@dbx-tools/appkit";
-import { async, log, type PollContext } from "@dbx-tools/shared-core";
+import { async, error, log, type PollContext } from "@dbx-tools/shared-core";
 import { event, genieModel, type GenieChatEvent, type GenieMessage } from "@dbx-tools/shared-genie";
 
+import { genieAgentModeChat, isAgentModeUnavailable } from "./agent-mode.ts";
+
 const logger = log.logger("genie/chat");
 
 /**
@@ -55,11 +61,16 @@ function validateMessage(raw: GenieMessage): GenieMessage {
 /** 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.
+   * Use the streaming Genie Agent Mode API. Defaults to `true`; set `false` to
+   * force the legacy start/create/get-message polling flow.
+   */
+  agentMode?: boolean;
+  /** Ask Agent Mode to generate visualizations when appropriate. */
+  enableVisualization?: boolean;
+  /**
+   * Continue an existing conversation. Agent Mode sends it as
+   * `conversation_id`; legacy polling passes it to `createMessage`. Read the id
+   * from the prior turn's terminal `GenieMessage` or `result` event.
    */
   conversationId?: string;
   /**
@@ -69,12 +80,12 @@ export interface GenieChatOptions {
    * otherwise.
    */
   workspaceClient?: WorkspaceClient;
-  /** Poll cadence in milliseconds between successive `getMessage` calls (default 500). */
+  /** Legacy fallback cadence between successive `getMessage` calls (default 500ms). */
   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.
+   * Agent Mode stream, SDK call, and the next inter-poll sleep.
    */
   context?: databricks.ContextLike;
 }
@@ -87,21 +98,19 @@ export interface GenieChatOptions {
  *
  * 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.
+ *   - Agent Mode (default): POST one Responses-style message to
+ *     `/api/2.0/genie/agents/{id}/responses` and yield projected snapshots from
+ *     its SSE events.
+ *   - Legacy polling (`agentMode: false`): start/create a Conversation API
+ *     message and poll `getMessage` until terminal.
+ *   - A pre-stream `FEATURE_DISABLED` or preview-toggle response falls back to
+ *     legacy polling automatically.
  *
  * 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`.
+ * down the Agent Mode SSE connection, SDK calls, and any inter-poll sleep.
+ * Breaking out of the `for await` also invokes the Agent Mode server-side
+ * cancel endpoint before the generator closes.
  *
  * @example
  * // Single turn.
@@ -132,6 +141,26 @@ export async function* genieChat(
     // (via `databricks.toContext` -> `async.tieAbortSignal`), eventually tripping
     // Node's `MaxListenersExceededWarning`.
     const ctx = databricks.toContext(controller, options?.context);
+    if (options?.agentMode !== false) {
+      let yielded = false;
+      try {
+        for await (const message of genieAgentModeChat(client, space_id, content, {
+          ...(options?.conversationId ? { conversationId: options.conversationId } : {}),
+          ...(options?.enableVisualization ? { enableVisualization: true } : {}),
+          context: ctx,
+        })) {
+          yielded = true;
+          yield validateMessage(message);
+        }
+        return;
+      } catch (err) {
+        if (yielded || !isAgentModeUnavailable(err)) throw err;
+        logger.warn("agent-mode:unavailable, falling back to polling", {
+          space_id,
+          error: error.errorMessage(err),
+        });
+      }
+    }
     let conversationId = options?.conversationId;
     let messageId: string | undefined;