@timqi/pier 0.1.4 → 0.1.6

package/dist/channels/telegram-panel.js

@@ -1,97 +0,0 @@
-// Telegram's half of the settings panel (panel.ts has the rest). A forced reply
-// arrives as an ordinary message, so the prompt's id is remembered to recognize it.
-import { ChatPanel, CWD_PLACEHOLDER, CWD_TAIL, PANEL_PREFIX, } from "./panel.js";
-import { escapeHtml as esc } from "./telegram-render.js";
-const button = (b) => ({ text: b.label, callback_data: `${PANEL_PREFIX}${b.action}` });
-export class TelegramPanel extends ChatPanel {
-    deps;
-    platform = "telegram";
-    fence = ["<code>", "</code>"];
-    cwdPrompts = new Map();
-    constructor(deps) {
-        super(deps);
-        this.deps = deps;
-    }
-    esc(text) {
-        return esc(text);
-    }
-    gateExtras(chat, policy) {
-        return chat.kind === "forum" ? ` · topics ${policy.topicMode ? "on" : "off"}` : "";
-    }
-    // --- rendering ---------------------------------------------------------------
-    text(view, note) {
-        const body = view.groups
-            .map((g) => [`<b>${g.title}</b>${g.suffix ?? ""}`, ...g.lines].join("\n"))
-            .join("\n\n");
-        return note ? `${body}\n\n<i>${esc(note)}</i>` : body;
-    }
-    /** A long model id does not share a row with anything. */
-    keyboard(view) {
-        return {
-            inline_keyboard: [
-                ...(view.picks ?? []).map((pick) => [button(pick)]),
-                ...view.rows.map((row) => row.map(button)),
-            ],
-        };
-    }
-    async open(key, chatId, topicId) {
-        const view = await this.view(key, chatId);
-        const sent = await this.deps.api.sendMessage({
-            chat_id: chatId,
-            message_thread_id: topicId,
-            text: this.text(view),
-            parse_mode: "HTML",
-            reply_markup: this.keyboard(view),
-        });
-        this.remember(key, { chatId, topicId, messageId: sent.message_id, models: [] });
-    }
-    async draw(state, view, note) {
-        await this.deps.api.editMessage({
-            chat_id: state.chatId,
-            message_id: state.messageId,
-            text: this.text(view, note),
-            parse_mode: "HTML",
-            reply_markup: this.keyboard(view),
-        }).catch((err) => this.deps.log(`panel edit failed: ${String(err)}`));
-    }
-    async erase(state) {
-        await this.deps.api.deleteMessage(state.chatId, state.messageId)
-            .catch((err) => this.deps.log(`panel close failed: ${String(err)}`));
-    }
-    // --- actions -----------------------------------------------------------------
-    /** Returns false when the payload is not ours. */
-    async onCallback(query, key) {
-        return this.dispatch(key, query.data ?? "", undefined, async () => {
-            const message = query.message;
-            if (message)
-                await this.open(key, String(message.chat.id), message.message_thread_id);
-        });
-    }
-    // --- working directory (one typed answer) ------------------------------------
-    async promptCwd(key, state) {
-        const sent = await this.deps.api.sendMessage({
-            chat_id: state.chatId,
-            message_thread_id: state.topicId,
-            text: `Reply with an absolute path. ${CWD_TAIL}`,
-            reply_markup: { force_reply: true, input_field_placeholder: CWD_PLACEHOLDER },
-        });
-        this.cwdPrompts.set(key.conversationId, sent.message_id);
-    }
-    /** True when this message was the answer and must not reach the agent. */
-    async consumeCwdReply(msg, key) {
-        const pending = this.cwdPrompts.get(key.conversationId);
-        if (!pending || msg.reply_to_message?.message_id !== pending)
-            return false;
-        this.cwdPrompts.delete(key.conversationId);
-        const path = (msg.text ?? "").trim();
-        const started = await this.startSessionIn(key, path);
-        // The answer was typed in the chat, so the outcome is said there too.
-        await this.deps.api.sendMessage({
-            chat_id: msg.chat.id,
-            message_thread_id: msg.message_thread_id,
-            text: "error" in started ? started.error : `New session in <code>${esc(path)}</code>.`,
-            parse_mode: "HTML",
-        });
-        return true;
-    }
-}

