arisa 4.3.2 → 4.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "4.3.2",
+  "version": "4.3.4",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",
@@ -37,7 +37,7 @@
   },
   "homepage": "https://arisa.sh",
   "dependencies": {
-    "@earendil-works/pi-coding-agent": "^0.80.6",
+    "@earendil-works/pi-coding-agent": "0.80.6",
     "@sinclair/typebox": "^0.34.41",
     "grammy": "^1.42.0"
   },

package/src/core/agent/agent-manager.js

@@ -8,6 +8,7 @@ import { appendArisaAgentsFile, arisaAgentsFile, arisaInstallDir, buildAgentRunt
 import { withTimeout } from "./prompt-timeout.js";
 import { buildPiToolPolicy, getCoreCodingTools } from "./core-tools.js";
 import { createSystemShellTool } from "./system-shell-tool.js";
+import { clampModelThinkingLevel } from "./pi-runtime.js";
 import { arisaHomeDir, getChatPiSessionsDir } from "../../runtime/paths.js";
 
 const piValidationTimeoutMs = 60_000;
@@ -172,6 +173,11 @@ export class AgentManager {
     if (this.sessions.has(sessionKey)) {
       const existing = this.sessions.get(sessionKey);
       if (existing?.modelKey === effectiveModelKey) {
+        const desiredThinkingLevel = clampModelThinkingLevel(existing.session.model, modelSelection.thinkingLevel);
+        if (existing.session.thinkingLevel !== desiredThinkingLevel) {
+          this.logger?.log("agent", `updating effort for chat ${sessionKey}: ${existing.session.thinkingLevel} -> ${desiredThinkingLevel}`);
+          existing.session.setThinkingLevel(desiredThinkingLevel);
+        }
         this.logger?.log("agent", `reusing session for chat ${sessionKey}`);
         return existing;
       }
@@ -189,6 +195,7 @@ export class AgentManager {
     if (requiresProviderAuth(model) && !this.config.pi.apiKey && !hasProviderAuth(this.config.pi.provider, { authStorage, modelRegistry })) {
       throw new Error(`No auth found for ${this.config.pi.provider}. Re-run bootstrap and complete login for this provider before Telegram starts.`);
     }
+    const thinkingLevel = clampModelThinkingLevel(model, modelSelection.thinkingLevel);
 
     const policy = buildPiToolPolicy({
       config: this.config,
@@ -201,7 +208,7 @@ export class AgentManager {
       modelSelection.sessionRevision
     );
     const hasExistingSession = sessionManager.buildSessionContext().messages.length > 0;
-    this.logger?.log("agent", `${hasExistingSession ? "resuming" : "creating"} session for chat ${sessionKey} with model ${effectiveModelId}`);
+    this.logger?.log("agent", `${hasExistingSession ? "resuming" : "creating"} session for chat ${sessionKey} with model ${effectiveModelId} effort ${thinkingLevel}`);
     const customTools = [
       ...this.createTools(telegram, chatId, policy),
       createSystemShellTool({ workspaceDir: policy.workspaceDir, shell: policy.shell })
@@ -217,6 +224,7 @@ export class AgentManager {
       authStorage,
       modelRegistry,
       model,
+      thinkingLevel,
       tools: policy.tools,
       excludeTools: policy.excludeTools,
       customTools,

package/src/core/agent/auth-flow.js

@@ -9,6 +9,7 @@ const authInvalidatedPatterns = [
 
 const missingAuthPatterns = [
   /no auth found/i,
+  /no api key(?: found)? for/i,
   /auth(?:entication)? .*missing/i
 ];
 

package/src/core/agent/model-selection.js

@@ -2,26 +2,42 @@ function chatKey(chatId) {
   return String(chatId);
 }
 
+function normalizeSessionRevision(sessionRevision) {
+  if (sessionRevision == null) return 0;
+  if (!Number.isSafeInteger(sessionRevision) || sessionRevision < 0) {
+    throw new Error("Invalid model session revision");
+  }
+  return sessionRevision;
+}
+
 export function resolveChatModelSelection(config, chatId) {
   const selection = config.pi.chatModels?.[chatKey(chatId)];
   if (!selection || selection.provider !== config.pi.provider) {
     return {
       provider: config.pi.provider,
       model: config.pi.model,
+      thinkingLevel: config.pi.thinkingLevel,
       sessionRevision: 0
     };
   }
-  if (!Number.isSafeInteger(selection.sessionRevision) || selection.sessionRevision <= 0) {
-    throw new Error(`Invalid model session revision for chat ${chatId}`);
-  }
-  return selection;
+  const sessionRevision = normalizeSessionRevision(selection.sessionRevision);
+  return {
+    provider: selection.provider,
+    model: selection.model,
+    thinkingLevel: selection.thinkingLevel ?? config.pi.thinkingLevel,
+    sessionRevision
+  };
 }
 
 export function resolveChatModel(config, chatId) {
   return resolveChatModelSelection(config, chatId).model;
 }
 
-export function selectChatModel(config, chatId, model) {
+export function resolveChatThinkingLevel(config, chatId) {
+  return resolveChatModelSelection(config, chatId).thinkingLevel;
+}
+
+export function selectChatModel(config, chatId, model, { thinkingLevel } = {}) {
   if (model.provider !== config.pi.provider) {
     throw new Error(`Cannot select model from provider ${model.provider}; active provider is ${config.pi.provider}`);
   }
@@ -31,6 +47,19 @@ export function selectChatModel(config, chatId, model) {
   config.pi.chatModels[key] = {
     provider: model.provider,
     model: model.id,
+    thinkingLevel,
     sessionRevision
   };
 }
+
+export function selectChatThinkingLevel(config, chatId, thinkingLevel) {
+  config.pi.chatModels ||= {};
+  const key = chatKey(chatId);
+  const current = resolveChatModelSelection(config, chatId);
+  config.pi.chatModels[key] = {
+    provider: current.provider,
+    model: current.model,
+    thinkingLevel,
+    sessionRevision: current.sessionRevision
+  };
+}

package/src/core/agent/pi-runtime.js

@@ -61,6 +61,47 @@ export function formatPiModelOption(model) {
   return capabilities ? `${model.id} [${capabilities}]` : model.id;
 }
 
+/** Mirrors @earendil-works/pi-ai getSupportedThinkingLevels for the active model. */
+const EXTENDED_THINKING_LEVELS = Object.freeze([
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+]);
+
+export function listModelThinkingLevels(model) {
+  if (!model?.reasoning) return ["off"];
+  return EXTENDED_THINKING_LEVELS.filter((level) => {
+    const mapped = model.thinkingLevelMap?.[level];
+    if (mapped === null) return false;
+    if (level === "xhigh" || level === "max") return mapped !== undefined;
+    return true;
+  });
+}
+
+export function clampModelThinkingLevel(model, level) {
+  const availableLevels = listModelThinkingLevels(model);
+  if (availableLevels.includes(level)) return level;
+  const requestedIndex = EXTENDED_THINKING_LEVELS.indexOf(level);
+  if (requestedIndex === -1) return availableLevels[0] ?? "off";
+  for (let i = requestedIndex; i < EXTENDED_THINKING_LEVELS.length; i++) {
+    const candidate = EXTENDED_THINKING_LEVELS[i];
+    if (availableLevels.includes(candidate)) return candidate;
+  }
+  for (let i = requestedIndex - 1; i >= 0; i--) {
+    const candidate = EXTENDED_THINKING_LEVELS[i];
+    if (availableLevels.includes(candidate)) return candidate;
+  }
+  return availableLevels[0] ?? "off";
+}
+
+export function modelSupportsThinking(model) {
+  return listModelThinkingLevels(model).some((level) => level !== "off");
+}
+
 export function findPiModel({ provider, model, apiKey } = {}) {
   const runtime = createPiRuntime({ provider, apiKey });
   return {

package/src/core/config/config-defaults.js

@@ -18,6 +18,10 @@ export const telegramConfigDefaults = Object.freeze({
   modelPickerPageSize: 8
 });
 
+export const piConfigDefaults = Object.freeze({
+  thinkingLevel: "medium"
+});
+
 export function applyConfigDefaults(config) {
   return {
     ...config,
@@ -25,6 +29,10 @@ export function applyConfigDefaults(config) {
       ...telegramConfigDefaults,
       ...(config.telegram || {})
     },
+    pi: {
+      ...piConfigDefaults,
+      ...(config.pi || {})
+    },
     daemons: {
       ...daemonConfigDefaults,
       ...(config.daemons || {})

package/src/transport/telegram/bot.js

@@ -3,12 +3,12 @@ import path from "node:path";
 import { authorizeChat } from "./auth.js";
 import { captureIncomingArtifact, formatLocationText } from "./media.js";
 import { buildDeviceCodeTelegramMessage } from "./device-code-message.js";
-import { buildModelPicker, parseModelPickerAction } from "./model-picker.js";
+import { buildEffortPicker, buildModelPicker, parseEffortPickerAction, parseModelPickerAction } from "./model-picker.js";
 import { renderTelegramHtml } from "./text-format.js";
 import { buildPiAuthRecoveryBlockedMessage, buildPiAuthTelegramMessage, getErrorMessage, getPiAuthIssue, getPiAuthStatus } from "../../core/agent/auth-flow.js";
 import { createPiOAuthLogin } from "../../core/agent/pi-auth-login.js";
-import { resolveChatModel, selectChatModel } from "../../core/agent/model-selection.js";
-import { createPiRuntime, listProviderModels } from "../../core/agent/pi-runtime.js";
+import { resolveChatModel, resolveChatThinkingLevel, selectChatModel, selectChatThinkingLevel } from "../../core/agent/model-selection.js";
+import { clampModelThinkingLevel, createPiRuntime, listModelThinkingLevels, listProviderModels, modelSupportsThinking } from "../../core/agent/pi-runtime.js";
 import { normalizeArtifactForReasoning, shouldNormalizeArtifactToText } from "../../core/artifacts/normalize-for-reasoning.js";
 
 const slowPromptNoticeMs = 300_000;
@@ -426,6 +426,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       provider: config.pi.provider,
       models: getProviderModels(),
       selectedModelId: resolveChatModel(config, ctx.chat.id),
+      selectedThinkingLevel: resolveChatThinkingLevel(config, ctx.chat.id),
       page,
       pageSize: config.telegram.modelPickerPageSize
     });
@@ -437,11 +438,42 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     return ctx.reply(picker.text, extra);
   }
 
-  async function persistChatModel(chatId, model) {
+  async function showEffortPicker(ctx, { model, modelIndex, selectedThinkingLevel } = {}) {
+    const models = getProviderModels();
+    const resolvedModel = model || models.find((item) => item.id === resolveChatModel(config, ctx.chat.id));
+    if (!resolvedModel) {
+      throw new Error(`Model not found for provider ${config.pi.provider}`);
+    }
+    if (!modelSupportsThinking(resolvedModel)) {
+      const text = `${resolvedModel.provider}/${resolvedModel.id} does not support effort levels.`;
+      if (ctx.callbackQuery?.message?.message_id) {
+        return ctx.api.editMessageText(ctx.chat.id, ctx.callbackQuery.message.message_id, text);
+      }
+      return ctx.reply(text);
+    }
+    const levels = listModelThinkingLevels(resolvedModel);
+    const picker = buildEffortPicker({
+      provider: resolvedModel.provider,
+      modelId: resolvedModel.id,
+      levels,
+      selectedThinkingLevel: selectedThinkingLevel
+        ?? clampModelThinkingLevel(resolvedModel, resolveChatThinkingLevel(config, ctx.chat.id)),
+      modelIndex
+    });
+    const extra = { reply_markup: picker.replyMarkup };
+    const messageId = ctx.callbackQuery?.message?.message_id;
+    if (messageId) {
+      return ctx.api.editMessageText(ctx.chat.id, messageId, picker.text, extra);
+    }
+    return ctx.reply(picker.text, extra);
+  }
+
+  async function persistChatModel(chatId, model, thinkingLevel) {
     const key = chatKey(chatId);
     const hadSelections = Boolean(config.pi.chatModels);
     const previousSelection = config.pi.chatModels?.[key];
-    selectChatModel(config, chatId, model);
+    const level = clampModelThinkingLevel(model, thinkingLevel ?? resolveChatThinkingLevel(config, chatId));
+    selectChatModel(config, chatId, model, { thinkingLevel: level });
     try {
       await saveConfig(config);
     } catch (error) {
@@ -454,6 +486,27 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       throw error;
     }
     agentManager.resetSession(chatId);
+    return level;
+  }
+
+  async function persistChatEffort(chatId, model, thinkingLevel) {
+    const key = chatKey(chatId);
+    const hadSelections = Boolean(config.pi.chatModels);
+    const previousSelection = config.pi.chatModels?.[key];
+    const level = clampModelThinkingLevel(model, thinkingLevel);
+    selectChatThinkingLevel(config, chatId, level);
+    try {
+      await saveConfig(config);
+    } catch (error) {
+      if (previousSelection) {
+        config.pi.chatModels[key] = previousSelection;
+      } else {
+        delete config.pi.chatModels[key];
+        if (!hadSelections) delete config.pi.chatModels;
+      }
+      throw error;
+    }
+    return level;
   }
 
   async function buildIncomingPrompt(ctx) {
@@ -736,6 +789,12 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     await showModelPicker(ctx);
   });
 
+  bot.command("effort", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
+    if (!auth.ok) return;
+    await showEffortPicker(ctx);
+  });
+
   bot.command("auth", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
@@ -770,7 +829,9 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   });
 
   bot.on("callback_query:data", async (ctx, next) => {
-    const action = parseModelPickerAction(ctx.callbackQuery.data);
+    const modelAction = parseModelPickerAction(ctx.callbackQuery.data);
+    const effortAction = modelAction ? null : parseEffortPickerAction(ctx.callbackQuery.data);
+    const action = modelAction || effortAction;
     if (!action) return next();
     if (action.type === "noop") {
       await ctx.answerCallbackQuery();
@@ -792,39 +853,140 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
 
       if (getChatState(ctx.chat.id).processing) {
         await ctx.answerCallbackQuery({
-          text: "Wait for the current response before changing models.",
+          text: action.type === "effort" || action.type === "model-effort"
+            ? "Wait for the current response before changing effort."
+            : "Wait for the current response before changing models.",
           show_alert: true
         });
         return;
       }
 
       const models = getProviderModels();
-      const model = models[action.value];
-      if (!model) {
-        await ctx.answerCallbackQuery({
-          text: "This model list is no longer current. Run /model again.",
-          show_alert: true
-        });
+
+      if (action.type === "select") {
+        const model = models[action.value];
+        if (!model) {
+          await ctx.answerCallbackQuery({
+            text: "This model list is no longer current. Run /model again.",
+            show_alert: true
+          });
+          return;
+        }
+
+        if (modelSupportsThinking(model)) {
+          await showEffortPicker(ctx, {
+            model,
+            modelIndex: action.value,
+            selectedThinkingLevel: clampModelThinkingLevel(model, resolveChatThinkingLevel(config, ctx.chat.id))
+          });
+          await ctx.answerCallbackQuery({ text: `Choose effort for ${model.id}.` });
+          return;
+        }
+
+        const currentModelId = resolveChatModel(config, ctx.chat.id);
+        const currentEffort = resolveChatThinkingLevel(config, ctx.chat.id);
+        if (model.id === currentModelId && currentEffort === "off") {
+          await ctx.answerCallbackQuery({ text: `Already using ${model.id}.` });
+          return;
+        }
+
+        await persistChatModel(ctx.chat.id, model, "off");
+        await ctx.api.editMessageText(
+          ctx.chat.id,
+          ctx.callbackQuery.message.message_id,
+          `Model changed to ${model.provider}/${model.id}.\nA new chat context will start with your next message.`
+        );
+        await ctx.answerCallbackQuery({ text: `Using ${model.id}.` });
         return;
       }
 
-      const currentModelId = resolveChatModel(config, ctx.chat.id);
-      if (model.id === currentModelId) {
-        await ctx.answerCallbackQuery({ text: `Already using ${model.id}.` });
+      if (action.type === "model-effort") {
+        const model = models[action.modelIndex];
+        if (!model) {
+          await ctx.answerCallbackQuery({
+            text: "This model list is no longer current. Run /model again.",
+            show_alert: true
+          });
+          return;
+        }
+        const levels = listModelThinkingLevels(model);
+        if (!levels.includes(action.level)) {
+          await ctx.answerCallbackQuery({
+            text: "That effort level is not available for this model.",
+            show_alert: true
+          });
+          return;
+        }
+
+        const currentModelId = resolveChatModel(config, ctx.chat.id);
+        const currentEffort = resolveChatThinkingLevel(config, ctx.chat.id);
+        if (model.id === currentModelId && action.level === currentEffort) {
+          await ctx.answerCallbackQuery({ text: `Already using ${model.id} at ${action.level}.` });
+          return;
+        }
+
+        if (model.id === currentModelId) {
+          await persistChatEffort(ctx.chat.id, model, action.level);
+          await ctx.api.editMessageText(
+            ctx.chat.id,
+            ctx.callbackQuery.message.message_id,
+            `Effort set to ${action.level} for ${model.provider}/${model.id}.`
+          );
+          await ctx.answerCallbackQuery({ text: `Effort: ${action.level}.` });
+          return;
+        }
+
+        await persistChatModel(ctx.chat.id, model, action.level);
+        await ctx.api.editMessageText(
+          ctx.chat.id,
+          ctx.callbackQuery.message.message_id,
+          `Model changed to ${model.provider}/${model.id} (effort: ${action.level}).\nA new chat context will start with your next message.`
+        );
+        await ctx.answerCallbackQuery({ text: `Using ${model.id} / ${action.level}.` });
         return;
       }
 
-      await persistChatModel(ctx.chat.id, model);
-      await ctx.api.editMessageText(
-        ctx.chat.id,
-        ctx.callbackQuery.message.message_id,
-        `Model changed to ${model.provider}/${model.id}.\nA new chat context will start with your next message.`
-      );
-      await ctx.answerCallbackQuery({ text: `Using ${model.id}.` });
+      if (action.type === "effort") {
+        const model = models.find((item) => item.id === resolveChatModel(config, ctx.chat.id));
+        if (!model) {
+          await ctx.answerCallbackQuery({
+            text: "Current model is unavailable. Run /model again.",
+            show_alert: true
+          });
+          return;
+        }
+        if (!modelSupportsThinking(model)) {
+          await ctx.answerCallbackQuery({
+            text: "This model does not support effort levels.",
+            show_alert: true
+          });
+          return;
+        }
+        const levels = listModelThinkingLevels(model);
+        if (!levels.includes(action.level)) {
+          await ctx.answerCallbackQuery({
+            text: "That effort level is not available for this model.",
+            show_alert: true
+          });
+          return;
+        }
+        const currentEffort = resolveChatThinkingLevel(config, ctx.chat.id);
+        if (action.level === currentEffort) {
+          await ctx.answerCallbackQuery({ text: `Already using effort ${action.level}.` });
+          return;
+        }
+        await persistChatEffort(ctx.chat.id, model, action.level);
+        await ctx.api.editMessageText(
+          ctx.chat.id,
+          ctx.callbackQuery.message.message_id,
+          `Effort set to ${action.level} for ${model.provider}/${model.id}.`
+        );
+        await ctx.answerCallbackQuery({ text: `Effort: ${action.level}.` });
+      }
     } catch (error) {
       logger?.error("telegram", `model selection failed for chat ${ctx.chat.id}: ${getErrorMessage(error)}`);
       await ctx.answerCallbackQuery({
-        text: "Could not change the model.",
+        text: "Could not change the model or effort.",
         show_alert: true
       }).catch(() => {});
     }
@@ -867,6 +1029,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       await bot.api.setMyCommands([
         { command: "new", description: "Start a new chat context" },
         { command: "model", description: "Choose the model for this chat" },
+        { command: "effort", description: "Choose reasoning effort for this chat" },
         { command: "auth", description: "Show Pi authentication status" }
       ]);
       if (!taskTimer) {

package/src/transport/telegram/model-picker.js

@@ -11,15 +11,59 @@ export function parseModelPickerAction(data) {
   };
 }
 
-export function buildModelPicker({ provider, models, selectedModelId, page, pageSize }) {
+export function parseEffortPickerAction(data) {
+  if (data === "noop:page") return { type: "noop", value: null };
+  const modelEffort = /^model-effort:(\d+):([a-z]+)$/.exec(String(data || ""));
+  if (modelEffort) {
+    return {
+      type: "model-effort",
+      modelIndex: Number(modelEffort[1]),
+      level: modelEffort[2]
+    };
+  }
+  const effort = /^effort:([a-z]+)$/.exec(String(data || ""));
+  if (effort) {
+    return {
+      type: "effort",
+      level: effort[1]
+    };
+  }
+  return null;
+}
+
+export function buildModelPicker({ provider, models, selectedModelId, selectedThinkingLevel, page, pageSize }) {
   if (!models.length) {
     throw new Error(`No models available for provider ${provider}`);
   }
   const items = models.map((model) => ({
     text: `${model.id === selectedModelId ? "✓ " : ""}${formatPiModelOption(model)}`
   }));
+  const effortLine = selectedThinkingLevel ? `\nEffort: ${selectedThinkingLevel}` : "";
   return {
-    text: `Current model: ${provider}/${selectedModelId}\nSelect a model for this chat:`,
+    text: `Current model: ${provider}/${selectedModelId}${effortLine}\nSelect a model for this chat:`,
     replyMarkup: buildPagedInlineKeyboard("model", items, { page, pageSize })
   };
 }
+
+export function buildEffortPicker({
+  provider,
+  modelId,
+  levels,
+  selectedThinkingLevel,
+  modelIndex
+}) {
+  if (!levels.length) {
+    throw new Error(`No effort levels available for ${provider}/${modelId}`);
+  }
+  const rows = levels.map((level) => ([{
+    text: `${level === selectedThinkingLevel ? "✓ " : ""}${level}`,
+    callback_data: modelIndex == null ? `effort:${level}` : `model-effort:${modelIndex}:${level}`
+  }]));
+  const scope = modelIndex == null
+    ? `Current model: ${provider}/${modelId}\nSelect effort for this chat:`
+    : `Model: ${provider}/${modelId}\nSelect effort:`;
+  return {
+    text: scope,
+    replyMarkup: { inline_keyboard: rows }
+  };
+}

package/test/auth-flow.test.js

@@ -25,6 +25,8 @@ test("classifies invalidated Pi authentication tokens", () => {
 test("classifies missing Pi authentication", () => {
   for (const error of [
     new Error("No auth found for provider"),
+    new Error("No API key for provider: openai-codex"),
+    new Error('No API key found for "openai-codex"'),
     new Error("authentication credentials are missing")
   ]) {
     assert.deepEqual(getPiAuthIssue(error), {

package/test/model-selection.test.js

@@ -1,33 +1,52 @@
 import assert from "node:assert/strict";
 import path from "node:path";
 import test from "node:test";
-import { resolveChatModel, selectChatModel } from "../src/core/agent/model-selection.js";
-import { applyConfigDefaults, telegramConfigDefaults } from "../src/core/config/config-defaults.js";
+import {
+  resolveChatModel,
+  resolveChatModelSelection,
+  resolveChatThinkingLevel,
+  selectChatModel,
+  selectChatThinkingLevel
+} from "../src/core/agent/model-selection.js";
+import { applyConfigDefaults, piConfigDefaults, telegramConfigDefaults } from "../src/core/config/config-defaults.js";
+import {
+  clampModelThinkingLevel,
+  listModelThinkingLevels,
+  modelSupportsThinking
+} from "../src/core/agent/pi-runtime.js";
 import { getChatPiSessionsDir } from "../src/runtime/paths.js";
-import { buildModelPicker, parseModelPickerAction } from "../src/transport/telegram/model-picker.js";
+import {
+  buildEffortPicker,
+  buildModelPicker,
+  parseEffortPickerAction,
+  parseModelPickerAction
+} from "../src/transport/telegram/model-picker.js";
 
 function createConfig() {
-  return {
+  return applyConfigDefaults({
     telegram: {},
     pi: {
       provider: "openai-codex",
       model: "gpt-default"
     }
-  };
+  });
 }
 
 test("resolves the default model until a chat selects one", () => {
   const config = createConfig();
 
   assert.equal(resolveChatModel(config, 123), "gpt-default");
+  assert.equal(resolveChatThinkingLevel(config, 123), piConfigDefaults.thinkingLevel);
 
-  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-selected" });
+  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-selected" }, { thinkingLevel: "high" });
 
   assert.equal(resolveChatModel(config, 123), "gpt-selected");
+  assert.equal(resolveChatThinkingLevel(config, 123), "high");
   assert.equal(resolveChatModel(config, 456), "gpt-default");
   assert.deepEqual(config.pi.chatModels["123"], {
     provider: "openai-codex",
     model: "gpt-selected",
+    thinkingLevel: "high",
     sessionRevision: 1
   });
 });
@@ -35,8 +54,8 @@ test("resolves the default model until a chat selects one", () => {
 test("starts a distinct persisted Pi session revision on every model change", () => {
   const config = createConfig();
 
-  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-a" });
-  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-b" });
+  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-a" }, { thinkingLevel: "medium" });
+  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-b" }, { thinkingLevel: "high" });
 
   assert.equal(config.pi.chatModels["123"].sessionRevision, 2);
   assert.equal(
@@ -45,13 +64,28 @@ test("starts a distinct persisted Pi session revision on every model change", ()
   );
 });
 
+test("updates effort without bumping the session revision", () => {
+  const config = createConfig();
+
+  selectChatModel(config, 123, { provider: "openai-codex", id: "gpt-a" }, { thinkingLevel: "medium" });
+  selectChatThinkingLevel(config, 123, "high");
+
+  assert.deepEqual(resolveChatModelSelection(config, 123), {
+    provider: "openai-codex",
+    model: "gpt-a",
+    thinkingLevel: "high",
+    sessionRevision: 1
+  });
+});
+
 test("ignores a chat selection from a different active provider", () => {
   const config = createConfig();
   config.pi.chatModels = {
-    123: { provider: "anthropic", model: "claude-selected" }
+    123: { provider: "anthropic", model: "claude-selected", thinkingLevel: "high", sessionRevision: 1 }
   };
 
   assert.equal(resolveChatModel(config, 123), "gpt-default");
+  assert.equal(resolveChatThinkingLevel(config, 123), piConfigDefaults.thinkingLevel);
 });
 
 test("rejects selecting a model outside the active provider", () => {
@@ -74,26 +108,88 @@ test("builds a paged model picker and marks the current model", () => {
     provider: "openai-codex",
     models,
     selectedModelId: "gpt-b",
+    selectedThinkingLevel: "high",
     page: 0,
     pageSize: 2
   });
 
   assert.match(picker.text, /openai-codex\/gpt-b/);
+  assert.match(picker.text, /Effort: high/);
   assert.equal(picker.replyMarkup.inline_keyboard[0][0].callback_data, "model:0");
   assert.match(picker.replyMarkup.inline_keyboard[1][0].text, /^✓ gpt-b \[reasoning, image\]$/);
   assert.equal(picker.replyMarkup.inline_keyboard[2][1].callback_data, "model-page:1");
 });
 
+test("builds an effort picker for the current model or pending model choice", () => {
+  const current = buildEffortPicker({
+    provider: "openai-codex",
+    modelId: "gpt-b",
+    levels: ["off", "low", "medium", "high"],
+    selectedThinkingLevel: "medium"
+  });
+  assert.match(current.text, /Current model: openai-codex\/gpt-b/);
+  assert.equal(current.replyMarkup.inline_keyboard[1][0].callback_data, "effort:low");
+  assert.match(current.replyMarkup.inline_keyboard[2][0].text, /^✓ medium$/);
+
+  const pending = buildEffortPicker({
+    provider: "openai-codex",
+    modelId: "gpt-b",
+    levels: ["off", "high"],
+    selectedThinkingLevel: "high",
+    modelIndex: 4
+  });
+  assert.match(pending.text, /^Model: openai-codex\/gpt-b/);
+  assert.equal(pending.replyMarkup.inline_keyboard[1][0].callback_data, "model-effort:4:high");
+});
+
 test("parses only model picker callback data", () => {
   assert.deepEqual(parseModelPickerAction("model:12"), { type: "select", value: 12 });
   assert.deepEqual(parseModelPickerAction("model-page:2"), { type: "page", value: 2 });
   assert.deepEqual(parseModelPickerAction("noop:page"), { type: "noop", value: null });
   assert.equal(parseModelPickerAction("provider:1"), null);
   assert.equal(parseModelPickerAction("model:-1"), null);
+  assert.equal(parseModelPickerAction("effort:high"), null);
+});
+
+test("parses effort picker callback data", () => {
+  assert.deepEqual(parseEffortPickerAction("effort:high"), { type: "effort", level: "high" });
+  assert.deepEqual(parseEffortPickerAction("model-effort:3:medium"), {
+    type: "model-effort",
+    modelIndex: 3,
+    level: "medium"
+  });
+  assert.deepEqual(parseEffortPickerAction("noop:page"), { type: "noop", value: null });
+  assert.equal(parseEffortPickerAction("model:1"), null);
 });
 
-test("centralizes the model picker page size in Telegram config defaults", () => {
-  const config = applyConfigDefaults(createConfig());
+test("centralizes picker defaults in config", () => {
+  const config = applyConfigDefaults({
+    telegram: {},
+    pi: { provider: "openai-codex", model: "gpt-default" }
+  });
 
   assert.equal(config.telegram.modelPickerPageSize, telegramConfigDefaults.modelPickerPageSize);
+  assert.equal(config.pi.thinkingLevel, piConfigDefaults.thinkingLevel);
+});
+
+test("lists and clamps thinking levels from model capabilities", () => {
+  const reasoning = {
+    reasoning: true,
+    thinkingLevelMap: { xhigh: "xhigh", minimal: "low", max: null }
+  };
+  assert.deepEqual(listModelThinkingLevels(reasoning), [
+    "off",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh"
+  ]);
+  assert.equal(clampModelThinkingLevel(reasoning, "max"), "xhigh");
+  assert.equal(modelSupportsThinking(reasoning), true);
+
+  const plain = { reasoning: false };
+  assert.deepEqual(listModelThinkingLevels(plain), ["off"]);
+  assert.equal(clampModelThinkingLevel(plain, "high"), "off");
+  assert.equal(modelSupportsThinking(plain), false);
 });