arisa 5.1.13 → 5.1.49

package/src/transport/telegram/chat-queue.js

@@ -0,0 +1,132 @@
+export function createChatStateStore() {
+  const states = new Map();
+
+  function reset(chatId) {
+    const state = {
+      processing: false,
+      pendingPrompts: [],
+      pendingPromptContexts: [],
+      continueAfterClose: false,
+      historyRevision: 0,
+      beforeNextPrompt: null,
+      activeSession: null,
+      assistantMessages: new Map(),
+      stopQueuedTyping: null
+    };
+    states.set(String(chatId), state);
+    return state;
+  }
+
+  return {
+    get(chatId) {
+      const key = String(chatId);
+      return states.get(key) || reset(key);
+    },
+    reset,
+    anyProcessing() {
+      return [...states.values()].some((state) => state.processing);
+    }
+  };
+}
+
+export function queueChatPrompt(chatState, prompt, { replace = false, ctx = null } = {}) {
+  chatState.pendingPromptContexts ||= [];
+  if (replace) {
+    chatState.pendingPrompts = [];
+    chatState.pendingPromptContexts = [];
+  }
+  chatState.pendingPrompts.push(prompt);
+  chatState.pendingPromptContexts.push(ctx);
+}
+
+function takeQueuedPrompt(chatState) {
+  return {
+    prompt: chatState.pendingPrompts.shift() || "",
+    ctx: (chatState.pendingPromptContexts ||= []).shift() || null
+  };
+}
+
+export function resolveTelegramBusyMessageMode(config, chatId) {
+  const chatMode = config.telegram?.chatMeta?.[String(chatId)]?.busyMessageMode;
+  const mode = chatMode || config.telegram?.busyMessageMode;
+  return mode === "steer" ? "steer" : "queue";
+}
+
+export async function routeBusyPrompt({ chatState, prompt, mode = "queue", replaceQueued = false, ctx = null }) {
+  const session = chatState.activeSession;
+  if (
+    mode === "steer"
+    && !replaceQueued
+    && !chatState.continueAfterClose
+    && !chatState.beforeNextPrompt
+    && session?.isStreaming
+    && typeof session.steer === "function"
+  ) {
+    try {
+      await session.steer(prompt);
+      return { disposition: "steered" };
+    } catch (error) {
+      queueChatPrompt(chatState, prompt, { ctx });
+      return { disposition: "queued", steerError: error };
+    }
+  }
+
+  queueChatPrompt(chatState, prompt, { replace: replaceQueued, ctx });
+  return { disposition: "queued" };
+}
+
+function stopQueuedTyping(chatState) {
+  chatState.stopQueuedTyping?.();
+  chatState.stopQueuedTyping = null;
+}
+
+export async function drainChatPromptQueue({
+  chatState,
+  initialPrompt,
+  initialCtx = null,
+  processPrompt,
+  onPromptFailure,
+  onPromptInterrupted,
+  beforeInitialPrompt
+}) {
+  let currentPrompt = initialPrompt;
+  let currentCtx = initialCtx;
+
+  try {
+    await beforeInitialPrompt?.();
+    while (currentPrompt) {
+      while (chatState.beforeNextPrompt) {
+        const gate = chatState.beforeNextPrompt;
+        await gate;
+        if (chatState.beforeNextPrompt === gate) chatState.beforeNextPrompt = null;
+      }
+      if (chatState.continueAfterClose && chatState.pendingPrompts.length) {
+        const queued = takeQueuedPrompt(chatState);
+        currentPrompt = queued.prompt;
+        currentCtx = queued.ctx;
+        chatState.continueAfterClose = false;
+      }
+      try {
+        await processPrompt({ prompt: currentPrompt, ctx: currentCtx });
+      } catch (error) {
+        if (chatState.continueAfterClose && chatState.pendingPrompts.length) {
+          await onPromptInterrupted?.(error);
+        } else {
+          await onPromptFailure?.(error);
+          throw error;
+        }
+      } finally {
+        currentCtx = null;
+      }
+
+      const queued = takeQueuedPrompt(chatState);
+      currentPrompt = queued.prompt;
+      currentCtx = queued.ctx;
+      chatState.continueAfterClose = false;
+    }
+  } finally {
+    stopQueuedTyping(chatState);
+    chatState.processing = false;
+    chatState.activeSession = null;
+  }
+}

package/src/transport/telegram/media.js

