@xmanrui/dsh-im 1.5.0 → 2.0.0

package/src/channels/qq/qq-bridge.mjs

@@ -40,8 +40,11 @@ import {
   providerMessageIdsFor,
 } from '../shared/semantic/delivery.mjs';
 import { sendMarkdownReply } from './markdown-reply.mjs';
+import { t } from '../shared/i18n.mjs';
 
-const INTERACTION_RESOLVED_TEXT = '这个问题已在其他客户端处理，无需再次回答。';
+function interactionResolvedText() {
+  return t('这个问题已在其他客户端处理，无需再次回答。');
+}
 const DEFAULT_FILE_UPLOAD_TIMEOUT_MS = 120_000;
 
 export const QQ_IMAGE_HOSTS = Object.freeze([
@@ -55,28 +58,30 @@ export const QQ_IMAGE_HOSTS = Object.freeze([
 
 const QQ_IMAGE_FILENAME = /\.(?:gif|jpe?g|png|webp)$/i;
 
-const HELP_TEXT = [
-  'QQ 机器人已连接 DeepSeek Harness。',
-  '',
-  '直接发送文字、图片或文件即可继续当前会话。',
-  '/new  开启一个全新会话',
-  '/compact  压缩当前会话的较早上下文',
-  '/workspace 工作区绝对路径  切换工作区',
-  '/workspacelist  列出工作区绝对路径',
-  '/sessionlist [工作区序号或绝对路径]  列出会话 ID 和标题',
-  '/session Session ID 或当前工作区序号  将当前聊天绑定到指定会话',
-  '/models  按序号列出所有可用模型',
-  '/model [序号或完整模型ID]  查看或切换当前会话模型',
-  '示例：先发 /models，再发 /model 2',
-  '/presetlist  按序号列出可用 Agent Preset',
-  '/preset [序号或完整ID]  查看或设置当前机器人 Agent Preset',
-  '纯数字 ID：/preset id:<ID>',
-  '/preset --default  跟随 Host 默认',
-  '/stop  停止当前任务',
-  '/steer 补充指令  纠偏当前任务',
-  '/status  检查连接状态',
-  '/help  显示本帮助',
-].join('\n');
+function helpText() {
+  return [
+    t('QQ 机器人已连接 DeepSeek Harness。'),
+    '',
+    t('直接发送文字、图片或文件即可继续当前会话。'),
+    t('/new  开启一个全新会话'),
+    t('/compact  压缩当前会话的较早上下文'),
+    t('/workspace 工作区绝对路径  切换工作区'),
+    t('/workspacelist  列出工作区绝对路径'),
+    t('/sessionlist [工作区序号或绝对路径]  列出会话 ID 和标题'),
+    t('/session Session ID 或当前工作区序号  将当前聊天绑定到指定会话'),
+    t('/models  按序号列出所有可用模型'),
+    t('/model [序号或完整模型ID]  查看或切换当前会话模型'),
+    t('示例：先发 /models，再发 /model 2'),
+    t('/presetlist  按序号列出可用 Agent Preset'),
+    t('/preset [序号或完整ID]  查看或设置当前机器人 Agent Preset'),
+    t('纯数字 ID：/preset id:<ID>'),
+    t('/preset --default  跟随 Host 默认'),
+    t('/stop  停止当前任务'),
+    t('/steer 补充指令  纠偏当前任务'),
+    t('/status  检查连接状态'),
+    t('/help  显示本帮助'),
+  ].join('\n');
+}
 
 function conversationKey(message) {
   return `${message.kind}:${message.kind === 'group' ? message.groupOpenid : message.senderId}`;
@@ -167,35 +172,35 @@ function nonEmptyString(value) {
 }
 
 function artifactFailureText(fileName, error) {
-  const name = String(fileName ?? '结果文件').replace(/[\r\n]+/g, ' ').trim() || '结果文件';
+  const name = String(fileName ?? t('结果文件')).replace(/[\r\n]+/g, ' ').trim() || t('结果文件');
   if (error?.name === 'UploadDailyLimitExceededError') {
-    return `结果文件「${name}」已生成，但 QQ 今日文件上传额度已用完，请稍后重试。`;
+    return t('结果文件「{name}」已生成，但 QQ 今日文件上传额度已用完，请稍后重试。', { name });
   }
   switch (error?.code) {
     case 'artifact-delivery-uncertain':
-      return `结果文件「${name}」的发送结果未能确认，请先检查聊天内是否已收到，不要立即重试。`;
+      return t('结果文件「{name}」的发送结果未能确认，请先检查聊天内是否已收到，不要立即重试。', { name });
     case 'artifact-permission-required':
-      return `结果文件「${name}」已生成，但当前 QQ 机器人没有文件消息权限。`;
+      return t('结果文件「{name}」已生成，但当前 QQ 机器人没有文件消息权限。', { name });
     case 'artifact-too-large':
-      return `结果文件「${name}」超过当前 QQ 机器人可发送的文件大小，未发送。`;
+      return t('结果文件「{name}」超过当前 QQ 机器人可发送的文件大小，未发送。', { name });
     case 'artifact-empty':
-      return `结果文件「${name}」为空，QQ 不允许发送空文件。`;
+      return t('结果文件「{name}」为空，QQ 不允许发送空文件。', { name });
     case 'artifact-changed':
     case 'artifact-invalid':
     case 'artifact-unavailable':
-      return `结果文件「${name}」暂时无法读取或准备发送，请确认文件仍可访问后重试。`;
+      return t('结果文件「{name}」暂时无法读取或准备发送，请确认文件仍可访问后重试。', { name });
     case 'artifact-rate-limited':
-      return `结果文件「${name}」暂时被 QQ 限流，未能发送，请稍后重试。`;
+      return t('结果文件「{name}」暂时被 QQ 限流，未能发送，请稍后重试。', { name });
     case 'artifact-provider-rejected':
-      return `结果文件「${name}」已生成，但 QQ 拒绝了该文件或文件消息。`;
+      return t('结果文件「{name}」已生成，但 QQ 拒绝了该文件或文件消息。', { name });
     default:
-      return `结果文件「${name}」已生成，但暂时未能通过 QQ 发送，请稍后重试。`;
+      return t('结果文件「{name}」已生成，但暂时未能通过 QQ 发送，请稍后重试。', { name });
   }
 }
 
 function answerTextForDelivery(answer, artifacts) {
   if (typeof answer === 'string' && answer.trim()) return answer;
-  return artifacts.length > 0 ? '结果文件已生成。' : answer;
+  return artifacts.length > 0 ? t('结果文件已生成。') : answer;
 }
 
 function qqArtifactError(error, { dispatched = false } = {}) {
@@ -420,7 +425,7 @@ export class QqHarnessBridge {
         if (error?.code === 'turn-stopped' || this.#signal?.aborted) return;
         this.#status.lastError = error?.message ?? String(error);
         this.#logger.error?.('[dsh-im:qq] failed to process a command:', error);
-        return this.#bot.sendText(message.replyTarget, '消息处理失败，请稍后重试。')
+        return this.#bot.sendText(message.replyTarget, t('消息处理失败，请稍后重试。'))
           .catch(() => undefined);
       }).finally(() => {
         this.#acceptedMessageIds.delete(messageId);
@@ -609,25 +614,25 @@ export class QqHarnessBridge {
     let stream = null;
     try {
       if (!text && !hasImages && !hasFiles) {
-        await this.#bot.sendText(target, '目前支持文字、图片和文件消息。');
+        await this.#bot.sendText(target, t('目前支持文字、图片和文件消息。'));
         await this.#state.markSeen(messageId);
         return;
       }
       const command = text.toLowerCase();
       if (!hasImages && !hasFiles && command === '/help') {
-        await this.#bot.sendText(target, HELP_TEXT);
+        await this.#bot.sendText(target, helpText());
         await this.#state.markSeen(messageId);
         return;
       }
       if (!hasImages && !hasFiles && command === '/status') {
         await this.#harness.ensureRunning({ signal: this.#signal });
-        await this.#bot.sendText(target, 'QQ 机器人与 DeepSeek Harness 连接正常。');
+        await this.#bot.sendText(target, t('QQ 机器人与 DeepSeek Harness 连接正常。'));
         await this.#state.markSeen(messageId);
         return;
       }
       if (!hasImages && !hasFiles && command === '/new') {
         await this.#state.clearSession(key);
-        await this.#bot.sendText(target, '已开启新会话。请发送你的问题。');
+        await this.#bot.sendText(target, t('已开启新会话。请发送你的问题。'));
         await this.#state.markSeen(messageId);
         return;
       }
@@ -771,7 +776,7 @@ export class QqHarnessBridge {
           this.#logger.warn?.('[dsh-im:qq] unable to cancel a stopped QQ stream:', streamError);
         }
         try {
-          await this.#bot.sendText(target, '已停止。');
+          await this.#bot.sendText(target, t('已停止。'));
         } catch (sendError) {
           this.#logger.warn?.('[dsh-im:qq] unable to announce a stopped QQ turn:', sendError);
         }
@@ -791,7 +796,7 @@ export class QqHarnessBridge {
           target,
           inboundFileUserMessage(error)
             ?? imagePromptUserMessage(error)
-            ?? '消息处理失败，请稍后重试。',
+            ?? t('消息处理失败，请稍后重试。'),
         );
         await this.#state.markSeen(messageId);
       } catch (sendError) {
@@ -818,14 +823,14 @@ export class QqHarnessBridge {
     if (message.kind === 'group' && message.rawEventType !== 'GROUP_AT_MESSAGE_CREATE') return;
     const text = nonEmptyString(safeText(message));
     if (!text || hasQqImageAttachments(message) || hasQqFileAttachments(message)) {
-      await this.#bot.sendText(message.replyTarget, '请用文字回答当前问题。');
+      await this.#bot.sendText(message.replyTarget, t('请用文字回答当前问题。'));
       return;
     }
 
     const pending = this.#pendingInteractions.get(key);
     if (!pending || pending !== expected || pending.submitting) {
       if (claimed && (!pending || pending !== expected)) {
-        await this.#bot.sendText(message.replyTarget, INTERACTION_RESOLVED_TEXT);
+        await this.#bot.sendText(message.replyTarget, interactionResolvedText());
         return;
       }
       return this.#enqueueMessage(message, messageId, key, {
@@ -838,7 +843,7 @@ export class QqHarnessBridge {
       try {
         await this.#presentInteraction(pending);
       } catch {
-        this.#status.lastError = 'QQ 交互问题发送失败。';
+        this.#status.lastError = t('QQ 交互问题发送失败。');
         this.#logger.error?.('[dsh-im:qq] failed to retry an interaction question');
         pending.interaction.reconnect?.();
         return;
@@ -846,7 +851,7 @@ export class QqHarnessBridge {
       const presentedPending = this.#pendingInteractions.get(key);
       if (!presentedPending || presentedPending !== expected || presentedPending.submitting) {
         if (claimed && (!presentedPending || presentedPending !== expected)) {
-          await this.#bot.sendText(message.replyTarget, INTERACTION_RESOLVED_TEXT)
+          await this.#bot.sendText(message.replyTarget, interactionResolvedText())
             .catch(() => undefined);
           return;
         }
@@ -869,7 +874,7 @@ export class QqHarnessBridge {
       try {
         await this.#presentInteraction(pending);
       } catch {
-        this.#status.lastError = 'QQ 交互问题发送失败。';
+        this.#status.lastError = t('QQ 交互问题发送失败。');
         this.#logger.error?.('[dsh-im:qq] failed to send the next interaction question');
         pending.interaction.reconnect?.();
       }
@@ -891,16 +896,16 @@ export class QqHarnessBridge {
       if (this.#signal?.aborted) return;
       if (error?.code === 'interaction-not-pending') {
         this.#clearPendingInteraction(key, pending.interactionId);
-        await this.#bot.sendText(pending.target, INTERACTION_RESOLVED_TEXT).catch(() => undefined);
+        await this.#bot.sendText(pending.target, interactionResolvedText()).catch(() => undefined);
         return;
       }
       if (this.#pendingInteractions.get(key) !== pending) return;
       pending.submitting = false;
       pending.answers.pop();
       pending.index -= 1;
-      this.#status.lastError = '回答提交失败。';
+      this.#status.lastError = t('回答提交失败。');
       this.#logger.error?.('[dsh-im:qq] failed to answer a Harness interaction');
-      await this.#bot.sendText(pending.target, '回答提交失败，请重新发送当前问题的答案。')
+      await this.#bot.sendText(pending.target, t('回答提交失败，请重新发送当前问题的答案。'))
         .catch(() => undefined);
     }
   }
@@ -945,7 +950,7 @@ export class QqHarnessBridge {
       });
       await this.#bot.sendText(
         target,
-        '检测到这个 Session 中遗留的待回答问题，已安全取消并继续处理你刚才的消息。',
+        t('检测到这个 Session 中遗留的待回答问题，已安全取消并继续处理你刚才的消息。'),
       ).catch(() => undefined);
       return;
     }
@@ -1030,7 +1035,7 @@ export class QqHarnessBridge {
     await this.#state.markSeen(messageId);
     this.#status.messagesReceived += 1;
     this.#status.lastMessageAt = new Date().toISOString();
-    await this.#bot.sendText(message.replyTarget, INTERACTION_RESOLVED_TEXT).catch(() => undefined);
+    await this.#bot.sendText(message.replyTarget, interactionResolvedText()).catch(() => undefined);
   }
 
   #takePendingInteraction(key, interactionId) {
@@ -1072,7 +1077,7 @@ export class QqHarnessBridge {
     if (!this.#state.hasSeen(messageId)) {
       await this.#state.markSeen(messageId).catch(() => undefined);
     }
-    await this.#bot.sendText(message.replyTarget, '消息处理失败，请稍后重试。')
+    await this.#bot.sendText(message.replyTarget, t('消息处理失败，请稍后重试。'))
       .catch(() => undefined);
   }
 }

package/src/channels/qq/qq-controller.mjs

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 
 import { connectionTestMessage } from '../shared/connection-test.mjs';
+import { t } from '../shared/i18n.mjs';
 import { deriveQqBotIdentity, maskQqAppId } from './config-store.mjs';
 
 const ACTIVE_ATTEMPT_STATES = new Set(['starting', 'pending', 'refreshing', 'connecting']);
@@ -77,14 +78,14 @@ export class QqController {
         if (this.#closed || this.#runtimes.get(config.botId)?.status?.ready) return;
         const appSecret = await this.#resolveSecret(config.secretRef);
         if (!appSecret) {
-          this.#errors.set(config.botId, safeError('missing-secret', 'QQ 机器人凭据缺失，请移除后重新扫码。'));
+          this.#errors.set(config.botId, safeError('missing-secret', t('QQ 机器人凭据缺失，请移除后重新扫码。')));
           return;
         }
         try {
           await this.#startRuntime(config, appSecret);
           this.#errors.delete(config.botId);
         } catch (error) {
-          this.#errors.set(config.botId, safeError('connection-failed', 'QQ 连接未就绪，插件会自动重试。'));
+          this.#errors.set(config.botId, safeError('connection-failed', t('QQ 连接未就绪，插件会自动重试。')));
           this.#logger.warn?.(`[dsh-im:qq] bot ${config.botId} failed to initialize:`, error);
         } finally {
           this.#touch();
@@ -147,7 +148,7 @@ export class QqController {
         onFailure: (error) => {
           if (record.controller.signal.aborted || TERMINAL_ATTEMPT_STATES.has(record.state)) return;
           record.state = 'failed';
-          record.error = safeError('qr-connect-failed', 'QQ 扫码服务暂时不可用，请重新生成二维码。');
+          record.error = safeError('qr-connect-failed', t('QQ 扫码服务暂时不可用，请重新生成二维码。'));
           if (this.#activeAttemptId === record.id) this.#activeAttemptId = null;
           this.#touch();
           firstQrReject(error);
@@ -158,10 +159,10 @@ export class QqController {
     } catch (error) {
       if (record.controller.signal.aborted) {
         record.state = 'cancelled';
-        record.error = safeError('cancelled', '扫码绑定已取消。');
+        record.error = safeError('cancelled', t('扫码绑定已取消。'));
       } else if (!TERMINAL_ATTEMPT_STATES.has(record.state)) {
         record.state = 'failed';
-        record.error = safeError('qr-start-failed', '无法生成 QQ 二维码，请稍后重试。');
+        record.error = safeError('qr-start-failed', t('无法生成 QQ 二维码，请稍后重试。'));
       }
       if (this.#activeAttemptId === record.id) this.#activeAttemptId = null;
       this.#touch();
@@ -207,7 +208,7 @@ export class QqController {
         await this.#startRuntime(config, normalizedSecret);
         this.#errors.delete(identity.botId);
       } catch (error) {
-        this.#errors.set(identity.botId, safeError('connection-failed', 'QQ 机器人已绑定，消息连接暂未就绪。'));
+        this.#errors.set(identity.botId, safeError('connection-failed', t('QQ 机器人已绑定，消息连接暂未就绪。')));
         this.#logger.warn?.(`[dsh-im:qq] bot ${identity.botId} credential connection failed:`, error);
       }
       this.#touch();
@@ -223,7 +224,7 @@ export class QqController {
       record.dispose?.();
       await record.task?.catch(() => undefined);
       if (!TERMINAL_ATTEMPT_STATES.has(record.state)) record.state = 'cancelled';
-      record.error ??= safeError('cancelled', '扫码绑定已取消。');
+      record.error ??= safeError('cancelled', t('扫码绑定已取消。'));
     }
     if (this.#activeAttemptId === record.id) this.#activeAttemptId = null;
     this.#touch();
@@ -240,7 +241,7 @@ export class QqController {
         await this.#startRuntime(config, secret);
         this.#errors.delete(botId);
       } catch (error) {
-        this.#errors.set(botId, safeError('connection-failed', 'QQ 连接仍未就绪，请稍后重试。'));
+        this.#errors.set(botId, safeError('connection-failed', t('QQ 连接仍未就绪，请稍后重试。')));
         throw error;
       } finally {
         this.#touch();
@@ -255,12 +256,12 @@ export class QqController {
     return this.#withBotTransition(botId, async () => {
       const runtime = this.#runtimes.get(botId);
       if (!runtime?.status?.ready || typeof runtime.sendConnectionTest !== 'function') {
-        const error = new Error('QQ机器人尚未连接');
+        const error = new Error(t('QQ机器人尚未连接'));
         error.code = 'test-target-unavailable';
         throw error;
       }
       await runtime.sendConnectionTest(connectionTestMessage(
-        `QQ 机器人（${maskQqAppId(config.appId)}）`,
+        t('QQ 机器人（{appId}）', { appId: maskQqAppId(config.appId) }),
       ));
       return { sent: true };
     });
@@ -306,11 +307,11 @@ export class QqController {
         state,
         connected,
         configured: true,
-        bot: { name: 'QQ机器人', appIdMasked: maskQqAppId(config.appId) },
+        bot: { name: t('QQ机器人'), appIdMasked: maskQqAppId(config.appId) },
         health: {
           status: connected ? 'healthy' : state === 'error' ? 'error' : 'offline',
-          summary: connected ? 'QQ WebSocket 长连接运行正常'
-            : state === 'error' ? 'QQ 连接未就绪，插件会自动重试' : 'QQ 连接当前离线',
+          summary: connected ? t('QQ WebSocket 长连接运行正常')
+            : state === 'error' ? t('QQ 连接未就绪，插件会自动重试') : t('QQ 连接当前离线'),
           lastCheckedAt: runtimeStatus?.lastCheckedAt ?? null,
           lastConnectedAt: runtimeStatus?.lastConnectedAt ?? null,
         },
@@ -364,10 +365,10 @@ export class QqController {
     } catch (error) {
       if (record.controller.signal.aborted) {
         record.state = 'cancelled';
-        record.error = safeError('cancelled', '扫码绑定已取消。');
+        record.error = safeError('cancelled', t('扫码绑定已取消。'));
       } else {
         record.state = 'failed';
-        record.error = safeError('activation-failed', 'QQ 已授权，但无法安全保存接入配置。');
+        record.error = safeError('activation-failed', t('QQ 已授权，但无法安全保存接入配置。'));
         this.#logger.error?.('[dsh-im:qq] provisioning failed:', error);
       }
     } finally {
@@ -417,7 +418,7 @@ export class QqController {
           await this.#restoreCredential(identity.secretRef, previousSecret);
           throw error;
         }
-        this.#errors.set(identity.botId, safeError('connection-failed', 'QQ 机器人已绑定，消息连接暂未就绪。'));
+        this.#errors.set(identity.botId, safeError('connection-failed', t('QQ 机器人已绑定，消息连接暂未就绪。')));
         this.#logger.warn?.(`[dsh-im:qq] bot ${identity.botId} activation connection failed:`, error);
       }
       this.#touch();

package/src/channels/qq/qq-runtime.mjs

@@ -4,6 +4,7 @@ import {
   connectionTestTarget,
   connectionTestTargetUnavailable,
 } from '../shared/connection-test.mjs';
+import { t } from '../shared/i18n.mjs';
 import { createQqBridgeStatus, QqHarnessBridge } from './qq-bridge.mjs';
 
 function timeoutError() {
@@ -73,7 +74,7 @@ export class QqRuntime {
 
   async sendConnectionTest(text) {
     if (!this.#status.ready || !this.#bot) {
-      throw connectionTestTargetUnavailable('QQ机器人');
+      throw connectionTestTargetUnavailable(t('QQ机器人'));
     }
     const ownerUserOpenid = typeof this.#config.ownerUserOpenid === 'string'
       ? this.#config.ownerUserOpenid.trim()
@@ -88,7 +89,7 @@ export class QqRuntime {
       : (ownerUserOpenid && ownerUserOpenid !== '*'
         ? { scope: 'c2c', targetId: ownerUserOpenid }
         : null);
-    if (!target) throw connectionTestTargetUnavailable('QQ机器人');
+    if (!target) throw connectionTestTargetUnavailable(t('QQ机器人'));
     await this.#bot.sendText(target, text);
     return { sent: true };
   }

package/src/channels/shared/agent-preset.mjs

@@ -1,3 +1,5 @@
+import { t } from './i18n.mjs';
+
 /** Matches DeepSeek Harness agent-preset directory ids. */
 export const AGENT_PRESET_ID = /^[a-z0-9][a-z0-9-]*$/;
 
@@ -17,7 +19,7 @@ export function validateAgentPresetId(value) {
   if (value == null || value === '') return null;
   const id = normalizeAgentPresetId(value);
   if (!id) {
-    const error = new Error('Agent Preset 无效。');
+    const error = new Error(t('Agent Preset 无效。'));
     error.code = 'agent-preset-invalid';
     throw error;
   }

package/src/channels/shared/compact-command.mjs

@@ -1,3 +1,4 @@
+import { t } from './i18n.mjs';
 import { WORKSPACE_SESSION_STALE } from './workspace-session.mjs';
 
 const COMPACT_COMMAND = /^\/compact(?=$|\s)([\s\S]*)$/i;
@@ -41,27 +42,27 @@ function compactResultText(result) {
   const text = result.text?.trim() ?? '';
   const compacted = /^Compacted (\d+) history items \(~(\d+) tokens\)\.$/u.exec(text);
   if (compacted) {
-    return `已压缩 ${compacted[1]} 条历史记录（约 ${compacted[2]} 个 token）。`;
+    return t('已压缩 {count} 条历史记录（约 {tokens} 个 token）。', { count: compacted[1], tokens: compacted[2] });
   }
-  if (COMPACT_RESULT_TEXT.has(text)) return COMPACT_RESULT_TEXT.get(text);
+  if (COMPACT_RESULT_TEXT.has(text)) return t(COMPACT_RESULT_TEXT.get(text));
   if (text) return text;
-  return result.kind === 'success' ? '上下文压缩完成。' : '上下文压缩失败。';
+  return result.kind === 'success' ? t('上下文压缩完成。') : t('上下文压缩失败。');
 }
 
 function compactErrorMessage(error) {
   const code = error?.code ?? error?.failure?.code;
   if (code === 'session-not-found') {
-    return '当前聊天绑定的会话已不存在，请发送新消息开启会话。';
+    return t('当前聊天绑定的会话已不存在，请发送新消息开启会话。');
   }
-  if (code === 'agent-busy') return '当前会话正在生成回复，请稍后重试。';
-  if (code === 'cancelled' || error?.name === 'AbortError') return '上下文压缩已取消。';
+  if (code === 'agent-busy') return t('当前会话正在生成回复，请稍后重试。');
+  if (code === 'cancelled' || error?.name === 'AbortError') return t('上下文压缩已取消。');
   if (code === WORKSPACE_SESSION_STALE || code === 'workspace-bot-not-found') {
-    return '工作区或机器人状态已发生变化，请重试。';
+    return t('工作区或机器人状态已发生变化，请重试。');
   }
   if (code === 'commands-unavailable') {
-    return '当前 Harness 暂不支持从机器人执行上下文压缩。';
+    return t('当前 Harness 暂不支持从机器人执行上下文压缩。');
   }
-  return '上下文压缩失败，请稍后重试。';
+  return t('上下文压缩失败，请稍后重试。');
 }
 
 /**
@@ -72,21 +73,21 @@ export async function runCompactCommand(text, harness, state, conversationKey, o
   if (typeof text !== 'string') return null;
   const match = COMPACT_COMMAND.exec(text.trim());
   if (!match) return null;
-  if (match[1].trim()) return commandResult(COMPACT_USAGE);
+  if (match[1].trim()) return commandResult(t(COMPACT_USAGE));
   if (typeof state?.sessionFor !== 'function') {
-    return commandResult('当前机器人没有可用的会话状态。');
+    return commandResult(t('当前机器人没有可用的会话状态。'));
   }
   const sessionId = state.sessionFor(conversationKey);
   if (typeof sessionId !== 'string' || !sessionId) {
-    return commandResult('当前聊天还没有可压缩的会话，请先发送一条消息。');
+    return commandResult(t('当前聊天还没有可压缩的会话，请先发送一条消息。'));
   }
   if (typeof harness?.executeCommand !== 'function') {
-    return commandResult('当前机器人暂不支持上下文压缩。');
+    return commandResult(t('当前机器人暂不支持上下文压缩。'));
   }
   try {
     const execution = await harness.executeCommand(sessionId, '/compact', options);
     if (execution === undefined) {
-      return commandResult('当前 Harness 未注册 /compact 命令，请确认上下文压缩组件已启用。');
+      return commandResult(t('当前 Harness 未注册 /compact 命令，请确认上下文压缩组件已启用。'));
     }
     return commandResult(compactResultText(execution?.result));
   } catch (error) {

package/src/channels/shared/connection-test.mjs

@@ -1,3 +1,5 @@
+import { t } from './i18n.mjs';
+
 const targets = new WeakMap();
 
 export const CONNECTION_TEST_STATE_IDENTITY = Symbol('dsh-im.connection-test-state-identity');
@@ -25,13 +27,13 @@ export function connectionTestTarget(state) {
   return target ? structuredClone(target) : null;
 }
 
-export function connectionTestMessage(botName, channelLabel = '机器人') {
+export function connectionTestMessage(botName, channelLabel = t('机器人')) {
   const name = cleanText(botName) ?? channelLabel;
-  return `✅ DeepSeek Harness 连接测试成功\n这条消息由插件页面中的“${name}”机器人卡片发出。`;
+  return `${t('✅ DeepSeek Harness 连接测试成功')}\n${t('这条消息由插件页面中的“{name}”机器人卡片发出。', { name })}`;
 }
 
-export function connectionTestTargetUnavailable(channelLabel = '机器人') {
-  const error = new Error(`${channelLabel}尚未收到可用于测试的私聊消息。`);
+export function connectionTestTargetUnavailable(channelLabel = t('机器人')) {
+  const error = new Error(t('{channelLabel}尚未收到可用于测试的私聊消息。', { channelLabel }));
   error.code = 'test-target-unavailable';
   return error;
 }

package/src/channels/shared/control-command.mjs

@@ -1,3 +1,5 @@
+import { t } from './i18n.mjs';
+
 const CONTROL_COMMAND = /^\/(?:stop|steer)(?=$|\s)/iu;
 const STOP_COMMAND = /^\/stop(?=$|\s)/iu;
 const STOP_USAGE = '用法：/stop（不带参数）';
@@ -40,35 +42,35 @@ export async function runControlCommand(text, harness, state, key, {
   const command = text.trim();
   const stop = STOP_COMMAND.test(command);
 
-  if (hasImages) return commandResult(TEXT_ONLY);
+  if (hasImages) return commandResult(t(TEXT_ONLY));
 
   if (stop) {
-    if (!/^\/stop$/iu.test(command)) return commandResult(STOP_USAGE);
+    if (!/^\/stop$/iu.test(command)) return commandResult(t(STOP_USAGE));
     const session = boundSession(harness, state, key);
-    if (!session) return commandResult('当前聊天没有正在运行的任务。');
+    if (!session) return commandResult(t('当前聊天没有正在运行的任务。'));
     if (typeof session.stopActiveTurn !== 'function') {
       throw new TypeError('Harness session does not support stopping active turns');
     }
     const stopped = await session.stopActiveTurn(control, requestOptions(signal));
     return stopped
-      ? commandResult('已请求停止当前任务。', { stopped: true })
-      : commandResult('当前聊天没有正在运行的任务。');
+      ? commandResult(t('已请求停止当前任务。'), { stopped: true })
+      : commandResult(t('当前聊天没有正在运行的任务。'));
   }
 
   const match = /^\/steer(?:\s+([\s\S]*))?$/iu.exec(command);
   const instruction = match?.[1]?.trim() ?? '';
-  if (!instruction) return commandResult(STEER_USAGE);
+  if (!instruction) return commandResult(t(STEER_USAGE));
   if (pendingInteraction) {
     return commandResult([
-      '当前任务正在等待你的回答或审批。',
+      t('当前任务正在等待你的回答或审批。'),
       '',
-      '请先处理当前请求，或者发送 /stop 停止任务。',
+      t('请先处理当前请求，或者发送 /stop 停止任务。'),
     ].join('\n'));
   }
 
   const session = boundSession(harness, state, key);
   if (!session) {
-    return commandResult('当前聊天没有正在运行的任务，请直接发送普通消息。');
+    return commandResult(t('当前聊天没有正在运行的任务，请直接发送普通消息。'));
   }
   if (typeof session.steerActiveTurn !== 'function') {
     throw new TypeError('Harness session does not support steering active turns');
@@ -79,6 +81,6 @@ export async function runControlCommand(text, harness, state, key, {
     requestOptions(signal),
   );
   return steered
-    ? commandResult('已提交补充指令，Agent 会在下一步读取。')
-    : commandResult('当前聊天没有正在运行的任务，请直接发送普通消息。');
+    ? commandResult(t('已提交补充指令，Agent 会在下一步读取。'))
+    : commandResult(t('当前聊天没有正在运行的任务，请直接发送普通消息。'));
 }

package/src/channels/shared/editable-message-stream.mjs

@@ -1,3 +1,5 @@
+import { t } from './i18n.mjs';
+
 export function splitMessageText(value, limit) {
   const text = typeof value === 'string' ? value.trim() : '';
   if (!text) return [];
@@ -15,7 +17,7 @@ export function splitMessageText(value, limit) {
 }
 
 export function createEditableMessageStream({
-  initialText = '正在处理…',
+  initialText = t('正在处理…'),
   limit,
   updateIntervalMs = 800,
   create,
@@ -77,7 +79,7 @@ export function createEditableMessageStream({
       pending = null;
       await inFlight?.catch(() => undefined);
       const chunks = splitMessageText(text, limit);
-      const first = chunks[0] ?? '处理完成。';
+      const first = chunks[0] ?? t('处理完成。');
       if (first !== lastSent) await edit(messageId, first);
       lastSent = first;
       for (const chunk of chunks.slice(1)) {