@friendlyrobot/discord-pi-agent 0.2.0 → 0.3.0

package/dist/agent-service.d.ts

@@ -1,4 +1,4 @@
-import type { AgentStatus, ResolvedDiscordPiBridgeConfig } from "./types";
+import type { AgentStatus, ResolvedDiscordPiBridgeConfig, ThinkingLevel } from "./types";
 export declare class AgentService {
     private readonly config;
     private readonly authStorage;
@@ -16,5 +16,12 @@ export declare class AgentService {
     private createOrResumeSession;
     private ensureConfiguredModel;
     private requireSession;
+    private applyConfiguredThinkingLevel;
+    getThinkingLevel(): {
+        current: ThinkingLevel;
+        available: ThinkingLevel[];
+        supported: boolean;
+    };
+    setThinkingLevel(level: ThinkingLevel): string;
     private getSessionDir;
 }

package/dist/index.js

@@ -127,7 +127,8 @@ class AgentService {
       agentDir: this.config.agentDir,
       sessionDir: this.getSessionDir(),
       modelProvider: this.config.modelProvider,
-      modelId: this.config.modelId
+      modelId: this.config.modelId,
+      thinkingLevel: this.config.thinkingLevel
     });
     await this.resourceLoader.reload();
     console.log("[agent] resources loaded", {
@@ -159,7 +160,8 @@ class AgentService {
       modelRegistry: this.modelRegistry,
       resourceLoader: this.resourceLoader,
       settingsManager: this.settingsManager,
-      sessionManager: SessionManager.create(this.config.cwd, this.getSessionDir())
+      sessionManager: SessionManager.create(this.config.cwd, this.getSessionDir()),
+      thinkingLevel: this.config.thinkingLevel
     });
     this.session = session;
     await this.ensureConfiguredModel();
@@ -169,12 +171,14 @@ class AgentService {
     const session = this.requireSession();
     const model = session.model ? `${session.model.provider}/${session.model.id}` : "(no model selected)";
     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
+      contextUsage,
+      thinkingInfo
     };
   }
   async shutdown() {
@@ -193,7 +197,8 @@ class AgentService {
       modelRegistry: this.modelRegistry,
       resourceLoader: this.resourceLoader,
       settingsManager: this.settingsManager,
-      sessionManager: SessionManager.continueRecent(this.config.cwd, this.getSessionDir())
+      sessionManager: SessionManager.continueRecent(this.config.cwd, this.getSessionDir()),
+      thinkingLevel: this.config.thinkingLevel
     });
     this.session = session;
     console.log("[agent] session ready", {
@@ -226,6 +231,7 @@ class AgentService {
       to: `${desiredModel.provider}/${desiredModel.id}`
     });
     await session.setModel(desiredModel);
+    await this.applyConfiguredThinkingLevel();
   }
   requireSession() {
     if (!this.session) {
@@ -233,6 +239,44 @@ class AgentService {
     }
     return this.session;
   }
+  async applyConfiguredThinkingLevel() {
+    const session = this.requireSession();
+    if (session.supportsThinking()) {
+      const available = session.getAvailableThinkingLevels();
+      if (available.includes(this.config.thinkingLevel)) {
+        session.setThinkingLevel(this.config.thinkingLevel);
+        console.log("[agent] thinking level applied", { level: this.config.thinkingLevel });
+      } else {
+        console.log("[agent] thinking level not available for model", {
+          requested: this.config.thinkingLevel,
+          available
+        });
+      }
+    }
+  }
+  getThinkingLevel() {
+    const session = this.requireSession();
+    if (!session.supportsThinking()) {
+      return { current: "off", available: [], supported: false };
+    }
+    return {
+      current: session.thinkingLevel,
+      available: session.getAvailableThinkingLevels(),
+      supported: true
+    };
+  }
+  setThinkingLevel(level) {
+    const session = this.requireSession();
+    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}".`;
+  }
   getSessionDir() {
     return path.join(this.config.agentDir, "sessions");
   }
