@ihazz/bitrix24 1.1.5 → 1.1.7

package/src/channel.ts

@@ -31,12 +31,14 @@ import { OPENCLAW_COMMANDS, buildCommandsHelpText, formatModelsCommandReply } fr
 import {
   accessApproved,
   accessDenied,
+  commandKeyboardLabels,
   groupPairingPending,
   mediaDownloadFailed,
   groupChatUnsupported,
   onboardingMessage,
   ownerAndAllowedUsersOnly,
   personalBotOwnerOnly,
+  replyGenerationFailed,
   watchOwnerDmNotice,
 } from './i18n.js';
 import { HistoryCache } from './history-cache.js';
@@ -923,14 +925,20 @@ export function __setGatewayStateForTests(state: GatewayState | null): void {
 // ─── Default command keyboard ────────────────────────────────────────────────
 
 /** Default keyboard shown with command responses and welcome messages. */
-export const DEFAULT_COMMAND_KEYBOARD: B24Keyboard = [
-  { TEXT: 'Help', COMMAND: 'help', BG_COLOR_TOKEN: 'primary', DISPLAY: 'LINE' },
-  { TEXT: 'Status', COMMAND: 'status', DISPLAY: 'LINE' },
-  { TEXT: 'Commands', COMMAND: 'commands', DISPLAY: 'LINE' },
-  { TYPE: 'NEWLINE' },
-  { TEXT: 'New session', COMMAND: 'new', DISPLAY: 'LINE' },
-  { TEXT: 'Models', COMMAND: 'models', DISPLAY: 'LINE' },
-];
+export function buildDefaultCommandKeyboard(language?: string): B24Keyboard {
+  const labels = commandKeyboardLabels(language);
+
+  return [
+    { TEXT: labels.help, COMMAND: 'help', BG_COLOR_TOKEN: 'primary', DISPLAY: 'LINE' },
+    { TEXT: labels.status, COMMAND: 'status', DISPLAY: 'LINE' },
+    { TEXT: labels.commands, COMMAND: 'commands', DISPLAY: 'LINE' },
+    { TYPE: 'NEWLINE' },
+    { TEXT: labels.newSession, COMMAND: 'new', DISPLAY: 'LINE' },
+    { TEXT: labels.models, COMMAND: 'models', DISPLAY: 'LINE' },
+  ];
+}
+
+export const DEFAULT_COMMAND_KEYBOARD: B24Keyboard = buildDefaultCommandKeyboard();
 
 // ─── Keyboard / Button conversion ────────────────────────────────────────────
 
@@ -1160,7 +1168,9 @@ async function sendInitialWelcomeToWebhookOwner(params: {
   };
   const isPairing = config.dmPolicy === 'pairing';
   const text = onboardingMessage(language, config.botName ?? 'OpenClaw', config.dmPolicy);
-  const options = isPairing ? undefined : { keyboard: DEFAULT_COMMAND_KEYBOARD };
+  const options = isPairing
+    ? undefined
+    : { keyboard: buildDefaultCommandKeyboard(language) };
 
   try {
     await sendService.sendText(sendCtx, text, options);
@@ -1978,6 +1988,8 @@ export const bitrix24Plugin = {
             sendCtx,
             config,
           });
+          let replyDelivered = false;
+          let dispatchFailed = false;
 
           // Download media files if present
           let mediaFields: Record<string, unknown> = {};
@@ -2101,7 +2113,7 @@ export const bitrix24Plugin = {
           });
 
           try {
-            await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            const dispatchResult = await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
               ctx: inboundCtx,
               cfg,
               dispatcherOptions: {
@@ -2128,6 +2140,7 @@ export const bitrix24Plugin = {
                       }
                     }
 
+                    replyDelivered = true;
                     await sendService.sendText(sendCtx, text, keyboard ? { keyboard } : undefined);
                   }
                 },
@@ -2139,11 +2152,28 @@ export const bitrix24Plugin = {
                 },
               },
             });
+
+            if (!replyDelivered && dispatchResult?.queuedFinal === false) {
+              await sendService.sendText(
+                sendCtx,
+                replyGenerationFailed(msgCtx.language),
+                { convertMarkdown: false },
+              );
+            }
           } catch (err) {
+            dispatchFailed = true;
             logger.error('Error dispatching message to agent', { senderId: msgCtx.senderId, chatId: msgCtx.chatId, error: err });
           } finally {
             replyStatusHeartbeat.stop();
           }
+
+          if (!replyDelivered && dispatchFailed) {
+            await sendService.sendText(
+              sendCtx,
+              replyGenerationFailed(msgCtx.language),
+              { convertMarkdown: false },
+            );
+          }
         } finally {
           await mediaService.cleanupDownloadedMedia(downloadedMedia.map((mediaItem) => mediaItem.path));
         }
