@plmbr/notebook-intelligence 5.0.1 → 5.1.0-a.1

package/README.md

@@ -383,6 +383,12 @@ jupyter lab --NotebookIntelligence.enable_chat_feedback=true
 
 The feedback fires an in-process `telemetry` event. Nothing leaves the process by default — see the [admin guide](docs/admin-guide.md#chat-feedback-event-hook) for how to wire it into your observability stack.
 
+The thumbs buttons reveal on hover by default. To keep them always visible, enable:
+
+```python
+c.NotebookIntelligence.enable_chat_feedback_always_visible = True
+```
+
 <img src="media/chat-feedback.png" alt="Chat feedback" width=500 />
 
 ## Documentation

package/lib/api.d.ts

@@ -174,6 +174,10 @@ export declare class NBIConfig {
     getMCPServerPrompt(serverId: string, promptName: string): any;
     get mcpServerSettings(): any;
     get claudeSettings(): any;
+    get spinnerVerbs(): {
+        mode: string;
+        verbs: string[];
+    } | null;
     get claudeModels(): IClaudeModelInfo[];
     get isInClaudeCodeMode(): boolean;
     get isClaudeCliAvailable(): boolean;
@@ -183,6 +187,7 @@ export declare class NBIConfig {
     get isCodexCliAvailable(): boolean;
     isCodingAgentLauncherDisabledByPolicy(launcherId: string): boolean;
     get chatFeedbackEnabled(): boolean;
+    get chatFeedbackAlwaysVisible(): boolean;
     get tourOverrides(): Record<string, any>;
     get allowGithubSkillImport(): boolean;
     get additionalSkippedWorkspaceDirectories(): string[];

package/lib/api.js

@@ -142,6 +142,10 @@ export class NBIConfig {
     get claudeSettings() {
         return this.capabilities.claude_settings;
     }
+    get spinnerVerbs() {
+        var _b;
+        return (_b = this.capabilities.spinner_verbs) !== null && _b !== void 0 ? _b : null;
+    }
     get claudeModels() {
         var _b;
         return ((_b = this.capabilities.claude_models) !== null && _b !== void 0 ? _b : []).map(claudeModelFromWire);
@@ -181,6 +185,9 @@ export class NBIConfig {
     get chatFeedbackEnabled() {
         return this.capabilities.chat_feedback_enabled === true;
     }
+    get chatFeedbackAlwaysVisible() {
+        return this.capabilities.chat_feedback_always_visible === true;
+    }
     // Admin-supplied tour-copy overrides, served from the capabilities
     // response after server-side validation. Returns the raw dict; the
     // tour module decides how to apply it. Defaults to a shared frozen

package/lib/chat-sidebar.js

@@ -20,6 +20,8 @@ import { mcpServerSettingsToEnabledState } from './components/mcp-util';
 import claudeSvgStr from '../style/icons/claude.svg';
 import { AskUserQuestion } from './components/ask-user-question';
 import { ClaudeSessionPicker } from './components/claude-session-picker';
+import { ToolCallGroup } from './components/tool-call-group';
+import { upsertToolCallContent } from './tool-call-stream';
 import { TourOverlay } from './tour/tour-overlay';
 import { TOUR_ANCHOR } from './tour/tour-anchors';
 import { TOUR_START_EVENT, TOUR_STOP_EVENT } from './tour/tour-events';
@@ -282,8 +284,81 @@ function ChatResponseHTMLFrame(props) {
 }
 // Memoize ChatResponse for performance
 function ChatResponse(props) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     const [renderCount, setRenderCount] = useState(0);
+    const shuffledOrder = useRef([]);
+    const shufflePos = useRef(0);
+    const _spinnerVerbs = NBIAPI.config.isInClaudeCodeMode
+        ? ((_a = NBIAPI.config.spinnerVerbs) !== null && _a !== void 0 ? _a : null)
+        : null;
+    const hasCustomVerbs = (_spinnerVerbs === null || _spinnerVerbs === void 0 ? void 0 : _spinnerVerbs.mode) === 'replace' &&
+        Array.isArray(_spinnerVerbs.verbs) &&
+        _spinnerVerbs.verbs.length > 0;
+    // Fisher-Yates shuffle. When `avoidFirst` is set, swap it out of
+    // position 0 so the new first verb is never the same as the last shown
+    // (prevents an identical repeat at the wrap point between passes).
+    const shuffleVerbs = (verbs, avoidFirst) => {
+        const order = verbs.map((_, i) => i);
+        for (let i = order.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [order[i], order[j]] = [order[j], order[i]];
+        }
+        if (avoidFirst !== undefined &&
+            order[0] === avoidFirst &&
+            order.length > 1) {
+            [order[0], order[1]] = [order[1], order[0]];
+        }
+        return order;
+    };
+    // Initialize the shuffle synchronously in useState so the correct verb
+    // is shown on the very first paint. A useEffect-based init fires after
+    // paint and causes a single-frame flash of verbs[0] before correcting.
+    const [verbIndex, setVerbIndex] = useState(() => {
+        var _a;
+        const sv = NBIAPI.config.isInClaudeCodeMode
+            ? ((_a = NBIAPI.config.spinnerVerbs) !== null && _a !== void 0 ? _a : null)
+            : null;
+        if (!sv ||
+            sv.mode !== 'replace' ||
+            !Array.isArray(sv.verbs) ||
+            sv.verbs.length === 0) {
+            return 0;
+        }
+        const order = shuffleVerbs(sv.verbs);
+        shuffledOrder.current = order;
+        shufflePos.current = 0;
+        return order[0];
+    });
+    useEffect(() => {
+        if (!props.showGenerating || !hasCustomVerbs) {
+            return;
+        }
+        const verbs = _spinnerVerbs.verbs;
+        // Shuffle already initialized by useState on mount. Only re-initialize
+        // if hasCustomVerbs just became true after a capabilities refresh
+        // (shuffledOrder would be empty because the lazy init found no verbs).
+        if (shuffledOrder.current.length === 0) {
+            shuffledOrder.current = shuffleVerbs(verbs);
+            shufflePos.current = 0;
+            setVerbIndex(shuffledOrder.current[0]);
+        }
+        let id;
+        const scheduleNext = () => {
+            const delay = 4000 + Math.random() * 3000;
+            id = setTimeout(() => {
+                shufflePos.current++;
+                if (shufflePos.current >= shuffledOrder.current.length) {
+                    const lastShown = shuffledOrder.current[shuffledOrder.current.length - 1];
+                    shuffledOrder.current = shuffleVerbs(verbs, lastShown);
+                    shufflePos.current = 0;
+                }
+                setVerbIndex(shuffledOrder.current[shufflePos.current]);
+                scheduleNext();
+            }, delay);
+        };
+        scheduleNext();
+        return () => clearTimeout(id);
+    }, [props.showGenerating, hasCustomVerbs]);
     const msg = props.message;
     const timestamp = msg.date.toLocaleTimeString('en-US', { hour12: false });
     const openNotebook = (event) => {
@@ -377,6 +452,19 @@ function ChatResponse(props) {
                 lastItem.reasoningFinished = true;
             }
         }
+        else if (item.type === ResponseStreamDataType.ToolCall &&
+            lastItemType === ResponseStreamDataType.ToolCall) {
+            // Bundle a run of consecutive tool calls into one group item so the
+            // renderer can collapse them; ToolCallGroup unwraps content.toolCalls.
+            const lastItem = groupedContents[groupedContents.length - 1];
+            lastItem.content.toolCalls.push(structuredClone(item.content));
+        }
+        else if (item.type === ResponseStreamDataType.ToolCall) {
+            const grouped = structuredClone(item);
+            grouped.content = { toolCalls: [structuredClone(item.content)] };
+            groupedContents.push(grouped);
+            lastItemType = item.type;
+        }
         else {
             groupedContents.push(structuredClone(item));
             lastItemType = item.type;
@@ -418,28 +506,35 @@ function ChatResponse(props) {
             ? 'Thought'
             : `Thinking (${Math.floor(item.reasoningTime)} s)`;
     };
-    const chatParticipantId = ((_a = msg.participant) === null || _a === void 0 ? void 0 : _a.id) || 'default';
+    const chatParticipantId = ((_b = msg.participant) === null || _b === void 0 ? void 0 : _b.id) || 'default';
     return (React.createElement("div", { className: `chat-message chat-message-${msg.from}`, "data-render-count": renderCount },
         React.createElement("div", { className: "chat-message-header" },
             React.createElement("div", { className: "chat-message-from" },
-                ((_b = msg.participant) === null || _b === void 0 ? void 0 : _b.iconPath) && (React.createElement("div", { className: `chat-message-from-icon chat-message-from-icon-${chatParticipantId} ${isDarkTheme() ? 'dark' : ''}` },
+                ((_c = msg.participant) === null || _c === void 0 ? void 0 : _c.iconPath) && (React.createElement("div", { className: `chat-message-from-icon chat-message-from-icon-${chatParticipantId} ${isDarkTheme() ? 'dark' : ''}` },
                     React.createElement("img", { src: msg.participant.iconPath, alt: "" }))),
                 React.createElement("div", { className: "chat-message-from-title" }, msg.from === 'user'
                     ? 'User'
-                    : ((_c = msg.participant) === null || _c === void 0 ? void 0 : _c.name) || 'AI Assistant'),
+                    : ((_d = msg.participant) === null || _d === void 0 ? void 0 : _d.name) || 'AI Assistant'),
                 React.createElement("div", { className: "chat-message-from-progress", style: { display: `${props.showGenerating ? 'visible' : 'none'}` } },
                     React.createElement("span", { 
                         // Key on the heartbeat tick so React re-mounts the dot on
                         // every beat; CSS-animation restart from an attribute-only
                         // change is not reliable across browsers.
                         key: props.heartbeatTick, className: `generating-pulse${props.isStalled ? ' is-stalled' : ''}`, "aria-hidden": "true" }),
-                    React.createElement("div", { className: "generating-label", "aria-live": "polite", "aria-atomic": "true" },
+                    React.createElement("div", { className: "generating-label", "aria-hidden": "true" },
                         props.isStalled
                             ? 'Still working, server may be slow'
-                            : 'Generating',
+                            : hasCustomVerbs
+                                ? _spinnerVerbs.verbs[verbIndex]
+                                : 'Generating',
                         props.showGenerating && props.elapsedSeconds > 0
                             ? ` (${formatElapsedSeconds(props.elapsedSeconds)})`
-                            : ''))),
+                            : ''),
+                    React.createElement("div", { className: "nbi-sr-only", "aria-live": "polite", "aria-atomic": "true" }, props.isStalled
+                        ? 'Still working, server may be slow'
+                        : hasCustomVerbs
+                            ? _spinnerVerbs.verbs[verbIndex]
+                            : 'Generating'))),
             React.createElement("div", { className: "chat-message-timestamp" }, timestamp)),
         React.createElement("div", { className: "chat-message-content" },
             groupedContents.map((item, index) => {
@@ -487,6 +582,12 @@ function ChatResponse(props) {
                         // ✗ for error) rather than forcing a single rendering here.
                         return index === groupedContents.length - 1 &&
                             props.showGenerating ? (React.createElement("div", { className: "chat-response-progress", key: `key-${index}` }, item.content)) : null;
+                    case ResponseStreamDataType.ToolCall:
+                        // Unlike Progress, tool-call cards persist after the turn ends,
+                        // so they render regardless of `showGenerating`. The grouping
+                        // pass bundled this run's calls into content.toolCalls; the
+                        // group renders a single card or a collapsible group.
+                        return (React.createElement(ToolCallGroup, { key: `key-${index}`, toolCalls: item.content.toolCalls }));
                     case ResponseStreamDataType.Confirmation:
                         return answeredForms.get(item.id) ===
                             'confirmed' ? null : answeredForms.get(item.id) ===
@@ -540,8 +641,8 @@ function ChatResponse(props) {
             }),
             msg.notebookLink && (React.createElement("button", { type: "button", className: "copilot-generated-notebook-link", "data-ref": msg.notebookLink, "aria-label": `Open notebook ${msg.notebookLink}`, onClick: openNotebook }, "open notebook"))),
         msg.from === 'copilot' &&
-            !props.showGenerating &&
-            NBIAPI.config.chatFeedbackEnabled && (React.createElement("div", { className: "chat-message-feedback" },
+            (NBIAPI.config.chatFeedbackAlwaysVisible || !props.showGenerating) &&
+            NBIAPI.config.chatFeedbackEnabled && (React.createElement("div", { className: `chat-message-feedback${NBIAPI.config.chatFeedbackAlwaysVisible ? ' always-visible' : ''}` },
             React.createElement("button", { className: `chat-feedback-btn ${msg.feedback === 'positive' ? 'selected' : ''}`, onClick: () => {
                     var _a;
                     props.onFeedback(msg.id, 'positive');
@@ -558,7 +659,7 @@ function ChatResponse(props) {
                             }
                         });
                     }
-                }, "aria-label": "Rate as helpful", "aria-pressed": msg.feedback === 'positive', title: "Helpful" }, msg.feedback === 'positive' ? (React.createElement(VscThumbsupFilled, null)) : (React.createElement(VscThumbsup, null))),
+                }, "aria-label": "Rate response as good", "aria-pressed": msg.feedback === 'positive', title: "Good response" }, msg.feedback === 'positive' ? (React.createElement(VscThumbsupFilled, null)) : (React.createElement(VscThumbsup, null))),
             React.createElement("button", { className: `chat-feedback-btn ${msg.feedback === 'negative' ? 'selected' : ''}`, onClick: () => {
                     var _a;
                     props.onFeedback(msg.id, 'negative');
@@ -575,7 +676,7 @@ function ChatResponse(props) {
                             }
                         });
                     }
-                }, "aria-label": "Rate as unhelpful", "aria-pressed": msg.feedback === 'negative', title: "Not helpful" }, msg.feedback === 'negative' ? (React.createElement(VscThumbsdownFilled, null)) : (React.createElement(VscThumbsdown, null)))))));
+                }, "aria-label": "Rate response as bad", "aria-pressed": msg.feedback === 'negative', title: "Bad response" }, msg.feedback === 'negative' ? (React.createElement(VscThumbsdownFilled, null)) : (React.createElement(VscThumbsdown, null)))))));
 }
 const MemoizedChatResponse = memo(ChatResponse);
 async function submitCompletionRequest(request, responseEmitter) {
@@ -2123,21 +2224,29 @@ function SidebarComponent(props) {
                     }
                     if (delta['nbiContent']) {
                         const nbiContent = delta['nbiContent'];
-                        contents.push({
-                            id: UUID.uuid4(),
-                            type: nbiContent.type,
-                            content: nbiContent.content || '',
-                            reasoningContent: nbiContent.reasoning_content || '',
-                            reasoningTag: nbiContent.reasoning_content
-                                ? '<think>'
-                                : undefined,
-                            reasoningFinished: nbiContent.type === ResponseStreamDataType.Markdown &&
-                                nbiContent.reasoning_content
-                                ? true
-                                : false,
-                            contentDetail: nbiContent.detail,
-                            created: new Date(response.created)
-                        });
+                        if (nbiContent.type === ResponseStreamDataType.ToolCall) {
+                            // A tool call streams twice under one id (start, then finish);
+                            // merge by id so it stays one persistent card. See
+                            // upsertToolCallContent.
+                            upsertToolCallContent(contents, nbiContent.content, new Date(response.created));
+                        }
+                        else {
+                            contents.push({
+                                id: UUID.uuid4(),
+                                type: nbiContent.type,
+                                content: nbiContent.content || '',
+                                reasoningContent: nbiContent.reasoning_content || '',
+                                reasoningTag: nbiContent.reasoning_content
+                                    ? '<think>'
+                                    : undefined,
+                                reasoningFinished: nbiContent.type === ResponseStreamDataType.Markdown &&
+                                    nbiContent.reasoning_content
+                                    ? true
+                                    : false,
+                                contentDetail: nbiContent.detail,
+                                created: new Date(response.created)
+                            });
+                        }
                     }
                     else {
                         responseMessage =
@@ -2497,21 +2606,29 @@ function SidebarComponent(props) {
                     }
                     if (delta['nbiContent']) {
                         const nbiContent = delta['nbiContent'];
-                        contents.push({
-                            id: UUID.uuid4(),
-                            type: nbiContent.type,
-                            content: nbiContent.content || '',
-                            reasoningContent: nbiContent.reasoning_content || '',
-                            reasoningTag: nbiContent.reasoning_content
-                                ? '<think>'
-                                : undefined,
-                            reasoningFinished: nbiContent.type === ResponseStreamDataType.Markdown &&
-                                nbiContent.reasoning_content
-                                ? true
-                                : false,
-                            contentDetail: nbiContent.detail,
-                            created: new Date(response.created)
-                        });
+                        if (nbiContent.type === ResponseStreamDataType.ToolCall) {
+                            // A tool call streams twice under one id (start, then finish);
+                            // merge by id so it stays one persistent card. See
+                            // upsertToolCallContent.
+                            upsertToolCallContent(contents, nbiContent.content, new Date(response.created));
+                        }
+                        else {
+                            contents.push({
+                                id: UUID.uuid4(),
+                                type: nbiContent.type,
+                                content: nbiContent.content || '',
+                                reasoningContent: nbiContent.reasoning_content || '',
+                                reasoningTag: nbiContent.reasoning_content
+                                    ? '<think>'
+                                    : undefined,
+                                reasoningFinished: nbiContent.type === ResponseStreamDataType.Markdown &&
+                                    nbiContent.reasoning_content
+                                    ? true
+                                    : false,
+                                contentDetail: nbiContent.detail,
+                                created: new Date(response.created)
+                            });
+                        }
                     }
                     else {
                         const responseMessage = (_e = (_d = (_c = response.data['choices']) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d['delta']) === null || _e === void 0 ? void 0 : _e['content'];

package/lib/components/tool-call-card.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+export interface IToolCallDiffLine {
+    type: 'add' | 'remove' | 'context' | string;
+    content: string;
+}
+export interface IToolCallDiff {
+    path: string;
+    lines: IToolCallDiffLine[];
+    truncated?: boolean;
+}
+/**
+ * A single agent tool call surfaced as a persistent chat card. Mirrors the
+ * `ToolCallData` payload emitted by the server: it stays in the transcript
+ * after the turn ends and carries its final status, unlike the transient
+ * single progress line it replaces. File-edit tools also carry inline diffs.
+ */
+export interface IToolCall {
+    id: string;
+    title: string;
+    kind: 'read' | 'edit' | 'execute' | 'other' | string;
+    status: 'in_progress' | 'completed' | 'failed' | 'cancelled' | string;
+    diffs?: IToolCallDiff[];
+}
+export declare function ToolCallCard(props: {
+    toolCall: IToolCall;
+}): JSX.Element;

package/lib/components/tool-call-card.js

@@ -0,0 +1,54 @@
+import React, { useState } from 'react';
+import { VscChevronDown, VscChevronRight, VscClose, VscEdit, VscError, VscEye, VscPassFilled, VscSync, VscTerminal, VscTools } from '../icons';
+const KIND_ICONS = {
+    read: VscEye,
+    edit: VscEdit,
+    execute: VscTerminal,
+    other: VscTools
+};
+const STATUS_LABELS = {
+    in_progress: 'in progress',
+    completed: 'completed',
+    failed: 'failed',
+    cancelled: 'cancelled'
+};
+const GUTTER = { add: '+', remove: '-' };
+function ToolCallDiffView(props) {
+    return (React.createElement("div", { className: "nbi-tool-call-diffs" }, props.diffs.map((diff, i) => (React.createElement("div", { className: "nbi-tool-call-diff", key: i },
+        diff.path ? (React.createElement("div", { className: "nbi-tool-call-diff-path", title: diff.path }, diff.path)) : null,
+        React.createElement("div", { className: "nbi-tool-call-diff-body" }, diff.lines.map((line, j) => {
+            var _a;
+            return (React.createElement("div", { className: `nbi-tool-call-diff-line nbi-diff-${line.type}`, key: j },
+                React.createElement("span", { className: "nbi-diff-gutter", "aria-hidden": "true" }, (_a = GUTTER[line.type]) !== null && _a !== void 0 ? _a : ' '),
+                line.type === 'add' || line.type === 'remove' ? (React.createElement("span", { className: "nbi-sr-only" }, line.type === 'add' ? 'added ' : 'removed ')) : null,
+                React.createElement("span", { className: "nbi-diff-text" }, line.content)));
+        })),
+        diff.truncated ? (React.createElement("div", { className: "nbi-tool-call-diff-truncated" }, "diff truncated")) : null)))));
+}
+export function ToolCallCard(props) {
+    var _a, _b;
+    const { title, kind, status, diffs } = props.toolCall;
+    const [expanded, setExpanded] = useState(true);
+    const KindIcon = (_a = KIND_ICONS[kind]) !== null && _a !== void 0 ? _a : VscTools;
+    let StatusIcon = VscSync;
+    if (status === 'completed') {
+        StatusIcon = VscPassFilled;
+    }
+    else if (status === 'failed') {
+        StatusIcon = VscError;
+    }
+    else if (status === 'cancelled') {
+        StatusIcon = VscClose;
+    }
+    const statusLabel = (_b = STATUS_LABELS[status]) !== null && _b !== void 0 ? _b : status;
+    const statusModifier = status.replace(/_/g, '-');
+    const hasDiffs = Array.isArray(diffs) && diffs.length > 0;
+    return (React.createElement("div", { className: "nbi-tool-call-wrapper" },
+        React.createElement("div", { className: `nbi-tool-call nbi-tool-call-${statusModifier}` },
+            React.createElement(KindIcon, { className: "nbi-tool-call-kind-icon", "aria-hidden": "true" }),
+            React.createElement("span", { className: "nbi-tool-call-title", title: title }, title),
+            hasDiffs ? (React.createElement("button", { type: "button", className: "nbi-tool-call-diff-toggle", onClick: () => setExpanded(e => !e), "aria-expanded": expanded, "aria-label": expanded ? 'Hide diff' : 'Show diff' }, expanded ? (React.createElement(VscChevronDown, { "aria-hidden": "true" })) : (React.createElement(VscChevronRight, { "aria-hidden": "true" })))) : null,
+            React.createElement(StatusIcon, { className: "nbi-tool-call-status-icon", "aria-hidden": "true" }),
+            React.createElement("span", { className: "nbi-sr-only" }, statusLabel)),
+        hasDiffs && expanded ? React.createElement(ToolCallDiffView, { diffs: diffs }) : null));
+}

package/lib/components/tool-call-group.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { IToolCall } from './tool-call-card';
+/**
+ * Renders a run of consecutive tool calls. A single call is shown as a bare
+ * card; multiple calls are wrapped in one collapsible group with a summary
+ * header, so consecutive agent activity reads as one unit instead of a wall
+ * of rows.
+ */
+export declare function ToolCallGroup(props: {
+    toolCalls: IToolCall[];
+}): JSX.Element;

package/lib/components/tool-call-group.js

@@ -0,0 +1,33 @@
+import React, { useState } from 'react';
+import { VscChevronDown, VscChevronRight } from '../icons';
+import { ToolCallCard } from './tool-call-card';
+// Groups with more calls than this start collapsed so a tool-heavy turn (or a
+// reloaded transcript) doesn't flood the chat. A live turn mounts the group at
+// length 1, so it starts expanded and stays visible as calls stream in.
+const GROUP_COLLAPSE_THRESHOLD = 3;
+/**
+ * Renders a run of consecutive tool calls. A single call is shown as a bare
+ * card; multiple calls are wrapped in one collapsible group with a summary
+ * header, so consecutive agent activity reads as one unit instead of a wall
+ * of rows.
+ */
+export function ToolCallGroup(props) {
+    const { toolCalls } = props;
+    // Hooks must run unconditionally and in a stable order: the group's length
+    // grows as calls stream in, so call useState before any length branch.
+    // Start collapsed only for a large group whose calls are all settled --
+    // never hide a still-running or failed call (matters on transcript reload,
+    // where a group can mount already large).
+    const [expanded, setExpanded] = useState(() => toolCalls.length <= GROUP_COLLAPSE_THRESHOLD ||
+        toolCalls.some(t => t.status === 'in_progress' || t.status === 'failed'));
+    if (toolCalls.length <= 1) {
+        return toolCalls.length === 1 ? (React.createElement(ToolCallCard, { toolCall: toolCalls[0] })) : (React.createElement(React.Fragment, null));
+    }
+    const failed = toolCalls.filter(t => t.status === 'failed').length;
+    const summary = `${toolCalls.length} tool calls` + (failed ? ` (${failed} failed)` : '');
+    return (React.createElement("div", { className: "nbi-tool-call-group" },
+        React.createElement("button", { type: "button", className: "nbi-tool-call-group-header", onClick: () => setExpanded(e => !e), "aria-expanded": expanded },
+            expanded ? (React.createElement(VscChevronDown, { "aria-hidden": "true" })) : (React.createElement(VscChevronRight, { "aria-hidden": "true" })),
+            React.createElement("span", { className: "nbi-tool-call-group-summary" }, summary)),
+        expanded ? (React.createElement("div", { className: "nbi-tool-call-group-body" }, toolCalls.map(toolCall => (React.createElement(ToolCallCard, { key: toolCall.id, toolCall: toolCall }))))) : null));
+}

package/lib/icons.d.ts

@@ -17,6 +17,7 @@ export declare const VscClose: IconLike;
 export declare const VscCloudUpload: IconLike;
 export declare const VscCopy: IconLike;
 export declare const VscEdit: IconLike;
+export declare const VscError: IconLike;
 export declare const VscEye: IconLike;
 export declare const VscEyeClosed: IconLike;
 export declare const VscFile: IconLike;
@@ -31,6 +32,8 @@ export declare const VscSend: IconLike;
 export declare const VscSettingsGear: IconLike;
 export declare const VscSparkle: IconLike;
 export declare const VscStopCircle: IconLike;
+export declare const VscSync: IconLike;
+export declare const VscTerminal: IconLike;
 export declare const VscThumbsdown: IconLike;
 export declare const VscThumbsdownFilled: IconLike;
 export declare const VscThumbsup: IconLike;

package/lib/icons.js

@@ -27,6 +27,7 @@ export const VscClose = asIcon(Vsc.VscClose);
 export const VscCloudUpload = asIcon(Vsc.VscCloudUpload);
 export const VscCopy = asIcon(Vsc.VscCopy);
 export const VscEdit = asIcon(Vsc.VscEdit);
+export const VscError = asIcon(Vsc.VscError);
 export const VscEye = asIcon(Vsc.VscEye);
 export const VscEyeClosed = asIcon(Vsc.VscEyeClosed);
 export const VscFile = asIcon(Vsc.VscFile);
@@ -41,6 +42,8 @@ export const VscSend = asIcon(Vsc.VscSend);
 export const VscSettingsGear = asIcon(Vsc.VscSettingsGear);
 export const VscSparkle = asIcon(Vsc.VscSparkle);
 export const VscStopCircle = asIcon(Vsc.VscStopCircle);
+export const VscSync = asIcon(Vsc.VscSync);
+export const VscTerminal = asIcon(Vsc.VscTerminal);
 export const VscThumbsdown = asIcon(Vsc.VscThumbsdown);
 export const VscThumbsdownFilled = asIcon(Vsc.VscThumbsdownFilled);
 export const VscThumbsup = asIcon(Vsc.VscThumbsup);

package/lib/index.js

@@ -36,7 +36,7 @@ import sparklesWarningSvgstr from '../style/icons/sparkles-warning.svg';
 import claudeSvgstr from '../style/icons/claude.svg';
 import openaiSvgstr from '../style/icons/openai.svg';
 import opencodeSvgstr from '../style/icons/opencode.svg';
-import { applyCodeToSelectionInEditor, cellOutputAsText, cellOutputHasError, chooseWorkspaceDirectory, compareSelections, extractLLMGeneratedCode, getSelectionInEditor, getTokenCount, getWholeNotebookContent, isSelectionEmpty, markdownToComment, waitForDuration } from './utils';
+import { applyCodeToSelectionInEditor, cellOutputAsText, cellOutputHasError, chooseWorkspaceDirectory, compareSelections, buildResumeCommand, extractLLMGeneratedCode, getSelectionInEditor, getTokenCount, getWholeNotebookContent, isSelectionEmpty, markdownToComment, waitForDuration } from './utils';
 import { cellOutputAsContextBundle } from './cell-output-bundle';
 import { UUID } from '@lumino/coreutils';
 import * as path from 'path';
@@ -1108,11 +1108,9 @@ const plugin = {
                     render() {
                         return React.createElement(LauncherPicker, {
                             onSessionSelected: (session) => {
+                                var _a;
                                 dialog.close();
-                                const cmd = session.cwd
-                                    ? `cd ${session.cwd} && claude --resume ${session.session_id}`
-                                    : `claude --resume ${session.session_id}`;
-                                launchCliInTerminal(cmd);
+                                launchCliInTerminal(buildResumeCommand((_a = session.cwd) !== null && _a !== void 0 ? _a : '', session.session_id));
                             }
                         });
                     }
@@ -1360,7 +1358,7 @@ const plugin = {
                     metadata: { trusted: true },
                     source: args.source
                 });
-                return true;
+                return { cellIndex: newCellIndex };
             }
         });
         app.commands.addCommand(CommandIDs.addCodeCellToActiveNotebook, {
@@ -1378,7 +1376,7 @@ const plugin = {
                     metadata: { trusted: true },
                     source: args.source
                 });
-                return true;
+                return { cellIndex: newCellIndex };
             }
         });
         app.commands.addCommand(CommandIDs.getCellTypeAndSource, {

package/lib/tokens.d.ts

@@ -41,6 +41,7 @@ export declare enum ResponseStreamDataType {
     Button = "button",
     Anchor = "anchor",
     Progress = "progress",
+    ToolCall = "tool-call",
     Confirmation = "confirmation",
     AskUserQuestion = "ask-user-question"
 }

package/lib/tokens.js

@@ -32,6 +32,7 @@ export var ResponseStreamDataType;
     ResponseStreamDataType["Button"] = "button";
     ResponseStreamDataType["Anchor"] = "anchor";
     ResponseStreamDataType["Progress"] = "progress";
+    ResponseStreamDataType["ToolCall"] = "tool-call";
     ResponseStreamDataType["Confirmation"] = "confirmation";
     ResponseStreamDataType["AskUserQuestion"] = "ask-user-question";
 })(ResponseStreamDataType || (ResponseStreamDataType = {}));

