@friendlyrobot/discord-pi-agent 0.21.0 → 0.21.3

package/dist/logger.js

@@ -0,0 +1,26 @@
+import pino from "pino";
+const loggerLevel = process.env.DISCORD_PI_AGENT_LOG_LEVEL || process.env.LOG_LEVEL || "info";
+const usePrettyTransport = process.stdout.isTTY;
+const baseOptions = {
+    level: loggerLevel,
+};
+export const logger = usePrettyTransport
+    ? pino({
+        ...baseOptions,
+        transport: {
+            target: "pino-pretty",
+            options: {
+                colorize: true,
+                colorizeObjects: true,
+                levelFirst: true,
+                translateTime: "SYS:standard",
+                ignore: "pid,hostname",
+                singleLine: false,
+                messageFormat: "[{module}] {if direction}{direction} {end}{msg}",
+            },
+        },
+    })
+    : pino(baseOptions);
+export function createModuleLogger(moduleName) {
+    return logger.child({ module: moduleName });
+}

package/dist/markdown-table-transformer.js

@@ -0,0 +1,138 @@
+/**
+ * Transforms markdown tables into Discord-friendly code blocks.
+ * Discord doesn't support markdown tables natively, so we:
+ * 1. Format the entire document with Prettier (tables get formatted)
+ * 2. Use marked Lexer to identify tables
+ * 3. Wrap tables in triple backticks
+ * 4. Run Prettier once more on the entire result (tables stay formatted in code blocks)
+ */
+import { Lexer } from "marked";
+import { createModuleLogger } from "./logger";
+const logger = createModuleLogger("markdown-table-transformer");
+const CODE_BLOCK_WRAPPER = "```\n{TABLE}\n```";
+/**
+ * Transforms markdown tables in the text to Discord-friendly code blocks.
+ * Uses marked's Lexer to properly identify tables.
+ */
+export async function transformMarkdownTablesToCodeBlocks(text) {
+    // Ensure code fences are on their own lines.
+    // AI responses sometimes place ``` at the end of a text line
+    // (e.g. "some text.```"). This breaks CommonMark parsing — marked
+    // doesn't see it as a fence, and Prettier later "fixes" the resulting
+    // unbalanced blocks by adding spurious closing ```.
+    const normalized = normalizeCodeFences(text);
+    // Format the whole document first (tables are still markdown, so they get formatted)
+    const formatted = await formatWithPrettier(normalized);
+    // Use marked Lexer to identify tables
+    const tokens = Lexer.lex(formatted);
+    const result = [];
+    for (const token of tokens) {
+        if (token.type === "table") {
+            result.push(CODE_BLOCK_WRAPPER.replace("{TABLE}", token.raw.trimEnd()));
+        }
+        else {
+            result.push(token.raw);
+        }
+    }
+    // Run Prettier once more (tables are now in code blocks, won't be reformatted)
+    return formatWithPrettier(result.join(""));
+}
+/**
+ * Normalizes misplaced code fences so CommonMark parsers handle them correctly.
+ * AI output often has ``` in positions that Discord renders fine but break
+ * standard markdown parsing:
+ *
+ *   1. "some text.```"   → fence at end of text line → split to own line
+ *   2. "```some text"    → fence at start with text after → split to own line
+ *
+ * Without this, Prettier may "fix" unbalanced fences by adding spurious ```.
+ */
+function normalizeCodeFences(text) {
+    const lines = text.split("\n");
+    const result = [];
+    for (const line of lines) {
+        const trimmed = line.trimEnd();
+        // Case 1: fence at end of non-fence line (e.g., "hello world.```")
+        if (trimmed.endsWith("```") && !trimmed.startsWith("```")) {
+            const beforeFence = trimmed.slice(0, -3).trimEnd();
+            if (beforeFence) {
+                result.push(beforeFence);
+            }
+            result.push("```");
+            // Case 2: fence at start with trailing text that is NOT a valid info string.
+            // "```java" → keep as-is (info string). "```修正了" → split (prose text).
+        }
+        else if (trimmed.startsWith("```") && !isValidFenceLine(trimmed)) {
+            result.push("```");
+            const afterFence = trimmed.slice(3).trimStart();
+            if (afterFence) {
+                result.push(afterFence);
+            }
+        }
+        else {
+            result.push(line);
+        }
+    }
+    return result.join("\n");
+}
+/**
+ * Returns true if the line looks like a valid CommonMark code fence.
+ *
+ * Valid fences:
+ *   ```          (bare fence)
+ *   ```java      (info string)
+ *   ```c++       (unusual but valid info string)
+ *   ```diff:ts   (colon-separated directive)
+ *
+ * We only split when the content after ``` looks like prose —
+ * starts with a non-ASCII character (e.g., Chinese text),
+ * or the first "word" has multiple space-separated pieces.
+ */
+function isValidFenceLine(line) {
+    const trimmed = line.trimEnd();
+    // Bare fence: ```
+    if (trimmed === "```") {
+        return true;
+    }
+    const afterFence = trimmed.slice(3);
+    if (!afterFence) {
+        return true;
+    }
+    // If it starts with a non-ASCII character, it's prose (e.g. ```修正了)
+    // ASCII range: 0x00-0x7F
+    if (afterFence.codePointAt(0) > 0x7f) {
+        return false;
+    }
+    // Info strings are a single non-whitespace token per CommonMark spec.
+    // If there's more than one token, it's prose (e.g. ```this is prose).
+    // Trailing whitespace like "```java  " is fine — trimEnd already handled.
+    const tokens = afterFence.trimStart().split(/\s+/);
+    if (tokens.length > 1) {
+        return false;
+    }
+    // The token must not contain a backtick (would break the fence)
+    if (tokens[0].includes("`")) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Formats markdown text using Prettier.
+ * Logs on failure.
+ */
+async function formatWithPrettier(text) {
+    const prettier = await import("prettier");
+    try {
+        const formatted = await prettier.format(text, {
+            parser: "markdown",
+            printWidth: 80,
+        });
+        return formatted.trim();
+    }
+    catch (error) {
+        logger.error({
+            error,
+        }, "Prettier formatting failed");
+        return text;
+    }
+}

package/dist/media-description.js

@@ -0,0 +1,87 @@
+import { createModuleLogger } from "./logger";
+const logger = createModuleLogger("media-description");
+/**
+ * Use a vision-capable model to describe a media attachment (image or PDF),
+ * returning a text description that can be inlined into a prompt for a
+ * non-vision model.
+ *
+ * Creates a temporary in-memory session, sends the media, extracts the
+ * assistant's text reply, then disposes the session.
+ */
+export async function describeMediaAttachment(agentService, imageData, mimeType, userText, visionModel) {
+    const session = await agentService.createTemporarySession();
+    await session.setModel(visionModel);
+    const mediaType = getMediaType(mimeType);
+    const imageContent = {
+        type: "image",
+        data: imageData,
+        mimeType,
+    };
+    let promptText;
+    if (mediaType === "document") {
+        promptText =
+            userText.trim().length > 0
+                ? `The user sent a document with the following message: "${userText}". Please extract and summarize the text content of this document. Be thorough — include all important details, sections, and data from the document.`
+                : "Please extract and summarize the text content of this document. Be thorough — include all important details, sections, data, and key points.";
+    }
+    else {
+        promptText =
+            userText.trim().length > 0
+                ? `The user sent this image with the following message: "${userText}". Please describe the image in detail and address any questions from the user's message.`
+                : "Please describe this image in detail. What do you see?";
+    }
+    let text = "";
+    try {
+        await session.prompt(promptText, { images: [imageContent] });
+        text = extractLastAssistantText(session);
+    }
+    catch (error) {
+        logger.error({ error, mimeType }, "vision model prompt failed");
+        text = "(Vision model failed to process the file.)";
+    }
+    finally {
+        session.dispose();
+    }
+    if (!text) {
+        return "(Vision model returned no description.)";
+    }
+    logger.debug({ textLength: text.length, mimeType }, "media described");
+    return text;
+}
+function extractLastAssistantText(session) {
+    const messages = session.messages;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (!msg || !isAssistantMessage(msg)) {
+            continue;
+        }
+        const content = msg.content;
+        if (!Array.isArray(content)) {
+            continue;
+        }
+        const textBlocks = [];
+        for (const item of content) {
+            if (typeof item === "object" &&
+                item !== null &&
+                "type" in item &&
+                item.type === "text") {
+                textBlocks.push(item.text);
+            }
+        }
+        return textBlocks.join("\n").trim();
+    }
+    return "";
+}
+function getMediaType(mimeType) {
+    if (mimeType.startsWith("image/")) {
+        return "image";
+    }
+    // PDF, Word, PowerPoint — all treated as documents for prompting.
+    return "document";
+}
+function isAssistantMessage(msg) {
+    return (typeof msg === "object" &&
+        msg !== null &&
+        "role" in msg &&
+        msg.role === "assistant");
+}