@@ -46,9 +46,9 @@ export function formatLocationText(message) {
   return lines.join("\n");
 }
 
-export async function captureIncomingArtifact(ctx, artifactStore) {
+export async function captureIncomingArtifact(ctx, artifactStore, { storageChatId = ctx.chat.id } = {}) {
   const chatId = ctx.chat.id;
-  const store = artifactStore.forChat(chatId);
+  const store = artifactStore.forChat(storageChatId);
   const baseSource = {
     type: "telegram",
     chatId,

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

@@ -0,0 +1,211 @@
+import { getErrorMessage } from "../../core/agent/auth-flow.js";
+import { resolveChatModel, resolveChatSpeed, resolveChatThinkingLevel } from "../../core/agent/model-selection.js";
+import { clampModelThinkingLevel, listModelThinkingLevels, modelSupportsThinking } from "../../core/agent/pi-runtime.js";
+import { modelSupportsSpeed } from "../../core/agent/model-speed.js";
+import { parseEffortPickerAction, parseModelPickerAction, parseSpeedPickerAction } from "./model-picker.js";
+
+export async function closeModelPicker(ctx, { messageText, callbackText }) {
+  await ctx.api.editMessageText(
+    ctx.chat.id,
+    ctx.callbackQuery.message.message_id,
+    messageText
+  );
+  await ctx.answerCallbackQuery({ text: callbackText });
+}
+
+export function createTelegramModelCallbackHandler({
+  config,
+  authorizeContext,
+  contextRoute,
+  getChatState,
+  getProviderModels,
+  showModelPicker,
+  showEffortPicker,
+  persistChatModel,
+  persistChatEffort,
+  persistChatSpeed,
+  logger
+}) {
+  return async (ctx, next) => {
+    const modelAction = parseModelPickerAction(ctx.callbackQuery.data);
+    const effortAction = modelAction ? null : parseEffortPickerAction(ctx.callbackQuery.data);
+    const speedAction = modelAction || effortAction ? null : parseSpeedPickerAction(ctx.callbackQuery.data);
+    const action = modelAction || effortAction || speedAction;
+    if (!action) return next();
+    if (action.type === "noop") {
+      await ctx.answerCallbackQuery();
+      return;
+    }
+
+    const auth = await authorizeContext(ctx);
+    if (!auth.ok) {
+      await ctx.answerCallbackQuery({ text: "This chat is not authorized.", show_alert: true });
+      return;
+    }
+
+    const modelChatId = contextRoute(ctx).sessionId;
+
+    try {
+      if (action.type === "page") {
+        await showModelPicker(ctx, action.value);
+        await ctx.answerCallbackQuery();
+        return;
+      }
+
+      const models = await getProviderModels(modelChatId);
+      const chatBusy = getChatState(modelChatId).processing;
+
+      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, modelChatId))
+          });
+          await ctx.answerCallbackQuery({ text: `Choose effort for ${model.id}.` });
+          return;
+        }
+        if (chatBusy) {
+          await ctx.answerCallbackQuery({ text: "Wait for the current response before changing models.", show_alert: true });
+          return;
+        }
+
+        const currentModelId = resolveChatModel(config, modelChatId);
+        const currentEffort = resolveChatThinkingLevel(config, modelChatId);
+        if (model.id === currentModelId && currentEffort === "off") {
+          await closeModelPicker(ctx, {
+            messageText: `Already using ${model.provider}/${model.id}.`,
+            callbackText: `Already using ${model.id}.`
+          });
+          return;
+        }
+
+        await persistChatModel(modelChatId, 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;
+      }
+
+      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, modelChatId);
+        const currentEffort = resolveChatThinkingLevel(config, modelChatId);
+        if (model.id === currentModelId && action.level === currentEffort) {
+          await closeModelPicker(ctx, {
+            messageText: `Already using ${model.provider}/${model.id} (effort: ${action.level}).`,
+            callbackText: `Already using ${model.id} at ${action.level}.`
+          });
+          return;
+        }
+        if (model.id === currentModelId) {
+          await persistChatEffort(modelChatId, 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;
+        }
+        if (chatBusy) {
+          await ctx.answerCallbackQuery({ text: "Wait for the current response before changing models.", show_alert: true });
+          return;
+        }
+
+        await persistChatModel(modelChatId, 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;
+      }
+
+      if (action.type === "effort") {
+        const model = models.find((item) => item.id === resolveChatModel(config, modelChatId));
+        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, modelChatId);
+        if (action.level === currentEffort) {
+          await closeModelPicker(ctx, {
+            messageText: `Already using effort ${action.level} for ${model.provider}/${model.id}.`,
+            callbackText: `Already using effort ${action.level}.`
+          });
+          return;
+        }
+        await persistChatEffort(modelChatId, 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;
+      }
+
+      if (action.type === "speed") {
+        const model = models.find((item) => item.id === resolveChatModel(config, modelChatId));
+        if (!model) {
+          await ctx.answerCallbackQuery({ text: "Current model is unavailable. Run /model again.", show_alert: true });
+          return;
+        }
+        if (!modelSupportsSpeed(model)) {
+          await ctx.answerCallbackQuery({ text: "This model does not support speed 1.5x.", show_alert: true });
+          return;
+        }
+        const currentSpeed = resolveChatSpeed(config, modelChatId);
+        if (action.speed === currentSpeed) {
+          await closeModelPicker(ctx, {
+            messageText: `Already using speed ${action.speed.toFixed(1)}x for ${model.provider}/${model.id}.`,
+            callbackText: `Already using speed ${action.speed.toFixed(1)}x.`
+          });
+          return;
+        }
+        await persistChatSpeed(modelChatId, model, action.speed);
+        await ctx.api.editMessageText(
+          ctx.chat.id,
+          ctx.callbackQuery.message.message_id,
+          `Speed set to ${action.speed.toFixed(1)}x for ${model.provider}/${model.id}.`
+        );
+        await ctx.answerCallbackQuery({ text: `Speed: ${action.speed.toFixed(1)}x.` });
+      }
+    } catch (error) {
+      logger?.error("telegram", `model selection failed for chat ${ctx.chat.id}: ${getErrorMessage(error)}`);
+      await ctx.answerCallbackQuery({
+        text: "Could not change the model, effort, or speed.",
+        show_alert: true
+      }).catch(() => {});
+    }
+  };
+}

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

