jupyterlab_ai_code_assistants_extension 1.2.47 → 1.2.50

package/README.md

@@ -47,7 +47,7 @@ Chat-panel extensions re-implement the agent loop and trail the real tool. This
 - **Conflict-safe upgrade** - if a retired standalone extension is still installed, its panel wins and this extension stands down for that assistant instead of showing a duplicate
 - **DeepSeek in the browser** - the DeepSeek Harness has no terminal chat; its panel lists the projects under `~/.dsh/sessions` (or `$DSH_HOME`) and `Open Web UI` starts `dsh --profile web --no-open --port 0` in the project's terminal, which prints the URL to open. The conversation is then chosen in the harness's own browser UI; branching and deleting work from the panel as for every other assistant. The URL is on the machine running JupyterLab, so a remote server needs a port forward to reach it
 - **Auto-disabled when absent** - an assistant whose CLI is not on `PATH` does not show a panel
-- **Open Callback** - when an assistant's login sends your browser to an `http://127.0.0.1:...` link that fails to load, because the login is waiting on the machine running JupyterLab, run `Open Callback` from the command palette and paste the link; the Jupyter server requests it for you. Only `http` links to that machine's own loopback are accepted
+- **Open Callback** - when an assistant's login sends your browser to an `http://127.0.0.1:...` link that fails to load, because the login is waiting on the machine running JupyterLab, run `Open Callback` from the command palette and paste the link; the Jupyter server requests it for you, and the popup says whether the login accepted it. Only `http` links to that machine's own loopback are accepted
 
 ## Requirements
 

package/lib/core/callback.js

@@ -1,7 +1,103 @@
-import { InputDialog, Notification } from '@jupyterlab/apputils';
+import { Dialog, Notification } from '@jupyterlab/apputils';
+import { Widget } from '@lumino/widgets';
 import { requestAPI } from './request';
 /** The command that delivers a pasted login callback link. */
 export const CALLBACK_COMMAND = 'open:callback';
