@bringg/dashboard-sdk 9.81.0 → 9.82.0-pre.3

package/dist/Analyst/Analyst.consts.d.ts

@@ -0,0 +1,37 @@
+/**
+ * api-gateway path prefix the analyst service is registered under.
+ *
+ * From `analyst-service/helm/service/_default.yaml`:
+ *
+ *   service:
+ *     endpoints:
+ *     - path: /analyst-service
+ *       stripPath: true
+ *
+ * `stripPath: true` means the gateway strips the prefix before forwarding, so the service receives
+ * `/analyst/threads` rather than `/analyst-service/analyst/threads`.
+ */
+export declare const GATEWAY_PATH = "/analyst-service";
+/**
+ * The graph this chat talks to, and the first segment of every path below.
+ *
+ * The service mounts one path per graph, so the URL - not a request field - is what selects the
+ * agent. That is why the old `agent_id` on the request body no longer exists.
+ */
+export declare const GRAPH = "analyst";
+/**
+ * Routes from the ag-ui contract (Confluence 5278728195, §3).
+ *
+ * `CHAT` is declared here for completeness but is **not** called from this package: it is the ag-ui
+ * protocol endpoint, opened by the consumer's `HttpAgent` as a streaming POST. It is exposed through
+ * {@link AnalystClientConfig.chatUrl} instead, so the URL is still built in one place.
+ *
+ * Note the paths deliberately do not say `agui`. If the protocol is replaced again, these do not
+ * have to change.
+ */
+export declare const Routes: {
+    CHAT: string;
+    CANCEL_RUN: string;
+    THREADS: string;
+    THREAD: string;
+};

package/dist/Analyst/Analyst.consts.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Routes = exports.GRAPH = exports.GATEWAY_PATH = void 0;
+/**
+ * api-gateway path prefix the analyst service is registered under.
+ *
+ * From `analyst-service/helm/service/_default.yaml`:
+ *
+ *   service:
+ *     endpoints:
+ *     - path: /analyst-service
+ *       stripPath: true
+ *
+ * `stripPath: true` means the gateway strips the prefix before forwarding, so the service receives
+ * `/analyst/threads` rather than `/analyst-service/analyst/threads`.
+ */
+exports.GATEWAY_PATH = '/analyst-service';
+/**
+ * The graph this chat talks to, and the first segment of every path below.
+ *
+ * The service mounts one path per graph, so the URL - not a request field - is what selects the
+ * agent. That is why the old `agent_id` on the request body no longer exists.
+ */
+exports.GRAPH = 'analyst';
+/**
+ * Routes from the ag-ui contract (Confluence 5278728195, §3).
+ *
+ * `CHAT` is declared here for completeness but is **not** called from this package: it is the ag-ui
+ * protocol endpoint, opened by the consumer's `HttpAgent` as a streaming POST. It is exposed through
+ * {@link AnalystClientConfig.chatUrl} instead, so the URL is still built in one place.
+ *
+ * Note the paths deliberately do not say `agui`. If the protocol is replaced again, these do not
+ * have to change.
+ */
+exports.Routes = {
+    CHAT: "".concat(exports.GATEWAY_PATH, "/").concat(exports.GRAPH, "/chat"),
+    CANCEL_RUN: "".concat(exports.GATEWAY_PATH, "/").concat(exports.GRAPH, "/chat/cancel"),
+    THREADS: "".concat(exports.GATEWAY_PATH, "/").concat(exports.GRAPH, "/threads"),
+    THREAD: "".concat(exports.GATEWAY_PATH, "/").concat(exports.GRAPH, "/threads/{:threadId}")
+};
+//# sourceMappingURL=Analyst.consts.js.map