package/lib/tool-call-stream.d.ts

@@ -0,0 +1,24 @@
+import { ResponseStreamDataType } from './tokens';
+/**
+ * The subset of a chat message's stream-content item this helper needs. A
+ * structural subset of `IChatMessageContent` (defined in chat-sidebar) so it
+ * can be unit-tested without importing the sidebar (and creating a cycle).
+ */
+export interface IToolCallStreamItem {
+    id: string;
+    type: ResponseStreamDataType;
+    content: any;
+    created: Date;
+}
+/**
+ * Merge a streamed tool-call payload into `contents` by its tool-call id.
+ *
+ * A tool call streams twice under one id (once when it starts, once when it
+ * finishes). The first emission pushes a new card; the second updates that
+ * card's content (its status) in place, so the call stays a single persistent
+ * row rather than appending a duplicate. Mutates `contents`.
+ */
+export declare function upsertToolCallContent(contents: IToolCallStreamItem[], content: {
+    id: string;
+    [key: string]: any;
+}, created: Date): void;

package/lib/tool-call-stream.js

@@ -0,0 +1,28 @@
+import { UUID } from '@lumino/coreutils';
+import { ResponseStreamDataType } from './tokens';
+/**
+ * Merge a streamed tool-call payload into `contents` by its tool-call id.
+ *
+ * A tool call streams twice under one id (once when it starts, once when it
+ * finishes). The first emission pushes a new card; the second updates that
+ * card's content (its status) in place, so the call stays a single persistent
+ * row rather than appending a duplicate. Mutates `contents`.
+ */
+export function upsertToolCallContent(contents, content, created) {
+    const existing = contents.find(c => {
+        var _a;
+        return c.type === ResponseStreamDataType.ToolCall &&
+            ((_a = c.content) === null || _a === void 0 ? void 0 : _a.id) === (content === null || content === void 0 ? void 0 : content.id);
+    });
+    if (existing) {
+        existing.content = content;
+    }
+    else {
+        contents.push({
+            id: UUID.uuid4(),
+            type: ResponseStreamDataType.ToolCall,
+            content,
+            created
+        });
+    }
+}

package/lib/utils.js

@@ -341,10 +341,11 @@ export function safeAnchorUri(uri) {
  * user happens to be in the JupyterLab working directory.
  */
 export function buildResumeCommand(cwd, sessionId) {
+    const quotedSessionId = shellSingleQuote(sessionId);
     if (!cwd) {
-        return `claude --resume ${sessionId}`;
+        return `claude --resume ${quotedSessionId}`;
     }
-    return `cd ${shellSingleQuote(cwd)} && claude --resume ${sessionId}`;
+    return `cd ${shellSingleQuote(cwd)} && claude --resume ${quotedSessionId}`;
 }
 /**
  * Write `text` to the system clipboard. Falls back to a hidden textarea +