@thoughtspot/visual-embed-sdk 1.52.2-beta.2 → 1.53.0

package/src/embed/app.spec.ts

@@ -8,6 +8,7 @@ import {
     ListPage,
 } from './app';
 import { SpotterQueryMode } from './conversation';
+import { SpotterExperienceVersion } from './spotter-utils';
 import { init } from '../index';
 import { Action, AuthType, EmbedEvent, HostEvent, RuntimeFilterOp } from '../types';
 import {
@@ -3081,3 +3082,34 @@ describe('AppEmbed updatedSpotterExperience tests', () => {
         });
     });
 });
+
+describe('AppEmbed spotterExperienceVersion tests', () => {
+    beforeEach(() => {
+        cleanUp();
+    });
+
+    const renderWithConfig = async (overrides: Partial<AppViewConfig>) => {
+        const appEmbed = new AppEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            ...overrides,
+        } as AppViewConfig);
+        appEmbed.render();
+        let src = '';
+        await executeAfterWait(() => {
+            src = getIFrameSrc();
+        });
+        return src;
+    };
+
+    test('should add the spotterExperienceVersion param when spotterExperienceVersion is set', async () => {
+        const src = await renderWithConfig({
+            spotterExperienceVersion: SpotterExperienceVersion.SPOTTER_2026_11,
+        });
+        expect(src).toContain(`spotterExperienceVersion=${SpotterExperienceVersion.SPOTTER_2026_11}`);
+    });
+
+    test('should not add the spotterExperienceVersion param when spotterExperienceVersion is not set', async () => {
+        const src = await renderWithConfig({});
+        expect(src).not.toContain('spotterExperienceVersion=');
+    });
+});

package/src/embed/app.ts

@@ -24,7 +24,12 @@ import {
 import { FullHeightController } from '../full-height';
 import { V1Embed } from './ts-embed';
 import { SpotterChatViewConfig, SpotterSidebarViewConfig, SpotterQueryMode, SpotterShareConversationConfig, StarterPromptsConfig } from './conversation';
-import { buildSpotterSidebarAppInitData, buildSpotterShareConversationAppInitData, buildStarterPromptsAppInitData } from './spotter-utils';
+import {
+    buildSpotterSidebarAppInitData,
+    buildSpotterShareConversationAppInitData,
+    buildStarterPromptsAppInitData,
+    SpotterExperienceVersion,
+} from './spotter-utils';
 import { SpotterVizConfig, buildSpotterVizAppInitData } from './spotter-viz-utils';
 
 /**
@@ -921,6 +926,20 @@ export interface AppViewConfig extends AllEmbedViewConfig, FullHeightViewConfig
      * ```
      */
     hideAnswerEditPanel?: boolean;
+
+    /**
+     * The Spotter experience version to load for the Spotter surface shown within
+     * this embed.
+     * @version SDK: 1.53.0 | ThoughtSpot Cloud: 26.11.0.cl
+     * @example
+     * ```js
+     * const embed = new AppEmbed('#tsEmbed', {
+     *    ... // other options
+     *    spotterExperienceVersion: SpotterExperienceVersion.SPOTTER_2026_11,
+     * });
+     * ```
+     */
+    spotterExperienceVersion?: SpotterExperienceVersion;
 }
 
 /**
@@ -991,7 +1010,7 @@ export class AppEmbed extends V1Embed {
      * embedded Liveboard or visualization.
      */
     protected getEmbedParams() {
-        const params = this.getEmbedParamsObject();
+        const params = this.getUrlQueryParamsObject();
         return getQueryParamString(params, true);
     }
 
@@ -1057,6 +1076,7 @@ export class AppEmbed extends V1Embed {
             isContinuousLiveboardPDFEnabled,
             enableLiveboardDataCache,
             hideAnswerEditPanel,
+            spotterExperienceVersion,
         } = this.viewConfig;
 
         let params: any = {};
@@ -1117,6 +1137,10 @@ export class AppEmbed extends V1Embed {
             params[Param.SpotterDataSources] = JSON.stringify(spotterDataSources);
         }
 