package/dist/Analyst/Analyst.consts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Analyst.consts.js","sourceRoot":"","sources":["../../src/Analyst/Analyst.consts.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;GAYG;AACU,QAAA,YAAY,GAAG,kBAAkB,CAAC;AAE/C;;;;;GAKG;AACU,QAAA,KAAK,GAAG,SAAS,CAAC;AAE/B;;;;;;;;;GASG;AACU,QAAA,MAAM,GAAG;IACrB,IAAI,EAAE,UAAG,oBAAY,cAAI,aAAK,UAAO;IACrC,UAAU,EAAE,UAAG,oBAAY,cAAI,aAAK,iBAAc;IAClD,OAAO,EAAE,UAAG,oBAAY,cAAI,aAAK,aAAU;IAC3C,MAAM,EAAE,UAAG,oBAAY,cAAI,aAAK,yBAAsB;CACtD,CAAC"}

package/dist/Analyst/Analyst.d.ts

@@ -0,0 +1,91 @@
+import type { AnalystChat } from '@bringg/types';
+import Session from '../Services/Identity/Session';
+/**
+ * Connection details for the Analyst agent's protocol client.
+ *
+ * Deliberately a plain object rather than a constructed client. The consumer builds the client
+ * itself - see the note on {@link Analyst}.
+ */
+export interface AnalystClientConfig {
+    /** Host and gateway prefix, with no graph or endpoint path on it. */
+    apiUrl: string;
+    /** The exact URL a turn is posted to. Built here so no consumer concatenates the path itself. */
+    chatUrl: string;
+    /** Applied to every request. */
+    defaultHeaders: Record<string, string>;
+}
+/**
+ * Where the dashboard reaches the Analyst agent, and how it authenticates.
+ *
+ * The browser never talks to analyst-service directly - it is reached through api-gateway under a
+ * path prefix, exactly like `data-query-service`. The service declares `bringg-jwt`, but no JWT
+ * exists client-side: the gateway performs the exchange from the ordinary Bringg session token, so
+ * we send the same `Authorization: Token token=...` plus `Client` that every other non-hagmonia
+ * call sends.
+ *
+ * **Why config and not a client.** Under ag-ui the chat is a single streaming POST, opened by
+ * `HttpAgent` from `@ag-ui/client` and answered with `text/event-stream` until the turn ends. A
+ * method returning a `Promise` cannot express that, and the client that can is a browser concern
+ * bound to a React lifecycle. So the split falls naturally: this package owns *where and how to
+ * connect*, which it already knows from `Session`, and the consumer owns the transport.
+ *
+ * ```ts
+ * const { chatUrl, defaultHeaders } = sdk.analyst.getClientConfig();
+ * const agent = new HttpAgent({ url: chatUrl, headers: defaultHeaders });
+ * ```
+ *
+ * Everything the dashboard requests *itself* - the thread list, one thread, cancelling a run - is an
+ * ordinary SDK call on this class, typed from the `AnalystChat` contract in `@bringg/types` so the
+ * shape is enforced by the compiler in both this repo and analyst-service.
+ */
+export declare class Analyst {
+    private readonly session;
+    private cached?;
+    private readonly entity;
+    constructor(session: Session);
+    /**
+     * The signed-in user's conversations, most recently active first.
+     *
+     * Carries no messages - the History list stays cheap, and opening a conversation hydrates it
+     * through {@link getThread}.
+     */
+    listThreads(): Promise<AnalystChat.ThreadSummary[]>;
+    /**
+     * One conversation, with its messages and whether a run is executing on it right now.
+     *
+     * `activeRun` is the load-bearing field: a run belongs to the server and outlives the connection
+     * that started it, so a caller opening a thread has to attach to that run rather than ask a new
+     * question - and must not accept typing meanwhile, because a normal post to a busy thread is
+     * answered with the running turn's feed and the typed message is discarded.
+     *
+     * Rejects on 404, which is also the answer for a thread belonging to someone else: the service
+     * deliberately does not distinguish "not yours" from "not there".
+     */
+    getThread(threadId: string): Promise<AnalystChat.ThreadDetail>;
+    /**
+     * Cancel the run in flight on a thread.
+     *
+     * Aborting the stream client-side stops events arriving but leaves the agent running, so Stop has
+     * to be this call rather than an abort. `cancelled: false` means the thread was already idle -
+     * a normal answer, not a failure.
+     *
+     * A cancelled run ends with no terminal event: the stream simply closes, with neither
+     * `RUN_FINISHED` nor `RUN_ERROR`. Callers that drive their loading state off terminal events
+     * alone will hang, and must treat stream close as its own case.
+     */
+    cancelRun(threadId: string): Promise<AnalystChat.CancelRunResponse>;
+    /**
+     * Returns the **same object** while the values are unchanged.
+     *
+     * Referential stability is load-bearing, not a micro-optimisation: a protocol client treats its
+     * config as a dependency and rebuilds itself whenever the identity changes. A fresh object per
+     * call rebuilds on every render, which refetches, which renders again - a loop.
+     *
+     * Recomputed each call and compared by value, so a changed session (login, region switch,
+     * impersonation) still produces a new config rather than a stale one.
+     */
+    getClientConfig(): AnalystClientConfig;
+    /** Matches the headers `ServiceRequest` builds for every other service. */
+    private getDefaultHeaders;
+}
+export default Analyst;

