@servicetitan/titan-chatbot-api 7.1.2 → 9.0.0

package/dist/streaming/index.d.ts

@@ -0,0 +1,3 @@
+export * from './agent-stream';
+export * from './run-agent-stream';
+//# sourceMappingURL=index.d.ts.map

package/dist/streaming/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/streaming/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC"}

package/dist/streaming/index.js

@@ -0,0 +1,4 @@
+export * from './agent-stream';
+export * from './run-agent-stream';
+
+//# sourceMappingURL=index.js.map

package/dist/streaming/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/streaming/index.ts"],"sourcesContent":["export * from './agent-stream';\nexport * from './run-agent-stream';\n"],"names":[],"mappings":"AAAA,cAAc,iBAAiB;AAC/B,cAAc,qBAAqB"}

package/dist/streaming/run-agent-stream.d.ts

@@ -0,0 +1,23 @@
+import { Models } from '../api-client';
+import { AgentStreamHandlers } from './agent-stream';
+export interface RunAgentStreamOptions {
+    /** Fully-constructed streaming endpoint URL. */
+    url: string;
+    /** Request headers (auth, X-Client-ID, …). */
+    headers?: Record<string, string>;
+    /** Request body, serialized as JSON by the SSE client. */
+    body: unknown;
+    /** Custom `fetch` (same as the regular API client) so auth/headers/credentials apply identically. */
+    fetch?: typeof fetch;
+    /** Progress + lifecycle callbacks (and the inactivity timeout). */
+    handlers: AgentStreamHandlers;
+    abortSignal?: AbortSignal;
+}
+/**
+ * Shared SSE consumption used by every {@link IChatbotApiClient} adapter: opens a {@link ChatSseClient},
+ * maps the agent events onto the supplied handlers, and resolves the final {@link Models.BotMessage}
+ * from `run.finished` (or rejects on `run.error` / a fatal connection error). The only per-adapter
+ * differences — the URL, headers and body — are passed in by the caller.
+ */
+export declare function runAgentStream({ abortSignal, body, fetch, handlers, headers, url, }: RunAgentStreamOptions): Promise<Models.BotMessage>;
+//# sourceMappingURL=run-agent-stream.d.ts.map

package/dist/streaming/run-agent-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-agent-stream.d.ts","sourceRoot":"","sources":["../../src/streaming/run-agent-stream.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAKH,mBAAmB,EAEtB,MAAM,gBAAgB,CAAC;AAExB,MAAM,WAAW,qBAAqB;IAClC,gDAAgD;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,8CAA8C;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,0DAA0D;IAC1D,IAAI,EAAE,OAAO,CAAC;IACd,qGAAqG;IACrG,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,mEAAmE;IACnE,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,WAAW,CAAC,EAAE,WAAW,CAAC;CAC7B;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,EAC3B,WAAW,EACX,IAAI,EACJ,KAAK,EACL,QAAQ,EACR,OAAO,EACP,GAAG,GACN,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAsEpD"}

package/dist/streaming/run-agent-stream.js

@@ -0,0 +1,83 @@
+import { ChatSseClient } from '@servicetitan/titan-chat-ui-common';
+import { AGENT_EVENT, AgentStreamError, convertAgentFinishToBotMessage } from './agent-stream';
+/**
+ * Shared SSE consumption used by every {@link IChatbotApiClient} adapter: opens a {@link ChatSseClient},
+ * maps the agent events onto the supplied handlers, and resolves the final {@link Models.BotMessage}
+ * from `run.finished` (or rejects on `run.error` / a fatal connection error). The only per-adapter
+ * differences — the URL, headers and body — are passed in by the caller.
+ */ export function runAgentStream({ abortSignal, body, fetch, handlers, headers, url }) {
+    return new Promise((resolve, reject)=>{
+        let finished;
+        const client = new ChatSseClient({
+            url,
+            headers,
+            fetch,
+            signal: abortSignal,
+            body,
+            inactivityTimeoutMs: handlers.inactivityTimeoutMs,
+            isTerminalEvent: (e)=>e.event === AGENT_EVENT.RunFinished || e.event === AGENT_EVENT.RunError,
+            handlers: {
+                [AGENT_EVENT.StatusChanged]: (d)=>{
+                    var _handlers_onStatus;
+                    (_handlers_onStatus = handlers.onStatus) === null || _handlers_onStatus === void 0 ? void 0 : _handlers_onStatus.call(handlers, d.text);
+                    if (d.stepId !== undefined) {
+                        var _handlers_onStepActive;
+                        (_handlers_onStepActive = handlers.onStepActive) === null || _handlers_onStepActive === void 0 ? void 0 : _handlers_onStepActive.call(handlers, d.stepId);
+                    }
+                },
+                [AGENT_EVENT.TextAppended]: (d)=>{
+                    var _handlers_onText;
+                    return (_handlers_onText = handlers.onText) === null || _handlers_onText === void 0 ? void 0 : _handlers_onText.call(handlers, d.text);
+                },
+                [AGENT_EVENT.PlanProposed]: (d)=>{
+                    var _d_activeStepId;
+                    var _handlers_onPlan, _d_steps_, _d_steps;
+                    (_handlers_onPlan = handlers.onPlan) === null || _handlers_onPlan === void 0 ? void 0 : _handlers_onPlan.call(handlers, d.steps);
+                    // Activate the explicitly-signalled step, else default to the first.
+                    const activeId = (_d_activeStepId = d.activeStepId) !== null && _d_activeStepId !== void 0 ? _d_activeStepId : (_d_steps = d.steps) === null || _d_steps === void 0 ? void 0 : (_d_steps_ = _d_steps[0]) === null || _d_steps_ === void 0 ? void 0 : _d_steps_.id;
+                    if (activeId !== undefined) {
+                        var _handlers_onStepActive;
+                        (_handlers_onStepActive = handlers.onStepActive) === null || _handlers_onStepActive === void 0 ? void 0 : _handlers_onStepActive.call(handlers, activeId);
+                    }
+                },
+                [AGENT_EVENT.InputRequested]: (d)=>{
+                    var _handlers_onInputRequested;
+                    return (_handlers_onInputRequested = handlers.onInputRequested) === null || _handlers_onInputRequested === void 0 ? void 0 : _handlers_onInputRequested.call(handlers, {
+                        kind: d.kind,
+                        prompt: d.prompt,
+                        options: d.options
+                    });
+                },
+                [AGENT_EVENT.RunFinished]: (d)=>{
+                    finished = d;
+                },
+                [AGENT_EVENT.RunError]: (d)=>{
+                    reject(new AgentStreamError(d.message));
+                }
+            },
+            onConnected: handlers.onConnected,
+            onDisconnected: handlers.onDisconnected,
+            onTimeout: handlers.onTimeout,
+            onInactivity: handlers.onInactivity,
+            onCompleted: handlers.onCompleted,
+            onError: reject
+        });
+        client.start().then(()=>{
+            if (finished) {
+                try {
+                    resolve(convertAgentFinishToBotMessage(finished));
+                } catch (err) {
+                    reject(err);
+                }
+                return;
+            }
+            /*
+             * Stream completed without `run.finished`. A run.error / fatal onError may have
+             * already rejected (subsequent reject calls are no-ops); otherwise the server closed
+             * the connection unexpectedly — reject so the returned Promise never hangs.
+             */ reject(new AgentStreamError('Stream ended without a run.finished event'));
+        }, reject);
+    });
+}
+
+//# sourceMappingURL=run-agent-stream.js.map