package/dist/channels/telegram-render.js

@@ -1,69 +0,0 @@
-import { chunkText } from "./chunk.js";
-// How a reply looks on Telegram: markdown → Bot API HTML. Telegram's parser
-// rejects the whole message on any tag outside its documented set (b, i, s,
-// code, pre, a), so text is escaped first and only those are reintroduced.
-const MAX_CHARS = 3800; // Telegram's hard limit is 4096; leave room for tags.
-export const escapeHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-/** Inline emphasis, applied after escaping so `<b>` can only come from us. */
-function inline(text) {
-    return text
-        // Links first: their label may itself carry emphasis.
-        .replace(/\[([^\]\n]+)\]\((https?:\/\/[^\s)]+)\)/g, (_m, label, url) => `<a href="${url.replace(/"/g, "&quot;")}">${label}</a>`)
-        .replace(/\*\*([^\n*]+)\*\*/g, "<b>$1</b>")
-        .replace(/~~([^\n~]+)~~/g, "<s>$1</s>")
-        .replace(/(^|[\s(])[*_]([^\n*_]+)[*_](?=[\s).,!?:;]|$)/g, "$1<i>$2</i>")
-        .replace(/^#{1,6}[ \t]+(.+)$/gm, "<b>$1</b>");
-}
-/** Code is stashed before escaping so emphasis inside it stays literal. */
-export function toTelegramHtml(markdown) {
-    const stash = [];
-    const keep = (html) => `\uE000${stash.push(html) - 1}\uE001`;
-    let out = markdown.replace(/```([\w.+-]*)\n?([\s\S]*?)```/g, (_m, lang, code) => keep(lang
-        ? `<pre><code class="language-${escapeHtml(lang)}">${escapeHtml(code.replace(/\n+$/, ""))}</code></pre>`
-        : `<pre>${escapeHtml(code.replace(/\n+$/, ""))}</pre>`));
-    out = out.replace(/`([^`\n]+)`/g, (_m, code) => keep(`<code>${escapeHtml(code)}</code>`));
-    out = inline(escapeHtml(out));
-    return out.replace(/\uE000(\d+)\uE001/g, (_m, i) => stash[Number(i)] ?? "");
-}
-/** A cut inside a <pre> block is fine: Telegram closes the tag on its own. */
-export const chunk = (html) => chunkText(html, MAX_CHARS);
-// --- next-step buttons -------------------------------------------------------
-/** `callback_data` caps at 64 bytes (~21 CJK characters), so buttons send an
- *  index and the label is read back off the message's own keyboard. */
-export const OFFER_PREFIX = "sg:";
-// Buttons in one row split its width evenly, so packing is budgeted by display
-// width, not count.
-const ROW_WIDTH = 26;
-const ROW_BUTTONS = 3;
-/** CJK, fullwidth punctuation and emoji take two cells. */
-const displayWidth = (label) => [...label].reduce((n, ch) => n + ((ch.codePointAt(0) ?? 0) > 0x2e7f ? 2 : 1), 0);
-/** A row that is already wide stops accepting: a long label squeezed in
- *  truncates everything beside it. */
-export function keyboard(labels) {
-    if (!labels.length)
-        return undefined;
-    const rows = [];
-    let used = 0;
-    labels.forEach((label, index) => {
-        const width = displayWidth(label);
-        const row = rows.at(-1);
-        const button = { text: label, callback_data: `${OFFER_PREFIX}${index}` };
-        if (!row || row.length >= ROW_BUTTONS || used + width > ROW_WIDTH) {
-            rows.push([button]);
-            used = width;
-            return;
-        }
-        row.push(button);
-        used += width;
-    });
-    return { inline_keyboard: rows };
-}
-/** A payload we never wrote (an older label-as-payload button) passes through. */
-export function offeredLabel(msg, data) {
-    if (!data.startsWith(OFFER_PREFIX))
-        return data;
-    return msg.reply_markup?.inline_keyboard
-        .flat()
-        .find((button) => button.callback_data === data)
-        ?.text;
-}

package/dist/channels/telegram.js

@@ -1,421 +0,0 @@
-// Telegram adapter: normalize inbound updates, render outbound turns.
-// Telegram-specific: topic mode, where a message in a forum group's General
-// opens a topic that becomes the session; 👀 receipts on every message that
-// entered a turn; `/bind <code>` in a DM.
-import { awaitsTurn, formatTurnMeta, isSilentReply, originLabel, quietLabel } from "../core/reply.js";
-import { saveInboundAll } from "../core/inbox.js";
-import { MAX_INBOUND_BYTES } from "../core/inbound-file.js";
-import { sendAttachments, splitAttachments } from "./attach.js";
-import { bindHint, bindResult, picked, STALE_OPTION, STOPPED } from "./lines.js";
-import { logger } from "../log.js";
-import { Chains } from "./chains.js";
-import { parseCommand } from "./commands.js";
-import { Gatekeeper } from "./gatekeeper.js";
-import { ReceiptLedger, Receipts } from "./receipts.js";
-import { TelegramPanel } from "./telegram-panel.js";
-import { chunk, escapeHtml, keyboard, offeredLabel, toTelegramHtml } from "./telegram-render.js";
-import { TelegramApi, } from "./telegram-api.js";
-const WORKING = "👀";
-const POLL_SECONDS = 30;
-// The poll loop waits here without advancing the offset past what it accepted.
-const MAX_ACTIVE_CHATS = 16;
-// Generous: a real coding turn can be long.
-const RECEIPT_STALE_MS = 30 * 60_000;
-const DRAIN_TIMEOUT_MS = 5000;
-const TOPIC_TITLE_MAX = 60;
-/** `<chatId>/<topicId>` or `<chatId>`; the only definition of the format. */
-const conversationId = (chatId, topicId) => topicId ? `${chatId}/${topicId}` : String(chatId);
-export const parseConversation = (id) => {
-    const [chatId = "", topic] = id.split("/");
-    const topicId = topic ? Number(topic) : undefined;
-    return { chatId, topicId: Number.isSafeInteger(topicId) ? topicId : undefined };
-};
-/** Telegram numbers General as topic 1 and omits the id on plain groups. */
-const inGeneral = (msg) => !msg.message_thread_id || msg.message_thread_id === 1;
-function topicTitle(text) {
-    const line = (text.split("\n").find((l) => l.trim()) ?? "").trim();
-    if (!line)
-        return `Session ${new Date().toISOString().slice(5, 16).replace("T", " ")}`;
-    return line.length > TOPIC_TITLE_MAX ? `${line.slice(0, TOPIC_TITLE_MAX - 3).trimEnd()}...` : line;
-}
-export class TelegramChannel {
-    deps;
-    id = "telegram";
-    api;
-    log;
-    receipts;
-    chains;
-    gate;
-    /** Absent when no control was wired (tests). */
-    panel;
-    me;
-    offset;
-    running = false;
-    constructor(deps) {
-        this.deps = deps;
-        this.api = deps.client ?? new TelegramApi(deps.store.get("telegram").token);
-        this.log = deps.log ?? ((m) => logger("telegram").warn(m));
-        // No cap: the poll loop applies backpressure itself.
-        this.chains = new Chains(this.log);
-        this.gate = new Gatekeeper(deps.store, "telegram", this.log);
-        this.receipts = new Receipts(
-        // The ledger keeps message ids as opaque strings (a Slack ts is not a number).
-        { setReaction: (chatId, messageId, emoji) => this.api.setReaction(chatId, Number(messageId), emoji) }, deps.receipts ?? new ReceiptLedger("telegram"), this.log, WORKING, RECEIPT_STALE_MS);
-        if (deps.control) {
-            this.panel = new TelegramPanel({
-                api: this.api,
-                control: deps.control,
-                store: deps.store,
-                log: this.log,
-            });
-        }
-    }
-    async start(onMessage) {
-        const me = await this.api.getMe();
-        this.me = { id: me.id, username: me.username ?? "" };
-        if (!this.me.username) {
-            // Every group with require-mention on goes silent; loud, not a debug line.
-            this.log("bot has no username: mention detection is disabled");
-        }
-        this.running = true;
-        void this.receipts.sweep(true);
-        void this.poll(onMessage);
-    }
-    async stop() {
-        this.running = false;
-        // reload() starts a replacement right after; two adapters handling one
-        // message would prompt the session twice. Bounded: a stuck handler must not
-        // hold the Console's save request open.
-        await this.chains.drain(DRAIN_TIMEOUT_MS);
-    }
-    // --- inbound ---------------------------------------------------------------
-    async poll(onMessage) {
-        while (this.running) {
-            try {
-                // Floor on an empty round trip: a proxy that answers instantly would
-                // otherwise turn the long poll into a hot loop.
-                const startedAt = Date.now();
-                const updates = await this.api.getUpdates(this.offset, POLL_SECONDS);
-                if (!this.running)
-                    return;
-                void this.receipts.sweep();
-                if (!updates.length && Date.now() - startedAt < 1000) {
-                    await new Promise((r) => setTimeout(r, 1000));
-                }
-                for (const update of updates) {
-                    if (!this.running)
-                        return;
-                    while (this.chains.size >= MAX_ACTIVE_CHATS)
-                        await this.chains.oldest();
-                    this.offset = update.update_id + 1;
-                    const chat = update.message?.chat.id ?? update.callback_query?.message?.chat.id;
-                    if (chat === undefined)
-                        continue; // malformed: no chat to answer in
-                    this.chains.run(String(chat), async () => {
-                        try {
-                            if (update.callback_query)
-                                await this.onCallback(update.callback_query, onMessage);
-                            else if (update.message)
-                                await this.onMessage(update.message, onMessage);
-                        }
-                        catch (err) {
-                            this.log(`update ${update.update_id} dropped: ${String(err)}`);
-                        }
-                    });
-                }
-            }
-            catch (err) {
-                if (!this.running)
-                    return;
-                this.log(`poll failed, retrying: ${String(err)}`);
-                await new Promise((r) => setTimeout(r, 3000));
-            }
-        }
-    }
-    async onMessage(msg, onMessage) {
-        if (!msg.from || msg.from.id === this.me?.id)
-            return; // own echo, or malformed
-        const raw = (msg.text ?? msg.caption ?? "").trim();
-        if (!raw && !msg.photo?.length && !msg.document)
-            return;
-        const chatId = String(msg.chat.id);
-        const isDm = msg.chat.type === "private";
-        const kind = isDm ? "dm" : msg.chat.is_forum ? "forum" : "group";
-        const name = msg.chat.title ?? [msg.from.first_name, msg.from.last_name].filter(Boolean).join(" ");
-        if (this.gate.mayDiscover({ isDm, userId: String(msg.from.id) })) {
-            this.deps.store.discoverChat("telegram", { id: chatId, name: name || chatId, kind });
-        }
-        const text = this.stripMention(raw);
-        const command = parseCommand(text);
-        const mine = !command?.target || command.target.toLowerCase() === this.me?.username.toLowerCase();
-        const bindRequest = mine && command?.name === "bind" && isDm;
-        const admitted = this.gate.admit("message", chatId, {
-            isDm,
-            addressed: this.addressed(raw, msg),
-            userId: String(msg.from.id),
-            bindRequest,
-        });
-        if (!admitted) {
-            if (isDm)
-                await this.hintBind(msg);
-            return;
-        }
-        if (bindRequest)
-            return this.bind(msg, command?.args ?? "");
-        if (mine && command?.name === "stop")
-            return this.abortTurn(msg);
-        const here = {
-            channelId: this.id,
-            conversationId: conversationId(chatId, msg.message_thread_id),
-        };
-        if (await this.panel?.consumeCwdReply(msg, here))
-            return;
-        // A bare `@bot` and `/settings` are the same request.
-        if (this.panel && mine && (command?.name === "settings" || (!text && !msg.photo?.length && !msg.document))) {
-            return this.panel.open(here, chatId, msg.message_thread_id);
-        }
-        // Downloading only past the gate: an unauthorized sender must not make the
-        // bot pull bytes on their behalf.
-        const markers = await this.saveAttachments(msg);
-        const topicId = await this.routeTopic(msg, text);
-        const key = { channelId: this.id, conversationId: conversationId(chatId, topicId) };
-        this.receipts.mark(key.conversationId, chatId, String(msg.message_id));
-        // Steer: a follow-up is the wrong default when the human is watching a 👀.
-        onMessage({
-            key,
-            senderId: String(msg.from.id),
-            sender: { id: String(msg.from.id), name: senderName(msg.from) },
-            text: [text, ...markers].filter(Boolean).join("\n"),
-            mode: "steer",
-        });
-    }
-    async onCallback(query, onMessage) {
-        // Unanswered, the tapped button keeps its spinner until Telegram gives up.
-        await this.api.answerCallbackQuery(query.id)
-            .catch((err) => this.log(`callback ack failed: ${String(err)}`));
-        const msg = query.message;
-        if (!msg || !query.data)
-            return;
-        const chatId = String(msg.chat.id);
-        const admitted = this.gate.admit("callback", chatId, {
-            isDm: msg.chat.type === "private",
-            addressed: true, // pressing the bot's own button is addressing it
-            userId: String(query.from.id),
-        });
-        if (!admitted)
-            return;
-        const key = {
-            channelId: this.id,
-            conversationId: conversationId(chatId, msg.message_thread_id),
-        };
-        if (await this.panel?.onCallback(query, key))
-            return;
-        const text = offeredLabel(msg, query.data);
-        if (text === undefined) {
-            // A callback query may be answered exactly once, and the ack above was
-            // it; a second answer is silently dropped.
-            await this.api.sendMessage({
-                chat_id: chatId,
-                message_thread_id: msg.message_thread_id,
-                text: STALE_OPTION,
-            }).catch((err) => this.log(`stale-option notice failed: ${String(err)}`));
-            return;
-        }
-        await this.api.clearKeyboard(chatId, msg.message_id)
-            .catch((err) => this.log(`retiring options failed: ${String(err)}`));
-        // A bot cannot post as the user, so the pick is echoed: otherwise the chat
-        // shows an answer to a request nobody can see, with nothing to carry the eyes.
-        const echo = await this.api.sendMessage({
-            chat_id: chatId,
-            message_thread_id: msg.message_thread_id,
-            text: picked(escapeHtml(text)),
-            parse_mode: "HTML",
-        }).catch((err) => {
-            this.log(`option echo failed: ${String(err)}`);
-            return undefined;
-        });
-        if (echo)
-            this.receipts.mark(key.conversationId, chatId, String(echo.message_id));
-        onMessage({ key, senderId: String(query.from.id), text, mode: "steer" });
-    }
-    /** The abort ends the turn, which reaches send() and clears the receipts. */
-    async abortTurn(msg) {
-        const key = {
-            channelId: this.id,
-            conversationId: conversationId(msg.chat.id, msg.message_thread_id),
-        };
-        await this.deps.control?.abort(key);
-        await this.api.sendMessage({
-            chat_id: msg.chat.id,
-            message_thread_id: msg.message_thread_id,
-            text: STOPPED,
-        });
-    }
-    /** Groups stay silent, but a DM that swallows every message looks broken
-     *  rather than locked. */
-    async hintBind(msg) {
-        if (!this.gate.mayHint(String(msg.from?.id ?? "")))
-            return;
-        await this.api.sendMessage({
-            chat_id: msg.chat.id,
-            text: bindHint("/bind <code>"),
-        }).catch((err) => this.log(`bind hint failed: ${String(err)}`));
-    }
-    async bind(msg, code) {
-        const user = msg.from;
-        const name = senderName(user);
-        const outcome = this.deps.store.redeemBindCode("telegram", code, { id: String(user.id), name });
-        await this.api.sendMessage({
-            chat_id: msg.chat.id,
-            text: bindResult(outcome, name),
-        });
-    }
-    /** A reply or a command stays put; failure falls back to the current thread. */
-    async routeTopic(msg, text) {
-        // Every reason to decline is logged: six invisible conditions are
-        // indistinguishable from a bug.
-        const decline = !this.deps.store.policy("telegram", String(msg.chat.id)).topicMode
-            ? "topic mode off for this chat"
-            : msg.chat.type !== "supergroup"
-                ? `chat is a ${msg.chat.type}, not a supergroup`
-                : !msg.chat.is_forum
-                    ? "group has Topics disabled in Telegram"
-                    : !inGeneral(msg)
-                        ? `already inside topic ${msg.message_thread_id}`
-                        : msg.reply_to_message
-                            ? "message is a reply, so it continues an existing thread"
-                            : text.startsWith("/")
-                                ? "message is a command"
-                                : "";
-        if (decline) {
-            this.log(`no new topic in chat ${msg.chat.id}: ${decline}`);
-            return msg.message_thread_id;
-        }
-        const title = topicTitle(text);
-        try {
-            const topic = await this.api.createForumTopic(msg.chat.id, title);
-            await this.api.sendMessage({
-                chat_id: msg.chat.id,
-                text: `→ <a href="${topicLink(msg.chat, topic.message_thread_id)}">${escapeHtml(title)}</a>`,
-                parse_mode: "HTML",
-                message_thread_id: msg.message_thread_id,
-                reply_to_message_id: msg.message_id,
-                // Without the pointer, General shows a question whose answer went elsewhere.
-            }).catch((err) => this.log(`topic pointer failed: ${String(err)}`));
-            return topic.message_thread_id;
-        }
-        catch (err) {
-            this.log(`topic creation failed, staying in General: ${String(err)}`);
-            return msg.message_thread_id;
-        }
-    }
-    saveAttachments(msg) {
-        // A photo is a size ladder; the last entry is the largest.
-        const photo = msg.photo?.at(-1);
-        const doc = msg.document;
-        return saveInboundAll(this.id, [
-            ...(photo ? [{
-                    label: "photo",
-                    mimeType: "image/jpeg",
-                    size: photo.file_size,
-                    // A filename comes only from getFile, so the fetch's wins.
-                    fetch: async () => this.api.downloadFile(photo.file_id, MAX_INBOUND_BYTES),
-                }] : []),
-            ...(doc ? [{
-                    label: doc.file_name ?? "file",
-                    name: doc.file_name,
-                    mimeType: doc.mime_type ?? "application/octet-stream",
-                    size: doc.file_size,
-                    fetch: async () => this.api.downloadFile(doc.file_id, MAX_INBOUND_BYTES),
-                }] : []),
-        ], this.log);
-    }
-    // --- addressing ------------------------------------------------------------
-    addressed(text, msg) {
-        if (msg.reply_to_message?.from?.id === this.me?.id)
-            return true;
-        if (text.startsWith("/")) {
-            const target = /^\/\S+?@(\S+)/.exec(text)?.[1];
-            return !target || target.toLowerCase() === this.me?.username.toLowerCase();
-        }
-        const handle = `@${this.me?.username.toLowerCase()}`;
-        return !!this.me?.username && text.toLowerCase().includes(handle);
-    }
-    stripMention(text) {
-        const handle = `@${this.me?.username ?? ""}`;
-        if (!this.me?.username)
-            return text;
-        return text.toLowerCase().startsWith(handle.toLowerCase())
-            ? text.slice(handle.length).replace(/^[\s,:-]+/, "")
-            : text;
-    }
-    // --- outbound --------------------------------------------------------------
-    async send(conversation, reply) {
-        const { chatId, topicId } = parseConversation(conversation);
-        // A local file link is dead in Telegram: the bytes are uploaded instead.
-        const { text: spoken, paths } = splitAttachments(reply.text);
-        const text = spoken.trim();
-        // An empty turn still posts its footer and says which kind of nothing (§5).
-        const buttons = keyboard(reply.suggestions);
-        const quiet = isSilentReply(reply)
-            ? `<i>${quietLabel(reply.silence && escapeHtml(reply.silence))}</i>`
-            : "";
-        // A keyboard cannot ride a message that was never sent.
-        const body = ((text ? toTelegramHtml(text) : quiet) + turnFooter(reply.meta)) ||
-            (buttons ? "…" : "");
-        // A 👀 left up by a failed send looks like work until the stale sweep.
-        await this.receipts.settleAfter(conversation, async () => {
-            if (body.trim()) {
-                const parts = chunk(body);
-                for (const [i, part] of parts.entries()) {
-                    await this.api.sendMessage({
-                        chat_id: chatId,
-                        message_thread_id: topicId,
-                        text: part,
-                        parse_mode: "HTML",
-                        reply_markup: i === parts.length - 1 ? buttons : undefined,
-                    });
-                }
-            }
-            const lost = await sendAttachments(paths, (file) => this.api.sendFile({ chat_id: chatId, message_thread_id: topicId, file }), this.log);
-            if (lost) {
-                await this.api.sendMessage({
-                    chat_id: chatId,
-                    message_thread_id: topicId,
-                    text: escapeHtml(lost),
-                    parse_mode: "HTML",
-                });
-            }
-        }, reply.meta);
-    }
-    /** No footer: the turn this input triggers has not ended. The 👀 goes on the
-     *  note itself, since that turn has no message of the user's to carry them. */
-    async notify(conversation, note) {
-        const { chatId, topicId } = parseConversation(conversation);
-        const label = originLabel(note.origin);
-        let posted;
-        for (const part of chunk(`<i>${label}</i>\n<blockquote>${toTelegramHtml(note.text)}</blockquote>`)) {
-            posted = await this.api.sendMessage({
-                chat_id: chatId,
-                message_thread_id: topicId,
-                text: part,
-                parse_mode: "HTML",
-            });
-        }
-        if (posted && awaitsTurn(note.origin)) {
-            this.receipts.mark(conversation, chatId, String(posted.message_id));
-        }
-    }
-}
-const senderName = (user) => [user.first_name, user.last_name].filter(Boolean).join(" ") || user.username || String(user.id);
-/** A private supergroup links as `/c/<internal id>`: the chat id with its
- *  `-100` prefix removed. */
-function topicLink(chat, topicId) {
-    if (chat.username)
-        return `https://t.me/${chat.username}/${topicId}`;
-    const internal = String(chat.id).replace(/^-100(?=\d)/, "").replace(/^-/, "");
-    return `https://t.me/c/${internal}/${topicId}`;
-}
-/** One newline, not a blank line: Telegram has no muted text, so tucking it
- *  against the reply is the only way it reads as a footnote. */
-const turnFooter = (meta) => meta ? `\n<i>${formatTurnMeta(meta)}</i>` : "";

package/dist/extensions/index.js

@@ -1,10 +0,0 @@
-// The extensions Pier ships with. Bundled rather than dropped in
-// <agentDir>/extensions because a copy on disk has an owner problem: an update
-// either clobbers the user's edits or skips them forever.
-import web from "./web/index.js";
-export const BUNDLED = [
-    { name: "web", factory: web },
-];
-/** The enabled ones as Pi inline extensions; unknown names are not ours. */
-export const inlineExtensions = (enabled) => BUNDLED.filter((ext) => enabled.includes(ext.name))
-    .map(({ name, factory }) => ({ name, factory }));

package/dist/extensions/web/index.js

@@ -1,9 +0,0 @@
-// Two tools — web_search and web_fetch — served by the provider's own hosted
-// web stack, so an agent reaches the public web with no extra key, service or
-// dependency. Registered as an inline extension by agent/pi.ts when the
-// Console has it switched on.
-import { webFetch, webSearch } from "./tools.js";
-export default function web(pi) {
-    pi.registerTool(webSearch);
-    pi.registerTool(webFetch);
-}