@@ -0,0 +1,164 @@
+import {
+  getAgentConfig,
+  resolveChatModel,
+  resolveChatSpeed,
+  resolveChatThinkingLevel,
+  selectChatModel,
+  selectChatSpeed,
+  selectChatThinkingLevel
+} from "../../core/agent/model-selection.js";
+import { clampModelThinkingLevel, createPiRuntime, listModelThinkingLevels, listProviderModels, modelSupportsThinking } from "../../core/agent/pi-runtime.js";
+import { clampModelSpeed, MODEL_SPEEDS, modelSupportsSpeed } from "../../core/agent/model-speed.js";
+import { buildEffortPicker, buildModelPicker, buildSpeedPicker, reverseModelOrder } from "./model-picker.js";
+
+function chatKey(chatId) {
+  return String(chatId);
+}
+
+async function editOrReplyPicker(ctx, picker) {
+  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 editOrReplyText(ctx, text) {
+  if (ctx.callbackQuery?.message?.message_id) {
+    return ctx.api.editMessageText(ctx.chat.id, ctx.callbackQuery.message.message_id, text);
+  }
+  return ctx.reply(text);
+}
+
+function restorePreviousSelection(agentConfig, key, hadSelections, previousSelection) {
+  if (previousSelection) {
+    agentConfig.chatModels[key] = previousSelection;
+  } else {
+    delete agentConfig.chatModels[key];
+    if (!hadSelections) delete agentConfig.chatModels;
+  }
+}
+
+export function createTelegramModelControls({ config, saveConfig, agentManager, contextRoute }) {
+  async function getProviderModels() {
+    const runtime = createPiRuntime({
+      provider: config.pi.provider,
+      apiKey: config.pi.apiKey
+    });
+    return reverseModelOrder(listProviderModels(config.pi.provider, runtime));
+  }
+
+  async function showModelPicker(ctx, page = 0) {
+    const route = contextRoute(ctx);
+    const agentConfig = getAgentConfig(config);
+    const picker = buildModelPicker({
+      provider: agentConfig.provider,
+      models: await getProviderModels(),
+      selectedModelId: resolveChatModel(config, route.sessionId),
+      selectedThinkingLevel: resolveChatThinkingLevel(config, route.sessionId),
+      selectedSpeed: resolveChatSpeed(config, route.sessionId),
+      page,
+      pageSize: config.telegram.modelPickerPageSize
+    });
+    return editOrReplyPicker(ctx, picker);
+  }
+
+  async function showEffortPicker(ctx, { model, modelIndex, selectedThinkingLevel } = {}) {
+    const route = contextRoute(ctx);
+    const agentConfig = getAgentConfig(config);
+    const models = await getProviderModels();
+    const resolvedModel = model || models.find((item) => item.id === resolveChatModel(config, route.sessionId));
+    if (!resolvedModel) throw new Error(`Model not found for provider ${agentConfig.provider}`);
+    if (!modelSupportsThinking(resolvedModel)) {
+      return editOrReplyText(ctx, `${resolvedModel.provider}/${resolvedModel.id} does not support effort levels.`);
+    }
+    const picker = buildEffortPicker({
+      provider: resolvedModel.provider,
+      modelId: resolvedModel.id,
+      levels: listModelThinkingLevels(resolvedModel),
+      selectedThinkingLevel: selectedThinkingLevel
+        ?? clampModelThinkingLevel(resolvedModel, resolveChatThinkingLevel(config, route.sessionId)),
+      modelIndex
+    });
+    return editOrReplyPicker(ctx, picker);
+  }
+
+  async function showSpeedPicker(ctx) {
+    const route = contextRoute(ctx);
+    const agentConfig = getAgentConfig(config);
+    const models = await getProviderModels();
+    const model = models.find((item) => item.id === resolveChatModel(config, route.sessionId));
+    if (!model) throw new Error(`Model not found for provider ${agentConfig.provider}`);
+    if (!modelSupportsSpeed(model)) {
+      return editOrReplyText(ctx, `${model.provider}/${model.id} does not support speed 1.5x.`);
+    }
+    const picker = buildSpeedPicker({
+      provider: model.provider,
+      modelId: model.id,
+      speeds: MODEL_SPEEDS,
+      selectedSpeed: resolveChatSpeed(config, route.sessionId)
+    });
+    return editOrReplyPicker(ctx, picker);
+  }
+
+  async function persistChatModel(chatId, model, thinkingLevel) {
+    const agentConfig = getAgentConfig(config);
+    const key = chatKey(chatId);
+    const hadSelections = Boolean(agentConfig.chatModels);
+    const previousSelection = agentConfig.chatModels?.[key];
+    const level = clampModelThinkingLevel(model, thinkingLevel ?? resolveChatThinkingLevel(config, chatId));
+    const speed = clampModelSpeed(model, resolveChatSpeed(config, chatId));
+    selectChatModel(config, chatId, model, { thinkingLevel: level, speed });
+    try {
+      await saveConfig(config);
+    } catch (error) {
+      restorePreviousSelection(agentConfig, key, hadSelections, previousSelection);
+      throw error;
+    }
+    agentManager.resetSession(chatId);
+    return level;
+  }
+
+  async function persistChatEffort(chatId, model, thinkingLevel) {
+    const agentConfig = getAgentConfig(config);
+    const key = chatKey(chatId);
+    const hadSelections = Boolean(agentConfig.chatModels);
+    const previousSelection = agentConfig.chatModels?.[key];
+    const level = clampModelThinkingLevel(model, thinkingLevel);
+    selectChatThinkingLevel(config, chatId, level);
+    try {
+      await saveConfig(config);
+    } catch (error) {
+      restorePreviousSelection(agentConfig, key, hadSelections, previousSelection);
+      throw error;
+    }
+    return level;
+  }
+
+  async function persistChatSpeed(chatId, model, speed) {
+    const agentConfig = getAgentConfig(config);
+    const key = chatKey(chatId);
+    const hadSelections = Boolean(agentConfig.chatModels);
+    const previousSelection = agentConfig.chatModels?.[key];
+    const level = clampModelSpeed(model, speed);
+    await agentManager.setModelSpeed(chatId, level);
+    selectChatSpeed(config, chatId, level);
+    try {
+      await saveConfig(config);
+    } catch (error) {
+      restorePreviousSelection(agentConfig, key, hadSelections, previousSelection);
+      agentManager.clearSessionCache(chatId);
+      throw error;
+    }
+    return level;
+  }
+
+  return {
+    getProviderModels,
+    showModelPicker,
+    showEffortPicker,
+    showSpeedPicker,
+    persistChatModel,
+    persistChatEffort,
+    persistChatSpeed
+  };
+}