package/dist/streaming/run-agent-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/streaming/run-agent-stream.ts"],"sourcesContent":["import { ChatSseClient } from '@servicetitan/titan-chat-ui-common';\nimport { Models } from '../api-client';\nimport {\n    AGENT_EVENT,\n    AgentPlanStep,\n    AgentRunFinishedData,\n    AgentStreamError,\n    AgentStreamHandlers,\n    convertAgentFinishToBotMessage,\n} from './agent-stream';\n\nexport interface RunAgentStreamOptions {\n    /** Fully-constructed streaming endpoint URL. */\n    url: string;\n    /** Request headers (auth, X-Client-ID, …). */\n    headers?: Record<string, string>;\n    /** Request body, serialized as JSON by the SSE client. */\n    body: unknown;\n    /** Custom `fetch` (same as the regular API client) so auth/headers/credentials apply identically. */\n    fetch?: typeof fetch;\n    /** Progress + lifecycle callbacks (and the inactivity timeout). */\n    handlers: AgentStreamHandlers;\n    abortSignal?: AbortSignal;\n}\n\n/**\n * Shared SSE consumption used by every {@link IChatbotApiClient} adapter: opens a {@link ChatSseClient},\n * maps the agent events onto the supplied handlers, and resolves the final {@link Models.BotMessage}\n * from `run.finished` (or rejects on `run.error` / a fatal connection error). The only per-adapter\n * differences — the URL, headers and body — are passed in by the caller.\n */\nexport function runAgentStream({\n    abortSignal,\n    body,\n    fetch,\n    handlers,\n    headers,\n    url,\n}: RunAgentStreamOptions): Promise<Models.BotMessage> {\n    return new Promise<Models.BotMessage>((resolve, reject) => {\n        let finished: AgentRunFinishedData | undefined;\n\n        const client = new ChatSseClient({\n            url,\n            headers,\n            fetch,\n            signal: abortSignal,\n            body,\n            inactivityTimeoutMs: handlers.inactivityTimeoutMs,\n            isTerminalEvent: e =>\n                e.event === AGENT_EVENT.RunFinished || e.event === AGENT_EVENT.RunError,\n            handlers: {\n                [AGENT_EVENT.StatusChanged]: (d: { text: string; stepId?: string }) => {\n                    handlers.onStatus?.(d.text);\n                    if (d.stepId !== undefined) {\n                        handlers.onStepActive?.(d.stepId);\n                    }\n                },\n                [AGENT_EVENT.TextAppended]: (d: { text: string }) => handlers.onText?.(d.text),\n                [AGENT_EVENT.PlanProposed]: (d: {\n                    steps: AgentPlanStep[];\n                    activeStepId?: string;\n                }) => {\n                    handlers.onPlan?.(d.steps);\n                    // Activate the explicitly-signalled step, else default to the first.\n                    const activeId = d.activeStepId ?? d.steps?.[0]?.id;\n                    if (activeId !== undefined) {\n                        handlers.onStepActive?.(activeId);\n                    }\n                },\n                [AGENT_EVENT.InputRequested]: (d: any) =>\n                    handlers.onInputRequested?.({\n                        kind: d.kind,\n                        prompt: d.prompt,\n                        options: d.options,\n                    }),\n                [AGENT_EVENT.RunFinished]: (d: AgentRunFinishedData) => {\n                    finished = d;\n                },\n                [AGENT_EVENT.RunError]: (d: { message?: string }) => {\n                    reject(new AgentStreamError(d.message));\n                },\n            },\n            onConnected: handlers.onConnected,\n            onDisconnected: handlers.onDisconnected,\n            onTimeout: handlers.onTimeout,\n            onInactivity: handlers.onInactivity,\n            onCompleted: handlers.onCompleted,\n            onError: reject,\n        });\n\n        client.start().then(() => {\n            if (finished) {\n                try {\n                    resolve(convertAgentFinishToBotMessage(finished));\n                } catch (err) {\n                    reject(err);\n                }\n                return;\n            }\n            /*\n             * Stream completed without `run.finished`. A run.error / fatal onError may have\n             * already rejected (subsequent reject calls are no-ops); otherwise the server closed\n             * the connection unexpectedly — reject so the returned Promise never hangs.\n             */\n            reject(new AgentStreamError('Stream ended without a run.finished event'));\n        }, reject);\n    });\n}\n"],"names":["ChatSseClient","AGENT_EVENT","AgentStreamError","convertAgentFinishToBotMessage","runAgentStream","abortSignal","body","fetch","handlers","headers","url","Promise","resolve","reject","finished","client","signal","inactivityTimeoutMs","isTerminalEvent","e","event","RunFinished","RunError","StatusChanged","d","onStatus","text","stepId","undefined","onStepActive","TextAppended","onText","PlanProposed","onPlan","steps","activeId","activeStepId","id","InputRequested","onInputRequested","kind","prompt","options","message","onConnected","onDisconnected","onTimeout","onInactivity","onCompleted","onError","start","then","err"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qCAAqC;AAEnE,SACIC,WAAW,EAGXC,gBAAgB,EAEhBC,8BAA8B,QAC3B,iBAAiB;AAgBxB;;;;;CAKC,GACD,OAAO,SAASC,eAAe,EAC3BC,WAAW,EACXC,IAAI,EACJC,KAAK,EACLC,QAAQ,EACRC,OAAO,EACPC,GAAG,EACiB;IACpB,OAAO,IAAIC,QAA2B,CAACC,SAASC;QAC5C,IAAIC;QAEJ,MAAMC,SAAS,IAAIf,cAAc;YAC7BU;YACAD;YACAF;YACAS,QAAQX;YACRC;YACAW,qBAAqBT,SAASS,mBAAmB;YACjDC,iBAAiBC,CAAAA,IACbA,EAAEC,KAAK,KAAKnB,YAAYoB,WAAW,IAAIF,EAAEC,KAAK,KAAKnB,YAAYqB,QAAQ;YAC3Ed,UAAU;gBACN,CAACP,YAAYsB,aAAa,CAAC,EAAE,CAACC;wBAC1BhB;qBAAAA,qBAAAA,SAASiB,QAAQ,cAAjBjB,yCAAAA,wBAAAA,UAAoBgB,EAAEE,IAAI;oBAC1B,IAAIF,EAAEG,MAAM,KAAKC,WAAW;4BACxBpB;yBAAAA,yBAAAA,SAASqB,YAAY,cAArBrB,6CAAAA,4BAAAA,UAAwBgB,EAAEG,MAAM;oBACpC;gBACJ;gBACA,CAAC1B,YAAY6B,YAAY,CAAC,EAAE,CAACN;wBAAwBhB;4BAAAA,mBAAAA,SAASuB,MAAM,cAAfvB,uCAAAA,sBAAAA,UAAkBgB,EAAEE,IAAI;;gBAC7E,CAACzB,YAAY+B,YAAY,CAAC,EAAE,CAACR;wBAMRA;wBAFjBhB,kBAEmCgB,WAAAA;qBAFnChB,mBAAAA,SAASyB,MAAM,cAAfzB,uCAAAA,sBAAAA,UAAkBgB,EAAEU,KAAK;oBACzB,qEAAqE;oBACrE,MAAMC,YAAWX,kBAAAA,EAAEY,YAAY,cAAdZ,6BAAAA,mBAAkBA,WAAAA,EAAEU,KAAK,cAAPV,gCAAAA,YAAAA,QAAS,CAAC,EAAE,cAAZA,gCAAAA,UAAca,EAAE;oBACnD,IAAIF,aAAaP,WAAW;4BACxBpB;yBAAAA,yBAAAA,SAASqB,YAAY,cAArBrB,6CAAAA,4BAAAA,UAAwB2B;oBAC5B;gBACJ;gBACA,CAAClC,YAAYqC,cAAc,CAAC,EAAE,CAACd;wBAC3BhB;4BAAAA,6BAAAA,SAAS+B,gBAAgB,cAAzB/B,iDAAAA,gCAAAA,UAA4B;wBACxBgC,MAAMhB,EAAEgB,IAAI;wBACZC,QAAQjB,EAAEiB,MAAM;wBAChBC,SAASlB,EAAEkB,OAAO;oBACtB;;gBACJ,CAACzC,YAAYoB,WAAW,CAAC,EAAE,CAACG;oBACxBV,WAAWU;gBACf;gBACA,CAACvB,YAAYqB,QAAQ,CAAC,EAAE,CAACE;oBACrBX,OAAO,IAAIX,iBAAiBsB,EAAEmB,OAAO;gBACzC;YACJ;YACAC,aAAapC,SAASoC,WAAW;YACjCC,gBAAgBrC,SAASqC,cAAc;YACvCC,WAAWtC,SAASsC,SAAS;YAC7BC,cAAcvC,SAASuC,YAAY;YACnCC,aAAaxC,SAASwC,WAAW;YACjCC,SAASpC;QACb;QAEAE,OAAOmC,KAAK,GAAGC,IAAI,CAAC;YAChB,IAAIrC,UAAU;gBACV,IAAI;oBACAF,QAAQT,+BAA+BW;gBAC3C,EAAE,OAAOsC,KAAK;oBACVvC,OAAOuC;gBACX;gBACA;YACJ;YACA;;;;aAIC,GACDvC,OAAO,IAAIX,iBAAiB;QAChC,GAAGW;IACP;AACJ"}

package/dist/utils/__tests__/axios-utils.test.js

@@ -1,28 +1,28 @@
 import { expect } from '@jest/globals';
 import { withTimeout } from '../axios-utils';
-describe('axios-utils', () => {
-    beforeEach(() => {
+describe('axios-utils', ()=>{
+    beforeEach(()=>{
         jest.useFakeTimers();
         jest.setSystemTime(new Date('2000-01-01T00:00:00.000Z'));
     });
-    afterEach(() => {
+    afterEach(()=>{
         jest.clearAllMocks();
         jest.useRealTimers();
     });
-    test('should withTimeout (timeout first)', async () => {
+    test('should withTimeout (timeout first)', async ()=>{
         const abortController = new AbortController();
         const spyAbort = jest.spyOn(abortController, 'abort');
-        const action = new Promise(resolve => setTimeout(() => resolve('done'), 100));
+        const action = new Promise((resolve)=>setTimeout(()=>resolve('done'), 100));
         const timeoutMs = 50;
         const p = expect(withTimeout(action, timeoutMs, abortController)).rejects.toThrow('The request is timed out');
         await jest.advanceTimersByTimeAsync(50);
         await p;
         expect(spyAbort).toHaveBeenCalledWith('The request is timed out');
     });
-    test('should withTimeout (resolves first)', async () => {
+    test('should withTimeout (resolves first)', async ()=>{
         const abortController = new AbortController();
         const spyAbort = jest.spyOn(abortController, 'abort');
-        const action = new Promise(resolve => setTimeout(() => resolve('done'), 100));
+        const action = new Promise((resolve)=>setTimeout(()=>resolve('done'), 100));
         const timeoutMs = 150;
         const p = expect(withTimeout(action, timeoutMs, abortController)).resolves.toEqual('done');
         await jest.advanceTimersByTimeAsync(100);
@@ -30,4 +30,5 @@ describe('axios-utils', () => {
         expect(spyAbort).not.toHaveBeenCalled();
     });
 });
+
 //# sourceMappingURL=axios-utils.test.js.map

package/dist/utils/__tests__/axios-utils.test.js.map

@@ -1 +1 @@
-{"version":3,"file":"axios-utils.test.js","sourceRoot":"","sources":["../../../src/utils/__tests__/axios-utils.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,QAAQ,CAAC,aAAa,EAAE,GAAG,EAAE;IACzB,UAAU,CAAC,GAAG,EAAE;QACZ,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,aAAa,CAAC,IAAI,IAAI,CAAC,0BAA0B,CAAC,CAAC,CAAC;IAC7D,CAAC,CAAC,CAAC;IAEH,SAAS,CAAC,GAAG,EAAE;QACX,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,aAAa,EAAE,CAAC;IACzB,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,oCAAoC,EAAE,KAAK,IAAI,EAAE;QAClD,MAAM,eAAe,GAAG,IAAI,eAAe,EAAE,CAAC;QAC9C,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;QACtD,MAAM,MAAM,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;QAC9E,MAAM,SAAS,GAAG,EAAE,CAAC;QAErB,MAAM,CAAC,GAAG,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAC7E,0BAA0B,CAC7B,CAAC;QACF,MAAM,IAAI,CAAC,wBAAwB,CAAC,EAAE,CAAC,CAAC;QACxC,MAAM,CAAC,CAAC;QACR,MAAM,CAAC,QAAQ,CAAC,CAAC,oBAAoB,CAAC,0BAA0B,CAAC,CAAC;IACtE,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,qCAAqC,EAAE,KAAK,IAAI,EAAE;QACnD,MAAM,eAAe,GAAG,IAAI,eAAe,EAAE,CAAC;QAC9C,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;QACtD,MAAM,MAAM,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;QAC9E,MAAM,SAAS,GAAG,GAAG,CAAC;QAEtB,MAAM,CAAC,GAAG,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC3F,MAAM,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,CAAC;QACzC,MAAM,CAAC,CAAC;QACR,MAAM,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,gBAAgB,EAAE,CAAC;IAC5C,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC"}
+{"version":3,"sources":["../../../src/utils/__tests__/axios-utils.test.ts"],"sourcesContent":["import { expect } from '@jest/globals';\nimport { withTimeout } from '../axios-utils';\n\ndescribe('axios-utils', () => {\n    beforeEach(() => {\n        jest.useFakeTimers();\n        jest.setSystemTime(new Date('2000-01-01T00:00:00.000Z'));\n    });\n\n    afterEach(() => {\n        jest.clearAllMocks();\n        jest.useRealTimers();\n    });\n\n    test('should withTimeout (timeout first)', async () => {\n        const abortController = new AbortController();\n        const spyAbort = jest.spyOn(abortController, 'abort');\n        const action = new Promise(resolve => setTimeout(() => resolve('done'), 100));\n        const timeoutMs = 50;\n\n        const p = expect(withTimeout(action, timeoutMs, abortController)).rejects.toThrow(\n            'The request is timed out'\n        );\n        await jest.advanceTimersByTimeAsync(50);\n        await p;\n        expect(spyAbort).toHaveBeenCalledWith('The request is timed out');\n    });\n\n    test('should withTimeout (resolves first)', async () => {\n        const abortController = new AbortController();\n        const spyAbort = jest.spyOn(abortController, 'abort');\n        const action = new Promise(resolve => setTimeout(() => resolve('done'), 100));\n        const timeoutMs = 150;\n\n        const p = expect(withTimeout(action, timeoutMs, abortController)).resolves.toEqual('done');\n        await jest.advanceTimersByTimeAsync(100);\n        await p;\n        expect(spyAbort).not.toHaveBeenCalled();\n    });\n});\n"],"names":["expect","withTimeout","describe","beforeEach","jest","useFakeTimers","setSystemTime","Date","afterEach","clearAllMocks","useRealTimers","test","abortController","AbortController","spyAbort","spyOn","action","Promise","resolve","setTimeout","timeoutMs","p","rejects","toThrow","advanceTimersByTimeAsync","toHaveBeenCalledWith","resolves","toEqual","not","toHaveBeenCalled"],"mappings":"AAAA,SAASA,MAAM,QAAQ,gBAAgB;AACvC,SAASC,WAAW,QAAQ,iBAAiB;AAE7CC,SAAS,eAAe;IACpBC,WAAW;QACPC,KAAKC,aAAa;QAClBD,KAAKE,aAAa,CAAC,IAAIC,KAAK;IAChC;IAEAC,UAAU;QACNJ,KAAKK,aAAa;QAClBL,KAAKM,aAAa;IACtB;IAEAC,KAAK,sCAAsC;QACvC,MAAMC,kBAAkB,IAAIC;QAC5B,MAAMC,WAAWV,KAAKW,KAAK,CAACH,iBAAiB;QAC7C,MAAMI,SAAS,IAAIC,QAAQC,CAAAA,UAAWC,WAAW,IAAMD,QAAQ,SAAS;QACxE,MAAME,YAAY;QAElB,MAAMC,IAAIrB,OAAOC,YAAYe,QAAQI,WAAWR,kBAAkBU,OAAO,CAACC,OAAO,CAC7E;QAEJ,MAAMnB,KAAKoB,wBAAwB,CAAC;QACpC,MAAMH;QACNrB,OAAOc,UAAUW,oBAAoB,CAAC;IAC1C;IAEAd,KAAK,uCAAuC;QACxC,MAAMC,kBAAkB,IAAIC;QAC5B,MAAMC,WAAWV,KAAKW,KAAK,CAACH,iBAAiB;QAC7C,MAAMI,SAAS,IAAIC,QAAQC,CAAAA,UAAWC,WAAW,IAAMD,QAAQ,SAAS;QACxE,MAAME,YAAY;QAElB,MAAMC,IAAIrB,OAAOC,YAAYe,QAAQI,WAAWR,kBAAkBc,QAAQ,CAACC,OAAO,CAAC;QACnF,MAAMvB,KAAKoB,wBAAwB,CAAC;QACpC,MAAMH;QACNrB,OAAOc,UAAUc,GAAG,CAACC,gBAAgB;IACzC;AACJ"}

package/dist/utils/axios-utils.js

@@ -1,23 +1,25 @@
 /**
  * Aborts the action if it takes longer than the specified timeout.
- */
-export async function withTimeout(action, timeoutMs, abortController) {
+ */ export async function withTimeout(action, timeoutMs, abortController) {
     let timeoutId = undefined;
-    const timeoutPromise = new Promise((_, reject) => {
-        timeoutId = setTimeout(() => {
+    const timeoutPromise = new Promise((_, reject)=>{
+        timeoutId = setTimeout(()=>{
             abortController.abort('The request is timed out');
             reject(new Error('The request is timed out'));
         }, timeoutMs);
     });
-    const promise = Promise.race([action, timeoutPromise]);
+    const promise = Promise.race([
+        action,
+        timeoutPromise
+    ]);
     try {
         return await promise;
-    }
-    finally {
+    } finally{
         if (timeoutId) {
             clearTimeout(timeoutId);
             timeoutId = undefined;
         }
     }
 }
+
 //# sourceMappingURL=axios-utils.js.map

package/dist/utils/axios-utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"axios-utils.js","sourceRoot":"","sources":["../../src/utils/axios-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC7B,MAAkB,EAClB,SAAiB,EACjB,eAAgC;IAEhC,IAAI,SAAS,GAA8C,SAAS,CAAC;IACrE,MAAM,cAAc,GAAG,IAAI,OAAO,CAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;QAChD,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE;YACxB,eAAe,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAC;YAClD,MAAM,CAAC,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC,CAAC;QAClD,CAAC,EAAE,SAAS,CAAC,CAAC;IAClB,CAAC,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC;IACvD,IAAI,CAAC;QACD,OAAO,MAAM,OAAO,CAAC;IACzB,CAAC;YAAS,CAAC;QACP,IAAI,SAAS,EAAE,CAAC;YACZ,YAAY,CAAC,SAAS,CAAC,CAAC;YACxB,SAAS,GAAG,SAAS,CAAC;QAC1B,CAAC;IACL,CAAC;AACL,CAAC"}
+{"version":3,"sources":["../../src/utils/axios-utils.ts"],"sourcesContent":["/**\n * Aborts the action if it takes longer than the specified timeout.\n */\nexport async function withTimeout<T>(\n    action: Promise<T>,\n    timeoutMs: number,\n    abortController: AbortController\n): Promise<T> {\n    let timeoutId: ReturnType<typeof setTimeout> | undefined = undefined;\n    const timeoutPromise = new Promise<T>((_, reject) => {\n        timeoutId = setTimeout(() => {\n            abortController.abort('The request is timed out');\n            reject(new Error('The request is timed out'));\n        }, timeoutMs);\n    });\n    const promise = Promise.race([action, timeoutPromise]);\n    try {\n        return await promise;\n    } finally {\n        if (timeoutId) {\n            clearTimeout(timeoutId);\n            timeoutId = undefined;\n        }\n    }\n}\n"],"names":["withTimeout","action","timeoutMs","abortController","timeoutId","undefined","timeoutPromise","Promise","_","reject","setTimeout","abort","Error","promise","race","clearTimeout"],"mappings":"AAAA;;CAEC,GACD,OAAO,eAAeA,YAClBC,MAAkB,EAClBC,SAAiB,EACjBC,eAAgC;IAEhC,IAAIC,YAAuDC;IAC3D,MAAMC,iBAAiB,IAAIC,QAAW,CAACC,GAAGC;QACtCL,YAAYM,WAAW;YACnBP,gBAAgBQ,KAAK,CAAC;YACtBF,OAAO,IAAIG,MAAM;QACrB,GAAGV;IACP;IACA,MAAMW,UAAUN,QAAQO,IAAI,CAAC;QAACb;QAAQK;KAAe;IACrD,IAAI;QACA,OAAO,MAAMO;IACjB,SAAU;QACN,IAAIT,WAAW;YACXW,aAAaX;YACbA,YAAYC;QAChB;IACJ;AACJ"}

package/dist/utils/test-utils.js

@@ -1,17 +1,17 @@
 import { Container } from '@servicetitan/react-ioc';
-export const initTestContainer = (serviceIdentifier, initDependenciesFn) => {
+export const initTestContainer = (serviceIdentifier, initDependenciesFn)=>{
     const rootContainer = new Container();
     if (Array.isArray(serviceIdentifier)) {
-        serviceIdentifier.forEach(identifier => rootContainer.bind(identifier).toSelf());
-    }
-    else {
+        serviceIdentifier.forEach((identifier)=>rootContainer.bind(identifier).toSelf());
+    } else {
         rootContainer.bind(serviceIdentifier).toSelf();
     }
-    return () => {
+    return ()=>{
         const container = new Container();
         container.parent = rootContainer;
         initDependenciesFn(container);
         return container;
     };
 };
+
 //# sourceMappingURL=test-utils.js.map

package/dist/utils/test-utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"test-utils.js","sourceRoot":"","sources":["../../src/utils/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAIpD,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC7B,iBAAwD,EACxD,kBAAkD,EACpD,EAAE;IACA,MAAM,aAAa,GAAG,IAAI,SAAS,EAAE,CAAC;IACtC,IAAI,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE,CAAC;QACnC,iBAAiB,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;IACrF,CAAC;SAAM,CAAC;QACJ,aAAa,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,MAAM,EAAE,CAAC;IACnD,CAAC;IAED,OAAO,GAAG,EAAE;QACR,MAAM,SAAS,GAAG,IAAI,SAAS,EAAE,CAAC;QAClC,SAAS,CAAC,MAAM,GAAG,aAAa,CAAC;QACjC,kBAAkB,CAAC,SAAS,CAAC,CAAC;QAC9B,OAAO,SAAS,CAAC;IACrB,CAAC,CAAC;AACN,CAAC,CAAC"}
+{"version":3,"sources":["../../src/utils/test-utils.ts"],"sourcesContent":["import { Container } from '@servicetitan/react-ioc';\n\ntype Newable<T> = new (...args: never[]) => T;\n\nexport const initTestContainer = (\n    serviceIdentifier: Newable<unknown> | Newable<unknown>[],\n    initDependenciesFn: (container: Container) => void\n) => {\n    const rootContainer = new Container();\n    if (Array.isArray(serviceIdentifier)) {\n        serviceIdentifier.forEach(identifier => rootContainer.bind(identifier).toSelf());\n    } else {\n        rootContainer.bind(serviceIdentifier).toSelf();\n    }\n\n    return () => {\n        const container = new Container();\n        container.parent = rootContainer;\n        initDependenciesFn(container);\n        return container;\n    };\n};\n"],"names":["Container","initTestContainer","serviceIdentifier","initDependenciesFn","rootContainer","Array","isArray","forEach","identifier","bind","toSelf","container","parent"],"mappings":"AAAA,SAASA,SAAS,QAAQ,0BAA0B;AAIpD,OAAO,MAAMC,oBAAoB,CAC7BC,mBACAC;IAEA,MAAMC,gBAAgB,IAAIJ;IAC1B,IAAIK,MAAMC,OAAO,CAACJ,oBAAoB;QAClCA,kBAAkBK,OAAO,CAACC,CAAAA,aAAcJ,cAAcK,IAAI,CAACD,YAAYE,MAAM;IACjF,OAAO;QACHN,cAAcK,IAAI,CAACP,mBAAmBQ,MAAM;IAChD;IAEA,OAAO;QACH,MAAMC,YAAY,IAAIX;QACtBW,UAAUC,MAAM,GAAGR;QACnBD,mBAAmBQ;QACnB,OAAOA;IACX;AACJ,EAAE"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@servicetitan/titan-chatbot-api",
-    "version": "7.1.2",
+    "version": "9.0.0",
     "description": "Chatbot client API package",
     "repository": {
         "type": "git",
@@ -17,10 +17,13 @@
         "push:local": "yalc push"
     },
     "dependencies": {
-        "@servicetitan/titan-chat-ui-common": "^7.1.2",
+        "@servicetitan/titan-chat-ui-common": "^9.0.0",
         "lodash": "^4.18.1",
         "nanoid": "^5.1.5"
     },
+    "devDependencies": {
+        "@microsoft/fetch-event-source": "^2.0.1"
+    },
     "peerDependencies": {
         "@servicetitan/log-service": ">=27",
         "@servicetitan/react-ioc": ">=24",
@@ -42,5 +45,5 @@
     "cli": {
         "webpack": false
     },
-    "gitHead": "ddacea8f1d7e9ffce602d24554aeb306e61a40e2"
+    "gitHead": "028073fe571014741da70bcff173d617e2738125"
 }

package/src/api-client/__mocks__/chatbot-api-client.mock.ts

@@ -9,4 +9,5 @@ export class ChatbotApiClientMock implements IChatbotApiClient {
     patchSession = jest.fn();
     deleteSession = jest.fn();
     getTranscripts = jest.fn();
+    streamMessage = jest.fn();
 }

package/src/api-client/base/chatbot-api-client.ts

@@ -1,5 +1,6 @@
 import { symbolToken } from '@servicetitan/react-ioc';
 import { Models } from '..';
+import { AgentStreamHandlers } from '../../streaming';
 
 /**
  * Token for injecting the chatbot client settings for proper initialization of the client.
@@ -25,6 +26,16 @@ export interface IChatbotClientSettings {}
 export interface IChatbotApiClient {
     postFeedback(body: Models.IFeedback, abortSignal?: AbortSignal): Promise<Models.Feedback>;
     postMessage(body: Models.IUserMessage, abortSignal?: AbortSignal): Promise<Models.BotMessage>;
+    /**
+     * Streaming variant of {@link postMessage}: consumes the SSE agent-progress stream, forwarding
+     * progress events to `handlers`, and resolves with the final {@link Models.BotMessage}.
+     * Optional — clients that do not support streaming omit it, and consumers fall back to {@link postMessage}.
+     */
+    streamMessage?(
+        body: Models.IUserMessage,
+        handlers: AgentStreamHandlers,
+        abortSignal?: AbortSignal
+    ): Promise<Models.BotMessage>;
     postFollowUpEmail(
         body: Models.IUserMessage,
         abortSignal?: AbortSignal

package/src/api-client/index.ts

@@ -1,12 +1,7 @@
 export * as ApiClientTitanChat from './titan-chat';
-export * as ApiClientHelpCenter from './help-center';
 export * as Models from './models';
 export * as ModelsMocks from './models/__mocks__/models.mock';
 export * as ClientMocks from './__mocks__/chatbot-api-client.mock';
 export * as ModelsUtils from './utils/model-utils';
-export {
-    IChatbotClientSettings,
-    IChatbotApiClient,
-    CHATBOT_CLIENT_SETTINGS,
-    CHATBOT_API_CLIENT,
-} from './base/chatbot-api-client';
+export type { IChatbotClientSettings, IChatbotApiClient } from './base/chatbot-api-client';
+export { CHATBOT_CLIENT_SETTINGS, CHATBOT_API_CLIENT } from './base/chatbot-api-client';

package/src/api-client/models/index.ts

@@ -1,7 +1,21 @@
 /* eslint-disable no-restricted-imports */
 import { IBotMessage, IFeedback, IUserMessage } from '../titan-chat/native-client';
-export {
+export type {
     IUserMessage,
+    IFeedback,
+    IFrontendModel,
+    IOption,
+    IScoredUrl,
+    ISelections,
+    ISession,
+    IBotMessage,
+    IExportHistoryMessage,
+    IAgentOption,
+    IWorkflowPlan,
+    IWorkflowStep,
+    IUserInput,
+} from '../titan-chat/native-client';
+export {
     Selections,
     FeedbackOptions,
     FeedbackRatings,
@@ -9,29 +23,17 @@ export {
     ApiException,
     Feedback,
     Option,
-    IFeedback,
     FrontendModel,
     UserMessage,
-    IFrontendModel,
-    IOption,
     OptionType,
     ScoredUrl,
-    IScoredUrl,
-    ISelections,
-    ISession,
     Experience,
-    IBotMessage,
     BotMessage,
-    IExportHistoryMessage,
     ExportHistoryMessage,
     AgentOption,
-    IAgentOption,
     WorkflowPlan,
-    IWorkflowPlan,
     WorkflowStep,
-    IWorkflowStep,
     UserInput,
-    IUserInput,
 } from '../titan-chat/native-client';
 
 export interface IBotMessageWithFeedback extends IBotMessage {

package/src/api-client/titan-chat/__tests__/chatbot-api-client-stream.test.ts

@@ -0,0 +1,208 @@
+import { beforeEach, describe, expect, jest, test } from '@jest/globals';
+import { type EventSourceMessage, fetchEventSource } from '@microsoft/fetch-event-source';
+import { Models } from '../..';
+import type { AgentStreamHandlers } from '../../../streaming';
+import { ChatbotApiClient, IChatbotClientSettingsTitanChat } from '../chatbot-api-client';
+
+jest.mock('@microsoft/fetch-event-source');
+
+const fetchEventSourceMock = fetchEventSource as jest.MockedFunction<typeof fetchEventSource>;
+
+const okResponse = () =>
+    ({ ok: true, status: 200, headers: { get: () => 'text/event-stream' } }) as unknown as Response;
+const evt = (event: string, data: unknown): EventSourceMessage => ({
+    id: '',
+    event,
+    data: JSON.stringify(data),
+});
+
+/** Mock that opens, exposes init, and stays pending until the client aborts. */
+function captureOpen() {
+    const capture: { init?: any; opened: Promise<void> } = { opened: undefined as any };
+    capture.opened = new Promise<void>(markOpened => {
+        fetchEventSourceMock.mockImplementation((_url, init) => {
+            capture.init = init;
+            markOpened();
+            return Promise.resolve(init.onopen?.(okResponse())).then(
+                () =>
+                    new Promise<void>(resolve => {
+                        const s: AbortSignal | null | undefined = init.signal;
+                        if (s?.aborted) {
+                            resolve();
+                        } else {
+                            s?.addEventListener('abort', () => resolve(), { once: true });
+                        }
+                    })
+            );
+        });
+    });
+    return capture;
+}
+
+/** The same custom fetch the regular API client would use (injects auth, etc.). */
+const customFetch = ((_url: any, _init?: any) => Promise.resolve(new Response())) as typeof fetch;
+
+const settings: IChatbotClientSettingsTitanChat = {
+    version: '2',
+    clientId: 'help-center',
+    constructorParametersFactory: () => ({
+        baseUrl: 'https://api.test/base',
+        httpClient: { fetch: customFetch },
+    }),
+    streamHeadersFactory: () => ({ Authorization: 'Bearer t' }),
+};
+
+describe('ChatbotApiClient (titan-chat).streamMessage', () => {
+    beforeEach(() => {
+        fetchEventSourceMock.mockReset();
+    });
+
+    test('opens the versioned stream endpoint with X-Client-ID + extra headers and the message body', async () => {
+        const capture = captureOpen();
+        const client = new ChatbotApiClient(settings);
+
+        const promise = client.streamMessage(
+            new Models.UserMessage({
+                sessionId: 9,
+                question: 'hi',
+                experience: Models.Experience.MultiTurn,
+            }),
+            {}
+        );
+        await capture.opened;
+
+        expect(String((fetchEventSourceMock.mock.calls[0] as any[])[0])).toBe(
+            'https://api.test/base/api/v2/message/stream'
+        );
+        expect(capture.init.method).toBe('POST');
+        expect(capture.init.headers).toMatchObject({
+            'X-Client-ID': 'help-center',
+            'Authorization': 'Bearer t',
+            'Accept': 'text/event-stream',
+        });
+        const sent = JSON.parse(capture.init.body);
+        expect(sent.question).toBe('hi');
+        expect(sent.sessionId).toBe(9);
+
+        capture.init.onmessage(evt('run.finished', { seq: 1, status: 'Success', answer: 'done' }));
+        await promise;
+    });
+
+    test('forwards the configured httpClient.fetch so SSE uses the same request config as the API', async () => {
+        const capture = captureOpen();
+        const client = new ChatbotApiClient(settings);
+
+        const promise = client.streamMessage(
+            new Models.UserMessage({ question: 'q', experience: Models.Experience.MultiTurn }),
+            {}
+        );
+        await capture.opened;
+
+        // fetchEventSource receives the same fetch the regular client uses → auth/headers apply identically.
+        expect(capture.init.fetch).toBe(customFetch);
+
+        capture.init.onmessage(evt('run.finished', { seq: 1, status: 'Success', answer: 'done' }));
+        await promise;
+    });
+
+    test('maps agent events and resolves a BotMessage from run.finished', async () => {
+        const capture = captureOpen();
+        const handlers: AgentStreamHandlers = { onStatus: jest.fn(), onText: jest.fn() };
+        const client = new ChatbotApiClient(settings);
+
+        const promise = client.streamMessage(
+            new Models.UserMessage({ question: 'q', experience: Models.Experience.MultiTurn }),
+            handlers
+        );
+        await capture.opened;
+
+        capture.init.onmessage(evt('status.changed', { seq: 1, text: 'Thinking…' }));
+        capture.init.onmessage(evt('text.appended', { seq: 2, text: '✓ done step' }));
+        capture.init.onmessage(
+            evt('run.finished', { seq: 3, status: 'Success', answer: 'final', sessionId: 5 })
+        );
+
+        const bot = await promise;
+        expect(handlers.onStatus).toHaveBeenCalledWith('Thinking…');
+        expect(handlers.onText).toHaveBeenCalledWith('✓ done step');
+        expect(bot).toBeInstanceOf(Models.BotMessage);
+        expect(bot.answer).toBe('final');
+        expect(bot.sessionId).toBe(5);
+    });
+
+    test('plan.proposed forwards steps and activates the first step by default', async () => {
+        const capture = captureOpen();
+        const handlers: AgentStreamHandlers = { onPlan: jest.fn(), onStepActive: jest.fn() };
+        const client = new ChatbotApiClient(settings);
+
+        const promise = client.streamMessage(
+            new Models.UserMessage({ question: 'q', experience: Models.Experience.MultiTurn }),
+            handlers
+        );
+        await capture.opened;
+
+        capture.init.onmessage(
+            evt('plan.proposed', {
+                seq: 1,
+                steps: [
+                    { id: 'a', title: 'Look up' },
+                    { id: 'b', title: 'Answer' },
+                ],
+            })
+        );
+        capture.init.onmessage(evt('run.finished', { seq: 2, status: 'Success', answer: 'x' }));
+
+        await promise;
+        expect(handlers.onPlan).toHaveBeenCalledWith([
+            { id: 'a', title: 'Look up' },
+            { id: 'b', title: 'Answer' },
+        ]);
+        expect(handlers.onStepActive).toHaveBeenCalledWith('a');
+    });
+
+    test('plan.proposed honors an explicit activeStepId', async () => {
+        const capture = captureOpen();
+        const handlers: AgentStreamHandlers = { onStepActive: jest.fn() };
+        const client = new ChatbotApiClient(settings);
+
+        const promise = client.streamMessage(
+            new Models.UserMessage({ question: 'q', experience: Models.Experience.MultiTurn }),
+            handlers
+        );
+        await capture.opened;
+
+        capture.init.onmessage(
+            evt('plan.proposed', {
+                seq: 1,
+                activeStepId: 'b',
+                steps: [
+                    { id: 'a', title: 'Look up' },
+                    { id: 'b', title: 'Answer' },
+                ],
+            })
+        );
+        capture.init.onmessage(evt('run.finished', { seq: 2, status: 'Success', answer: 'x' }));
+
+        await promise;
+        expect(handlers.onStepActive).toHaveBeenCalledWith('b');
+    });
+
+    test('status.changed advances the active step when it carries a stepId', async () => {
+        const capture = captureOpen();
+        const handlers: AgentStreamHandlers = { onStatus: jest.fn(), onStepActive: jest.fn() };
+        const client = new ChatbotApiClient(settings);
+
+        const promise = client.streamMessage(
+            new Models.UserMessage({ question: 'q', experience: Models.Experience.MultiTurn }),
+            handlers
+        );
+        await capture.opened;
+
+        capture.init.onmessage(evt('status.changed', { seq: 1, text: 'Searching…', stepId: 'b' }));
+        capture.init.onmessage(evt('run.finished', { seq: 2, status: 'Success', answer: 'x' }));
+
+        await promise;
+        expect(handlers.onStatus).toHaveBeenCalledWith('Searching…');
+        expect(handlers.onStepActive).toHaveBeenCalledWith('b');
+    });
+});