package/dist/Analyst/Analyst.js

@@ -0,0 +1,173 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Analyst = void 0;
+var Analyst_consts_1 = require("./Analyst.consts");
+var AnalystEntity_1 = __importDefault(require("./Entity/AnalystEntity"));
+var isSameConfig = function (a, b) {
+    if (a.apiUrl !== b.apiUrl || a.chatUrl !== b.chatUrl) {
+        return false;
+    }
+    var keys = Object.keys(a.defaultHeaders);
+    return (keys.length === Object.keys(b.defaultHeaders).length &&
+        keys.every(function (key) { return a.defaultHeaders[key] === b.defaultHeaders[key]; }));
+};
+/**
+ * Where the dashboard reaches the Analyst agent, and how it authenticates.
+ *
+ * The browser never talks to analyst-service directly - it is reached through api-gateway under a
+ * path prefix, exactly like `data-query-service`. The service declares `bringg-jwt`, but no JWT
+ * exists client-side: the gateway performs the exchange from the ordinary Bringg session token, so
+ * we send the same `Authorization: Token token=...` plus `Client` that every other non-hagmonia
+ * call sends.
+ *
+ * **Why config and not a client.** Under ag-ui the chat is a single streaming POST, opened by
+ * `HttpAgent` from `@ag-ui/client` and answered with `text/event-stream` until the turn ends. A
+ * method returning a `Promise` cannot express that, and the client that can is a browser concern
+ * bound to a React lifecycle. So the split falls naturally: this package owns *where and how to
+ * connect*, which it already knows from `Session`, and the consumer owns the transport.
+ *
+ * ```ts
+ * const { chatUrl, defaultHeaders } = sdk.analyst.getClientConfig();
+ * const agent = new HttpAgent({ url: chatUrl, headers: defaultHeaders });
+ * ```
+ *
+ * Everything the dashboard requests *itself* - the thread list, one thread, cancelling a run - is an
+ * ordinary SDK call on this class, typed from the `AnalystChat` contract in `@bringg/types` so the
+ * shape is enforced by the compiler in both this repo and analyst-service.
+ */
+var Analyst = /** @class */ (function () {
+    function Analyst(session) {
+        this.session = session;
+        this.entity = new AnalystEntity_1.default(session);
+    }
+    /**
+     * The signed-in user's conversations, most recently active first.
+     *
+     * Carries no messages - the History list stays cheap, and opening a conversation hydrates it
+     * through {@link getThread}.
+     */
+    Analyst.prototype.listThreads = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.entity.listThreads()];
+            });
+        });
+    };
+    /**
+     * One conversation, with its messages and whether a run is executing on it right now.
+     *
+     * `activeRun` is the load-bearing field: a run belongs to the server and outlives the connection
+     * that started it, so a caller opening a thread has to attach to that run rather than ask a new
+     * question - and must not accept typing meanwhile, because a normal post to a busy thread is
+     * answered with the running turn's feed and the typed message is discarded.
+     *
+     * Rejects on 404, which is also the answer for a thread belonging to someone else: the service
+     * deliberately does not distinguish "not yours" from "not there".
+     */
+    Analyst.prototype.getThread = function (threadId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.entity.getThread(threadId)];
+            });
+        });
+    };
+    /**
+     * Cancel the run in flight on a thread.
+     *
+     * Aborting the stream client-side stops events arriving but leaves the agent running, so Stop has
+     * to be this call rather than an abort. `cancelled: false` means the thread was already idle -
+     * a normal answer, not a failure.
+     *
+     * A cancelled run ends with no terminal event: the stream simply closes, with neither
+     * `RUN_FINISHED` nor `RUN_ERROR`. Callers that drive their loading state off terminal events
+     * alone will hang, and must treat stream close as its own case.
+     */
+    Analyst.prototype.cancelRun = function (threadId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.entity.cancelRun(threadId)];
+            });
+        });
+    };
+    /**
+     * Returns the **same object** while the values are unchanged.
+     *
+     * Referential stability is load-bearing, not a micro-optimisation: a protocol client treats its
+     * config as a dependency and rebuilds itself whenever the identity changes. A fresh object per
+     * call rebuilds on every render, which refetches, which renders again - a loop.
+     *
+     * Recomputed each call and compared by value, so a changed session (login, region switch,
+     * impersonation) still produces a new config rather than a stale one.
+     */
+    Analyst.prototype.getClientConfig = function () {
+        // Resolved from the SIGNED-IN USER's region, not the environment default: a user's region can
+        // differ from it, and resolving against the default points them at the wrong cluster.
+        var apiEndpoint = this.session.config.getApiEndpoint().encode();
+        var next = {
+            apiUrl: "".concat(apiEndpoint).concat(Analyst_consts_1.GATEWAY_PATH),
+            chatUrl: "".concat(apiEndpoint).concat(Analyst_consts_1.Routes.CHAT),
+            defaultHeaders: this.getDefaultHeaders()
+        };
+        if (this.cached && isSameConfig(this.cached, next)) {
+            return this.cached;
+        }
+        this.cached = next;
+        return next;
+    };
+    /** Matches the headers `ServiceRequest` builds for every other service. */
+    Analyst.prototype.getDefaultHeaders = function () {
+        var _a;
+        var headers = {};
+        var token = (_a = this.session.user) === null || _a === void 0 ? void 0 : _a.authentication_token;
+        if (token) {
+            headers.Authorization = "Token token=".concat(token);
+        }
+        if (this.session.clientId) {
+            headers.Client = String(this.session.clientId);
+        }
+        return headers;
+    };
+    return Analyst;
+}());
+exports.Analyst = Analyst;
+exports.default = Analyst;
+//# sourceMappingURL=Analyst.js.map