@@ -255,6 +299,7 @@ function resolveConfig(config) {
     agentDir: config.agentDir?.trim() || path2.join(config.cwd, ".pi-agent"),
     modelProvider: config.modelProvider?.trim() || "moonshot-cn",
     modelId: config.modelId?.trim() || "kimi-k2.5",
+    thinkingLevel: parseThinkingLevel(config.thinkingLevel) || "medium",
     promptTransform: config.promptTransform || identityPromptTransform,
     startupMessage: config.startupMessage === undefined ? "Bot is online and ready." : config.startupMessage,
     shutdownOnSignals: config.shutdownOnSignals ?? true
@@ -269,6 +314,7 @@ function loadDiscordPiBridgeConfigFromEnv(overrides = {}) {
     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),
     promptTransform: overrides.promptTransform,
     startupMessage: overrides.startupMessage ?? readStartupMessageFromEnv(),
     shutdownOnSignals: overrides.shutdownOnSignals
@@ -292,6 +338,17 @@ function readStartupMessageFromEnv() {
   }
   return trimmedValue;
 }
+function parseThinkingLevel(value) {
+  if (!value) {
+    return;
+  }
+  const trimmed = value.trim().toLowerCase();
+  const validLevels = ["off", "minimal", "low", "medium", "high", "xhigh"];
+  if (validLevels.includes(trimmed)) {
+    return trimmed;
+  }
+  return;
+}
 function identityPromptTransform(input) {
   return input;
 }
@@ -318,6 +375,7 @@ async function handleCommand(input, agentService, promptQueue) {
         "Commands:",
         "!help - show this message",
         "!status - show current session status",
+        "!thinking - show or set thinking/reasoning level",
         "!compact - compact the persistent session",
         "!reset-session - start a fresh persistent session",
         "Any other DM text goes to the persistent agent session."
@@ -337,6 +395,7 @@ async function handleCommand(input, agentService, promptQueue) {
         `session-id: ${agentStatus.sessionId}`,
         `session-file: ${agentStatus.sessionFile ?? "(none)"}`,
         `streaming: ${agentStatus.streaming}`,
+        agentStatus.thinkingInfo,
         contextLine,
         `queue-pending: ${queueStatus.pending}`,
         `queue-busy: ${queueStatus.busy}`
@@ -344,6 +403,33 @@ async function handleCommand(input, agentService, promptQueue) {
 `)
     };
   }
+  if (trimmed === "!thinking" || trimmed.startsWith("!thinking ")) {
+    const parts = trimmed.split(" ");
+    if (parts.length === 1) {
+      const info = agentService.getThinkingLevel();
+      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(`
+`)
+      };
+    }
+    const requestedLevel = parts[1];
+    const result = agentService.setThinkingLevel(requestedLevel);
+    return {
+      handled: true,
+      response: result
+    };
+  }
   if (trimmed === "!compact") {
     return {
       handled: true,

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 import type { Client } from "discord.js";
 export type PromptTransform = (input: string) => string | Promise<string>;
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
 export type DiscordPiBridgeConfig = {
     discordBotToken: string;
     discordAllowedUserId: string;
@@ -7,6 +8,7 @@ export type DiscordPiBridgeConfig = {
     agentDir?: string;
     modelProvider?: string;
     modelId?: string;
+    thinkingLevel?: ThinkingLevel;
     promptTransform?: PromptTransform;
     startupMessage?: string | false;
     shutdownOnSignals?: boolean;
@@ -18,6 +20,7 @@ export type ResolvedDiscordPiBridgeConfig = {
     agentDir: string;
     modelProvider: string;
     modelId: string;
+    thinkingLevel: ThinkingLevel;
     promptTransform: PromptTransform;
     startupMessage: string | false;
     shutdownOnSignals: boolean;
@@ -33,6 +36,7 @@ export type AgentStatus = {
     model: string;
     streaming: boolean;
     contextUsage: ContextUsageStatus | undefined;
+    thinkingInfo: string;
 };
 export type DiscordPiBridge = {
     client: Client;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@friendlyrobot/discord-pi-agent",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Reusable Discord gateway bridge for persistent pi agent sessions",
   "type": "module",
   "main": "./dist/index.js",
@@ -16,6 +16,10 @@
     "dist",
     "README.md"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/friendlyrobot/discord-pi-agent.git"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -24,8 +28,8 @@
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
-    "@mariozechner/pi-ai": "latest",
-    "@mariozechner/pi-coding-agent": "latest",
+    "@mariozechner/pi-ai": "^0.69.0",
+    "@mariozechner/pi-coding-agent": "^0.69.0",
     "discord.js": "^14.19.3",
     "dotenv": "^16.6.1"
   },