A tiny friend in your Mac's notch and on your iPhone that keeps an eye on your AI coding agents: Claude Code, Codex, Cursor, Gemini CLI, Antigravity and more. Approve from the notch or your Lock Screen.
Swift ai-agentsanthropicantigravityclaudeclaude-codecodexcursordynamic-islandgemini-cliiosiphonlinuxmacosmacos-appmenubar-appnotchopen-sourceswiftswiftuiwindows
// Chat view — DOM port of PromptView / ChatBubble / TypingDotsView /
// ModelPickerView from IslandViewContent.swift.
//
// Answers are rendered as Markdown (markdown.ts). A local model streams its
// answer: Rust sends `chat-delta` events with the text visible so far. The
// model name above the text field opens the picker: provider chips, then the
// models of the chosen provider, asked for only once it is picked.
import { h, svg, clear } from "./dom";
import { ICONS } from "./icons";
import { renderMarkdown } from "./markdown";
import { Bridge, onEvent, type ChatContext, type ModelInfo } from "../core/bridge";
import {
activeModel, pickModel, providerDef, visibleProviders, withModel, type ProviderDef,
} from "../core/providers";
import { Sound } from "../core/sound";
import { chipLabel, loadSubscriptions, subscribedProviders, subscription } from "../core/subscriptions";
import { State, type ChatMessage } from "../core/state";
import type { ViewHost } from "./views";
import { N_, t, tl } from "../i18n/i18n";
import { HOST_OS } from "../core/pills";
import { MailChat, splitPlan } from "../core/mail";
import { mailPlanCard } from "./mailplan";
const STRINGS = {
placeholderFirst: N_("Ask me anything…"),
placeholderNext: N_("Continue…"),
send: N_("Send"),
switchModel: N_("Switch provider or model"),
noModel: N_("Choose a model"),
loading: N_("Loading models…"),
noKey: N_("No API key — add it in Settings."),
openSettings: N_("Open Settings"),
};
let nextId = 1;
function bubble(message: ChatMessage): HTMLElement {
if (message.role === "user") {
return h(
"div",
{ class: "chat-row user" },
h("div", { class: "bubble", text: message.content }),
);
}
const reply = h("div", { class: "reply" });
// A mail plan (```coucou-mail) is never shown as raw JSON: its card goes under the answer.
const { prose, plan } = splitPlan(message.content);
renderMarkdown(reply, prose);
if (plan) reply.append(mailPlanCard(`chat-${message.id}-${message.content.length}`, "", message.content));
return h("div", { class: "chat-row" }, reply);
}
function typingDots(): HTMLElement {
return h(
"div",
{ class: "chat-row" },
h("div", { class: "typing" }, h("i"), h("i"), h("i")),
);
}
/** The coloured chip showing what the question is about (a dropped file). */
function contextChip(label: string): HTMLElement {
const chip = h("div", { class: "chip" }, h("i", { class: "chip-dot" }), h("span", { text: label }));
requestAnimationFrame(() => chip.classList.add("settled"));
return chip;
}
function saveSettings() {
void Bridge.saveSettings(State.settings);
}
// ── Model picker ──────────────────────────────────────────────────────────────
interface Picker {
el: HTMLElement;
open(): void;
close(): void;
readonly isOpen: boolean;
}
/** Provider chips, then the chosen provider's models — ModelPickerView. */
function buildPicker(onChange: () => void): Picker {
const chips = h("div", { class: "picker-chips" });
const list = h("div", { class: "picker-list" });
const el = h("div", { class: "picker" }, chips, h("div", { class: "picker-rule" }), list);
/** Models already asked for, by provider; a model server is asked again each time. */
const cache = new Map<string, ModelInfo[]>();
let isOpen = false;
let request = 0;
function drawChips() {
clear(chips);
for (const p of visibleProviders(State.settings, subscribedProviders())) {
const on = p.id === State.settings.chatProvider;
const chip = h(
"button",
{ class: on ? "picker-chip on" : "picker-chip", style: `--accent:${p.accent}` },
h("i", { class: "picker-dot" }),
h("span", { text: t(p.name) }),
);
chip.addEventListener("click", () => {
if (p.id === State.settings.chatProvider) return;
State.settings = { ...State.settings, chatProvider: p.id };
saveSettings();
Sound.play("pop");
drawChips();
void loadModels();
onChange();
});
chips.append(chip);
}
}
function status(text: string, withSettings = false) {
clear(list);
const line = h("div", { class: "picker-status", text });
if (withSettings) {
line.append(
h("button", {
class: "picker-link",
text: tl(STRINGS.openSettings),
onclick: () => void Bridge.openSettingsWindow(),
}),
);
}
list.append(line);
}
function drawModels(p: ProviderDef, models: ModelInfo[]) {
clear(list);
// Through a subscription, a tool other than Claude Code uses its own model ("").
const ownModel = subscription(p.id)?.on && p.id !== "anthropic";
const current = ownModel ? "" : activeModel(State.settings);
for (const m of models) {
const on = m.id === current;
const row = h(
"button",
{ class: on ? "picker-model on" : "picker-model", style: `--accent:${p.accent}`, title: m.id },
h("span", { class: "picker-model-name", text: m.label }),
on ? svg(ICONS.check, 11, { stroke: 2.2 }) : null,
);
row.addEventListener("click", () => {
if (!m.id) return close();
State.settings = withModel(State.settings, p.id, m.id);
saveSettings();
Sound.play("blip");
close();
});
list.append(row);
}
list.querySelector(".picker-model.on")?.scrollIntoView({ block: "nearest" });
}
async function loadModels() {
const p = providerDef(State.settings.chatProvider);
const ticket = ++request;
const subscribed = subscription(p.id)?.on ?? false;
const cacheKey = `${p.id}:${subscribed}`;
const cached = p.urlField ? undefined : cache.get(cacheKey);
if (cached) {
drawModels(p, cached);
return;
}
// Nothing is asked of a provider that has no key yet (its subscription needs none).
if (!subscribed && p.key && !(await Bridge.keyReady(p.key))) {
if (ticket === request) status(t(STRINGS.noKey), true);
return;
}
if (ticket !== request) return;
status(t(STRINGS.loading));
try {
const models = await Bridge.chatModels(p.id);
if (ticket !== request) return;
if (!p.urlField) cache.set(cacheKey, models);
const keep = subscribed && p.id !== "anthropic" ? null : pickModel(p, models.map((m) => m.id), activeModel(State.settings));
if (keep && keep !== activeModel(State.settings)) {
State.settings = withModel(State.settings, p.id, keep);
saveSettings();
onChange();
}
drawModels(p, models);
} catch (err) {
if (ticket === request) status(String(err).replace(/^Error:\s*/, ""), Boolean(p.key));
}
}
function open() {
isOpen = true;
el.classList.add("on");
drawChips();
onChange();
// Which subscriptions are on may have changed in Settings: ask, then list.
void loadSubscriptions().then(() => {
if (!isOpen) return;
drawChips();
onChange();
void loadModels();
});
}
function close() {
isOpen = false;
request++;
el.classList.remove("on");
onChange();
}
return {
el,
open,
close,
get isOpen() {
return isOpen;
},
};
}
// ── View ──────────────────────────────────────────────────────────────────────
export function buildPrompt(onHeightChange: () => void): ViewHost {
const chipRow = h("div", { class: "chip-row" });
const log = h("div", { class: "chat-log" });
const input = h("input", {
type: "text",
class: "chat-input",
placeholder: t(STRINGS.placeholderFirst),
spellcheck: "false",
}) as HTMLInputElement;
const send = h("button", { class: "send-btn", title: tl(STRINGS.send) }, svg(ICONS.arrowUp, 11));
const bar = h("div", { class: "chat-bar" }, input, send);
const modelDot = h("i", { class: "model-dot" });
const modelName = h("span", { class: "model-name" });
const modelBtn = h(
"button",
{ class: "model-btn", title: tl(STRINGS.switchModel) },
modelDot,
modelName,
svg(ICONS.chevronUpDown, 9, { stroke: 2 }),
);
// The Mail switch (classic Outlook, Windows): on, the AI sees the latest messages and may
// prepare actions on them, which run only after a click on the plan's card.
const mailBtn = h("button", { class: "mail-toggle", title: tl("Lets the AI see your latest messages and prepare actions on them. Nothing happens until you click Run.") },
h("span", { text: "✉" }), h("span", { text: tl("Mail") }));
mailBtn.addEventListener("click", () => {
MailChat.on = !MailChat.on;
mailBtn.classList.toggle("on", MailChat.on);
});
const modelRow = h("div", { class: "model-row" }, modelBtn);
if (HOST_OS === "windows") modelRow.prepend(mailBtn);
const body = h("div", { class: "chat-body" });
const picker = buildPicker(() => {
body.classList.toggle("picking", picker.isOpen);
drawModelButton();
});
body.append(chipRow, log, picker.el, modelRow, bar);
void loadSubscriptions().then(() => drawModelButton());
const el = h("div", { class: "view" }, h("div", { class: "card wash chat-card" }, body));
(el.querySelector(".card") as HTMLElement).style.setProperty("--wash", "rgba(99,102,241,0.5)");
let sending = false;
let renderedCount = -1;
// A local model answers token by token: where its text so far is shown.
let live: HTMLElement | null = null;
function drawModelButton() {
const p = providerDef(State.settings.chatProvider);
modelDot.style.background = p.accent;
modelName.textContent = chipLabel(State.settings, activeModel(State.settings)) || t(STRINGS.noModel);
modelBtn.classList.toggle("open", picker.isOpen);
modelBtn.disabled = sending;
}
modelBtn.addEventListener("click", () => {
if (sending) return;
if (picker.isOpen) picker.close();
else picker.open();
});
void onEvent<string>("chat-delta", (text) => {
if (!sending || !text) return; // nothing visible yet: the dots stay
if (!live) {
live = h("div", { class: "reply" });
log.querySelector(".typing")?.parentElement?.remove();
log.append(h("div", { class: "chat-row" }, live));
}
renderMarkdown(live, splitPlan(text).prose);
log.scrollTop = log.scrollHeight;
});
async function submit() {
const query = input.value.trim();
if (!query || sending) return;
if (picker.isOpen) picker.close();
input.value = "";
sending = true;
drawModelButton();
Sound.play("send");
State.chatHistory.push({ id: nextId++, role: "user", content: query });
State.stateOverride = "thinking";
State.notify();
onHeightChange();
const file = State.droppedFile;
const context: ChatContext | null =
State.chatHistory.length === 1 && file ? { kind: "file", name: file.name, path: file.path } : null;
try {
const reply = await Bridge.chatSend(query, context, MailChat.on && HOST_OS === "windows");
State.chatHistory.push({ id: nextId++, role: "assistant", content: reply.text });
State.stateOverride = null;
Sound.play("finish");
} catch (err) {
State.stateOverride = null;
State.noteMessage = String(err).replace(/^Error:\s*/, "");
State.view = "note";
Sound.play("error");
} finally {
sending = false;
live = null;
renderedCount = -1; // the finished answer replaces the streamed one
drawModelButton();
State.notify();
onHeightChange();
// Back to typing without a click. The field was disabled while the
// answer came, which took the focus away, and the sync that enables it
// again is a frame away: a disabled field can't take the focus.
if (State.view === "prompt") {
input.disabled = false;
input.focus();
}
}
}
send.addEventListener("click", () => void submit());
input.addEventListener("keydown", (e) => {
const key = (e as KeyboardEvent).key;
if (key === "Enter") {
e.preventDefault();
void submit();
} else if (key === "Escape" && picker.isOpen) {
e.preventDefault();
picker.close();
}
e.stopPropagation(); // Escape closes the island, not the chat
});
return {
el,
sync() {
const file = State.droppedFile;
const wantChip = file?.name ?? "";
if (chipRow.dataset.label !== wantChip) {
chipRow.dataset.label = wantChip;
clear(chipRow);
if (wantChip) chipRow.append(contextChip(wantChip));
}
const thinking = State.stateOverride === "thinking";
const count = State.chatHistory.length + (thinking ? 0.5 : 0);
if (count !== renderedCount && !live) {
renderedCount = count;
clear(log);
for (const m of State.chatHistory) log.append(bubble(m));
if (thinking) log.append(typingDots());
log.scrollTop = log.scrollHeight;
}
// Leaving the chat folds the picker away.
if (State.view !== "prompt" && picker.isOpen) picker.close();
drawModelButton();
input.placeholder = t(State.chatHistory.length === 0 ? STRINGS.placeholderFirst : STRINGS.placeholderNext);
input.disabled = sending;
},
focus() {
input.focus();
input.select();
},
};
}