package/dist/Analyst/Analyst.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Analyst.js","sourceRoot":"","sources":["../../src/Analyst/Analyst.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,mDAAwD;AACxD,yEAAmD;AAiBnD,IAAM,YAAY,GAAG,UAAC,CAAsB,EAAE,CAAsB;IACnE,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,EAAE;QACrD,OAAO,KAAK,CAAC;KACb;IAED,IAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC;IAE3C,OAAO,CACN,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,MAAM;QACpD,IAAI,CAAC,KAAK,CAAC,UAAA,GAAG,IAAI,OAAA,CAAC,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,cAAc,CAAC,GAAG,CAAC,EAA/C,CAA+C,CAAC,CAClE,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAKC,iBAA6B,OAAgB;QAAhB,YAAO,GAAP,OAAO,CAAS;QAC5C,IAAI,CAAC,MAAM,GAAG,IAAI,uBAAa,CAAC,OAAO,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;OAKG;IACU,6BAAW,GAAxB;;;gBACC,sBAAO,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,EAAC;;;KACjC;IAED;;;;;;;;;;OAUG;IACU,2BAAS,GAAtB,UAAuB,QAAgB;;;gBACtC,sBAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAC;;;KACvC;IAED;;;;;;;;;;OAUG;IACU,2BAAS,GAAtB,UAAuB,QAAgB;;;gBACtC,sBAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAC;;;KACvC;IAED;;;;;;;;;OASG;IACI,iCAAe,GAAtB;QACC,8FAA8F;QAC9F,sFAAsF;QACtF,IAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,MAAM,EAAE,CAAC;QAClE,IAAM,IAAI,GAAwB;YACjC,MAAM,EAAE,UAAG,WAAW,SAAG,6BAAY,CAAE;YACvC,OAAO,EAAE,UAAG,WAAW,SAAG,uBAAM,CAAC,IAAI,CAAE;YACvC,cAAc,EAAE,IAAI,CAAC,iBAAiB,EAAE;SACxC,CAAC;QAEF,IAAI,IAAI,CAAC,MAAM,IAAI,YAAY,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE;YACnD,OAAO,IAAI,CAAC,MAAM,CAAC;SACnB;QAED,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QAEnB,OAAO,IAAI,CAAC;IACb,CAAC;IAED,2EAA2E;IACnE,mCAAiB,GAAzB;;QACC,IAAM,OAAO,GAA2B,EAAE,CAAC;QAC3C,IAAM,KAAK,GAAG,MAAA,IAAI,CAAC,OAAO,CAAC,IAAI,0CAAE,oBAAoB,CAAC;QAEtD,IAAI,KAAK,EAAE;YACV,OAAO,CAAC,aAAa,GAAG,sBAAe,KAAK,CAAE,CAAC;SAC/C;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE;YAC1B,OAAO,CAAC,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;SAC/C;QAED,OAAO,OAAO,CAAC;IAChB,CAAC;IACF,cAAC;AAAD,CAAC,AA7FD,IA6FC;AA7FY,0BAAO;AA+FpB,kBAAe,OAAO,CAAC"}

