@friendlyrobot/discord-pi-agent 0.21.0 → 0.21.3

package/README.md

@@ -53,7 +53,7 @@ DM prompts omit thread-only fields. `sent_at_local` uses `promptTimeZone` and `p
 ## Install
 
 ```bash
-bun add @friendlyrobot/discord-pi-agent
+npm install @friendlyrobot/discord-pi-agent
 ```
 
 ## Usage
@@ -163,10 +163,21 @@ Not all models support thinking/reasoning. The configured `thinkingLevel` is app
 ## Build
 
 ```bash
-bun run build
-bun run typecheck
+npm run build
+npm run typecheck
 ```
 
+## Dependency updates
+
+To check for newer package versions and update `package.json`, run:
+
+```bash
+npx npm-check-updates -u
+npm install
+```
+
+This is the npm-side replacement for the old `bun update` workflow.
+
 ## Notes
 
 - DM and forum threads supported via `startDiscordGateway`

package/dist/agent-model-service.js

@@ -0,0 +1,132 @@
+import { createModuleLogger } from "./logger";
+const logger = createModuleLogger("agent-model-service");
+export class AgentModelService {
+    config;
+    modelRegistry;
+    constructor(config, modelRegistry) {
+        this.config = config;
+        this.modelRegistry = modelRegistry;
+    }
+    findModel(provider, modelId) {
+        return this.modelRegistry.find(provider, modelId);
+    }
+    async ensureSessionHasConfiguredModel(session) {
+        if (session.model) {
+            logger.debug({
+                model: `${session.model.provider}/${session.model.id}`,
+            }, "retaining existing session model");
+            return;
+        }
+        const desiredModel = this.modelRegistry.find(this.config.modelProvider, this.config.modelId);
+        const availableModels = await this.modelRegistry.getAvailable();
+        logger.debug({
+            count: availableModels.length,
+            matches: availableModels
+                .filter((model) => {
+                return model.provider === this.config.modelProvider;
+            })
+                .map((model) => `${model.provider}/${model.id}`),
+        }, "available models");
+        if (!desiredModel) {
+            throw new Error(`Configured model not found: ${this.config.modelProvider}/${this.config.modelId}. Check your pi agent config and installed extensions.`);
+        }
+        logger.info({
+            to: `${desiredModel.provider}/${desiredModel.id}`,
+        }, "setting initial session model");
+        await session.setModel(desiredModel);
+        await this.applyConfiguredThinkingLevelForSession(session);
+    }
+    async listModels(session) {
+        const availableModels = await this.modelRegistry.getAvailable();
+        const currentDisplay = session?.model
+            ? `${session.model.provider}/${session.model.id}`
+            : null;
+        const lines = availableModels.map((model) => {
+            const display = `${model.provider}/${model.id}`;
+            const marker = currentDisplay === display ? " (current)" : "";
+            return `  ${display}${marker}`;
+        });
+        return [
+            `Available models (${availableModels.length}):`,
+            ...lines,
+            `\nUsage: !model <provider/modelId> to switch.`,
+        ].join("\n");
+    }
+    async switchModel(provider, modelId, session) {
+        const model = this.modelRegistry.find(provider, modelId);
+        if (!model) {
+            const availableModels = await this.modelRegistry.getAvailable();
+            const matches = availableModels
+                .filter((availableModel) => {
+                return availableModel.provider === provider;
+            })
+                .map((availableModel) => {
+                return `${availableModel.provider}/${availableModel.id}`;
+            });
+            const hint = matches.length > 0
+                ? `\nModels from "${provider}": ${matches.join(", ")}`
+                : `\nUse !model to see all available models.`;
+            return `Model not found: ${provider}/${modelId}.${hint}`;
+        }
+        if (isSameModel(session.model, model)) {
+            return `Already using ${provider}/${modelId}.`;
+        }
+        await session.setModel(model);
+        await this.applyConfiguredThinkingLevelForSession(session);
+        const thinkingInfo = session.supportsThinking()
+            ? ` (thinking: ${session.thinkingLevel})`
+            : "";
+        return `Switched to ${provider}/${modelId}${thinkingInfo}.`;
+    }
+    getCurrentModelDisplay(session) {
+        if (!session?.model) {
+            return "(no model selected)";
+        }
+        return `${session.model.provider}/${session.model.id}`;
+    }
+    getThinkingLevel(session) {
+        if (!session.supportsThinking()) {
+            return { current: "off", available: [], supported: false };
+        }
+        return {
+            current: session.thinkingLevel,
+            available: session.getAvailableThinkingLevels(),
+            supported: true,
+        };
+    }
+    setThinkingLevel(session, level) {
+        if (!session.supportsThinking()) {
+            return "Current model does not support reasoning/thinking.";
+        }
+        const available = session.getAvailableThinkingLevels();
+        if (!available.includes(level)) {
+            return `Invalid thinking level "${level}" for current model. Available: ${available.join(", ")}`;
+        }
+        session.setThinkingLevel(level);
+        return `Thinking level set to "${level}".`;
+    }
+    async applyConfiguredThinkingLevelForSession(session) {
+        if (session.supportsThinking()) {
+            const available = session.getAvailableThinkingLevels();
+            if (available.includes(this.config.thinkingLevel)) {
+                session.setThinkingLevel(this.config.thinkingLevel);
+                logger.debug({
+                    level: this.config.thinkingLevel,
+                }, "thinking level applied");
+            }
+            else {
+                logger.debug({
+                    requested: this.config.thinkingLevel,
+                    available,
+                }, "thinking level not available for model");
+            }
+        }
+    }
+}
+function isSameModel(currentModel, desiredModel) {
+    if (!currentModel) {
+        return false;
+    }
+    return (currentModel.provider === desiredModel.provider &&
+        currentModel.id === desiredModel.id);
+}

package/dist/agent-resource-service.js

@@ -0,0 +1,70 @@
+export class AgentResourceService {
+    resourceLoader;
+    constructor(resourceLoader) {
+        this.resourceLoader = resourceLoader;
+    }
+    getSkillsSummary() {
+        const result = this.resourceLoader.getSkills();
+        const { skills } = result;
+        if (skills.length === 0) {
+            return "Skills: (none loaded)";
+        }
+        const names = skills.map((skill) => {
+            return skill.name;
+        });
+        return `Skills (${skills.length}): ${names.join(", ") || "(none)"}`;
+    }
+    getExtensionsSummary() {
+        const result = this.resourceLoader.getExtensions();
+        const { extensions, errors } = result;
+        if (extensions.length === 0) {
+            return "Extensions: (none loaded)";
+        }
+        const lines = extensions.map((extension) => {
+            const toolCount = extension.tools.size;
+            const commandCount = extension.commands.size;
+            const parts = [];
+            if (toolCount > 0) {
+                parts.push(`${toolCount} tool${toolCount !== 1 ? "s" : ""}`);
+            }
+            if (commandCount > 0) {
+                parts.push(`${commandCount} command${commandCount !== 1 ? "s" : ""}`);
+            }
+            const summary = parts.length > 0 ? ` (${parts.join(", ")})` : "";
+            return `  ${extension.path}${summary}`;
+        });
+        const header = `Extensions (${extensions.length}):`;
+        const errorLines = errors.length > 0
+            ? [
+                `Errors (${errors.length}):`,
+                ...errors.map((error) => {
+                    return `  ${error.path}: ${error.error}`;
+                }),
+            ]
+            : [];
+        return [header, ...lines, ...errorLines].join("\n");
+    }
+    async reloadResources() {
+        await this.resourceLoader.reload();
+        const extensions = this.resourceLoader
+            .getExtensions()
+            .extensions.map((extension) => {
+            return extension.path;
+        });
+        const skills = this.resourceLoader.getSkills();
+        const skillNames = skills.skills.map((skill) => {
+            return skill.name;
+        });
+        const agentsFiles = this.resourceLoader
+            .getAgentsFiles()
+            .agentsFiles.map((file) => {
+            return file.path;
+        });
+        return [
+            "Resources reloaded.",
+            `Extensions (${extensions.length}): ${extensions.join(", ") || "(none)"}`,
+            `Skills (${skills.skills.length}): ${skillNames.join(", ") || "(none)"}`,
+            `AGENTS.md files (${agentsFiles.length}): ${agentsFiles.join(", ") || "(none)"}`,
+        ].join("\n");
+    }
+}

package/dist/agent-service.js

@@ -0,0 +1,189 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { AuthStorage, createAgentSession, DefaultResourceLoader, ModelRegistry, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { AgentModelService } from "./agent-model-service";
+import { AgentResourceService } from "./agent-resource-service";
+import { createModuleLogger } from "./logger";
+import { runAgentTurn } from "./agent-turn-runner";
+const logger = createModuleLogger("agent-service");
+export class AgentService {
+    config;
+    authStorage;
+    modelRegistry;
+    settingsManager;
+    resourceLoader;
+    session = null;
+    models;
+    resources;
+    constructor(config) {
+        this.config = config;
+        this.authStorage = AuthStorage.create(path.join(config.agentDir, "auth.json"));
+        this.modelRegistry = ModelRegistry.create(this.authStorage, path.join(config.agentDir, "models.json"));
+        this.settingsManager = SettingsManager.create(config.cwd, config.agentDir);
+        this.resourceLoader = new DefaultResourceLoader({
+            cwd: config.cwd,
+            agentDir: config.agentDir,
+            settingsManager: this.settingsManager,
+        });
+        this.models = new AgentModelService(config, this.modelRegistry);
+        this.resources = new AgentResourceService(this.resourceLoader);
+    }
+    async initialize() {
+        await fs.mkdir(this.config.agentDir, { recursive: true });
+        await fs.mkdir(this.getSessionDir(), { recursive: true });
+        logger.info({
+            cwd: this.config.cwd,
+            agentDir: this.config.agentDir,
+            sessionDir: this.getSessionDir(),
+            modelProvider: this.config.modelProvider,
+            modelId: this.config.modelId,
+            thinkingLevel: this.config.thinkingLevel,
+        }, "config");
+        await this.resourceLoader.reload();
+        logger.info({
+            extensions: this.resourceLoader
+                .getExtensions()
+                .extensions.map((extension) => extension.path),
+            agentsFiles: this.resourceLoader
+                .getAgentsFiles()
+                .agentsFiles.map((file) => file.path),
+        }, "resources loaded");
+        await this.createOrResumeSession();
+        await this.ensureConfiguredModel();
+    }
+    getSession() {
+        return this.session;
+    }
+    getAgentDir() {
+        return this.config.agentDir;
+    }
+    /**
+     * Create a temporary in-memory session. For one-shot tasks like image
+     * description — no file persistence, no cleanup needed. The caller must
+     * setModel() before prompting and dispose() when done.
+     */
+    async createTemporarySession() {
+        const { session } = await createAgentSession({
+            cwd: this.config.cwd,
+            agentDir: this.config.agentDir,
+            authStorage: this.authStorage,
+            modelRegistry: this.modelRegistry,
+            resourceLoader: this.resourceLoader,
+            settingsManager: this.settingsManager,
+            sessionManager: SessionManager.inMemory(),
+            thinkingLevel: "off",
+        });
+        logger.debug({ sessionId: session.sessionId }, "temporary session created");
+        return session;
+    }
+    async createSession(sessionDir) {
+        await fs.mkdir(sessionDir, { recursive: true });
+        const { session } = await createAgentSession({
+            cwd: this.config.cwd,
+            agentDir: this.config.agentDir,
+            authStorage: this.authStorage,
+            modelRegistry: this.modelRegistry,
+            resourceLoader: this.resourceLoader,
+            settingsManager: this.settingsManager,
+            sessionManager: SessionManager.continueRecent(this.config.cwd, sessionDir),
+            thinkingLevel: this.config.thinkingLevel,
+        });
+        logger.debug({
+            sessionDir,
+            sessionId: session.sessionId,
+            sessionFile: session.sessionFile,
+        }, "scoped session created");
+        await this.models.ensureSessionHasConfiguredModel(session);
+        return session;
+    }
+    async prompt(text) {
+        const session = this.requireSession();
+        const transformedPrompt = await this.config.promptTransform({
+            rawContent: text,
+            discordMetadata: "",
+            now: () => "",
+            userMessage: () => text,
+        });
+        return runAgentTurn(session, transformedPrompt);
+    }
+    async compact() {
+        const session = this.requireSession();
+        await session.compact();
+        return `Compaction finished for session ${session.sessionId}.`;
+    }
+    async resetSession() {
+        const previousSession = this.requireSession();
+        await previousSession.abort();
+        previousSession.dispose();
+        this.session = null;
+        const { session } = await createAgentSession({
+            cwd: this.config.cwd,
+            agentDir: this.config.agentDir,
+            authStorage: this.authStorage,
+            modelRegistry: this.modelRegistry,
+            resourceLoader: this.resourceLoader,
+            settingsManager: this.settingsManager,
+            sessionManager: SessionManager.create(this.config.cwd, this.getSessionDir()),
+            thinkingLevel: this.config.thinkingLevel,
+        });
+        this.session = session;
+        await this.ensureConfiguredModel();
+        return `Started a fresh session. Old session kept at ${previousSession.sessionFile ?? "(unknown path)"}.`;
+    }
+    getStatus() {
+        const session = this.requireSession();
+        const model = this.models.getCurrentModelDisplay(session);
+        const contextUsage = session.getContextUsage();
+        const thinkingInfo = session.supportsThinking()
+            ? `thinking: ${session.thinkingLevel} (available: ${session.getAvailableThinkingLevels().join(", ")})`
+            : "thinking: not supported";
+        return {
+            sessionId: session.sessionId,
+            sessionFile: session.sessionFile,
+            model,
+            streaming: session.isStreaming,
+            contextUsage,
+            thinkingInfo,
+        };
+    }
+    async shutdown() {
+        const session = this.session;
+        if (session) {
+            await session.abort();
+            session.dispose();
+        }
+        await this.settingsManager.flush();
+    }
+    async createOrResumeSession() {
+        const { session } = await createAgentSession({
+            cwd: this.config.cwd,
+            agentDir: this.config.agentDir,
+            authStorage: this.authStorage,
+            modelRegistry: this.modelRegistry,
+            resourceLoader: this.resourceLoader,
+            settingsManager: this.settingsManager,
+            sessionManager: SessionManager.continueRecent(this.config.cwd, this.getSessionDir()),
+            thinkingLevel: this.config.thinkingLevel,
+        });
+        this.session = session;
+        logger.info({
+            sessionId: session.sessionId,
+            sessionFile: session.sessionFile,
+            restoredModel: session.model
+                ? `${session.model.provider}/${session.model.id}`
+                : null,
+        }, "session ready");
+    }
+    async ensureConfiguredModel() {
+        await this.models.ensureSessionHasConfiguredModel(this.requireSession());
+    }
+    requireSession() {
+        if (!this.session) {
+            throw new Error("Agent session has not been initialized.");
+        }
+        return this.session;
+    }
+    getSessionDir() {
+        return path.join(this.config.agentDir, "sessions");
+    }
+}

package/dist/agent-turn-runner.js

@@ -0,0 +1,148 @@
+import { debugPrint } from "./debug-print";
+import { createModuleLogger } from "./logger";
+import { transformMarkdownTablesToCodeBlocks } from "./markdown-table-transformer";
+const logger = createModuleLogger("agent-turn-runner");
+export async function runAgentTurn(session, prompt, options = {}) {
+    let streamedText = "";
+    let eventCount = 0;
+    let toolCount = 0;
+    const toolInputsByCallId = new Map();
+    const model = session.model
+        ? `${session.model.provider}/${session.model.id}`
+        : "none";
+    debugPrint(prompt, "Full Prompt");
+    // logger.debug(
+    //   {
+    //     promptLength: prompt.length,
+    //     model,
+    //     prompt,
+    //   },
+    //   "prompt start",
+    // );
+    const unsubscribe = session.subscribe((event) => {
+        eventCount += 1;
+        if (event.type === "message_update") {
+            if (event.assistantMessageEvent.type === "text_delta") {
+                streamedText += event.assistantMessageEvent.delta;
+            }
+            if (event.assistantMessageEvent.type === "thinking_delta") {
+                // Intentionally ignored. Thinking deltas are too noisy for routine logs.
+            }
+        }
+        if (event.type === "tool_execution_start") {
+            toolCount += 1;
+            const input = event.toolName === "bash" ? event.args.command : event.args;
+            toolInputsByCallId.set(event.toolCallId, input);
+            if (event.toolName === "bash") {
+                debugPrint(input, "CMD");
+                // logger.debug(
+                //   {
+                //     toolName: event.toolName,
+                //   },
+                //   `agent tool start: [${event.toolName}]`,
+                // );
+            }
+            else {
+                logger.debug({
+                    toolName: event.toolName,
+                    // input,
+                }, `agent tool start: [${event.toolName}]`);
+            }
+        }
+        if (event.type === "tool_execution_end") {
+            const input = toolInputsByCallId.get(event.toolCallId);
+            toolInputsByCallId.delete(event.toolCallId);
+            if (event.toolName === "bash") {
+                debugPrint(extractToolOutput(event.result), event.isError ? "BASH TOOL ERROR OUTPUT" : "BASH TOOL OUTPUT");
+                // logger.debug(
+                //   {
+                //     toolName: event.toolName,
+                //     isError: event.isError,
+                //   },
+                //   `agent tool end: [${event.toolName}] ${truncateForLog(
+                //     typeof input === "string" ? input : "",
+                //   )}`,
+                // );
+            }
+            else {
+                logger.debug({
+                    toolName: event.toolName,
+                    // input: truncateForLog(extractToolOutput(input)),
+                    isError: event.isError,
+                    // output: event.result,
+                    // output: truncateForLog(extractToolOutput(event.result)),
+                }, `agent tool end: [${event.toolName}]`);
+            }
+        }
+        // if (event.type === "agent_end") {
+        //   logger.debug(
+        //     {
+        //       messageCount: event.messages.length,
+        //       model,
+        //       toolCount,
+        //       eventCount,
+        //     },
+        //     "agent end",
+        //   );
+        // }
+    });
+    try {
+        await session.prompt(prompt, { images: options.images });
+    }
+    finally {
+        unsubscribe();
+    }
+    const errorMessage = session.agent.state.errorMessage?.trim();
+    const fallbackText = getLatestAssistantText(session.messages);
+    const finalText = streamedText.trim() || fallbackText.trim();
+    if (errorMessage) {
+        return errorMessage;
+    }
+    if (finalText) {
+        const transformed = await transformMarkdownTablesToCodeBlocks(finalText);
+        debugPrint(finalText, "BEFORE TRANSFORM");
+        debugPrint(transformed, "TRANSFORMED");
+        return transformed;
+    }
+    return "No response generated.";
+}
+function truncateForLog(value, maxLength = 400) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, maxLength)}...`;
+}
+function extractToolOutput(output) {
+    if (typeof output === "object" && output !== null) {
+        const obj = output;
+        if (Array.isArray(obj.content)) {
+            return obj.content
+                .map((item) => {
+                if (item.type === "text" && typeof item.text === "string") {
+                    return item.text;
+                }
+                return JSON.stringify(item);
+            })
+                .join("\n");
+        }
+    }
+    return String(output);
+}
+function getLatestAssistantText(messages) {
+    const latestAssistantMessage = [...messages].reverse().find((message) => {
+        return message.role === "assistant";
+    });
+    if (!latestAssistantMessage ||
+        !Array.isArray(latestAssistantMessage.content)) {
+        return "";
+    }
+    return latestAssistantMessage.content
+        .filter((item) => {
+        return item.type === "text";
+    })
+        .map((item) => {
+        return item.text ?? "";
+    })
+        .join("\n")
+        .trim();
+}

package/dist/config.js

@@ -0,0 +1,103 @@
+import path from "node:path";
+import dotenv from "dotenv";
+export function resolveConfig(config) {
+    const discordAllowedUserId = requireNonEmptyConfigValue("discordAllowedUserId", config.discordAllowedUserId);
+    const cwd = requireNonEmptyConfigValue("cwd", config.cwd);
+    return {
+        discordBotToken: requireNonEmptyConfigValue("discordBotToken", config.discordBotToken),
+        discordAllowedUserId,
+        cwd,
+        agentDir: config.agentDir?.trim() || path.join(cwd, ".pi-agent"),
+        modelProvider: config.modelProvider?.trim() || "openrouter",
+        modelId: config.modelId?.trim() || "anthropic/claude-3.5-haiku",
+        thinkingLevel: parseThinkingLevel(config.thinkingLevel) || "medium",
+        promptTimeZone: config.promptTimeZone?.trim() || "UTC",
+        promptLocale: config.promptLocale?.trim() || "en-AU",
+        promptTransform: config.promptTransform || defaultPromptTransform,
+        startupMessage: config.startupMessage === undefined
+            ? "Bot is online and ready."
+            : config.startupMessage,
+        shutdownOnSignals: config.shutdownOnSignals ?? true,
+        visionModelId: config.visionModelId?.trim() || null,
+        discordAllowedForumChannelIds: config.discordAllowedForumChannelIds ?? [],
+        discordAllowedUserIds: config.discordAllowedUserIds ?? [
+            discordAllowedUserId,
+        ],
+    };
+}
+export function loadDiscordGatewayConfigFromEnv(overrides = {}) {
+    dotenv.config();
+    return resolveConfig({
+        discordBotToken: overrides.discordBotToken || process.env.DISCORD_BOT_TOKEN || "",
+        discordAllowedUserId: overrides.discordAllowedUserId ||
+            process.env.DISCORD_ALLOWED_USER_ID ||
+            "",
+        cwd: overrides.cwd || process.env.PI_AGENT_CWD || process.cwd(),
+        agentDir: overrides.agentDir || process.env.PI_AGENT_DIR,
+        modelProvider: overrides.modelProvider || process.env.PI_MODEL_PROVIDER,
+        modelId: overrides.modelId || process.env.PI_MODEL_ID,
+        thinkingLevel: parseThinkingLevel(overrides.thinkingLevel || process.env.PI_THINKING_LEVEL),
+        promptTimeZone: overrides.promptTimeZone || process.env.PI_PROMPT_TIME_ZONE,
+        promptLocale: overrides.promptLocale || process.env.PI_PROMPT_LOCALE,
+        promptTransform: overrides.promptTransform,
+        startupMessage: overrides.startupMessage ?? readStartupMessageFromEnv(),
+        shutdownOnSignals: overrides.shutdownOnSignals,
+        visionModelId: overrides.visionModelId ?? process.env.PI_VISION_MODEL_ID,
+        discordAllowedForumChannelIds: overrides.discordAllowedForumChannelIds ??
+            parseStringArrayFromEnv("DISCORD_FORUM_CHANNEL_IDS") ??
+            [],
+        discordAllowedUserIds: overrides.discordAllowedUserIds ??
+            parseStringArrayFromEnv("DISCORD_ALLOWED_USER_IDS"),
+    });
+}
+function requireNonEmptyConfigValue(name, value) {
+    const trimmedValue = value.trim();
+    if (!trimmedValue) {
+        throw new Error(`Missing required config value: ${name}`);
+    }
+    return trimmedValue;
+}
+function readStartupMessageFromEnv() {
+    const value = process.env.DISCORD_STARTUP_MESSAGE;
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmedValue = value.trim();
+    if (!trimmedValue || trimmedValue.toLowerCase() === "false") {
+        return false;
+    }
+    return trimmedValue;
+}
+function parseThinkingLevel(value) {
+    if (!value) {
+        return undefined;
+    }
+    const trimmed = value.trim().toLowerCase();
+    const validLevels = [
+        "off",
+        "minimal",
+        "low",
+        "medium",
+        "high",
+        "xhigh",
+    ];
+    if (validLevels.includes(trimmed)) {
+        return trimmed;
+    }
+    return undefined;
+}
+function defaultPromptTransform(ctx) {
+    return [ctx.now(), ctx.discordMetadata, "", ctx.userMessage()]
+        .filter(Boolean)
+        .join("\n");
+}
+function parseStringArrayFromEnv(key) {
+    const value = process.env[key];
+    if (!value) {
+        return undefined;
+    }
+    return value
+        .split(",")
+        .map((id) => id.trim())
+        .filter(Boolean);
+}