@@ -2714,12 +2744,24 @@ export const bitrix24Plugin = {
 
           await directTextCoalescer.flush(ctx.accountId, conversation.dialogId);
 
+          const defaultCommandKeyboard = buildDefaultCommandKeyboard(cmdCtx.language);
+
           if (commandName === 'help' || commandName === 'commands') {
-            await sendService.answerCommandText(
-              commandSendCtx,
-              buildCommandsHelpText(cmdCtx.language, { concise: commandName === 'help' }),
-              { keyboard: DEFAULT_COMMAND_KEYBOARD, convertMarkdown: false },
-            );
+            const helpText = buildCommandsHelpText(cmdCtx.language, { concise: commandName === 'help' });
+
+            if (isDm) {
+              await sendService.sendText(
+                sendCtx,
+                helpText,
+                { keyboard: defaultCommandKeyboard, convertMarkdown: false },
+              );
+            } else {
+              await sendService.answerCommandText(
+                commandSendCtx,
+                helpText,
+                { keyboard: defaultCommandKeyboard, convertMarkdown: false },
+              );
+            }
             return;
           }
 
@@ -2763,17 +2805,19 @@ export const bitrix24Plugin = {
             config,
           });
           let commandReplyDelivered = false;
+          let commandDispatchFailed = false;
 
           try {
             await replyStatusHeartbeat.start();
-            await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            const dispatchResult = await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
               ctx: inboundCtx,
               cfg,
               dispatcherOptions: {
                 deliver: async (payload) => {
                   await replyStatusHeartbeat.stopAndWait();
                   if (payload.text) {
-                    const keyboard = extractKeyboardFromPayload(payload) ?? DEFAULT_COMMAND_KEYBOARD;
+                    const keyboard = extractKeyboardFromPayload(payload)
+                      ?? defaultCommandKeyboard;
                     const formattedPayload = normalizeCommandReplyPayload({
                       commandName,
                       commandParams,
@@ -2781,14 +2825,23 @@ export const bitrix24Plugin = {
                       language: cmdCtx.language,
                     });
                     if (!commandReplyDelivered) {
-                      commandReplyDelivered = true;
-                      await sendService.answerCommandText(commandSendCtx, formattedPayload.text, {
-                        keyboard,
-                        convertMarkdown: formattedPayload.convertMarkdown,
-                      });
+                      if (isDm) {
+                        commandReplyDelivered = true;
+                        await sendService.sendText(sendCtx, formattedPayload.text, {
+                          keyboard,
+                          convertMarkdown: formattedPayload.convertMarkdown,
+                        });
+                      } else {
+                        commandReplyDelivered = true;
+                        await sendService.answerCommandText(commandSendCtx, formattedPayload.text, {
+                          keyboard,
+                          convertMarkdown: formattedPayload.convertMarkdown,
+                        });
+                      }
                       return;
                     }
 
+                    commandReplyDelivered = true;
                     await sendService.sendText(sendCtx, formattedPayload.text, {
                       keyboard,
                       convertMarkdown: formattedPayload.convertMarkdown,
@@ -2803,11 +2856,42 @@ export const bitrix24Plugin = {
                 },
               },
             });
+
+            if (!commandReplyDelivered && dispatchResult?.queuedFinal === false) {
+              const fallbackText = replyGenerationFailed(cmdCtx.language);
+              if (isDm) {
+                await sendService.sendText(sendCtx, fallbackText, {
+                  keyboard: defaultCommandKeyboard,
+                  convertMarkdown: false,
+                });
+              } else {
+                await sendService.answerCommandText(commandSendCtx, fallbackText, {
+                  keyboard: defaultCommandKeyboard,
+                  convertMarkdown: false,
+                });
+              }
+            }
           } catch (err) {
+            commandDispatchFailed = true;
             logger.error('Error dispatching command to agent', { commandName, senderId, dialogId, error: err });
           } finally {
             replyStatusHeartbeat.stop();
           }
+
+          if (!commandReplyDelivered && commandDispatchFailed) {
+            const fallbackText = replyGenerationFailed(cmdCtx.language);
+            if (isDm) {
+              await sendService.sendText(sendCtx, fallbackText, {
+                keyboard: defaultCommandKeyboard,
+                convertMarkdown: false,
+              });
+            } else {
+              await sendService.answerCommandText(commandSendCtx, fallbackText, {
+                keyboard: defaultCommandKeyboard,
+                convertMarkdown: false,
+              });
+            }
+          }
         },
 
         onJoinChat: async (joinCtx: FetchJoinChatContext) => {
@@ -2898,7 +2982,7 @@ export const bitrix24Plugin = {
             await sendService.sendText(
               sendCtx,
               text,
-              isPairing ? undefined : { keyboard: DEFAULT_COMMAND_KEYBOARD },
+              isPairing ? undefined : { keyboard: buildDefaultCommandKeyboard(language) },
             );
             welcomedDialogs.add(dialogId);
             logger.info('Welcome message sent', { dialogId });

package/src/i18n.ts

@@ -215,3 +215,73 @@ export function onboardingMessage(
     ? pairingWelcomeMessage(lang, botName)
     : welcomeMessage(lang, botName);
 }
+
+interface CommandKeyboardLabels {
+  help: string;
+  status: string;
+  commands: string;
+  newSession: string;
+  models: string;
+}
+
+const I18N_COMMAND_KEYBOARD_LABELS: Record<string, CommandKeyboardLabels> = {
+  en: {
+    help: 'Help',
+    status: 'Status',
+    commands: 'Commands',
+    newSession: 'New session',
+    models: 'Models',
+  },
+  ru: {
+    help: 'Справка',
+    status: 'Статус',
+    commands: 'Команды',
+    newSession: 'Новая сессия',
+    models: 'Модели',
+  },
+  de: {
+    help: 'Hilfe',
+    status: 'Status',
+    commands: 'Befehle',
+    newSession: 'Neue Sitzung',
+    models: 'Modelle',
+  },
+  es: {
+    help: 'Ayuda',
+    status: 'Estado',
+    commands: 'Comandos',
+    newSession: 'Nueva sesion',
+    models: 'Modelos',
+  },
+  fr: {
+    help: 'Aide',
+    status: 'Statut',
+    commands: 'Commandes',
+    newSession: 'Nouvelle session',
+    models: 'Modeles',
+  },
+  pt: {
+    help: 'Ajuda',
+    status: 'Status',
+    commands: 'Comandos',
+    newSession: 'Nova sessao',
+    models: 'Modelos',
+  },
+};
+
+export function commandKeyboardLabels(lang: string | undefined): CommandKeyboardLabels {
+  return resolve(I18N_COMMAND_KEYBOARD_LABELS, lang);
+}
+
+const I18N_REPLY_GENERATION_FAILED: Record<string, string> = {
+  en: 'I could not prepare a final reply. Please try again. If your request needs web search or external tools, check that they are configured on the server.',
+  ru: 'Не удалось подготовить итоговый ответ. Попробуйте повторить запрос. Если вопрос требует веб-поиска или внешних инструментов, проверьте, что они настроены на сервере.',
+  de: 'Ich konnte keine abschliessende Antwort vorbereiten. Bitte versuchen Sie es erneut. Wenn Ihre Anfrage Websuche oder externe Tools braucht, pruefen Sie deren Server-Konfiguration.',
+  es: 'No pude preparar una respuesta final. Intente de nuevo. Si su solicitud necesita busqueda web o herramientas externas, verifique que esten configuradas en el servidor.',
+  fr: 'Je n ai pas pu preparer de reponse finale. Reessayez. Si votre demande a besoin de recherche web ou d outils externes, verifiez leur configuration sur le serveur.',
+  pt: 'Nao consegui preparar uma resposta final. Tente novamente. Se sua solicitacao precisa de busca na web ou ferramentas externas, verifique se elas estao configuradas no servidor.',
+};
+
+export function replyGenerationFailed(lang: string | undefined): string {
+  return resolve(I18N_REPLY_GENERATION_FAILED, lang);
+}

package/src/message-utils.ts

@@ -214,19 +214,26 @@ function isInlineAccentToken(value: string): boolean {
     return false;
   }
 
+  // In Bitrix chat UI inline [CODE] is visually heavy, so inline backticks
+  // should default to a compact docs accent unless the token clearly looks
+  // like an executable/code snippet.
+  if (looksLikeInlineCodeSnippet(trimmed)) {
+    return false;
+  }
+
   if (isWrappedInlineAccentToken(trimmed)) {
     return true;
   }
 
-  if (looksLikeInlineCodeSnippet(trimmed)) {
-    return false;
+  if (isCompactInlineAccentAssignment(trimmed)) {
+    return true;
   }
 
-  return isInlineAccentCandidate(trimmed);
+  return isInlineAccentReference(trimmed);
 }
 
 function looksLikeInlineCodeSnippet(value: string): boolean {
-  if (/[`"'{};]/.test(value)) {
+  if (/`|;\s*$/.test(value)) {
     return true;
   }
 
@@ -234,13 +241,41 @@ function looksLikeInlineCodeSnippet(value: string): boolean {
     return true;
   }
 
-  return /\b(?:const|let|var|function|class|return|await|async|import|export|from|yield|switch|case)\b/.test(value);
+  if (/\b(?:const|let|var|function|class|return|await|async|import|export|from|yield|switch|case|if|else|for|while|try|catch|finally|throw|new|delete|typeof|void)\b/.test(value)) {
+    return true;
+  }
+
+  if (/\s(?:[+\-*/%<>]=?|===|!==|==|!=|<=|>=|\|\||&&|\?\?)\s/.test(value)) {
+    return true;
+  }
+
+  if (looksLikeStructuredInlineSnippet(value)) {
+    return true;
+  }
+
+  return /^(?:curl|wget|npm|pnpm|yarn|bun|node|php|python(?:3)?|ssh|git|docker(?:-compose)?|kubectl|composer)\b.*(?:\||>|<|\$|\s--?[a-z])/i.test(value);
+}
+
+function looksLikeStructuredInlineSnippet(value: string): boolean {
+  if (/^(?:\{\}|\[\]|\(\))$/.test(value)) {
+    return false;
+  }
+
+  if (/^\{[\s\S]+\}$/.test(value)) {
+    return /[:,[\]{}]/.test(value.slice(1, -1));
+  }
+
+  if (/^\[[\s\S]+\]$/.test(value)) {
+    return /[:,[\]{}]/.test(value.slice(1, -1));
+  }
+
+  return false;
 }
 
 function isWrappedInlineAccentToken(value: string): boolean {
   const match = value.match(/^([("'`])(.+)([)"'`])$/);
   if (!match) {
-    return false;
+    return /^(?:\{\}|\[\]|\(\))$/.test(value);
   }
 
   const open = match[1];
@@ -262,7 +297,59 @@ function isWrappedInlineAccentToken(value: string): boolean {
     return false;
   }
 
-  return isInlineAccentCandidate(inner);
+  return isInlineAccentReference(inner);
+}
+
+function isCompactInlineAccentAssignment(value: string): boolean {
+  const match = value.match(/^([\p{L}_][\p{L}\p{N}._[\]-]{0,47})\s*=\s*(.+)$/u);
+  if (!match) {
+    return false;
+  }
+
+  const left = match[1].trim();
+  const right = match[2].trim();
+
+  if (!right || /\s{2,}/.test(left)) {
+    return false;
+  }
+
+  if (/^(?:const|let|var|return|await|yield|import|export|function|class|new|delete|typeof|void)$/i.test(left)) {
+    return false;
+  }
+
+  if (looksLikeInlineCodeSnippet(left)) {
+    return false;
+  }
+
+  return isInlineAccentReference(right);
+}
+
+function isInlineAccentReference(value: string): boolean {
+  return isInlineAccentScalar(value) || isInlineAccentCandidate(value) || isWrappedInlineAccentToken(value);
+}
+
+function isInlineAccentScalar(value: string): boolean {
+  if (!value || value.length > 48) {
+    return false;
+  }
+
+  if (/^(?:true|false|null|none|yes|no|on|off|\d+(?:\.\d+)?)$/i.test(value)) {
+    return true;
+  }
+
+  if (/^#(?:[\p{L}\p{N}_-]+|[0-9A-Fa-f]{3}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/u.test(value)) {
+    return true;
+  }
+
+  if (/^https?:\/\/[^\s]+$/i.test(value)) {
+    return true;
+  }
+
+  if (/^0x[0-9A-Fa-f]+$/.test(value)) {
+    return true;
+  }
+
+  return false;
 }
 
 function isLowercaseNaturalLanguageWord(value: string): boolean {

package/src/send-service.ts

@@ -109,7 +109,7 @@ export class SendService {
         ctx.messageId,
         ctx.commandDialogId ?? ctx.dialogId,
         chunks[0],
-        chunks.length === 1 && options?.keyboard
+        options?.keyboard
           ? { keyboard: options.keyboard }
           : undefined,
       );
@@ -119,18 +119,13 @@ export class SendService {
     }
 
     for (let i = 1; i < chunks.length; i++) {
-      const isLast = i === chunks.length - 1;
-      const msgOptions = isLast && options?.keyboard
-        ? { keyboard: options.keyboard }
-        : undefined;
-
       try {
         lastMessageId = await this.api.sendMessage(
           ctx.webhookUrl,
           ctx.bot,
           ctx.dialogId,
           chunks[i],
-          msgOptions,
+          undefined,
         );
       } catch (error) {
         this.logger.error('Failed to send command follow-up message', { error: serializeError(error) });