package/dist/Analyst/Entity/AnalystEntity.d.ts

@@ -0,0 +1,38 @@
+import type { AnalystChat } from '@bringg/types';
+import Entity from '../../Core/Entity';
+import type Session from '../../Services/Identity/Session';
+/**
+ * The Analyst REST surface.
+ *
+ * **Why the chat endpoint is not here.** The ag-ui contract has four endpoints, and exactly one of
+ * them is the protocol: `POST /analyst/chat` is a streaming POST that answers with `text/event-stream`
+ * until the turn ends. A method returning a `Promise` cannot express that, and re-implementing SSE
+ * framing here would duplicate the transport we are deferring to - so the consumer's `HttpAgent`
+ * opens it, and this package's contribution is {@link Analyst.getClientConfig}: where to connect and
+ * how to authenticate.
+ *
+ * The other three carry no protocol content at all. They are ordinary JSON over REST, and the
+ * dashboard - not the protocol client - decides when to call them: the History tab asks for the
+ * list, opening a conversation asks for one thread, and pressing Stop cancels the run. That makes
+ * them ours.
+ */
+export default class AnalystEntity extends Entity<AnalystChat.ThreadSummary> {
+    constructor(session: Session);
+    /** The signed-in user's threads, most recently active first. A bare array, no envelope. */
+    listThreads(): Promise<AnalystChat.ThreadSummary[]>;
+    /**
+     * One thread, with its messages and whether a run is currently executing on it.
+     *
+     * A thread belonging to another user answers **404**, never 403 - so a rejected id is
+     * indistinguishable from a missing one, by design.
+     */
+    getThread(threadId: string): Promise<AnalystChat.ThreadDetail>;
+    /**
+     * Cancel the run in flight on a thread.
+     *
+     * Needed because a run belongs to the server, not to the connection that started it: aborting the
+     * stream client-side stops the events arriving but leaves the agent working. `cancelled: false`
+     * means the thread was already idle, which is a normal answer rather than a failure.
+     */
+    cancelRun(threadId: string): Promise<AnalystChat.CancelRunResponse>;
+}

package/dist/Analyst/Entity/AnalystEntity.js

