@xmanrui/dsh-im 0.9.0 → 0.11.0

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

@@ -3,6 +3,7 @@ import {
   createDingtalkBridgeStatus,
   DingtalkHarnessBridge,
 } from './dingtalk-bridge.mjs';
+import { sendRememberedConnectionTest } from '../shared/connection-test.mjs';
 
 function nonEmptyString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
@@ -347,6 +348,26 @@ export class DingtalkRuntime {
     return this.status;
   }
 
+  async sendConnectionTest(text) {
+    return sendRememberedConnectionTest({
+      state: this.#state,
+      text,
+      channelLabel: '钉钉机器人',
+      send: async ({ sessionWebhook }, content) => {
+        if (!this.#status.ready || !this.#abortController) {
+          throw new Error('DingTalk runtime is not connected');
+        }
+        await this.#api.sendText({
+          clientId: this.#config.clientId,
+          clientSecret: this.#clientSecret,
+          sessionWebhook,
+          text: content,
+          signal: this.#abortController.signal,
+        });
+      },
+    });
+  }
+
   #pendingSenders() {
     return typeof this.#state.pendingSenders === 'function'
       ? this.#state.pendingSenders()

package/src/channels/discord/discord-api.mjs

@@ -108,7 +108,7 @@ export class DiscordApi {
         headers: {
           authorization: `Bot ${this.#token}`,
           'content-type': 'application/json',
-          'user-agent': 'DeepSeek-Harness-dsh-im (https://github.com/xmanrui/dsh-im, 0.9.0)',
+          'user-agent': 'DeepSeek-Harness-dsh-im (https://github.com/xmanrui/dsh-im, 0.11.0)',
         },
         ...(body === undefined ? {} : { body: JSON.stringify(body) }),
         signal: requestSignal(signal, timeoutMs),

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

@@ -1,9 +1,19 @@
 import { createEditableMessageStream, splitMessageText } from '../shared/editable-message-stream.mjs';
+import { fetchImageBuffer } from '../shared/image-prompt.mjs';
 import { DiscordApi } from './discord-api.mjs';
 import { createDiscordBridgeStatus, DiscordHarnessBridge } from './discord-bridge.mjs';
 
 const DISCORD_GATEWAY_INTENTS = (1 << 0) | (1 << 9) | (1 << 12);
 const RECONNECT_DELAYS_MS = Object.freeze([1_000, 3_000, 5_000, 10_000, 30_000]);
+const IMAGE_MEDIA_TYPES = new Set(['image/jpeg', 'image/png', 'image/webp', 'image/gif']);
+const IMAGE_FILE_TYPES = new Map([
+  ['.jpg', 'image/jpeg'],
+  ['.jpeg', 'image/jpeg'],
+  ['.png', 'image/png'],
+  ['.webp', 'image/webp'],
+  ['.gif', 'image/gif'],
+]);
+const DISCORD_IMAGE_HOSTS = Object.freeze(['cdn.discordapp.com']);
 
 function socketUrl(value) {
   const url = new URL(value);
@@ -48,7 +58,37 @@ function stripBotMention(text, botId) {
   return text.replace(new RegExp(`<@!?${botId}>`, 'g'), '').trim();
 }
 
-export function normalizeDiscordMessage(message, botId) {
+function attachmentMediaType(attachment) {
+  const value = typeof attachment?.content_type === 'string'
+    ? attachment.content_type.split(';', 1)[0].trim().toLowerCase() : '';
+  if (IMAGE_MEDIA_TYPES.has(value)) return value;
+  const filename = typeof attachment?.filename === 'string' ? attachment.filename.toLowerCase() : '';
+  for (const [extension, mediaType] of IMAGE_FILE_TYPES) {
+    if (filename.endsWith(extension)) return mediaType;
+  }
+  return null;
+}
+
+function attachmentSize(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+
+function discordImageSource(attachment, fetchImpl) {
+  const mediaType = attachmentMediaType(attachment);
+  if (!mediaType || typeof attachment?.url !== 'string') return null;
+  return {
+    name: typeof attachment.filename === 'string' ? attachment.filename : undefined,
+    mediaType,
+    size: attachmentSize(attachment.size),
+    load: (options) => fetchImageBuffer(attachment.url, {
+      ...options,
+      fetchImpl,
+      allowedHosts: DISCORD_IMAGE_HOSTS,
+    }),
+  };
+}
+
+export function normalizeDiscordMessage(message, botId, { fetchImpl = fetch } = {}) {
   if (!message?.id || !message?.channel_id || !message?.author?.id) return null;
   const direct = !message.guild_id;
   const addressed = direct
@@ -60,11 +100,15 @@ export function normalizeDiscordMessage(message, botId) {
     kind: direct ? 'direct' : 'group',
     conversationId: String(message.channel_id),
     content: stripBotMention(message.content ?? '', botId),
+    images: Array.isArray(message.attachments)
+      ? message.attachments.map((attachment) => discordImageSource(attachment, fetchImpl)).filter(Boolean)
+      : [],
     addressed,
     replyTarget: {
       channelId: String(message.channel_id),
       replyToMessageId: String(message.id),
     },
+    connectionTestTarget: { channelId: String(message.channel_id) },
   };
 }
 
@@ -196,6 +240,15 @@ export class DiscordRuntime {
     return structuredClone(this.#status);
   }
 
+  async sendConnectionTest(text) {
+    if (!this.#status.ready || !this.#bridge) {
+      const error = new Error('Discord bot is not connected');
+      error.code = 'test-target-unavailable';
+      throw error;
+    }
+    return this.#bridge.sendConnectionTest(text);
+  }
+
   async start() {
     if (this.#status.ready && this.#socket) return this.status;
     if (this.#starting) return this.#starting;

package/src/channels/feishu/bridge.mjs

@@ -1,10 +1,16 @@
 import {
   conversationKey,
+  extractInboundMessage,
   extractText,
   isAllowedSender,
   isBotSender,
   splitText,
 } from './message-utils.mjs';
+import {
+  hasInboundImages,
+  imagePromptUserMessage,
+  promptContentForMessage,
+} from '../shared/image-prompt.mjs';
 import {
   harnessAnswerForQuestion,
   harnessQuestionText,
@@ -12,6 +18,7 @@ import {
 } from '../shared/harness-question.mjs';
 import { HarnessApprovalQueue } from '../shared/harness-approval.mjs';
 import { runCompactCommand } from '../shared/compact-command.mjs';
+import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
 import { runWorkspaceCommand } from '../shared/workspace-command.mjs';
 import { askInWorkspaceSession } from '../shared/workspace-session.mjs';
 
@@ -21,7 +28,7 @@ const RESOLVED_REPLY_TTL_MS = 30 * 60_000;
 const HELP_TEXT = [
   '北汇星河 AIOS 已连接 DeepSeek Harness。',
   '',
-  '直接发送问题即可继续当前会话。',
+  '直接发送文字或图片即可继续当前会话。',
   '/new  开启一个全新会话',
   '/compact  压缩当前会话的较早上下文',
   '/workspace 工作区绝对路径  切换工作区',
@@ -127,6 +134,11 @@ export class FeishuHarnessBridge {
       return Promise.resolve();
     }
 
+    if (event.message.chat_type === 'p2p') {
+      const chatId = nonEmptyString(event.message.chat_id);
+      if (chatId) rememberConnectionTestTarget(this.#state, { chatId });
+    }
+
     this.#acceptedMessageIds.add(messageId);
     const processingReaction = this.#addReaction(messageId, 'OnIt');
     if (this.#isResolvedQuestionReply(event, key)) {
@@ -273,7 +285,8 @@ export class FeishuHarnessBridge {
     await this.#finishReaction(messageId, processingReaction, 'ERROR');
     await this.#send(
       event.message.chat_id,
-      '处理失败，请稍后重试。如果问题持续，请在 DeepSeek Harness 的飞书插件页面检查连接状态。',
+      imagePromptUserMessage(error)
+        ?? '处理失败，请稍后重试。如果问题持续，请在 DeepSeek Harness 的飞书插件页面检查连接状态。',
     ).catch(() => undefined);
   }
 
@@ -297,40 +310,47 @@ export class FeishuHarnessBridge {
       this.#status.messagesReceived += 1;
     }
 
-    const text = extractText(event);
-    if (!text) {
-      await this.#send(event.message.chat_id, '目前仅支持文字消息。');
+    const message = extractInboundMessage(event, this.#client);
+    const text = message.content;
+    const hasImages = hasInboundImages(message);
+    const commandText = event.message.message_type === 'text' && !hasImages ? text : null;
+    if (!text && !hasImages) {
+      await this.#send(event.message.chat_id, '目前支持文字和图片消息。');
       return;
     }
 
-    if (text === '/help') {
+    if (commandText === '/help') {
       await this.#send(event.message.chat_id, HELP_TEXT);
       return;
     }
-    if (text === '/new') {
+    if (commandText === '/new') {
       await this.#state.clearSession(key);
       await this.#send(event.message.chat_id, '已开启全新 Harness 会话。');
       return;
     }
-    if (text === '/status') {
+    if (commandText === '/status') {
       await this.#harness.ensureRunning({ signal: this.#signal });
       await this.#send(event.message.chat_id, '飞书机器人与 DeepSeek Harness 连接正常。');
       return;
     }
-    const workspaceCommand = await runWorkspaceCommand(text, this.#harness, key);
+    const workspaceCommand = commandText === null
+      ? null
+      : await runWorkspaceCommand(text, this.#harness, key);
     if (workspaceCommand) {
       for (const reply of workspaceCommand.messages ?? [workspaceCommand.message]) {
         await this.#send(event.message.chat_id, reply);
       }
       return;
     }
-    const compactCommand = await runCompactCommand(
-      text,
-      this.#harness,
-      this.#state,
-      key,
-      { signal: this.#signal },
-    );
+    const compactCommand = commandText === null
+      ? null
+      : await runCompactCommand(
+          commandText,
+          this.#harness,
+          this.#state,
+          key,
+          { signal: this.#signal },
+        );
     if (compactCommand) {
       await this.#send(event.message.chat_id, compactCommand.message);
       return;
@@ -338,7 +358,7 @@ export class FeishuHarnessBridge {
 
     this.#logger.info?.(`[dsh-feishu] processing ${event.message.chat_type} message ${messageId}`);
     try {
-      await this.#answerWithStream(event, key, text);
+      await this.#answerWithStream(event, key, message);
       this.#status.messagesReplied += 1;
       this.#status.lastReplyAt = new Date().toISOString();
       this.#status.lastError = null;
@@ -362,15 +382,20 @@ export class FeishuHarnessBridge {
     };
   }
 
-  async #answerWithStream(event, key, text) {
+  async #answerWithStream(event, key, message) {
     const chatId = event.message.chat_id;
     const messageId = event.message.message_id;
+    const text = message.content;
+    const content = hasInboundImages(message)
+      ? await promptContentForMessage(message, { signal: this.#signal })
+      : undefined;
     if (!this.#channel?.stream) {
       const { answer } = await askInWorkspaceSession({
         harness: this.#harness,
         state: this.#state,
         key,
         text,
+        content,
         createOptions: { signal: this.#signal },
         existsOptions: { signal: this.#signal },
         askOptions: this.#interactionAskOptions(event, key),
@@ -398,6 +423,7 @@ export class FeishuHarnessBridge {
             state: this.#state,
             key,
             text,
+            content,
             createOptions: { signal: this.#signal },
             existsOptions: { signal: this.#signal },
             askOptions,
@@ -425,6 +451,7 @@ export class FeishuHarnessBridge {
         state: this.#state,
         key,
         text,
+        content,
         createOptions: { signal: this.#signal },
         existsOptions: { signal: this.#signal },
         askOptions: this.#interactionAskOptions(event, key),

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

@@ -1,5 +1,9 @@
 import { FeishuHarnessBridge } from './bridge.mjs';
 import { VerifiedFeishuChannel } from './feishu-channel.mjs';
+import {
+  connectionTestTargetUnavailable,
+  sendRememberedConnectionTest,
+} from '../shared/connection-test.mjs';
 
 const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
 
@@ -240,6 +244,47 @@ export class FeishuRuntime {
     }
   }
 
+  async sendConnectionTest(text) {
+    if (!this.#status.ready || !this.#client) {
+      const error = new Error('飞书机器人尚未连接');
+      error.code = 'test-target-unavailable';
+      throw error;
+    }
+    if (typeof text !== 'string' || !text.trim()) {
+      throw new TypeError('Feishu connection test text is required');
+    }
+    const send = async (receiveIdType, receiveId, content) => {
+      const response = await this.#client.im.v1.message.create({
+        params: { receive_id_type: receiveIdType },
+        data: {
+          receive_id: receiveId,
+          msg_type: 'text',
+          content: JSON.stringify({ text: content }),
+        },
+      });
+      if (response?.code && response.code !== 0) {
+        throw new Error(`Feishu connection test failed: ${response.msg || response.code}`);
+      }
+    };
+
+    const ownerOpenId = this.#ownerOpenIds.find((value) => value !== '*');
+    if (ownerOpenId) {
+      await send('open_id', ownerOpenId, text);
+      return { sent: true };
+    }
+
+    return sendRememberedConnectionTest({
+      state: this.#state,
+      text,
+      channelLabel: '飞书机器人',
+      send: async (target, content) => {
+        const chatId = typeof target?.chatId === 'string' ? target.chatId.trim() : '';
+        if (!chatId) throw connectionTestTargetUnavailable('飞书机器人');
+        await send('chat_id', chatId, content);
+      },
+    });
+  }
+
   async stop({ preserveError = false } = {}) {
     const error = preserveError ? this.#status.lastError : null;
     const abortController = this.#abortController;

package/src/channels/feishu/message-utils.mjs

@@ -1,3 +1,11 @@
+import { ImagePromptError } from '../shared/image-prompt.mjs';
+
+const FEISHU_MISSING_MESSAGE_SCOPE_CODE = 99991672;
+const FEISHU_ERROR_BODY_LIMIT = 64 * 1024;
+const FEISHU_ERROR_BODY_TIMEOUT_MS = 1_000;
+const FEISHU_IMAGE_PERMISSION_MESSAGE =
+  '飞书机器人缺少图片读取权限。请在飞书开放平台为该应用添加 im:message:readonly，发布新版本并完成必要的管理员审批后，再重新发送图片。';
+
 export function conversationKey(event) {
   const chatType = event?.message?.chat_type;
   if (chatType === 'p2p') {
@@ -10,19 +18,232 @@ export function conversationKey(event) {
   return `group:${chatId}`;
 }
 
+function parsedMessageContent(event) {
+  const value = event?.message?.content;
+  if (value && typeof value === 'object') return value;
+  if (typeof value !== 'string') return null;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function withoutMentions(text, event) {
+  let result = typeof text === 'string' ? text : '';
+  for (const mention of event?.message?.mentions ?? []) {
+    if (typeof mention?.key === 'string' && mention.key) {
+      result = result.replaceAll(mention.key, '');
+    }
+  }
+  return result.trim();
+}
+
 export function extractText(event) {
   if (event?.message?.message_type !== 'text') return null;
-  let parsed;
+  const parsed = parsedMessageContent(event);
+  return parsed ? withoutMentions(parsed.text, event) : null;
+}
+
+function nonEmptyString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function postContent(event, parsed = parsedMessageContent(event)) {
+  if (event?.message?.message_type !== 'post') return null;
+  if (!parsed) return null;
+
+  const lines = [];
+  const title = nonEmptyString(withoutMentions(parsed.title, event));
+  if (title) lines.push(title);
+  const imageKeys = [];
+  for (const paragraph of Array.isArray(parsed.content) ? parsed.content : []) {
+    if (!Array.isArray(paragraph)) continue;
+    let visibleText = '';
+    for (const element of paragraph) {
+      const tag = String(element?.tag ?? '').toLowerCase();
+      if (tag === 'img') {
+        const key = nonEmptyString(element?.image_key);
+        if (key) imageKeys.push(key);
+      } else if (tag === 'text' || tag === 'a' || tag === 'link') {
+        if (typeof element?.text === 'string') visibleText += element.text;
+      }
+    }
+    const line = nonEmptyString(withoutMentions(visibleText, event));
+    if (line) lines.push(line);
+  }
+
+  return {
+    text: lines.join('\n'),
+    imageKeys,
+  };
+}
+
+function headerValue(headers, name) {
+  if (typeof headers?.get === 'function') return headers.get(name);
+  return headers?.[name] ?? headers?.[name.toLowerCase()] ?? null;
+}
+
+function declaredSize(headers) {
+  const header = headerValue(headers, 'content-length');
+  if (header === null || header === undefined || header === '') return null;
+  const value = Number(header);
+  return Number.isFinite(value) && value >= 0 ? value : null;
+}
+
+async function readBoundedStream(stream, { signal, maxBytes }) {
+  if (!stream || typeof stream[Symbol.asyncIterator] !== 'function') {
+    throw new Error('Feishu image download returned no readable stream');
+  }
+  signal?.throwIfAborted();
+  const abort = () => stream.destroy?.(
+    signal.reason ?? new DOMException('Feishu image download aborted', 'AbortError'),
+  );
+  signal?.addEventListener('abort', abort, { once: true });
+  const chunks = [];
+  let size = 0;
+  try {
+    for await (const chunk of stream) {
+      signal?.throwIfAborted();
+      const data = Buffer.from(chunk);
+      size += data.length;
+      if (size > maxBytes) {
+        stream.destroy?.();
+        throw new ImagePromptError(
+          'image-too-large',
+          `Feishu image exceeds ${maxBytes} bytes`,
+          '图片超过 5 MB，请压缩后重试。',
+        );
+      }
+      chunks.push(data);
+    }
+    signal?.throwIfAborted();
+    return Buffer.concat(chunks, size);
+  } finally {
+    signal?.removeEventListener('abort', abort);
+  }
+}
+
+function providerCode(value) {
+  if (!value || typeof value !== 'object') return null;
+  const code = value.code ?? value.error?.code;
+  return Number.isSafeInteger(Number(code)) ? Number(code) : null;
+}
+
+async function readFeishuErrorBody(stream, signal) {
+  if (!stream || typeof stream[Symbol.asyncIterator] !== 'function') return null;
+  signal?.throwIfAborted();
+  const timeout = AbortSignal.timeout(FEISHU_ERROR_BODY_TIMEOUT_MS);
+  const readSignal = signal ? AbortSignal.any([signal, timeout]) : timeout;
+  const abort = () => stream.destroy?.(readSignal.reason);
+  readSignal.addEventListener('abort', abort, { once: true });
+  const chunks = [];
+  let size = 0;
   try {
-    parsed = JSON.parse(event.message.content);
+    for await (const chunk of stream) {
+      const data = Buffer.from(chunk);
+      size += data.length;
+      if (size > FEISHU_ERROR_BODY_LIMIT) {
+        stream.destroy?.();
+        return null;
+      }
+      chunks.push(data);
+    }
+    return Buffer.concat(chunks, size).toString('utf8');
   } catch {
+    signal?.throwIfAborted();
     return null;
+  } finally {
+    readSignal.removeEventListener('abort', abort);
   }
-  let text = typeof parsed.text === 'string' ? parsed.text : '';
-  for (const mention of event.message.mentions ?? []) {
-    if (typeof mention.key === 'string' && mention.key) text = text.replaceAll(mention.key, '');
+}
+
+async function feishuProviderCode(error, signal) {
+  const pending = [error];
+  const seen = new Set();
+  while (pending.length > 0 && seen.size < 8) {
+    const value = pending.shift();
+    if (!value || (typeof value !== 'object' && typeof value !== 'function') || seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    const directCode = providerCode(value);
+    const data = value.response?.data ?? value.data;
+    if (directCode === FEISHU_MISSING_MESSAGE_SCOPE_CODE) {
+      data?.destroy?.();
+      return directCode;
+    }
+    if (data && typeof data[Symbol.asyncIterator] === 'function') {
+      const body = await readFeishuErrorBody(data, signal);
+      try {
+        const parsedCode = providerCode(JSON.parse(body));
+        if (parsedCode === FEISHU_MISSING_MESSAGE_SCOPE_CODE) return parsedCode;
+      } catch {
+        // Non-JSON provider failures keep the generic image download message.
+      }
+    } else {
+      const dataCode = providerCode(data);
+      if (dataCode === FEISHU_MISSING_MESSAGE_SCOPE_CODE) return dataCode;
+    }
+    pending.push(value.cause);
   }
-  return text.trim();
+  return null;
+}
+
+async function feishuImageDownloadError(error, signal) {
+  if (await feishuProviderCode(error, signal) !== FEISHU_MISSING_MESSAGE_SCOPE_CODE) return error;
+  return new ImagePromptError(
+    'feishu-image-permission-required',
+    'Feishu image download requires the im:message:readonly tenant scope',
+    FEISHU_IMAGE_PERMISSION_MESSAGE,
+    { cause: error },
+  );
+}
+
+function feishuImageSource(event, client, key) {
+  return {
+    async load({ signal, maxBytes }) {
+      signal?.throwIfAborted();
+      let resource;
+      try {
+        resource = await client?.im?.v1?.messageResource?.get?.({
+          path: {
+            message_id: event.message.message_id,
+            file_key: key,
+          },
+          params: { type: 'image' },
+        });
+      } catch (error) {
+        throw await feishuImageDownloadError(error, signal);
+      }
+      signal?.throwIfAborted();
+      const size = declaredSize(resource?.headers);
+      if (size !== null && size > maxBytes) {
+        resource?.getReadableStream?.().destroy?.();
+        throw new ImagePromptError(
+          'image-too-large',
+          `Feishu image declares ${size} bytes; the limit is ${maxBytes}`,
+          '图片超过 5 MB，请压缩后重试。',
+        );
+      }
+      return readBoundedStream(resource?.getReadableStream?.(), { signal, maxBytes });
+    },
+  };
+}
+
+export function extractInboundMessage(event, client) {
+  const messageType = event?.message?.message_type;
+  const parsed = parsedMessageContent(event);
+  const post = postContent(event, parsed);
+  const standaloneImageKey = messageType === 'image'
+    ? nonEmptyString(parsed?.image_key)
+    : null;
+  const imageKeys = standaloneImageKey ? [standaloneImageKey] : post?.imageKeys ?? [];
+  return {
+    content: messageType === 'text' ? extractText(event) ?? '' : post?.text ?? '',
+    images: imageKeys.map((key) => feishuImageSource(event, client, key)),
+  };
 }
 
 export function splitText(text, maxChars = 9000) {

package/src/channels/feishu/multi-bot-controller.mjs

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { connectionTestMessage } from '../shared/connection-test.mjs';
 import { RegistrationManager } from './registration-manager.mjs';
 import { REQUIRED_TENANT_SCOPES } from './plugin-controller.mjs';
 
@@ -339,6 +340,26 @@ export class MultiBotDshFeishuController {
     });
   }
 
+  async sendConnectionTest(botId) {
+    this.#assertOpen();
+    return this.#withBotTransition(botId, async () => {
+      const config = this.#requireBot(botId);
+      const runtime = this.#runtimes.get(botId);
+      if (!isConnected(connectionStatus(runtime))
+        || typeof runtime.sendConnectionTest !== 'function') {
+        const error = new Error('飞书机器人尚未连接');
+        error.code = 'test-target-unavailable';
+        throw error;
+      }
+      return runtime.sendConnectionTest(
+        connectionTestMessage(
+          `${config.botName}（${maskedAppId(config.appId)}）`,
+          '飞书机器人',
+        ),
+      );
+    });
+  }
+
   async disconnectBot(botId) {
     this.#assertOpen();
     // An operational pause only: credentials/config remain durable, so the

package/src/channels/feishu/plugin-controller.mjs

@@ -5,6 +5,7 @@ export const FEISHU_SECRET_REF = 'DSH_FEISHU_APP_SECRET';
 export const REQUIRED_TENANT_SCOPES = Object.freeze([
   'im:message.p2p_msg:readonly',
   'im:message.group_at_msg:readonly',
+  'im:message:readonly',
   'im:message:send_as_bot',
   'im:message.reactions:write_only',
   'im:message:recall',