package/dist/message-chunker.js

@@ -0,0 +1,38 @@
+import { marked } from "marked";
+const DISCORD_MESSAGE_LIMIT = 2000;
+const SAFE_MESSAGE_LIMIT = 1900;
+/**
+ * Chunk markdown text safely, preserving structural integrity of
+ * code blocks, tables, lists, and other block-level elements.
+ * Uses marked's lexer to split on token boundaries so no element
+ * gets bisected mid-structure.
+ */
+export function chunkMessage(text, maxChunkSize = SAFE_MESSAGE_LIMIT) {
+    if (text.length <= maxChunkSize) {
+        return [text];
+    }
+    const tokens = marked.lexer(text);
+    const chunks = [];
+    let currentTokens = [];
+    let currentSize = 0;
+    const flushChunk = () => {
+        if (currentTokens.length > 0) {
+            chunks.push(currentTokens
+                .map((t) => t.raw)
+                .join("")
+                .trim());
+            currentTokens = [];
+            currentSize = 0;
+        }
+    };
+    for (const token of tokens) {
+        const size = token.raw.length;
+        if (currentSize + size > maxChunkSize && currentTokens.length > 0) {
+            flushChunk();
+        }
+        currentTokens.push(token);
+        currentSize += size;
+    }
+    flushChunk();
+    return chunks.map((chunk) => chunk.slice(0, DISCORD_MESSAGE_LIMIT));
+}