@@ -0,0 +1,140 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Entity_1 = __importDefault(require("../../Core/Entity"));
+var Analyst_consts_1 = require("../Analyst.consts");
+/**
+ * The Analyst REST surface.
+ *
+ * **Why the chat endpoint is not here.** The ag-ui contract has four endpoints, and exactly one of
+ * them is the protocol: `POST /analyst/chat` is a streaming POST that answers with `text/event-stream`
+ * until the turn ends. A method returning a `Promise` cannot express that, and re-implementing SSE
+ * framing here would duplicate the transport we are deferring to - so the consumer's `HttpAgent`
+ * opens it, and this package's contribution is {@link Analyst.getClientConfig}: where to connect and
+ * how to authenticate.
+ *
+ * The other three carry no protocol content at all. They are ordinary JSON over REST, and the
+ * dashboard - not the protocol client - decides when to call them: the History tab asks for the
+ * list, opening a conversation asks for one thread, and pressing Stop cancels the run. That makes
+ * them ours.
+ */
+var AnalystEntity = /** @class */ (function (_super) {
+    __extends(AnalystEntity, _super);
+    function AnalystEntity(session) {
+        return _super.call(this, {
+            session: session,
+            entityName: 'threads',
+            routePrefix: 'analyst-service'
+        }) || this;
+    }
+    /** The signed-in user's threads, most recently active first. A bare array, no envelope. */
+    AnalystEntity.prototype.listThreads = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var threads;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.service.routeGenerator
+                            .get(Analyst_consts_1.Routes.THREADS)
+                            .setException('Failed to fetch analyst chat threads')
+                            .invoke()];
+                    case 1:
+                        threads = _a.sent();
+                        return [2 /*return*/, threads !== null && threads !== void 0 ? threads : []];
+                }
+            });
+        });
+    };
+    /**
+     * One thread, with its messages and whether a run is currently executing on it.
+     *
+     * A thread belonging to another user answers **404**, never 403 - so a rejected id is
+     * indistinguishable from a missing one, by design.
+     */
+    AnalystEntity.prototype.getThread = function (threadId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.service.routeGenerator
+                        .get(Analyst_consts_1.Routes.THREAD)
+                        .withRouteParams({ threadId: threadId })
+                        .setException('Failed to fetch analyst chat thread')
+                        .invoke()];
+            });
+        });
+    };
+    /**
+     * Cancel the run in flight on a thread.
+     *
+     * Needed because a run belongs to the server, not to the connection that started it: aborting the
+     * stream client-side stops the events arriving but leaves the agent working. `cancelled: false`
+     * means the thread was already idle, which is a normal answer rather than a failure.
+     */
+    AnalystEntity.prototype.cancelRun = function (threadId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload;
+            return __generator(this, function (_a) {
+                payload = { threadId: threadId };
+                return [2 /*return*/, this.service.routeGenerator
+                        .post(Analyst_consts_1.Routes.CANCEL_RUN)
+                        .withPayload(payload)
+                        .setException('Failed to cancel the analyst chat run')
+                        .invoke()];
+            });
+        });
+    };
+    return AnalystEntity;
+}(Entity_1.default));
+exports.default = AnalystEntity;
+//# sourceMappingURL=AnalystEntity.js.map

