@redocly/theme 0.70.0-next.1 → 0.70.0-next.11

package/lib/core/utils/content-segments.js

@@ -1,22 +1,107 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitContentByToolCalls = splitContentByToolCalls;
+exports.groupToolCallSegments = groupToolCallSegments;
+exports.hasToolCallsAndText = hasToolCallsAndText;
+const SENTENCE_END_MARKS = '.!?:;';
+const CLOSING_MARKS = `"')]*_\``;
+const CODE_FENCE = /^[ \t]*(```|~~~)/gm;
+/**
+ * Splits an answer at its tool calls. A call made in the middle of a sentence or a code block is
+ * placed at the end of that paragraph, so the sentence reads as one piece.
+ */
 function splitContentByToolCalls(content, toolCalls) {
     if (!toolCalls || toolCalls.length === 0) {
         return [{ type: 'text', text: content || '' }];
     }
+    const text = content !== null && content !== void 0 ? content : '';
+    const fences = Array.from(text.matchAll(CODE_FENCE), (match) => match.index);
     const segments = [];
     let lastPos = 0;
     for (const toolCall of toolCalls) {
-        if (content && toolCall.position > lastPos) {
-            segments.push({ type: 'text', text: content.substring(lastPos, toolCall.position) });
+        const position = Math.max(lastPos, getBlockBoundary(text, toolCall.position, fences));
+        if (position > lastPos) {
+            segments.push({ type: 'text', text: text.substring(lastPos, position) });
         }
         segments.push({ type: 'tool', toolCall });
-        lastPos = toolCall.position;
+        lastPos = position;
     }
-    if (content && lastPos < content.length) {
-        segments.push({ type: 'text', text: content.substring(lastPos) });
+    if (lastPos < text.length) {
+        segments.push({ type: 'text', text: text.substring(lastPos) });
     }
     return segments;
 }
+function getBlockBoundary(content, position, fences) {
+    if (position <= 0 || position >= content.length) {
+        return position;
+    }
+    const isInsideCodeFence = (index) => {
+        let count = 0;
+        while (count < fences.length && fences[count] < index)
+            count++;
+        return count % 2 === 1;
+    };
+    if (!isInsideCodeFence(position) && endsBlockOrSentence(content, position)) {
+        return position;
+    }
+    for (let boundary = content.indexOf('\n\n', position); boundary !== -1; boundary = content.indexOf('\n\n', boundary + 2)) {
+        if (!isInsideCodeFence(boundary)) {
+            return boundary;
+        }
+    }
+    return content.length;
+}
+function endsBlockOrSentence(content, position) {
+    let index = position - 1;
+    while (index >= 0 && /\s/.test(content[index])) {
+        if (content[index] === '\n')
+            return true;
+        index--;
+    }
+    while (index >= 0 && CLOSING_MARKS.includes(content[index]))
+        index--;
+    return index >= 0 && SENTENCE_END_MARKS.includes(content[index]);
+}
+/**
+ * Groups consecutive tool calls and drops text that is only whitespace. While the answer is
+ * generated, an answer with nothing to show yet is one empty active group (the thinking status),
+ * and the last group is active until text that is not whitespace follows it.
+ */
+function groupToolCallSegments(segments, isGenerating) {
+    var _a;
+    var _b;
+    const grouped = [];
+    let text = '';
+    for (const segment of segments) {
+        if (segment.type === 'text') {
+            text += segment.text;
+            if (segment.text.trim()) {
+                grouped.push(segment);
+            }
+            continue;
+        }
+        const previous = grouped.at(-1);
+        if ((previous === null || previous === void 0 ? void 0 : previous.type) === 'tools') {
+            previous.toolCalls.push(segment.toolCall);
+        }
+        else {
+            grouped.push({ type: 'tools', toolCalls: [segment.toolCall], isActive: false });
+        }
+    }
+    if (!isGenerating) {
+        return grouped;
+    }
+    const last = grouped.at(-1);
+    if ((last === null || last === void 0 ? void 0 : last.type) === 'tools') {
+        last.isActive = !text.slice((_b = (_a = last.toolCalls.at(-1)) === null || _a === void 0 ? void 0 : _a.position) !== null && _b !== void 0 ? _b : 0).trim();
+    }
+    else if (grouped.length === 0) {
+        return [{ type: 'tools', toolCalls: [], isActive: true }];
+    }
+    return grouped;
+}
+function hasToolCallsAndText(segments) {
+    return (segments.some((segment) => segment.type === 'tool') &&
+        segments.some((segment) => segment.type === 'text' && segment.text.trim().length > 0));
+}
 //# sourceMappingURL=content-segments.js.map

package/lib/core/utils/download-code-walkthrough.d.ts

@@ -1,4 +1,4 @@
-import type { CodeWalkthroughFile } from '@redocly/config';
+import type { CodeWalkthroughFile } from '../../core/types';
 export declare function downloadCodeWalkthrough(files: CodeWalkthroughFile[], state: Record<string, {
     value: string | boolean;
 }>, inputsState: Record<string, {

package/lib/core/utils/dropdown.d.ts

@@ -0,0 +1,2 @@
+import type { DropdownAlignment } from '../types/dropdown';
+export declare function fitDropdownAlignment(anchor: DOMRect, menuWidth: number, alignment?: DropdownAlignment): DropdownAlignment;

package/lib/core/utils/dropdown.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fitDropdownAlignment = fitDropdownAlignment;
+function fitDropdownAlignment(anchor, menuWidth, alignment = 'start') {
+    const fits = {
+        start: anchor.left + menuWidth <= window.innerWidth,
+        end: anchor.right - menuWidth >= 0,
+    };
+    const other = alignment === 'end' ? 'start' : 'end';
+    return fits[alignment] || !fits[other] ? alignment : other;
+}
+//# sourceMappingURL=dropdown.js.map

package/lib/core/utils/get-ai-prompt-link.d.ts

@@ -0,0 +1,15 @@
+import type { AiPromptTarget } from '../types/prompt';
+/**
+ * Builds a link that opens an AI tool with the prompt prefilled.
+ *
+ * @param target - The AI tool to open.
+ * @param prompt - The plain-text prompt to prefill.
+ * @returns The absolute URL with the encoded prompt in the query string.
+ *
+ * @example
+ * ```ts
+ * getAiPromptLink('claude', 'Summarize this page');
+ * // 'https://claude.ai/new?q=Summarize+this+page'
+ * ```
+ */
+export declare function getAiPromptLink(target: AiPromptTarget, prompt: string): string;

package/lib/core/utils/get-ai-prompt-link.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAiPromptLink = getAiPromptLink;
+const AI_PROMPT_ENDPOINTS = {
+    chatgpt: { baseUrl: 'https://chat.openai.com', queryParam: 'q' },
+    claude: { baseUrl: 'https://claude.ai/new', queryParam: 'q' },
+    // Encoding: https://cursor.com/docs/integrations/deeplinks
+    cursor: { baseUrl: 'https://cursor.com/link/prompt', queryParam: 'text' },
+};
+/**
+ * Builds a link that opens an AI tool with the prompt prefilled.
+ *
+ * @param target - The AI tool to open.
+ * @param prompt - The plain-text prompt to prefill.
+ * @returns The absolute URL with the encoded prompt in the query string.
+ *
+ * @example
+ * ```ts
+ * getAiPromptLink('claude', 'Summarize this page');
+ * // 'https://claude.ai/new?q=Summarize+this+page'
+ * ```
+ */
+function getAiPromptLink(target, prompt) {
+    const { baseUrl, queryParam } = AI_PROMPT_ENDPOINTS[target];
+    const url = new URL(baseUrl);
+    url.searchParams.set(queryParam, prompt);
+    return url.toString();
+}
+//# sourceMappingURL=get-ai-prompt-link.js.map

package/lib/core/utils/get-code-walkthrough-file-text.d.ts

@@ -1,4 +1,4 @@
-import type { CodeWalkthroughFile } from '@redocly/config';
+import type { CodeWalkthroughFile } from '../../core/types';
 export declare function getCodeWalkthroughFileText(file: CodeWalkthroughFile, state: Record<string, {
     value: string | boolean;
 }>, inputsState: Record<string, {

package/lib/core/utils/index.d.ts

@@ -17,6 +17,7 @@ export * from './type-guards';
 export * from './dom';
 export * from './toc';
 export * from './menu';
+export * from './navigation-tabs';
 export * from './load-and-navigate';
 export * from './get-scorecard-color-variable';
 export * from './change-text-casing';
@@ -49,3 +50,7 @@ export * from './tooltip-placement';
 export * from './telemetry/get-base-data-attributes';
 export * from './telemetry/generate-before-after-context';
 export * from './RenderWithLink';
+export * from './consent-settings-link-placement';
+export * from './assign-ref';
+export * from './dropdown';
+export * from './get-ai-prompt-link';

package/lib/core/utils/index.js

@@ -33,6 +33,7 @@ __exportStar(require("./type-guards"), exports);
 __exportStar(require("./dom"), exports);
 __exportStar(require("./toc"), exports);
 __exportStar(require("./menu"), exports);
+__exportStar(require("./navigation-tabs"), exports);
 __exportStar(require("./load-and-navigate"), exports);
 __exportStar(require("./get-scorecard-color-variable"), exports);
 __exportStar(require("./change-text-casing"), exports);
@@ -65,4 +66,8 @@ __exportStar(require("./tooltip-placement"), exports);
 __exportStar(require("./telemetry/get-base-data-attributes"), exports);
 __exportStar(require("./telemetry/generate-before-after-context"), exports);
 __exportStar(require("./RenderWithLink"), exports);
+__exportStar(require("./consent-settings-link-placement"), exports);
+__exportStar(require("./assign-ref"), exports);
+__exportStar(require("./dropdown"), exports);
+__exportStar(require("./get-ai-prompt-link"), exports);
 //# sourceMappingURL=index.js.map

package/lib/core/utils/match-code-walkthrough-conditions.d.ts

@@ -1,4 +1,4 @@
-import type { CodeWalkthroughConditionsObject } from '@redocly/config';
+import type { CodeWalkthroughConditionsObject } from '../../core/types';
 export declare function matchCodeWalkthroughConditions(conditions: CodeWalkthroughConditionsObject | undefined, state: Record<string, {
     value: string | boolean;
 }>): boolean;

package/lib/core/utils/mcp.d.ts

@@ -1,4 +1,5 @@
-import type { MCPClientType, McpConnectionParams } from '../types';
+import type { MCPClientType, McpConnectionParams, MCPOption } from '../types';
+export declare function isMCPOption(value: unknown): value is MCPOption;
 export declare function generateMCPDeepLink(clientType: MCPClientType, config: McpConnectionParams): string;
 export declare function slugifyMcpServerName(name: string): string;
 export declare function generateClaudeCodeCommand(config: McpConnectionParams): string;

package/lib/core/utils/mcp.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMCPOption = isMCPOption;
 exports.generateMCPDeepLink = generateMCPDeepLink;
 exports.slugifyMcpServerName = slugifyMcpServerName;
 exports.generateClaudeCodeCommand = generateClaudeCodeCommand;
 exports.generateCodexCommand = generateCodexCommand;
 exports.generateMcpInstallPrompt = generateMcpInstallPrompt;
+const mcp_1 = require("../constants/mcp");
+function isMCPOption(value) {
+    return mcp_1.MCP_OPTIONS.includes(value);
+}
 function generateCursorMCPDeepLink(config) {
     const cursorConfig = {
         url: config.url,
@@ -22,14 +27,19 @@ function generateVSCodeMCPDeepLink(config) {
     const encodedConfig = encodeURIComponent(JSON.stringify(vscodeConfig));
     return `vscode:mcp/install?${encodedConfig}`;
 }
+function generateClaudeConnectorLink(config) {
+    const connectorName = encodeURIComponent(config.serverName);
+    const connectorUrl = encodeURIComponent(config.url);
+    return `https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=${connectorName}&connectorUrl=${connectorUrl}`;
+}
 function generateMCPDeepLink(clientType, config) {
     switch (clientType) {
         case 'cursor':
             return generateCursorMCPDeepLink(config);
         case 'vscode':
             return generateVSCodeMCPDeepLink(config);
-        default:
-            return generateCursorMCPDeepLink(config);
+        case 'claude':
+            return generateClaudeConnectorLink(config);
     }
 }
 // Server names can contain spaces (e.g. "Docs MCP server") which break bare CLI
@@ -38,7 +48,7 @@ function slugifyMcpServerName(name) {
     return name
         .toLowerCase()
         .replace(/[^a-z0-9_-]+/g, '-')
-        .replace(/^-+|-+$/g, '');
+        .replace(/^-+|(?<!-)-+$/g, '');
 }
 function generateClaudeCodeCommand(config) {
     return `claude mcp add --transport http ${slugifyMcpServerName(config.serverName)} ${config.url}`;

package/lib/core/utils/menu.d.ts

@@ -2,9 +2,13 @@ import type { ResolvedNavItem, Version } from '@redocly/config';
 import type { Location } from 'react-router';
 import type { Locale, TFunction } from '../types/l10n';
 import type { ItemState } from '../types/sidebar';
+import type { NavigationTabsState } from '../types/navigation-tabs';
 import { MenuItemType } from '../constants/common';
 export declare const mapNavbarItems: (items: ResolvedNavItem[], defaultLocale: string, currentLocale: string, locales: Locale[], location: Location) => ItemState[];
 export declare const isItemActive: (item: ResolvedNavItem, defaultLocale: string, currentLocale: string, locales: Locale[], location: Location) => boolean;
 export declare const buildLanguagesGroup: (locales: Locale[], defaultLocale: string, currentLocale: string) => ResolvedNavItem | undefined;
 export declare const buildVersionSection: (translate: TFunction, versions: Version[], activeVersion?: Version) => ResolvedNavItem[];
+export declare const buildNavigationTabsSelect: ({ navigationTabs, }: {
+    navigationTabs: NavigationTabsState | undefined;
+}) => ItemState | undefined;
 export declare function getMenuItemType(item: ItemState): MenuItemType;

package/lib/core/utils/menu.js

@@ -1,24 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildVersionSection = exports.buildLanguagesGroup = exports.isItemActive = exports.mapNavbarItems = void 0;
+exports.buildNavigationTabsSelect = exports.buildVersionSection = exports.buildLanguagesGroup = exports.isItemActive = exports.mapNavbarItems = void 0;
 exports.getMenuItemType = getMenuItemType;
 const common_1 = require("../constants/common");
 const urls_1 = require("./urls");
+const navigation_tabs_1 = require("./navigation-tabs");
 const TRANSLATION_KEYS = {
     version: 'mobileMenu.version',
 };
 const mapNavbarItems = (items, defaultLocale, currentLocale, locales, location) => {
-    return items.map((navItem) => { var _a; return (Object.assign(Object.assign(Object.assign(Object.assign({}, navItem), (navItem.items && {
+    return items.map((navItem) => { var _a; return (Object.assign(Object.assign(Object.assign({}, navItem), (navItem.items && {
         items: (0, exports.mapNavbarItems)(navItem.items, defaultLocale, currentLocale, locales, location),
-    })), ('link' in navItem && { link: navItem.link || '/' })), { active: 'link' in navItem &&
-            (0, exports.isItemActive)(navItem, defaultLocale, currentLocale, locales, location), hasActiveSubItem: !!((_a = navItem.items) === null || _a === void 0 ? void 0 : _a.find((item) => (0, exports.isItemActive)(item, defaultLocale, currentLocale, locales, location))) })); });
+    })), { active: (0, exports.isItemActive)(navItem, defaultLocale, currentLocale, locales, location), hasActiveSubItem: !!((_a = navItem.items) === null || _a === void 0 ? void 0 : _a.find((item) => (0, exports.isItemActive)(item, defaultLocale, currentLocale, locales, location))) })); });
 };
 exports.mapNavbarItems = mapNavbarItems;
 const isItemActive = (item, defaultLocale, currentLocale, locales, location) => {
+    if (!item.link)
+        return false;
     const pathHash = location.pathname + location.hash;
     const link = item.languageInsensitive
-        ? item.link || ''
-        : (0, urls_1.getPathnameForLocale)(item.link || '/', defaultLocale, currentLocale, locales);
+        ? item.link
+        : (0, urls_1.getPathnameForLocale)(item.link, defaultLocale, currentLocale, locales);
     return pathHash === (0, urls_1.withPathPrefix)(link);
 };
 exports.isItemActive = isItemActive;
@@ -34,7 +36,7 @@ const buildLanguagesGroup = (locales, defaultLocale, currentLocale) => {
             .filter((locale) => locale.code !== currentLocale)
             .map((locale) => {
             const newLangPathname = (0, urls_1.getPathnameForLocale)((0, urls_1.withoutPathPrefix)(location.pathname), defaultLocale, locale.code, locales);
-            const newUrlWithLanguage = `${newLangPathname}${location.search}${location.hash}`;
+            const newUrlWithLanguage = `${(0, urls_1.addLeadingSlash)(newLangPathname)}${location.search}${location.hash}`;
             return {
                 type: 'link',
                 label: locale.name || locale.code || '',
@@ -71,9 +73,30 @@ const buildVersionSection = (translate, versions, activeVersion) => {
     ];
 };
 exports.buildVersionSection = buildVersionSection;
+const buildNavigationTabsSelect = ({ navigationTabs, }) => {
+    var _a;
+    var _b;
+    const tabs = (_a = (0, navigation_tabs_1.toNavigationTabsConfig)({ state: navigationTabs })) === null || _a === void 0 ? void 0 : _a.items;
+    if (!tabs) {
+        return;
+    }
+    const activeTab = tabs.find((tab) => tab.active);
+    return {
+        type: common_1.MenuItemType.Select,
+        label: (_b = activeTab === null || activeTab === void 0 ? void 0 : activeTab.label) !== null && _b !== void 0 ? _b : 'Navigation tabs',
+        labelTranslationKey: activeTab ? activeTab.labelTranslationKey : 'navigationTabs.label',
+        items: tabs.map(toNavigationTabOption),
+        active: false,
+        hasActiveSubItem: !!activeTab,
+    };
+};
+exports.buildNavigationTabsSelect = buildNavigationTabsSelect;
 function getMenuItemType(item) {
     var _a, _b;
-    if (item.type === common_1.MenuItemType.Separator) {
+    if (item.type === common_1.MenuItemType.Select) {
+        return common_1.MenuItemType.Select;
+    }
+    else if (item.type === common_1.MenuItemType.Separator) {
         return common_1.MenuItemType.Separator;
     }
     else if (item.menuStyle === 'drilldown') {
@@ -88,4 +111,21 @@ function getMenuItemType(item) {
     else
         return common_1.MenuItemType.Default;
 }
+function toNavigationTabOption(tab) {
+    var _a;
+    const landing = tab.type === 'group' ? ((_a = tab.items.find((entry) => entry.active)) !== null && _a !== void 0 ? _a : tab.items[0]) : tab;
+    return {
+        type: tab.type,
+        label: tab.label,
+        labelTranslationKey: tab.labelTranslationKey,
+        icon: tab.icon,
+        srcSet: tab.srcSet,
+        link: landing === null || landing === void 0 ? void 0 : landing.link,
+        external: landing === null || landing === void 0 ? void 0 : landing.external,
+        target: landing === null || landing === void 0 ? void 0 : landing.target,
+        items: [],
+        active: !!tab.active,
+        hasActiveSubItem: false,
+    };
+}
 //# sourceMappingURL=menu.js.map

package/lib/core/utils/navigation-tabs.d.ts

@@ -0,0 +1,8 @@
+import type { ThemeHooks } from '../types/hooks';
+import type { NavigationTabsConfig, NavigationTabsState } from '../types/navigation-tabs';
+type NavbarItemClickedPayload = Parameters<ReturnType<ThemeHooks['useTelemetry']>['sendNavbarMenuItemClickedMessage']>[0];
+export declare function toNavigationTabsConfig({ state, }: {
+    state: NavigationTabsState | undefined;
+}): NavigationTabsConfig | undefined;
+export declare function getNavbarItemClickedPayload(type: 'link' | 'group'): NavbarItemClickedPayload;
+export {};

package/lib/core/utils/navigation-tabs.js

@@ -0,0 +1,71 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toNavigationTabsConfig = toNavigationTabsConfig;
+exports.getNavbarItemClickedPayload = getNavbarItemClickedPayload;
+const get_base_data_attributes_1 = require("./telemetry/get-base-data-attributes");
+function toNavigationTabsConfig({ state, }) {
+    const items = toNavigationTabEntries(state).map((entry) => entry.kind === 'menu'
+        ? {
+            type: 'group',
+            label: entry.tab.label,
+            labelTranslationKey: entry.tab.labelTranslationKey,
+            icon: entry.tab.icon,
+            srcSet: entry.tab.srcSet,
+            items: entry.entries.map((_a) => {
+                var { active } = _a, link = __rest(_a, ["active"]);
+                return toRowLink(link, active);
+            }),
+            active: entry.active,
+        }
+        : toRowLink(entry.link, entry.active));
+    return items.length ? { items } : undefined;
+}
+function getNavbarItemClickedPayload(type) {
+    return [
+        Object.assign(Object.assign({}, (0, get_base_data_attributes_1.getBaseDataAttributes)('navbarItem', 'navbar')), { type }),
+    ];
+}
+function toNavigationTabEntries(state) {
+    if (!(state === null || state === void 0 ? void 0 : state.tabs.length))
+        return [];
+    return state.tabs.flatMap((tab) => {
+        var _a;
+        const active = ((_a = state.activeTab) === null || _a === void 0 ? void 0 : _a.tabId) === tab.tabId;
+        if (tab.menu) {
+            const entries = tab.menu
+                .filter((menuEntry) => !!menuEntry.link)
+                .map((_a) => { var _b; var { tabId } = _a, link = __rest(_a, ["tabId"]); return (Object.assign(Object.assign({}, link), { active: active && tabId === ((_b = state.activeMenuEntry) === null || _b === void 0 ? void 0 : _b.tabId) })); });
+            return entries.length ? [{ kind: 'menu', tab, entries, active }] : [];
+        }
+        if (!tab.link)
+            return [];
+        return [
+            {
+                kind: 'link',
+                link: {
+                    label: tab.label,
+                    labelTranslationKey: tab.labelTranslationKey,
+                    link: tab.link,
+                    icon: tab.icon,
+                    srcSet: tab.srcSet,
+                },
+                active,
+            },
+        ];
+    });
+}
+function toRowLink(link, active) {
+    return Object.assign(Object.assign({ type: 'link' }, link), { active });
+}
+//# sourceMappingURL=navigation-tabs.js.map

package/lib/core/utils/search-ai-activity.d.ts

@@ -0,0 +1,4 @@
+import type { TFunction } from '../types/l10n';
+import { type SearchAiActivityStatus, type SearchAiActivityStep, type ToolCall } from '../types/search';
+export declare function getSearchAiActivityStatus(toolCalls: ToolCall[], isActive: boolean, runningToolCall: ToolCall | undefined, translate: TFunction): SearchAiActivityStatus;
+export declare function getSearchAiActivityStep(toolCall: ToolCall, isRunning: boolean, translate: TFunction): SearchAiActivityStep;

package/lib/core/utils/search-ai-activity.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSearchAiActivityStatus = getSearchAiActivityStatus;
+exports.getSearchAiActivityStep = getSearchAiActivityStep;
+const search_1 = require("../types/search");
+const search_2 = require("../constants/search");
+const type_guards_1 = require("./type-guards");
+function getSearchAiActivityStatus(toolCalls, isActive, runningToolCall, translate) {
+    var _a;
+    const latestToolCall = toolCalls.at(-1);
+    if (!latestToolCall) {
+        return {
+            label: translate('search.ai.thinkingText', 'Thinking...'),
+            kind: 'thinking',
+            isRunning: true,
+        };
+    }
+    if (isActive || toolCalls.length === 1) {
+        const toolCall = runningToolCall !== null && runningToolCall !== void 0 ? runningToolCall : latestToolCall;
+        return Object.assign(Object.assign({}, getToolCallLabel(toolCall, !isActive, translate)), { kind: getSearchAiActivityKind(toolCall.name), isRunning: isActive });
+    }
+    const isSameTool = toolCalls.every((toolCall) => toolCall.name === latestToolCall.name);
+    const sharedText = isSameTool
+        ? (_a = search_2.TOOL_CALL_DISPLAY_TEXT[latestToolCall.name]) === null || _a === void 0 ? void 0 : _a.completedText
+        : undefined;
+    return {
+        label: sharedText !== null && sharedText !== void 0 ? sharedText : translate('search.ai.toolCall.usedTools', 'Used tools'),
+        kind: isSameTool ? getSearchAiActivityKind(latestToolCall.name) : 'code',
+        isRunning: false,
+    };
+}
+function getSearchAiActivityStep(toolCall, isRunning, translate) {
+    const detail = getToolCallDetail(toolCall);
+    const kind = getSearchAiActivityKind(toolCall.name);
+    if (toolCall.name === search_1.ToolCallName.SearchDocumentation && detail) {
+        return { id: toolCall.id, label: `“${detail}”`, kind, isRunning };
+    }
+    const { label } = getToolCallLabel(toolCall, !isRunning, translate);
+    return { id: toolCall.id, label: detail ? label : stripEllipsis(label), kind, isRunning };
+}
+function getToolCallLabel(toolCall, isCompleted, translate) {
+    const detail = getToolCallDetail(toolCall);
+    if (toolCall.name === search_1.ToolCallName.Execute && detail) {
+        return { label: detail };
+    }
+    const builtInText = search_2.TOOL_CALL_DISPLAY_TEXT[toolCall.name];
+    if (builtInText) {
+        const text = isCompleted ? builtInText.completedText : builtInText.inProgressText;
+        return detail ? { label: stripEllipsis(text), detail } : { label: text };
+    }
+    const prefix = isCompleted
+        ? translate('search.ai.toolCall.executed', 'Executed')
+        : translate('search.ai.toolCall.executing', 'Executing');
+    return { label: `${prefix} ${toolCall.name}` };
+}
+function getSearchAiActivityKind(name) {
+    if (name === search_1.ToolCallName.SearchDocumentation)
+        return 'search';
+    if (name === search_1.ToolCallName.ContactSupport)
+        return 'support';
+    return 'code';
+}
+function getToolCallDetail(toolCall) {
+    switch (toolCall.name) {
+        case search_1.ToolCallName.SearchDocumentation:
+            return getStringArg(toolCall.args, 'query');
+        case search_1.ToolCallName.Execute:
+            return getStringArg(toolCall.args, 'description');
+        default:
+            return undefined;
+    }
+}
+function getStringArg(args, name) {
+    if (!(0, type_guards_1.isObject)(args) || !(name in args)) {
+        return undefined;
+    }
+    const value = Reflect.get(args, name);
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+function stripEllipsis(text) {
+    return text.replace(/(\.{3}|…)$/, '');
+}
+//# sourceMappingURL=search-ai-activity.js.map

package/lib/core/utils/urls.js

@@ -18,7 +18,9 @@ const common_1 = require("../constants/common");
 function combineUrls(baseURL, ...relativeURLs) {
     let res = baseURL;
     for (let relativeURL of relativeURLs) {
-        res = relativeURL ? res.replace(/[/\\]+$/, '') + '/' + relativeURL.replace(/^[/\\]+/, '') : res;
+        res = relativeURL
+            ? res.replace(/(?<![/\\])[/\\]+$/, '') + '/' + relativeURL.replace(/^[/\\]+/, '')
+            : res;
     }
     return res;
 }

package/lib/core/utils/with-load-progress.d.ts

@@ -1 +1,4 @@
+/** Shows the load progress bar until the most recent `withLoadProgress` load settles. */
 export declare function withLoadProgress<T>(loadTarget: Promise<T>): Promise<T>;
+export declare function subscribeToLoadProgress(listener: () => void): () => void;
+export declare function isLoadInProgress(): boolean;

package/lib/core/utils/with-load-progress.js

@@ -8,31 +8,36 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.withLoadProgress = withLoadProgress;
-const nprogress_1 = __importDefault(require("nprogress"));
-nprogress_1.default.configure({
-    trickleSpeed: 100,
-    template: '<div class="bar" role="bar"><div class="peg"></div></div>',
-});
-// Only the last caller should be able to call nprogress.done()
-let lastCalledBy;
+exports.subscribeToLoadProgress = subscribeToLoadProgress;
+exports.isLoadInProgress = isLoadInProgress;
+let latestLoad = null;
+const listeners = new Set();
+function setLatestLoad(load) {
+    latestLoad = load;
+    // e2e suites wait for this class, named after the progress library it replaced, to clear.
+    document.documentElement.classList.toggle('nprogress-busy', load !== null);
+    listeners.forEach((listener) => listener());
+}
+/** Shows the load progress bar until the most recent `withLoadProgress` load settles. */
 function withLoadProgress(loadTarget) {
     return __awaiter(this, void 0, void 0, function* () {
-        const callIdentifier = Symbol();
-        lastCalledBy = callIdentifier;
-        // Cancel any existing progress and restart
-        nprogress_1.default.done();
-        nprogress_1.default.start();
+        const load = Symbol();
+        setLatestLoad(load);
         return loadTarget.finally(() => {
-            if (lastCalledBy === callIdentifier) {
-                nprogress_1.default.done();
-                nprogress_1.default.remove();
-            }
+            if (latestLoad === load)
+                setLatestLoad(null);
         });
     });
 }
+function subscribeToLoadProgress(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+function isLoadInProgress() {
+    return latestLoad !== null;
+}
 //# sourceMappingURL=with-load-progress.js.map

package/lib/ext/configure.d.ts

@@ -1,5 +1,5 @@
 import type { UserClaims, OpenAPIServer } from '../core/types';
-export * from '../ext/configure-helpers';
+export type * from '../ext/configure-helpers';
 export * from '../ext/helpers/is-direct-configure-request-values';
 import type { ConfigureRequestValues, ConfigureServerRequestValues } from '../ext/configure-helpers';
 type Configure = {