It seems to me that a smart terminal would need a microprocessor, so I would expect them to start showing up in the early seventies,
Not really, as discrete, specialized processors could do the job even before that.
When did they arrive on the scene?
TL;DR: Gradually between 1964 and 1971
As with every 'first' question, the answer is rather vague and needs a plethora of adjectives to construct a 'first'.
The use of 'smaller systems' with specialized programming as 'intelligent' subsystems can be traced back as early as the 1950s. Distinction between specialized computers (subsystems) and Terminals is a bit blurry in the beginning, but a rough timeline can be drawn. The following examples follow mostly IBM developments. There have been several others, and IBM wasn't always the first to introduce a feature, but in the long run they not only resulted in the widest usage but also reflected the best known instances. Last but not least, differences in introduction between competing systems where rather in a scale of month than years.
Further, we should clarify the term 'intelligent terminal' as some kind of device(s) allowing local editing/manipulation of data output from a computer before sending the result back for further processing.
With this definition a point could be made that already the punch card environment of the 1940s may qualify by offering local punching, reading, duplication, and repunch of cards to be fed back again. The more compact IBM 26 Interpreting Card Punch of 1962 does define local editing. But yeah, it's a stretch.
(modified) TTY are the beginning of individual terminals. They are the equivalent of a dumb terminal. Every character typed is send right away toward the mainframe. With an increasing number of terminals, mainframe side buffers/communication controllers where added to reduce interrupt load, making them somewhat less dumb by collecting a line before interrupting the host.
IBMs 1050, a printing terminal, introduced in March 1963, diverged (first?) from TTY like unsynchronized single character I/O and introduced a line mode. Here the 1051 Control Unit managed a line buffer. While each keystroke was directly displayed, a line was only sent to the mainframe when
EOB (End Of Block) was pressed.
CR did implicitly send an
EOB following the
CR. After sending the keyboard became locked until released by the mainframe (*1). Another important improvement over TTY with its 10 characters per second was that the used Selectric mechanics did allow a 15 characters per second output.
IBM's very first (graphical) terminal system, the 2250 of 1964 did also use a line/block mode when it came to text entry. While the terminal was direct connected to the Mainframes I/O channel, a local data buffer was used for editing. Entered text was displayed and could be edited in line mode. When a 'message was composed', as it was called back then, a mainframe I/O interrupt was issued to transmit the whole data block. To some degree the 2250 did set the lead for all terminals to follow, while it's direct impact was rather limited (*2).
IBM's 2240 of 1964 and later 2241 did continue what was set with the 1150. But without the ability of additional peripherals like card punch/reader or paper tape handling in favor of a simple low-cost approach to terminals. Instead of integrating a Selectric mechanism in a new case, controlled by a separate controller now a more standard Selectric with new logic could be used. The advantage was achieved due higher integration using SLT (Solid Logic Technology).
March 1965 brought what eventually could be called the first intelligent terminal as we see it today: The 2260, IBM's first CRT based text terminal. Unlike the 2250 it was raster based (*3). Here for the first time a whole screen or parts thereof could be edited and sent back when done. Line mode was thus replaced by a wider block mode. In a strict sense it was still not an all-in-one terminal, as the logic, handling and storage was contained in a 2248 Display Control Unit which in turn handled up to 24 terminals at once. The 2260 Unit itself was barely more than keyboard and monitor. The first 2260 'only' displayed six rows of forty characters each. Model 2 did 12x40 characters and Model 3 finally 12x80 characters.
September 1966 brought the 2250 Model 2/3 which now no longer needed to be direct connected to the mainframe I/O, but acted via a 2840 control unit over remote, serial line. (*4)
In February 1968 the 2265 got introduced. IBM's first terminal where controller and display where located in one case, close to what we today imagine as a terminal. Functionally it was the same as 1965s 2260, but now a single terminal was tied to a single serial line. Beside the 2260's 12x80 mode a more form entry orientated 15x64 mode was offered (*5).
Other companies did also work on intelligent terminals (-systems). In 1969 SIEMENS introduced the 8150 system. While it was, like the 2265, a single terminal per line, its electronics were still rather huge and confined in a heavy, tower PC like case. Display size was 20 lines with 54 characters each (*6). To my knowledge, the 8150 system was the first to introduce field delimiters and attributes, so forms could be displayed and cursor handling was done according to these fields. Even simple data local entry checks could be done by declaring a field as numeric, so only digits could be entered.
To handle these more complex operation a microprogram controlled discrete, specialized processor was implemented on 12 Eurocard like PCBs. In a simplified view, the microprogram was much like an interpreter processing the screen data for each frame, feeding the test according to the attributes to the character display logic. Display was done as vector output, so each character was just drawn as it came along. Keyboard input was handled whenever the cursor position was reached. The whole program structure was rather clever, albeit unusual from today's view (*7). Each Field descriptor did take up a character position and was displayed as a space. The later 8160 system of 1975 removed that limitation and added a few more features.
Eventually the largest 8150 installation early on where the 1972 Munich Olympic Games, where more than 200 terminals where connected to a single mainframe to collect data from all competitions and deliver real time information updates them to journalists.
Now, in 1970, in retrospect, another milestone was introduced: The Datapoint 2200. Delivery started in Summer 1971. Like the IBM 2260/65, display was 12x80, but unlike the IBM it was not meant to be 'a' terminal, but to emulate as many as possible other terminals. After designing their first product, the Datapoint 3300, a classic dumb glass-TTY, CTC realized that there is a market for compatible terminals. So they decided to go for a programmable system they could adapt. But instead of keeping it a closed system trying to earn a premium by adapting the emulation to new systems, they made it an open system with programming available to users. While the basic idea was to enable some local programming to improve data entry, customers soon used it as a desktop computer. The fact that they convinced TI and Intel in trying to fit their CPU design on a single chip still shapes today's computing :))
Finally, in May 1971 the IBM 3270 terminal system was introduced. Various models displaying 12x80 up to 43x80 and 27x132 were available. But more important, form handling was added. The rest, I guess, is history:)
Caveat: As said before, this timeline is (mostly) IBM orientated, but there where many more companies, during the 60s and 70s usually ahead of IBM.
As a final note it might be useful to explicitly note that the 'intelligent'(CRT based) terminal is not an evolutionary step from 'dumb' (CRT-based) terminals. This common assumption is wrong. Both developments happened in parallel. Dumb terminals are a rather straight continuation from TTYs, supported by the growing availability of local computing power (aka mini computers) and direct CPU interaction. Demand to handle more users (terminals) was satisfied by buying more computers (and partitioning workload along department lines).
In contrast intelligent terminals were developed to offload editing and screen manipulation duties from the mainframe to enable more terminals to be handled by a single machine. Intelligent terminals where created by departing from the TTY paradigm, not dumb terminals.
*1- After all, this already constructs a simple hardware implementation for a command line, doesn't it?
*2 - Not the least due its initial price of 200-300 thousand USD. No, not today's, but 1964 Dollars - make that more like 2 million of today's.
*3 - Scanned 'sideways' - the beam did not run in horizontal rows, but vertical columns. Yup, These are terminals, not TVs, so not limited to TV specifics.
*4 - Notable, it also introducing a character generator within the 2840, so the mainframe no longer had to send each output character as series of strokes :))
*5 - the 2265 was also the first IBM terminal system to use the ASCII character set. While transmission encoding was still BCD based, all ASCII glyphs could be displayed.
*6 - Like many manufacturers of compatible systems, SIEMENS had to offer more than IBM to convince customers (or more precisely, their management), so 1080 characters on a single screen instead of 960 is a lot, isn't it :)
*7 - Or in other words, it was clever and elegant programming instead of throwing code and libraries on a problem until it surrenders.