+        if (spotterExperienceVersion !== undefined) {
+            params[Param.SpotterExperienceVersion] = spotterExperienceVersion;
+        }
+
         // Handle spotterChatConfig params
         if (spotterChatConfig) {
             const {
@@ -1281,7 +1305,7 @@ export class AppEmbed extends V1Embed {
 
         // Navigation V1/V2 and home page V1/V2 are deprecated. V3 is now the
         // default experience, Need to send navigationVersion=v3 and
-        // homepageVersion=v3 even when the no discoveryExperience / 
+        // homepageVersion=v3 even when the no discoveryExperience /
         // modularHomeExperience config is set. Without these
         // params, older TSA versions (< 26.7) fall back to V2 for nav and
         // home page, so the defaults must be sent explicitly from the SDK.
@@ -1293,7 +1317,7 @@ export class AppEmbed extends V1Embed {
             if (discoveryExperience.listPageVersion !== undefined) {
                 params[Param.ListPageVersion] = discoveryExperience.listPageVersion;
             }
-            
+
             if (discoveryExperience.homePage === HomePage.Focused) {
                 params[Param.HomepageVersion] = HomePage.Focused;
                 // The Focused (V4) homepage experience requires the updated

package/src/embed/auto-frame-renderer.spec.ts

@@ -673,4 +673,468 @@ describe('startAutoMCPFrameRenderer', () => {
             expect(JSON.parse(autoValue)).toEqual(JSON.parse(liveboardValue));
         });
     });
+
+    // ─── replaying a stored conversation
+    // ──────────────────────────────────────
+
+    describe('stored conversation replay', () => {
+        const CONVERSATION_ID = 'U0Tfqmjlz6WT';
+        const REPLAY_SRC =
+            `https://${thoughtSpotHost}/v2/?${Param.Tsmcp}=true`
+            + `&${Param.TsmcpConversationId}=${CONVERSATION_ID}`
+            + `&${Param.TsmcpAnswerIndex}=1`;
+
+        /** Conversation-service shape: two real answers around a thinking one. */
+        const messagesPayload = {
+            messages: [
+                {
+                    message_id: 'm1',
+                    response_items: [
+                        { type: 'tool_call', is_thinking: false },
+                        { type: 'answer', answer_id: 'ans_first', is_thinking: false },
+                    ],
+                },
+                {
+                    message_id: 'm2',
+                    response_items: [
+                        { type: 'answer', answer_id: 'ans_thinking', is_thinking: true },
+                        { type: 'answer', answer_id: 'ans_second', is_thinking: false },
+                    ],
+                },
+            ],
+        };
+
+        const detailsPayload = {
+            answer: {
+                session_identifier: 'fresh-session',
+                generation_number: 3,
+                ac_state: { transaction_identifier: 'fresh-ac', generation_number: 2 },
+            },
+        };
+
+        let fetchMock: jest.SpyInstance;
+
+        /** Renders one replay iframe and returns the src plus the frame element. */
+        async function renderReplayFrame(
+            viewConfig: AutoMCPFrameRendererViewConfig = {},
+            src: string = REPLAY_SRC,
+        ): Promise<{ renderedSrc: string; frame: HTMLIFrameElement }> {
+            let renderedSrc = '';
+            let frame: HTMLIFrameElement;
+            renderIFrameSpy.mockRestore();
+            renderIFrameSpy = jest.spyOn(TsEmbed.prototype as any, 'renderIFrame')
+                .mockImplementation(async function (this: any, capturedSrc: string) {
+                    renderedSrc = capturedSrc;
+                    // Stand in for the real iframe the notice attaches to.
+                    frame = document.createElement('iframe');
+                    this.iFrame = frame;
+                });
+
+            const observer = startAutoMCPFrameRenderer(viewConfig);
+            const iframe = document.createElement('iframe');
+            iframe.src = src;
+            document.body.appendChild(iframe);
+            await new Promise((r) => setTimeout(r, 100));
+            observer.disconnect();
+            return { renderedSrc, frame: frame! };
+        }
+
+        beforeEach(() => {
+            fetchMock = jest.spyOn(global, 'fetch').mockImplementation(async (input: any) => {
+                const url = typeof input === 'string' ? input : input.url;
+                const body = url.includes('/load/public') ? detailsPayload : messagesPayload;
+                return { ok: true, status: 200, json: async () => body } as any;
+            });
+        });
+
+        afterEach(() => {
+            fetchMock.mockRestore();
+        });
+
+        test('resolves session params from the conversation and answer APIs', async () => {
+            const { renderedSrc } = await renderReplayFrame();
+
+            expect(renderedSrc).toContain('sessionId=fresh-session');
+            expect(renderedSrc).toContain('genNo=3');
+            expect(renderedSrc).toContain('acSessionId=fresh-ac');
+            expect(renderedSrc).toContain('acGenNo=2');
+        });
+
+        test('picks the answer at the requested index, skipping thinking items', async () => {
+            await renderReplayFrame();
+
+            const detailsCall = fetchMock.mock.calls
+                .map(([input]: any) => (typeof input === 'string' ? input : input.url))
+                .find((url: string) => url.includes('/load/public'));
+            // index 1 = second non-thinking answer; ans_thinking must not
+            // count.
+            expect(detailsCall).toContain('/message/ans_second/load/public');
+        });
+
+        test('defaults to the conversational answer route when none is given', async () => {
+            const { renderedSrc } = await renderReplayFrame();
+            expect(renderedSrc).toContain('/embed/conv-assist-answer');
+        });
+
+        test('strips the replay markers from the URL sent to ThoughtSpot', async () => {
+            const { renderedSrc } = await renderReplayFrame();
+            expect(renderedSrc).not.toContain(Param.TsmcpConversationId);
+            expect(renderedSrc).not.toContain(Param.TsmcpAnswerIndex);
+            expect(renderedSrc).not.toContain(`${Param.Tsmcp}=true`);
+        });
+
+        test('marks a replayed answer with the stale-data notice', async () => {
+            const { frame } = await renderReplayFrame();
+            expect(frame.dataset.tsStaleAnswer).toBe('true');
+            expect(frame.title).toBe(
+                'This data may have changed since the last time you had a chat.',
+            );
+        });
+
+        test('suppressStaleAnswerNotice leaves the frame unmarked', async () => {
+            const { frame } = await renderReplayFrame({ suppressStaleAnswerNotice: true });
+            expect(frame.dataset.tsStaleAnswer).toBeUndefined();
+            expect(frame.title).toBe('');
+        });
+
+        test('staleAnswerNoticeText overrides the default copy', async () => {
+            const { frame } = await renderReplayFrame({ staleAnswerNoticeText: 'Numbers may differ.' });
+            expect(frame.title).toBe('Numbers may differ.');
+        });
+
+        test('falls back to the source URL when resolution fails', async () => {
+            fetchMock.mockImplementation(async () => ({ ok: false, status: 500 } as any));
+            const { renderedSrc, frame } = await renderReplayFrame();
+
+            // No invented params, and no notice claiming a successful refresh.
+            expect(renderedSrc).toBe(REPLAY_SRC);
+            expect(renderedSrc).not.toContain('sessionId=');
+            expect(frame.dataset.tsStaleAnswer).toBeUndefined();
+        });
+
+        test.each([
+            ['a null messages body', null],
+            ['a messages body that is not an object', 'nope'],
+            ['messages that is not an array', { messages: null }],
+        ])('falls back on %s instead of throwing', async (_label, body) => {
+            fetchMock.mockImplementation(async (input: any) => {
+                const url = typeof input === 'string' ? input : input.url;
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => (url.includes('/load/public') ? detailsPayload : body),
+                } as any;
+            });
+            const { renderedSrc, frame } = await renderReplayFrame();
+
+            expect(renderedSrc).not.toContain('sessionId=');
+            expect(frame.dataset.tsStaleAnswer).toBeUndefined();
+        });
+
+        test('falls back on a null details body instead of throwing', async () => {
+            fetchMock.mockImplementation(async (input: any) => {
+                const url = typeof input === 'string' ? input : input.url;
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => (url.includes('/load/public') ? null : messagesPayload),
+                } as any;
+            });
+            const { renderedSrc } = await renderReplayFrame();
+
+            expect(renderedSrc).not.toContain('sessionId=');
+        });
+
+        test.each([
+            ['answer.generation_number', { ...detailsPayload.answer, generation_number: null }],
+            [
+                'ac_state.generation_number',
+                { ...detailsPayload.answer, ac_state: { transaction_identifier: 'fresh-ac', generation_number: null } },
+            ],
+        ])('treats a null %s as unresolvable', async (_label, answer) => {
+            fetchMock.mockImplementation(async (input: any) => {
+                const url = typeof input === 'string' ? input : input.url;
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => (url.includes('/load/public') ? { answer } : messagesPayload),
+                } as any;
+            });
+            const { renderedSrc, frame } = await renderReplayFrame();
+
+            // Never emit a literal "null" generation into the hash.
+            expect(renderedSrc).not.toContain('genNo=null');
+            expect(renderedSrc).not.toContain('acGenNo=null');
+            expect(renderedSrc).not.toContain('sessionId=');
+            expect(frame.dataset.tsStaleAnswer).toBeUndefined();
+        });
+
+        test.each([
+            ['a fractional index', '1.5'],
+            ['a negative index', '-1'],
+            ['a malformed index', 'abc'],
+            ['a trailing-junk index', '1abc'],
+        ])('%s falls back to the first answer', async (_label, value) => {
+            const src = `https://${thoughtSpotHost}/v2/?${Param.Tsmcp}=true`
+                + `&${Param.TsmcpConversationId}=${CONVERSATION_ID}`
+                + `&${Param.TsmcpAnswerIndex}=${value}`;
+            await renderReplayFrame({}, src);
+
+            const detailsCall = fetchMock.mock.calls
+                .map(([input]: any) => (typeof input === 'string' ? input : input.url))
+                .find((url: string) => url.includes('/load/public'));
+            expect(detailsCall).toContain('/message/ans_first/load/public');
+        });
+
+        /** URLs passed to fetch, in call order. */
+        function fetchedUrls(): string[] {
+            return fetchMock.mock.calls
+                .map(([input]: any) => (typeof input === 'string' ? input : input.url));
+        }
+
+        /** Serves `messages` for the list call and `details` for the load call. */
+        function mockConversation(messages: any, details: any = detailsPayload) {
+            fetchMock.mockImplementation(async (input: any) => {
+                const url = typeof input === 'string' ? input : input.url;
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => (url.includes('/load/public') ? details : messages),
+                } as any;
+            });
+        }
+
+        test('calls the conversation service with the encoded conversation id', async () => {
+            const src = `https://${thoughtSpotHost}/v2/?${Param.Tsmcp}=true`
+                + `&${Param.TsmcpConversationId}=${encodeURIComponent('conv/1')}`;
+            await renderReplayFrame({}, src);
+
+            const [listUrl, loadUrl] = fetchedUrls();
+            expect(listUrl).toBe(`http://${thoughtSpotHost}/conversation/v2/conv%2F1/public`);
+            expect(loadUrl).toBe(
+                `http://${thoughtSpotHost}/conversation/v2/conv%2F1/message/ans_first/load/public`,
+            );
+            const loadInit = fetchMock.mock.calls[1][1];
+            expect(loadInit.method).toBe('POST');
+            expect(JSON.parse(loadInit.body)).toEqual({ type: 'TS_ANSWER' });
+        });
+
+        test('defaults to the first answer when no index is given', async () => {
+            const src = `https://${thoughtSpotHost}/v2/?${Param.Tsmcp}=true`
+                + `&${Param.TsmcpConversationId}=${CONVERSATION_ID}`;
+            await renderReplayFrame({}, src);
+
+            expect(fetchedUrls()[1]).toContain('/message/ans_first/load/public');
+        });
+
+        test('keeps the source route and its other hash params', async () => {
+            const src = `${REPLAY_SRC}#/embed/viz/lb1?keep=yes&sessionId=expired`;
+            const { renderedSrc } = await renderReplayFrame({}, src);
+
+            expect(renderedSrc).toContain('/embed/viz/lb1?');
+            expect(renderedSrc).not.toContain('/embed/conv-assist-answer');
+            expect(renderedSrc).toContain('keep=yes');
+            expect(renderedSrc).toContain('sessionId=fresh-session');
+            expect(renderedSrc).not.toContain('sessionId=expired');
+        });
+
+        test('ignores messages without response items and answers without an id', async () => {
+            mockConversation({
+                messages: [
+                    { message_id: 'm0' },
+                    null,
+                    { message_id: 'm1', response_items: [{ type: 'answer', is_thinking: false }] },
+                    {
+                        message_id: 'm2',
+                        response_items: [null, { type: 'answer', answer_id: 'ans_only', is_thinking: false }],
+                    },
+                ],
+            });
+            const src = `https://${thoughtSpotHost}/v2/?${Param.Tsmcp}=true`
+                + `&${Param.TsmcpConversationId}=${CONVERSATION_ID}`;
+            const { renderedSrc } = await renderReplayFrame({}, src);
+
+            expect(fetchedUrls()[1]).toContain('/message/ans_only/load/public');
+            expect(renderedSrc).toContain('sessionId=fresh-session');
+        });
+
+        test('falls back when no answer exists at the requested index', async () => {
+            const src = `https://${thoughtSpotHost}/v2/?${Param.Tsmcp}=true`
+                + `&${Param.TsmcpConversationId}=${CONVERSATION_ID}`
+                + `&${Param.TsmcpAnswerIndex}=5`;
+            const { renderedSrc, frame } = await renderReplayFrame({}, src);
+
+            // The list, read once more in case it predated the answer; there is
+            // no answer to load.
+            expect(fetchedUrls()).toHaveLength(2);
+            expect(fetchedUrls().every((url) => url.endsWith('/public') && !url.includes('/load/'))).toBe(true);
+            expect(renderedSrc).not.toContain('sessionId=');
+            expect(frame.dataset.tsStaleAnswer).toBeUndefined();
+        });
+
+        test('falls back when the answer load fails', async () => {
+            fetchMock.mockImplementation(async (input: any) => {
+                const url = typeof input === 'string' ? input : input.url;
+                if (url.includes('/load/public')) {
+                    return { ok: false, status: 404 } as any;
+                }
+                return { ok: true, status: 200, json: async () => messagesPayload } as any;
+            });
+            const { renderedSrc, frame } = await renderReplayFrame();
+
+            expect(fetchedUrls()).toHaveLength(2);
+            expect(renderedSrc).not.toContain('sessionId=');
+            expect(frame.dataset.tsStaleAnswer).toBeUndefined();
+        });
+
+        test('falls back when a fetch throws', async () => {
+            fetchMock.mockImplementation(async () => {
+                throw new Error('network down');
+            });
+            const { renderedSrc, frame } = await renderReplayFrame();
+
+            expect(renderedSrc).not.toContain('sessionId=');
+            expect(frame.dataset.tsStaleAnswer).toBeUndefined();
+        });
+
+        test.each([
+            ['session_identifier', { ...detailsPayload.answer, session_identifier: '' }],
+            [
+                'ac_state.transaction_identifier',
+                { ...detailsPayload.answer, ac_state: { generation_number: 2 } },
+            ],
+            ['ac_state', { ...detailsPayload.answer, ac_state: undefined }],
+            ['a positive generation_number', { ...detailsPayload.answer, generation_number: 0 }],
+        ])('treats a missing %s as unresolvable', async (_label, answer) => {
+            mockConversation(messagesPayload, { answer });
+            const { renderedSrc, frame } = await renderReplayFrame();
+
+            expect(renderedSrc).not.toContain('sessionId=');
+            expect(frame.dataset.tsStaleAnswer).toBeUndefined();
+        });
+
+        test('skips the notice when no iframe was rendered', async () => {
+            renderIFrameSpy.mockRestore();
+            renderIFrameSpy = jest.spyOn(TsEmbed.prototype as any, 'renderIFrame')
+                .mockImplementation(async function (this: any) {
+                    this.iFrame = undefined;
+                });
+
+            const observer = startAutoMCPFrameRenderer({});
+            const iframe = document.createElement('iframe');
+            iframe.src = REPLAY_SRC;
+            document.body.appendChild(iframe);
+            await new Promise((r) => setTimeout(r, 100));
+            observer.disconnect();
+
+            // Resolution ran, and marking a missing frame did not throw.
+            expect(fetchedUrls()).toHaveLength(2);
+            expect(renderIFrameSpy).toHaveBeenCalledTimes(1);
+        });
+
+        describe('sharing the answer-id list', () => {
+            const replaySrc = (index: number, conversationId = CONVERSATION_ID) =>
+                `https://${thoughtSpotHost}/v2/?${Param.Tsmcp}=true`
+                + `&${Param.TsmcpConversationId}=${conversationId}`
+                + `&${Param.TsmcpAnswerIndex}=${index}`;
+
+            /**
+             * Mounts all `srcs` in one batch, as a replayed chat does.
+             * Returns the rendered srcs.
+             */
+            async function renderReplayBatch(srcs: string[]): Promise<string[]> {
+                const rendered: string[] = [];
+                renderIFrameSpy.mockRestore();
+                renderIFrameSpy = jest.spyOn(TsEmbed.prototype as any, 'renderIFrame')
+                    .mockImplementation(async function (this: any, capturedSrc: string) {
+                        rendered.push(capturedSrc);
+                        this.iFrame = document.createElement('iframe');
+                    });
+
+                const observer = startAutoMCPFrameRenderer({});
+                const container = document.createElement('div');
+                srcs.forEach((src) => {
+                    const iframe = document.createElement('iframe');
+                    iframe.src = src;
+                    container.appendChild(iframe);
+                });
+                document.body.appendChild(container);
+                await new Promise((r) => setTimeout(r, 100));
+                observer.disconnect();
+                return rendered;
+            }
+
+            const listCalls = () => fetchedUrls().filter((url) => !url.includes('/load/'));
+            const loadCalls = () => fetchedUrls().filter((url) => url.includes('/load/'));
+
+            test('concurrent frames from one conversation share one list call', async () => {
+                const rendered = await renderReplayBatch([replaySrc(0), replaySrc(1)]);
+
+                expect(listCalls()).toHaveLength(1);
+                // Each answer still loads its own live session.
+                expect(loadCalls()).toHaveLength(2);
+                expect(loadCalls().some((url) => url.includes('/message/ans_first/'))).toBe(true);
+                expect(loadCalls().some((url) => url.includes('/message/ans_second/'))).toBe(true);
+                expect(rendered.every((src) => src.includes('sessionId=fresh-session'))).toBe(true);
+            });
+
+            test('frames from different conversations do not share a list', async () => {
+                await renderReplayBatch([replaySrc(0), replaySrc(0, 'otherConversation')]);
+
+                expect(listCalls()).toHaveLength(2);
+                expect(listCalls().some((url) => url.includes('/otherConversation/'))).toBe(true);
+            });
+
+            test('a failed list is not reused by a later frame', async () => {
+                fetchMock.mockImplementation(async () => ({ ok: false, status: 500 } as any));
+                await renderReplayBatch([replaySrc(0)]);
+                expect(listCalls()).toHaveLength(1);
+
+                mockConversation(messagesPayload);
+                const rendered = await renderReplayBatch([replaySrc(0)]);
+
+                expect(listCalls()).toHaveLength(2);
+                expect(rendered[0]).toContain('sessionId=fresh-session');
+            });
+
+            test('a frame mounted after the batch settles reads a fresh list', async () => {
+                await renderReplayBatch([replaySrc(0)]);
+                await renderReplayBatch([replaySrc(1)]);
+
+                expect(listCalls()).toHaveLength(2);
+            });
+
+            test('a list too short for the index is read exactly once more', async () => {
+                // The first read predates the second answer; the
+                // second read has it.
+                let listReads = 0;
+                fetchMock.mockImplementation(async (input: any) => {
+                    const url = typeof input === 'string' ? input : input.url;
+                    if (url.includes('/load/public')) {
+                        return { ok: true, status: 200, json: async () => detailsPayload } as any;
+                    }
+                    listReads += 1;
+                    const messages = listReads === 1
+                        ? { messages: [messagesPayload.messages[0]] }
+                        : messagesPayload;
+                    return { ok: true, status: 200, json: async () => messages } as any;
+                });
+                const rendered = await renderReplayBatch([replaySrc(1), replaySrc(1)]);
+
+                // Both frames missed on the first list and joined one re-read.
+                expect(listCalls()).toHaveLength(2);
+                expect(loadCalls()).toHaveLength(2);
+                expect(loadCalls().every((url) => url.includes('/message/ans_second/'))).toBe(true);
+                expect(rendered.every((src) => src.includes('sessionId=fresh-session'))).toBe(true);
+            });
+        });
+
+        test('a frame without a conversation id makes no API calls and is unmarked', async () => {
+            const { renderedSrc, frame } = await renderReplayFrame({}, TSMCP_SRC);
+
+            expect(fetchMock).not.toHaveBeenCalled();
+            expect(renderedSrc).toContain('/embed/viz/lb1');
+            expect(frame.dataset.tsStaleAnswer).toBeUndefined();
+        });
+    });
 });