package/dist/prompt-context.d.ts

@@ -2,17 +2,6 @@ export type DiscordPromptTimeFormatOptions = {
     timeZone?: string;
     locale?: string;
 };
-export type DiscordPromptScope = "dm" | "thread";
-export type DiscordMessageContextPromptOptions = {
-    scope: DiscordPromptScope;
-    messageId: string;
-    authorId: string;
-    sentAt?: string;
-    sentAtLocal?: string;
-    authorName?: string;
-    threadId?: string;
-    threadTitle?: string;
-    forumChannelId?: string | null;
-};
-export declare function buildDiscordMessageContextPrompt(userMessage: string, options: DiscordMessageContextPromptOptions): string;
 export declare function formatDiscordPromptTime(date: Date, options?: DiscordPromptTimeFormatOptions): string;
+/** Wrap content in an XML-style tag: `<tag>content</tag>`. */
+export declare function wrapXmlTag(tag: string, content: string): string;

package/dist/prompt-context.js

@@ -0,0 +1,19 @@
+export function formatDiscordPromptTime(date, options = {}) {
+    const timeZone = options.timeZone || "UTC";
+    const locale = options.locale || "en-AU";
+    return new Intl.DateTimeFormat(locale, {
+        timeZone,
+        weekday: "short",
+        day: "numeric",
+        month: "short",
+        year: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+        timeZoneName: "short",
+    }).format(date);
+}
+/** Wrap content in an XML-style tag: `<tag>content</tag>`. */
+export function wrapXmlTag(tag, content) {
+    return `<${tag}>${content}</${tag}>`;
+}

package/dist/prompt-queue.js