+async function deliver(url, app, trans) {
+    try {
+        const answer = await requestAPI('callback', app.serviceManager.serverSettings, { method: 'POST', body: JSON.stringify({ url }) });
+        return answer.status < 400
+            ? {
+                level: 'success',
+                message: trans.__('The login accepted the link. Check the terminal where the login is running.')
+            }
+            : {
+                level: 'warning',
+                message: trans.__('The login did not accept this link. Start the login again and paste the new link.')
+            };
+    }
+    catch (err) {
+        const code = err instanceof Error ? err.message : '';
+        return {
+            level: 'error',
+            message: code === 'callback_not_loopback'
+                ? trans.__('This link cannot be used. It must start with http://127.0.0.1 or http://localhost.')
+                : code === 'callback_unreachable'
+                    ? trans.__('No login is waiting for this link. Start the login again and paste the new link.')
+                    : trans.__('The link could not be sent to the Jupyter server. Try again.')
+        };
+    }
+}
+/** The popup's body: the link field and, below it, what the last send came
+ * to. */
+class CallbackForm extends Widget {
+    constructor(trans) {
+        super();
+        this.addClass('jp-AiAssistantsCallback');
+        const label = document.createElement('label');
+        label.textContent = trans.__('Callback link from the browser address bar');
+        this._input = document.createElement('input');
+        this._input.type = 'text';
+        this._input.className = 'jp-mod-styled';
+        this._input.placeholder = 'http://127.0.0.1:1455/auth/callback?code=...';
+        label.appendChild(this._input);
+        this._status = document.createElement('div');
+        this._status.className = 'jp-AiAssistantsCallback-status';
+        this._status.setAttribute('role', 'status');
+        this.node.append(label, this._status);
+    }
+    get url() {
+        return this._input.value.trim();
+    }
+    report(level, message) {
+        this._status.dataset.level = level;
+        this._status.textContent = message;
+    }
+}
+/** OK sends the link and leaves the window open, so the result is read - and
+ * a refused link replaced - in the same place. Close and Escape end it. */
+class CallbackDialog extends Dialog {
+    constructor(_form, _send, _trans) {
+        super({
+            title: _trans.__('Open Callback'),
+            body: _form,
+            buttons: [
+                Dialog.cancelButton({ label: _trans.__('Close') }),
+                Dialog.okButton({ label: _trans.__('OK') })
+            ],
+            defaultButton: 1,
+            focusNodeSelector: 'input'
+        });
+        this._form = _form;
+        this._send = _send;
+        this._trans = _trans;
+        this._sending = false;
+    }
+    resolve(index) {
+        if (index === 0) {
+            super.resolve(index);
+            return;
+        }
+        void this._deliver();
+    }
+    async _deliver() {
+        const url = this._form.url;
+        if (this._sending) {
+            return;
+        }
+        if (!url) {
+            this._form.report('error', this._trans.__('Paste the link first.'));
+            return;
+        }
+        this._sending = true;
+        this._form.report('pending', this._trans.__('Sending the link...'));
+        const outcome = await this._send(url);
+        this._sending = false;
+        if (!this.isDisposed) {
+            this._form.report(outcome.level, outcome.message);
+        }
+    }
+}
 /**
  * Register the command that sends a pasted login callback link to the login
  * waiting on the Jupyter server.
@@ -21,44 +117,23 @@ export function addCallbackCommand(app, palette, category, trans) {
                 properties: {
                     url: {
                         type: 'string',
-                        description: 'The callback link. Asked for in a dialog when absent.'
+                        description: 'The callback link. Asked for in a popup when absent.'
                     }
                 }
             }
         },
         execute: async (args) => {
-            var _a;
-            let url = typeof args.url === 'string' ? args.url.trim() : '';
-            if (!url) {
-                const asked = await InputDialog.getText({
-                    title: trans.__('Open Callback'),
-                    label: trans.__('Callback link from the browser address bar'),
-                    placeholder: 'http://127.0.0.1:1455/auth/callback?code=...'
+            const send = (url) => deliver(url, app, trans);
+            const given = typeof args.url === 'string' ? args.url.trim() : '';
+            if (given) {
+                // No popup to write into, so the result is a toast.
+                const outcome = await send(given);
+                Notification[outcome.level](outcome.message, {
+                    autoClose: outcome.level === 'success' ? 4000 : 8000
                 });
-                url = asked.button.accept ? ((_a = asked.value) !== null && _a !== void 0 ? _a : '').trim() : '';
-                if (!url) {
-                    return;
-                }
-            }
-            try {
-                const answer = await requestAPI('callback', app.serviceManager.serverSettings, { method: 'POST', body: JSON.stringify({ url }) });
-                if (answer.status < 400) {
-                    Notification.success(trans.__('Callback delivered - the login answered HTTP %1.', answer.status), { autoClose: 4000 });
-                }
-                else {
-                    Notification.warning(trans.__('The login refused the callback (HTTP %1). Start the login again and paste the new link.', answer.status), { autoClose: 8000 });
-                }
-            }
-            catch (err) {
-                // The server's own codes, never the link: it carries a login code.
-                const code = err instanceof Error ? err.message : String(err);
-                const message = code === 'callback_not_loopback'
-                    ? trans.__('Only an http link to 127.0.0.1 or localhost can be opened.')
-                    : code === 'callback_unreachable'
-                        ? trans.__('No login is waiting at that address. Start the login again and paste the new link.')
-                        : trans.__('Could not open the callback: %1', code);
-                Notification.error(message, { autoClose: 8000 });
+                return;
             }
+            await new CallbackDialog(new CallbackForm(trans), send, trans).launch();
         }
     });
     palette === null || palette === void 0 ? void 0 : palette.addItem({ command: CALLBACK_COMMAND, category });

package/lib/core/icons.js

@@ -103,15 +103,16 @@ export const filterIcon = new LabIcon({
     name: `${ICON_PREFIX}:filter`,
     svgstr: filterSvgStr
 });
-// Row status mark - one filled circle, drawn for a conversation that is live
-// or under remote control. An SVG rather than a rounded span so its colour is
-// a CSS `fill` on the circle itself, the way every other glyph here is
-// recoloured through its class (DEF-PANE-174). The circle carries no `fill`
-// attribute: the stylesheet is the single source of that colour, and a
-// presentation attribute here would be a second one to keep in step
-// (DEF-PANE-179).
+// Row status mark - a light, drawn for a conversation that is live or under
+// remote control: a 6px circle over the 8px disc that casts its halo. An SVG
+// rather than a rounded span so each colour is a CSS `fill` on the circle
+// itself, the way every other glyph here is recoloured through its class
+// (DEF-PANE-174). The circles carry no `fill` attribute: the stylesheet is the
+// single source of those colours, and a presentation attribute here would be
+// a second one to keep in step (DEF-PANE-179).
 const statusDotSvgStr = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" width="16" height="16">
-  <circle class="jp-AiAssistantsPanel-dotGlyph" cx="8" cy="8" r="8"/>
+  <circle class="jp-AiAssistantsPanel-dotHalo" cx="8" cy="8" r="8"/>
+  <circle class="jp-AiAssistantsPanel-dotGlyph" cx="8" cy="8" r="6"/>
 </svg>`;
 export const statusDotIcon = new LabIcon({
     name: `${ICON_PREFIX}:status-dot`,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterlab_ai_code_assistants_extension",
-    "version": "1.2.47",
+    "version": "1.2.50",
     "description": "A full launcher and manager for every AI code assistant in JupyterLab - Claude Code, Codex, Kimi, Gemini and DeepSeek. Start, resume, fork, switch, and clean up CLI sessions from a side panel per assistant - one click lands you in the right terminal with the assistant already running, no duplicate tabs, no UUID hunting.",
     "keywords": [
         "jupyter",

package/src/__tests__/callback.spec.ts

@@ -18,7 +18,7 @@ jest.mock('../core/request', () => ({
   requestAPI: jest.fn()
 }));
 
-import { InputDialog, Notification } from '@jupyterlab/apputils';
+import { Notification } from '@jupyterlab/apputils';
 import { nullTranslator } from '@jupyterlab/translation';
 import { CommandRegistry } from '@lumino/commands';
 
@@ -28,6 +28,10 @@ import { requestAPI } from '../core/request';
 const request = requestAPI as jest.Mock;
 const LINK = 'http://127.0.0.1:1455/auth/callback?code=one-time&state=s';
 
+/** One macrotask: `Dialog.launch` attaches the popup after its own awaits. */
+const settle = (): Promise<void> =>
+  new Promise(resolve => setTimeout(resolve, 0));
+
 function setup(): {
   commands: CommandRegistry;
   added: { command: string; category: string }[];
@@ -45,21 +49,56 @@ function setup(): {
   return { commands, added, serverSettings };
 }
 
+interface IPopup {
+  /** Settles when the popup has closed. */
+  closed: Promise<unknown>;
+  input: HTMLInputElement;
+  status: HTMLElement;
+  ok: HTMLElement;
+  close: HTMLElement;
+}
+
+async function openPopup(commands: CommandRegistry): Promise<IPopup> {
+  const closed = commands.execute(CALLBACK_COMMAND);
+  await settle();
+  const node = document.querySelector('.jp-Dialog') as HTMLElement;
+  return {
+    closed,
+    input: node.querySelector(
+      '.jp-AiAssistantsCallback input'
+    ) as HTMLInputElement,
+    status: node.querySelector(
+      '.jp-AiAssistantsCallback-status'
+    ) as HTMLElement,
+    ok: node.querySelector('.jp-mod-accept') as HTMLElement,
+    close: node.querySelector('.jp-mod-reject') as HTMLElement
+  };
+}
+
+/** No status code, no server error code and never the link, which carries a
+ * login code. */
+function expectPlainWords(text: string): void {
+  expect(text).not.toMatch(
+    /callback_|HTTP|\b[45]\d\d\b|Internal Server Error|one-time/
+  );
+}
+
 describe('the Open Callback command', () => {
   let success: jest.SpyInstance;
-  let warning: jest.SpyInstance;
   let error: jest.SpyInstance;
-  let dialog: jest.SpyInstance;
 
   beforeEach(() => {
     request.mockReset();
     success = jest.spyOn(Notification, 'success').mockReturnValue('' as any);
-    warning = jest.spyOn(Notification, 'warning').mockReturnValue('' as any);
     error = jest.spyOn(Notification, 'error').mockReturnValue('' as any);
-    dialog = jest.spyOn(InputDialog, 'getText');
   });
 
-  afterEach(() => {
+  afterEach(async () => {
+    // A popup left open would hold every later one in JupyterLab's queue.
+    (
+      document.querySelector('.jp-Dialog .jp-mod-reject') as HTMLElement
+    )?.click();
+    await settle();
     jest.restoreAllMocks();
   });
 
@@ -83,75 +122,137 @@ describe('the Open Callback command', () => {
     expect(commands.hasCommand(CALLBACK_COMMAND)).toBe(true);
   });
 
-  it('asks for the link in a popup and posts it, trimmed, to the server', async () => {
+  it('OK sends the trimmed link and writes the result under the field, window still open', async () => {
     const { commands, serverSettings } = setup();
-    dialog.mockResolvedValue({
-      button: { accept: true },
-      value: `  ${LINK}\n`
-    } as any);
     request.mockResolvedValue({ status: 302 });
+    const popup = await openPopup(commands);
 
-    await commands.execute(CALLBACK_COMMAND);
+    popup.input.value = `  ${LINK}\n`;
+    popup.ok.click();
+    await settle();
 
-    expect(dialog).toHaveBeenCalledTimes(1);
     expect(request).toHaveBeenCalledWith('callback', serverSettings, {
       method: 'POST',
       body: JSON.stringify({ url: LINK })
     });
-    expect(success).toHaveBeenCalledTimes(1);
-    expect(String(success.mock.calls[0][0])).toContain('302');
+    expect(popup.status.dataset.level).toBe('success');
+    expect(popup.status.textContent).toContain('The login accepted the link');
+    expectPlainWords(popup.status.textContent ?? '');
+    // Read in the popup, not in a toast, and the popup is still there.
+    expect(success).not.toHaveBeenCalled();
+    expect(document.querySelector('.jp-Dialog')).not.toBeNull();
+
+    popup.close.click();
+    await popup.closed;
+    expect(document.querySelector('.jp-Dialog')).toBeNull();
   });
 
-  it('takes the link as an argument without a popup', async () => {
+  it('Enter in the field sends, as OK does', async () => {
     const { commands } = setup();
     request.mockResolvedValue({ status: 200 });
+    const popup = await openPopup(commands);
 
-    await commands.execute(CALLBACK_COMMAND, { url: LINK });
+    popup.input.value = LINK;
+    popup.input.dispatchEvent(
+      new KeyboardEvent('keydown', { key: 'Enter', bubbles: true })
+    );
+    await settle();
 
-    expect(dialog).not.toHaveBeenCalled();
     expect(request).toHaveBeenCalledTimes(1);
-    expect(success).toHaveBeenCalledTimes(1);
+    expect(popup.status.dataset.level).toBe('success');
   });
 
-  it.each([
-    ['cancelled', { button: { accept: false }, value: LINK }],
-    ['left empty', { button: { accept: true }, value: '   ' }]
-  ])('sends nothing when the popup is %s', async (_name, answer) => {
+  it('a refused link is replaced and sent again in the same window', async () => {
+    const { commands } = setup();
+    request
+      .mockRejectedValueOnce(new Error('callback_unreachable'))
+      .mockResolvedValueOnce({ status: 302 });
+    const popup = await openPopup(commands);
+
+    popup.input.value = LINK;
+    popup.ok.click();
+    await settle();
+    expect(popup.status.dataset.level).toBe('error');
+
+    popup.input.value = LINK.replace('one-time', 'second');
+    popup.ok.click();
+    await settle();
+    expect(request).toHaveBeenCalledTimes(2);
+    expect(popup.status.dataset.level).toBe('success');
+  });
+
+  it('OK on an empty field sends nothing and says so', async () => {
     const { commands } = setup();
-    dialog.mockResolvedValue(answer as any);
+    const popup = await openPopup(commands);
 
-    await commands.execute(CALLBACK_COMMAND);
+    popup.input.value = '   ';
+    popup.ok.click();
+    await settle();
 
     expect(request).not.toHaveBeenCalled();
-    expect(success).not.toHaveBeenCalled();
-    expect(error).not.toHaveBeenCalled();
+    expect(popup.status.textContent).toBe('Paste the link first.');
   });
 
-  it('says so when the login refused the callback', async () => {
+  it('Close sends nothing', async () => {
     const { commands } = setup();
-    request.mockResolvedValue({ status: 400 });
+    const popup = await openPopup(commands);
 
-    await commands.execute(CALLBACK_COMMAND, { url: LINK });
+    popup.input.value = LINK;
+    popup.close.click();
+    await popup.closed;
 
-    expect(success).not.toHaveBeenCalled();
-    expect(warning).toHaveBeenCalledTimes(1);
-    expect(String(warning.mock.calls[0][0])).toContain('400');
+    expect(request).not.toHaveBeenCalled();
+    expect(document.querySelector('.jp-Dialog')).toBeNull();
   });
 
   it.each([
-    ['callback_not_loopback', '127.0.0.1'],
-    ['callback_unreachable', 'No login is waiting'],
-    ['Internal Server Error', 'Internal Server Error']
-  ])('reports %s without repeating the link', async (code, expected) => {
+    [
+      'the login answers with an error',
+      () => Promise.resolve({ status: 400 }),
+      'warning',
+      'The login did not accept this link'
+    ],
+    [
+      'the link is not a loopback link',
+      () => Promise.reject(new Error('callback_not_loopback')),
+      'error',
+      'It must start with http://127.0.0.1 or http://localhost'
+    ],
+    [
+      'no login is listening',
+      () => Promise.reject(new Error('callback_unreachable')),
+      'error',
+      'No login is waiting for this link'
+    ],
+    [
+      'the server fails',
+      () => Promise.reject(new Error('Internal Server Error')),
+      'error',
+      'The link could not be sent to the Jupyter server'
+    ]
+  ])('says in plain words that %s', async (_case, answer, level, expected) => {
     const { commands } = setup();
-    request.mockRejectedValue(new Error(code));
+    request.mockImplementation(answer);
+    const popup = await openPopup(commands);
+
+    popup.input.value = LINK;
+    popup.ok.click();
+    await settle();
+
+    expect(popup.status.dataset.level).toBe(level);
+    expect(popup.status.textContent).toContain(expected);
+    expectPlainWords(popup.status.textContent ?? '');
+  });
+
+  it('given the link as an argument, opens no popup and reports in a toast', async () => {
+    const { commands } = setup();
+    request.mockRejectedValue(new Error('callback_unreachable'));
 
     await commands.execute(CALLBACK_COMMAND, { url: LINK });
 
+    expect(document.querySelector('.jp-Dialog')).toBeNull();
+    expect(request).toHaveBeenCalledTimes(1);
     expect(error).toHaveBeenCalledTimes(1);
-    const message = String(error.mock.calls[0][0]);
-    expect(message).toContain(expected);
-    // The link carries a login code.
-    expect(message).not.toContain('one-time');
+    expectPlainWords(String(error.mock.calls[0][0]));
   });
 });

package/src/core/callback.ts

@@ -1,16 +1,145 @@
 import { JupyterFrontEnd } from '@jupyterlab/application';
-import {
-  ICommandPalette,
-  InputDialog,
-  Notification
-} from '@jupyterlab/apputils';
+import { Dialog, ICommandPalette, Notification } from '@jupyterlab/apputils';
 import { TranslationBundle } from '@jupyterlab/translation';
+import { Widget } from '@lumino/widgets';
 
 import { requestAPI } from './request';
 
 /** The command that delivers a pasted login callback link. */
 export const CALLBACK_COMMAND = 'open:callback';
 
+/** What a delivery came to, in words for the user. Never the link, which
+ * carries a login code, and never a status code. */
+interface IOutcome {
+  level: 'success' | 'warning' | 'error';
+  message: string;
+}
+
+async function deliver(
+  url: string,
+  app: JupyterFrontEnd,
+  trans: TranslationBundle
+): Promise<IOutcome> {
+  try {
+    const answer = await requestAPI<{ status: number }>(
+      'callback',
+      app.serviceManager.serverSettings,
+      { method: 'POST', body: JSON.stringify({ url }) }
+    );
+    return answer.status < 400
+      ? {
+          level: 'success',
+          message: trans.__(
+            'The login accepted the link. Check the terminal where the login is running.'
+          )
+        }
+      : {
+          level: 'warning',
+          message: trans.__(
+            'The login did not accept this link. Start the login again and paste the new link.'
+          )
+        };
+  } catch (err) {
+    const code = err instanceof Error ? err.message : '';
+    return {
+      level: 'error',
+      message:
+        code === 'callback_not_loopback'
+          ? trans.__(
+              'This link cannot be used. It must start with http://127.0.0.1 or http://localhost.'
+            )
+          : code === 'callback_unreachable'
+            ? trans.__(
+                'No login is waiting for this link. Start the login again and paste the new link.'
+              )
+            : trans.__(
+                'The link could not be sent to the Jupyter server. Try again.'
+              )
+    };
+  }
+}
+
+/** The popup's body: the link field and, below it, what the last send came
+ * to. */
+class CallbackForm extends Widget {
+  constructor(trans: TranslationBundle) {
+    super();
+    this.addClass('jp-AiAssistantsCallback');
+    const label = document.createElement('label');
+    label.textContent = trans.__('Callback link from the browser address bar');
+    this._input = document.createElement('input');
+    this._input.type = 'text';
+    this._input.className = 'jp-mod-styled';
+    this._input.placeholder = 'http://127.0.0.1:1455/auth/callback?code=...';
+    label.appendChild(this._input);
+    this._status = document.createElement('div');
+    this._status.className = 'jp-AiAssistantsCallback-status';
+    this._status.setAttribute('role', 'status');
+    this.node.append(label, this._status);
+  }
+
+  get url(): string {
+    return this._input.value.trim();
+  }
+
+  report(level: IOutcome['level'] | 'pending', message: string): void {
+    this._status.dataset.level = level;
+    this._status.textContent = message;
+  }
+
+  private _input: HTMLInputElement;
+  private _status: HTMLDivElement;
+}
+
+/** OK sends the link and leaves the window open, so the result is read - and
+ * a refused link replaced - in the same place. Close and Escape end it. */
+class CallbackDialog extends Dialog<void> {
+  constructor(
+    private _form: CallbackForm,
+    private _send: (url: string) => Promise<IOutcome>,
+    private _trans: TranslationBundle
+  ) {
+    super({
+      title: _trans.__('Open Callback'),
+      body: _form,
+      buttons: [
+        Dialog.cancelButton({ label: _trans.__('Close') }),
+        Dialog.okButton({ label: _trans.__('OK') })
+      ],
+      defaultButton: 1,
+      focusNodeSelector: 'input'
+    });
+  }
+
+  resolve(index?: number): void {
+    if (index === 0) {
+      super.resolve(index);
+      return;
+    }
+    void this._deliver();
+  }
+
+  private async _deliver(): Promise<void> {
+    const url = this._form.url;
+    if (this._sending) {
+      return;
+    }
+    if (!url) {
+      this._form.report('error', this._trans.__('Paste the link first.'));
+      return;
+    }
+    this._sending = true;
+    this._form.report('pending', this._trans.__('Sending the link...'));
+    const outcome = await this._send(url);
+    this._sending = false;
+    if (!this.isDisposed) {
+      this._form.report(outcome.level, outcome.message);
+    }
+  }
+
+  private _sending = false;
+}
+
 /**
  * Register the command that sends a pasted login callback link to the login
  * waiting on the Jupyter server.
@@ -37,62 +166,23 @@ export function addCallbackCommand(
         properties: {
           url: {
             type: 'string',
-            description: 'The callback link. Asked for in a dialog when absent.'
+            description: 'The callback link. Asked for in a popup when absent.'
           }
         }
       }
     },
     execute: async args => {
-      let url = typeof args.url === 'string' ? args.url.trim() : '';
-      if (!url) {
-        const asked = await InputDialog.getText({
-          title: trans.__('Open Callback'),
-          label: trans.__('Callback link from the browser address bar'),
-          placeholder: 'http://127.0.0.1:1455/auth/callback?code=...'
+      const send = (url: string): Promise<IOutcome> => deliver(url, app, trans);
+      const given = typeof args.url === 'string' ? args.url.trim() : '';
+      if (given) {
+        // No popup to write into, so the result is a toast.
+        const outcome = await send(given);
+        Notification[outcome.level](outcome.message, {
+          autoClose: outcome.level === 'success' ? 4000 : 8000
         });
-        url = asked.button.accept ? (asked.value ?? '').trim() : '';
-        if (!url) {
-          return;
-        }
-      }
-      try {
-        const answer = await requestAPI<{ status: number }>(
-          'callback',
-          app.serviceManager.serverSettings,
-          { method: 'POST', body: JSON.stringify({ url }) }
-        );
-        if (answer.status < 400) {
-          Notification.success(
-            trans.__(
-              'Callback delivered - the login answered HTTP %1.',
-              answer.status
-            ),
-            { autoClose: 4000 }
-          );
-        } else {
-          Notification.warning(
-            trans.__(
-              'The login refused the callback (HTTP %1). Start the login again and paste the new link.',
-              answer.status
-            ),
-            { autoClose: 8000 }
-          );
-        }
-      } catch (err) {
-        // The server's own codes, never the link: it carries a login code.
-        const code = err instanceof Error ? err.message : String(err);
-        const message =
-          code === 'callback_not_loopback'
-            ? trans.__(
-                'Only an http link to 127.0.0.1 or localhost can be opened.'
-              )
-            : code === 'callback_unreachable'
-              ? trans.__(
-                  'No login is waiting at that address. Start the login again and paste the new link.'
-                )
-              : trans.__('Could not open the callback: %1', code);
-        Notification.error(message, { autoClose: 8000 });
+        return;
       }
+      await new CallbackDialog(new CallbackForm(trans), send, trans).launch();
     }
   });
   palette?.addItem({ command: CALLBACK_COMMAND, category });

package/src/core/icons.ts

@@ -126,15 +126,16 @@ export const filterIcon = new LabIcon({
   svgstr: filterSvgStr
 });
 
-// Row status mark - one filled circle, drawn for a conversation that is live
-// or under remote control. An SVG rather than a rounded span so its colour is
-// a CSS `fill` on the circle itself, the way every other glyph here is
-// recoloured through its class (DEF-PANE-174). The circle carries no `fill`
-// attribute: the stylesheet is the single source of that colour, and a
-// presentation attribute here would be a second one to keep in step
-// (DEF-PANE-179).
+// Row status mark - a light, drawn for a conversation that is live or under
+// remote control: a 6px circle over the 8px disc that casts its halo. An SVG
+// rather than a rounded span so each colour is a CSS `fill` on the circle
+// itself, the way every other glyph here is recoloured through its class
+// (DEF-PANE-174). The circles carry no `fill` attribute: the stylesheet is the
+// single source of those colours, and a presentation attribute here would be
+// a second one to keep in step (DEF-PANE-179).
 const statusDotSvgStr = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16" width="16" height="16">
-  <circle class="jp-AiAssistantsPanel-dotGlyph" cx="8" cy="8" r="8"/>
+  <circle class="jp-AiAssistantsPanel-dotHalo" cx="8" cy="8" r="8"/>
+  <circle class="jp-AiAssistantsPanel-dotGlyph" cx="8" cy="8" r="6"/>
 </svg>`;
 
 export const statusDotIcon = new LabIcon({

package/style/base.css

@@ -394,6 +394,15 @@
   fill: var(--jp-success-color1);
 }
 
+/* The 8px disc behind the 6px light. It is what casts the halo, so the halo
+   keeps the size it had when the light itself was 8px; fully opaque for that
+   reason, since a shadow is cast by alpha. The 1px of it that shows around the
+   light is painted as the halo looks at that point - the glow colour, dimmed -
+   so it reads as the halo's inner edge and not as a second dot. */
+.jp-AiAssistantsPanel-dotHalo {
+  fill: color-mix(in srgb, var(--jp-success-color1) 65%, black);
+}
+
 /* Light themes take a different dot, because both halves of the one above stop
    working there. JupyterLab stamps the theme's own `isLight` onto the body, so
    the switch is CSS and no TypeScript sees it.
@@ -426,6 +435,12 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotGlyph {
   fill: var(--md-green-500);
 }
 
+/* The mint ring's own colour: three passes saturate the ring at the disc's
+   edge, so undimmed mint is what the halo looks like there. */
+body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotHalo {
+  fill: var(--md-green-200);
+}
+
 .jp-AiAssistantsPanel-dotPlaceholder {
   background-color: transparent;
 }
@@ -1001,3 +1016,40 @@ body[data-jp-theme-light='true'] .jp-AiAssistantsPanel-dotGlyph {
 .jp-AiAssistantsPanel-row.jp-mod-stale .jp-AiAssistantsPanel-name {
   opacity: 0.65;
 }
+
+/* The Open Callback popup. A callback link runs to about 250 characters, so
+   the field takes the width a normal window can give it. */
+.jp-AiAssistantsCallback {
+  width: min(640px, 80vw);
+}
+
+.jp-AiAssistantsCallback label {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.jp-AiAssistantsCallback input {
+  width: 100%;
+  box-sizing: border-box;
+}
+
+/* What the last send came to. The height is reserved, so the buttons do not
+   move when the text arrives. */
+.jp-AiAssistantsCallback-status {
+  min-height: 1.5em;
+  margin-top: 8px;
+  color: var(--jp-ui-font-color2);
+}
+
+.jp-AiAssistantsCallback-status[data-level='success'] {
+  color: var(--jp-success-color1);
+}
+
+.jp-AiAssistantsCallback-status[data-level='warning'] {
+  color: var(--jp-warn-color1);
+}
+
+.jp-AiAssistantsCallback-status[data-level='error'] {
+  color: var(--jp-error-color1);
+}