notebooks.widgetAdded.connect((sender, panel) => {
      const cell = panel.notebook.activeCell;
      const editor = cell && cell.editor;
      const session = panel.session;
      const parent = panel;
      const handler = manager.register({ editor, session, parent });

      // Listen for active cell changes.
      panel.notebook.activeCellChanged.connect((sender, cell) => {
        handler.editor = cell && cell.editor;
      });
    });

    notebooks.widgetAdded.connect((sender, panel) => {
      const cell = panel.content.activeCell;
      const editor = cell && cell.editor;
      const session = panel.session;
      const parent = panel;
      const connector = new CompletionConnector({ session, editor });
      const handler = manager.register({ connector, editor, parent });

      // Listen for active cell changes.
      panel.content.activeCellChanged.connect((sender, cell) => {
        const editor = cell && cell.editor;
        handler.editor = editor;
        handler.connector = new CompletionConnector({ session, editor });
      });
    });

    editorTracker.widgetAdded.connect((sender, widget) => {
      const sessions = app.serviceManager.sessions;
      const editor = widget.content.editor;
      const contextConnector = new ContextConnector({ editor });

      // When the list of running sessions changes,
      // check to see if there are any kernels with a
      // matching path for this file editor.
      const onRunningChanged = (
        sender: Session.IManager,
        models: Session.IModel[]
      ) => {
        const oldSession = activeSessions[widget.id];
        // Search for a matching path.
        const model = find(models, m => m.path === widget.context.path);
        if (model) {
          // If there is a matching path, but it is the same
          // session as we previously had, do nothing.
          if (oldSession && oldSession.id === model.id) {
            return;
          }
          // Otherwise, dispose of the old session and reset to
          // a new CompletionConnector.
          if (oldSession) {
            delete activeSessions[widget.id];
            oldSession.dispose();
          }
          const session = sessions.connectTo(model);
          handler.connector = new CompletionConnector({ session, editor });
          activeSessions[widget.id] = session;
        } else {
          // If we didn't find a match, make sure
          // the connector is the contextConnector and
          // dispose of any previous connection.
          handler.connector = contextConnector;
          if (oldSession) {
            delete activeSessions[widget.id];
            oldSession.dispose();
          }
        }
      };
      Session.listRunning().then(models => {
        onRunningChanged(sessions, models);
      });
      sessions.runningChanged.connect(onRunningChanged);

      // Initially create the handler with the contextConnector.
      // If a kernel session is found matching this file editor,
      // it will be replaced in onRunningChanged().
      const handler = manager.register({
        connector: contextConnector,
        editor,
        parent: widget
      });

      // When the widget is disposed, do some cleanup.
      widget.disposed.connect(() => {
        sessions.runningChanged.disconnect(onRunningChanged);
        const session = activeSessions[widget.id];
        if (session) {
          delete activeSessions[widget.id];
          session.dispose();
        }
      });
    });