@@ -0,0 +1,37 @@
+export class PromptQueue {
+    queue = [];
+    running = false;
+    enqueue(task) {
+        return new Promise((resolve, reject) => {
+            this.queue.push(async () => {
+                try {
+                    resolve(await task());
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+            this.runNextTask();
+        });
+    }
+    getSnapshot() {
+        return {
+            pending: this.queue.length,
+            busy: this.running,
+        };
+    }
+    runNextTask() {
+        if (this.running) {
+            return;
+        }
+        const next = this.queue.shift();
+        if (!next) {
+            return;
+        }
+        this.running = true;
+        void next().finally(() => {
+            this.running = false;
+            this.runNextTask();
+        });
+    }
+}

package/dist/session-commands.js

@@ -0,0 +1,281 @@
+import { sessionDirForScope } from "./session-registry";
+function getSessionStatusText(session, promptQueue, extras) {
+    const model = session.model
+        ? `${session.model.provider}/${session.model.id}`
+        : "(no model selected)";
+    const contextUsage = session.getContextUsage();
+    const contextLine = contextUsage
+        ? contextUsage.tokens === null || contextUsage.percent === null
+            ? `context: ?/${contextUsage.contextWindow}`
+            : `context: ${contextUsage.tokens}/${contextUsage.contextWindow} (${Math.round(contextUsage.percent)}%)`
+        : "context: (unavailable)";
+    const thinkingInfo = session.supportsThinking()
+        ? `thinking: ${session.thinkingLevel} (available: ${session.getAvailableThinkingLevels().join(", ")})`
+        : "thinking: not supported";
+    const queueStatus = promptQueue.getSnapshot();
+    const lines = [
+        `model: ${model}`,
+        `session-id: ${session.sessionId}`,
+        `session-file: ${session.sessionFile ?? "(none)"}`,
+        `streaming: ${session.isStreaming}`,
+        thinkingInfo,
+        contextLine,
+        `queue-pending: ${queueStatus.pending}`,
+        `queue-busy: ${queueStatus.busy}`,
+    ];
+    if (extras?.tools && extras.tools.length > 0) {
+        const toolNames = extras.tools.map((tool) => tool.name);
+        lines.push("", `Tools (${extras.tools.length}): ${toolNames.join(", ")}`);
+    }
+    if (extras?.skillsSummary) {
+        lines.push("", extras.skillsSummary);
+    }
+    if (extras?.extensionsSummary) {
+        lines.push("", extras.extensionsSummary);
+    }
+    return lines.join("\n");
+}
+function getEffectiveSession(context) {
+    return context.session ?? context.agentService.getSession();
+}
+function requireEffectiveSession(context) {
+    const session = getEffectiveSession(context);
+    if (!session) {
+        return {
+            handled: true,
+            response: "No active session.",
+        };
+    }
+    return { session };
+}
+async function handleHelpCommand(trimmedInput, context) {
+    if (trimmedInput !== "!help") {
+        return null;
+    }
+    const extraCommands = context.session
+        ? "\n!archive - archive this thread and end the session"
+        : "";
+    return {
+        handled: true,
+        response: [
+            "Commands:",
+            "!help - show this message",
+            "!status - show current session status",
+            "!thinking - show or set thinking/reasoning level",
+            "!model - list available models or switch to one",
+            "!compact - compact the persistent session",
+            "!reset-session - start a fresh persistent session",
+            "!reload - reload resources (AGENTS.md, extensions, skills, etc.)",
+            "!reaction - show or set the working reaction emoji",
+            extraCommands,
+            "Any other text goes to the agent session.",
+        ]
+            .filter(Boolean)
+            .join("\n"),
+    };
+}
+async function handleArchiveCommand(trimmedInput, context) {
+    if (trimmedInput !== "!archive") {
+        return null;
+    }
+    if (!context.session) {
+        return {
+            handled: true,
+            response: "!archive is only available in forum threads.",
+        };
+    }
+    return {
+        handled: true,
+        archive: true,
+        response: "Archiving thread and shutting down session.",
+    };
+}
+async function handleStatusCommand(trimmedInput, context) {
+    if (trimmedInput !== "!status") {
+        return null;
+    }
+    const effectiveSession = requireEffectiveSession(context);
+    if ("handled" in effectiveSession) {
+        return effectiveSession;
+    }
+    const tools = effectiveSession.session.getAllTools();
+    const extensionsSummary = context.agentService.resources.getExtensionsSummary();
+    const skillsSummary = context.agentService.resources.getSkillsSummary();
+    return {
+        handled: true,
+        response: getSessionStatusText(effectiveSession.session, context.promptQueue, {
+            tools,
+            extensionsSummary,
+            skillsSummary,
+        }),
+    };
+}
+async function handleThinkingCommand(trimmedInput, context) {
+    if (trimmedInput !== "!thinking" && !trimmedInput.startsWith("!thinking ")) {
+        return null;
+    }
+    const effectiveSession = requireEffectiveSession(context);
+    if ("handled" in effectiveSession) {
+        return effectiveSession;
+    }
+    const parts = trimmedInput.split(" ");
+    if (parts.length === 1) {
+        const info = context.agentService.models.getThinkingLevel(effectiveSession.session);
+        if (!info.supported) {
+            return {
+                handled: true,
+                response: "Current model does not support reasoning/thinking.",
+            };
+        }
+        return {
+            handled: true,
+            response: [
+                `Current: ${info.current}`,
+                `Available: ${info.available.join(", ")}`,
+                `Usage: !thinking <level>`,
+            ].join("\n"),
+        };
+    }
+    const requestedLevel = parts[1];
+    return {
+        handled: true,
+        response: context.agentService.models.setThinkingLevel(effectiveSession.session, requestedLevel),
+    };
+}
+async function handleModelCommand(trimmedInput, context) {
+    if (trimmedInput !== "!model" && !trimmedInput.startsWith("!model ")) {
+        return null;
+    }
+    const effectiveSession = requireEffectiveSession(context);
+    if ("handled" in effectiveSession) {
+        return effectiveSession;
+    }
+    const parts = trimmedInput.split(" ");
+    if (parts.length === 1) {
+        const current = context.agentService.models.getCurrentModelDisplay(effectiveSession.session);
+        const modelList = await context.agentService.models.listModels(effectiveSession.session);
+        return {
+            handled: true,
+            response: `Current model: ${current}\n\n${modelList}`,
+        };
+    }
+    const argument = parts.slice(1).join(" ");
+    const slashIndex = argument.indexOf("/");
+    if (slashIndex === -1) {
+        return {
+            handled: true,
+            response: "Usage: !model <provider/modelId>\n" +
+                "Example: !model openrouter/anthropic/claude-sonnet-4\n" +
+                "Use !model without args to see available models.",
+        };
+    }
+    const provider = argument.substring(0, slashIndex).trim();
+    const modelId = argument.substring(slashIndex + 1).trim();
+    return {
+        handled: true,
+        response: await context.agentService.models.switchModel(provider, modelId, effectiveSession.session),
+    };
+}
+async function handleCompactCommand(trimmedInput, context) {
+    if (trimmedInput !== "!compact") {
+        return null;
+    }
+    const effectiveSession = requireEffectiveSession(context);
+    if ("handled" in effectiveSession) {
+        return effectiveSession;
+    }
+    return {
+        handled: true,
+        response: await context.promptQueue.enqueue(async () => {
+            await effectiveSession.session.compact();
+            return `Compaction finished for session ${effectiveSession.session.sessionId}.`;
+        }),
+    };
+}
+async function handleReloadCommand(trimmedInput, context) {
+    if (trimmedInput !== "!reload") {
+        return null;
+    }
+    return {
+        handled: true,
+        response: await context.promptQueue.enqueue(async () => {
+            return context.agentService.resources.reloadResources();
+        }),
+    };
+}
+async function handleResetSessionCommand(trimmedInput, context) {
+    if (trimmedInput !== "!reset-session") {
+        return null;
+    }
+    const effectiveSession = requireEffectiveSession(context);
+    if ("handled" in effectiveSession) {
+        return effectiveSession;
+    }
+    let newSession;
+    const response = await context.promptQueue.enqueue(async () => {
+        const previousSessionFile = effectiveSession.session.sessionFile;
+        await effectiveSession.session.abort();
+        effectiveSession.session.dispose();
+        const sessionDir = sessionDirForScope(context.agentService.getAgentDir(), context.scope);
+        newSession = await context.agentService.createSession(sessionDir);
+        return `Started a fresh session. Old session kept at ${previousSessionFile ?? "(unknown path)"}.`;
+    });
+    return {
+        handled: true,
+        response,
+        newSession,
+    };
+}
+async function handleReactionCommand(trimmedInput, _context) {
+    if (trimmedInput !== "!reaction" && !trimmedInput.startsWith("!reaction ")) {
+        return null;
+    }
+    const parts = trimmedInput.split(" ");
+    if (parts.length === 1) {
+        return {
+            handled: true,
+            response: `Current working reaction: ${_context.workingEmoji}\n` +
+                `Usage: !reaction <emoji> to change it.\n` +
+                `Examples: !reaction 🔄 or !reaction ⏳`,
+        };
+    }
+    const emoji = parts.slice(1).join(" ").trim();
+    if (!emoji) {
+        return {
+            handled: true,
+            response: "Please provide an emoji. Example: !reaction 🔄",
+        };
+    }
+    return {
+        handled: true,
+        workingEmoji: emoji,
+        response: `Working reaction emoji set to ${emoji}`,
+    };
+}
+const commandHandlers = [
+    handleHelpCommand,
+    handleArchiveCommand,
+    handleStatusCommand,
+    handleThinkingCommand,
+    handleModelCommand,
+    handleCompactCommand,
+    handleReloadCommand,
+    handleResetSessionCommand,
+    handleReactionCommand,
+];
+export async function executeSessionCommand(input, context) {
+    const trimmedInput = input.trim();
+    if (!trimmedInput.startsWith("!")) {
+        return { handled: false };
+    }
+    for (const handler of commandHandlers) {
+        const result = await handler(trimmedInput, context);
+        if (result) {
+            return result;
+        }
+    }
+    return {
+        handled: true,
+        response: `Unknown command: ${trimmedInput}. Try !help.`,
+    };
+}