package/dist/Analyst/Entity/AnalystEntity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AnalystEntity.js","sourceRoot":"","sources":["../../../src/Analyst/Entity/AnalystEntity.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,6DAAuC;AAEvC,oDAA2C;AAE3C;;;;;;;;;;;;;;GAcG;AACH;IAA2C,iCAAiC;IAC3E,uBAAY,OAAgB;eAC3B,kBAAM;YACL,OAAO,SAAA;YACP,UAAU,EAAE,SAAS;YACrB,WAAW,EAAE,iBAAiB;SAC9B,CAAC;IACH,CAAC;IAED,2FAA2F;IACrF,mCAAW,GAAjB;;;;;4BACiB,qBAAM,IAAI,CAAC,OAAO,CAAC,cAAc;6BAC/C,GAAG,CAAC,uBAAM,CAAC,OAAO,CAAC;6BACnB,YAAY,CAAC,sCAAsC,CAAC;6BACpD,MAAM,EAA4D,EAAA;;wBAH9D,OAAO,GAAG,SAGoD;wBAEpE,sBAAO,OAAO,aAAP,OAAO,cAAP,OAAO,GAAI,EAAE,EAAC;;;;KACrB;IAED;;;;;OAKG;IACG,iCAAS,GAAf,UAAgB,QAAgB;;;gBAC/B,sBAAO,IAAI,CAAC,OAAO,CAAC,cAAc;yBAChC,GAAG,CAAC,uBAAM,CAAC,MAAM,CAAC;yBAClB,eAAe,CAAC,EAAE,QAAQ,UAAA,EAAE,CAAC;yBAC7B,YAAY,CAAC,qCAAqC,CAAC;yBACnD,MAAM,EAAsD,EAAC;;;KAC/D;IAED;;;;;;OAMG;IACG,iCAAS,GAAf,UAAgB,QAAgB;;;;gBACzB,OAAO,GAAiC,EAAE,QAAQ,UAAA,EAAE,CAAC;gBAE3D,sBAAO,IAAI,CAAC,OAAO,CAAC,cAAc;yBAChC,IAAI,CAAC,uBAAM,CAAC,UAAU,CAAC;yBACvB,WAAW,CAAC,OAAO,CAAC;yBACpB,YAAY,CAAC,uCAAuC,CAAC;yBACrD,MAAM,EAAgE,EAAC;;;KACzE;IACF,oBAAC;AAAD,CAAC,AAjDD,CAA2C,gBAAM,GAiDhD"}

package/dist/Analyst/index.d.ts

@@ -0,0 +1 @@
+export * from './Analyst';

package/dist/Analyst/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Analyst"), exports);
+//# sourceMappingURL=index.js.map

package/dist/Analyst/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/Analyst/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4CAA0B"}

package/dist/BringgDashboardSDK.d.ts

@@ -1,6 +1,7 @@
 import { OTPActions, SendOTPResponse, TaskRejectReasonResponse, WorkflowResponse } from '@bringg/types';
 import AddonsApi from './Addons/AddonsApi';
 import AlertsApi from './Alerts/AlertsApi';
+import { Analyst } from './Analyst';
 import AnalyticsReportsApi from './AnalyticsReports/AnalyticsReportsApi';
 import ApplicationApi from './Application/ApplicationApi';
 import ApplicationMerchantConfigurationApi from './ApplicationMerchantConfiguration/ApplicationMerchantConfigurationApi';
@@ -215,6 +216,7 @@ export declare class BringgDashboardSDK {
     parkingSpotApi: ParkingSpotApi;
     customAttributesApi: CustomAttributesApi;
     asyncOperationStatus: AsyncOperationStatus;
+    analyst: Analyst;
     addons: AddonsApi;
     supportTicket: SupportTicketApi;
     orderExecutionActions: OrderExecutionActionsApi;

package/dist/BringgDashboardSDK.js

@@ -91,6 +91,7 @@ exports.newConfigurationProvider = exports.getFullConfiguration = exports.setEnv
 var mobx = __importStar(require("mobx"));
 var AddonsApi_1 = __importDefault(require("./Addons/AddonsApi"));
 var AlertsApi_1 = __importDefault(require("./Alerts/AlertsApi"));
+var Analyst_1 = require("./Analyst");
 var AnalyticsReportsApi_1 = __importDefault(require("./AnalyticsReports/AnalyticsReportsApi"));
 var ApplicationApi_1 = __importDefault(require("./Application/ApplicationApi"));
 var ApplicationMerchantConfigurationApi_1 = __importDefault(require("./ApplicationMerchantConfiguration/ApplicationMerchantConfigurationApi"));
@@ -611,6 +612,7 @@ function init(session) {
                     bringg.parkingSpotApi = new ParkingSpotApi_1.default(session);
                     bringg.customAttributesApi = new CustomAttributesApi_1.default(session);
                     bringg.asyncOperationStatus = new AsyncOperationStatus_1.AsyncOperationStatus(session);
+                    bringg.analyst = new Analyst_1.Analyst(session);
                     bringg.addons = new AddonsApi_1.default(session);
                     bringg.supportTicket = new SupportTicketApi_1.default(session);
                     bringg.optimizationKpi = new OptimizationKpiApi_1.default(session);