@invago/mixin 1.0.10 → 1.0.12

package/src/message-context.ts

@@ -0,0 +1,114 @@
+type MixinMessageDirection = "inbound" | "outbound";
+
+export type MixinMessageContext = {
+  accountId: string;
+  conversationId: string;
+  messageId: string;
+  senderId?: string;
+  senderName?: string;
+  body: string;
+  timestamp: string;
+  direction: MixinMessageDirection;
+  quoteMessageId?: string;
+};
+
+export type ResolvedMixinReplyContext = {
+  id: string;
+  body?: string;
+  sender?: string;
+  senderId?: string;
+  timestamp?: string;
+  direction?: MixinMessageDirection;
+  found: boolean;
+};
+
+const MAX_MESSAGE_CONTEXTS = 4000;
+const recentMessages = new Map<string, MixinMessageContext>();
+
+function normalizeKeyPart(value: string | null | undefined): string {
+  return value?.trim().toLowerCase() ?? "";
+}
+
+function buildMessageContextKey(params: {
+  accountId: string;
+  conversationId: string;
+  messageId: string;
+}): string {
+  return [
+    normalizeKeyPart(params.accountId),
+    normalizeKeyPart(params.conversationId),
+    normalizeKeyPart(params.messageId),
+  ].join(":");
+}
+
+function pruneRecentMessages(): void {
+  while (recentMessages.size > MAX_MESSAGE_CONTEXTS) {
+    const first = recentMessages.keys().next().value;
+    if (!first) {
+      break;
+    }
+    recentMessages.delete(first);
+  }
+}
+
+export function rememberMixinMessage(context: MixinMessageContext): void {
+  const accountId = context.accountId.trim();
+  const conversationId = context.conversationId.trim();
+  const messageId = context.messageId.trim();
+  if (!accountId || !conversationId || !messageId) {
+    return;
+  }
+
+  recentMessages.set(
+    buildMessageContextKey({ accountId, conversationId, messageId }),
+    {
+      accountId,
+      conversationId,
+      messageId,
+      senderId: context.senderId?.trim() || undefined,
+      senderName: context.senderName?.trim() || undefined,
+      body: context.body ?? "",
+      timestamp: context.timestamp,
+      direction: context.direction,
+      quoteMessageId: context.quoteMessageId?.trim() || undefined,
+    },
+  );
+
+  pruneRecentMessages();
+}
+
+export function resolveMixinReplyContext(params: {
+  accountId: string;
+  conversationId: string;
+  quoteMessageId?: string | null;
+}): ResolvedMixinReplyContext | null {
+  const quoteMessageId = params.quoteMessageId?.trim();
+  if (!quoteMessageId) {
+    return null;
+  }
+
+  const message = recentMessages.get(
+    buildMessageContextKey({
+      accountId: params.accountId,
+      conversationId: params.conversationId,
+      messageId: quoteMessageId,
+    }),
+  );
+
+  if (!message) {
+    return {
+      id: quoteMessageId,
+      found: false,
+    };
+  }
+
+  return {
+    id: message.messageId,
+    body: message.body || undefined,
+    sender: message.senderName || message.senderId,
+    senderId: message.senderId,
+    timestamp: message.timestamp,
+    direction: message.direction,
+    found: true,
+  };
+}

package/src/onboarding.ts

@@ -0,0 +1,342 @@
+import type {
+  ChannelOnboardingAdapter,
+  ChannelOnboardingDmPolicy,
+  DmPolicy,
+  OpenClawConfig,
+  WizardPrompter,
+} from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID, promptAccountId } from "openclaw/plugin-sdk";
+import { getAccountConfig, listAccountIds, resolveAccount, resolveDefaultAccountId } from "./config.js";
+import type { MixinAccountConfig } from "./config-schema.js";
+
+const channel = "mixin" as const;
+
+type MixinConfigRoot = Partial<MixinAccountConfig> & {
+  defaultAccount?: string;
+  accounts?: Record<string, Partial<MixinAccountConfig> | undefined>;
+};
+
+type MixinGroupPolicy = NonNullable<MixinAccountConfig["groupPolicy"]>;
+
+type MixinDmPolicy = NonNullable<MixinAccountConfig["dmPolicy"]>;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function getMixinRoot(cfg: OpenClawConfig): MixinConfigRoot {
+  const root = cfg as unknown as Record<string, unknown>;
+  const channels = isRecord(root.channels) ? root.channels : undefined;
+  const channelConfig = channels && isRecord(channels.mixin) ? channels.mixin : undefined;
+  if (channelConfig) {
+    return channelConfig as MixinConfigRoot;
+  }
+
+  const legacyNamedConfig = isRecord(root.mixin) ? root.mixin : undefined;
+  if (legacyNamedConfig) {
+    return legacyNamedConfig as MixinConfigRoot;
+  }
+
+  const plugins = isRecord(root.plugins) ? root.plugins : undefined;
+  const entries = plugins && isRecord(plugins.entries) ? plugins.entries : undefined;
+  const mixinEntry = entries && isRecord(entries.mixin) ? entries.mixin : undefined;
+  const pluginEntryConfig = mixinEntry && isRecord(mixinEntry.config) ? mixinEntry.config : undefined;
+  if (pluginEntryConfig) {
+    return pluginEntryConfig as MixinConfigRoot;
+  }
+
+  return isRecord(root) ? (root as MixinConfigRoot) : {};
+}
+
+function updateMixinRoot(cfg: OpenClawConfig, patch: Partial<MixinConfigRoot>): OpenClawConfig {
+  const current = getMixinRoot(cfg);
+  return {
+    ...cfg,
+    channels: {
+      ...(cfg.channels ?? {}),
+      mixin: {
+        ...current,
+        ...patch,
+      },
+    },
+  } as OpenClawConfig;
+}
+
+function updateMixinAccountConfig(
+  cfg: OpenClawConfig,
+  accountId: string,
+  patch: Partial<MixinAccountConfig>,
+): OpenClawConfig {
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    return updateMixinRoot(cfg, patch);
+  }
+
+  const current = getMixinRoot(cfg);
+  const accounts = current.accounts ?? {};
+
+  return updateMixinRoot(cfg, {
+    accounts: {
+      ...accounts,
+      [accountId]: {
+        ...(accounts[accountId] ?? {}),
+        ...patch,
+      },
+    },
+  });
+}
+
+function mergeAllowFrom(values: string[] | undefined, nextValue: string): string[] {
+  const parts = nextValue
+    .split(/[\n,;]+/g)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+  return [...new Set([...(values ?? []), ...parts])];
+}
+
+
+async function promptAccountGuide(prompter: WizardPrompter): Promise<void> {
+  await prompter.note(
+    [
+      "Mixin uses Blaze WebSocket and needs one account block per bot account.",
+      "Required fields: appId, sessionId, serverPublicKey, sessionPrivateKey.",
+      "Single-account setup lives directly under channels.mixin.",
+      "Multi-account setup lives under channels.mixin.accounts.<accountId>.",
+      "Optional fields: dmPolicy, allowFrom, groupPolicy, mixpay, proxy.",
+      "Docs: README.md / README.zh-CN.md",
+    ].join("\n"),
+    "Mixin setup guide",
+  );
+}
+
+function setRootDmPolicy(cfg: OpenClawConfig, policy: DmPolicy): OpenClawConfig {
+  return updateMixinRoot(cfg, {
+    dmPolicy: policy as MixinDmPolicy,
+  });
+}
+
+function normalizeDmPolicy(value: unknown): MixinDmPolicy {
+  return value === "allowlist" || value === "open" || value === "disabled" ? value : "pairing";
+}
+
+function normalizeGroupPolicy(value: unknown): MixinGroupPolicy {
+  return value === "allowlist" || value === "open" || value === "disabled" ? value : "open";
+}
+
+function defaultMixpayConfig(existing?: MixinAccountConfig["mixpay"]): NonNullable<MixinAccountConfig["mixpay"]> {
+  return {
+    enabled: existing?.enabled ?? false,
+    apiBaseUrl: existing?.apiBaseUrl,
+    payeeId: existing?.payeeId,
+    defaultQuoteAssetId: existing?.defaultQuoteAssetId,
+    defaultSettlementAssetId: existing?.defaultSettlementAssetId,
+    expireMinutes: existing?.expireMinutes ?? 15,
+    pollIntervalSec: existing?.pollIntervalSec ?? 30,
+    allowedCreators: existing?.allowedCreators ?? [],
+    notifyOnPending: existing?.notifyOnPending ?? false,
+    notifyOnPaidLess: existing?.notifyOnPaidLess ?? true,
+  };
+}
+
+async function promptAllowFrom(params: {
+  cfg: OpenClawConfig;
+  prompter: WizardPrompter;
+  accountId?: string;
+}): Promise<OpenClawConfig> {
+  const accountId = params.accountId ?? DEFAULT_ACCOUNT_ID;
+  const current = getAccountConfig(params.cfg, accountId).allowFrom ?? [];
+  await params.prompter.note(
+    [
+      "Enter Mixin UUID values separated by commas or new lines.",
+      "Example: 12345678-1234-1234-1234-123456789abc",
+      "Leave blank if you want to keep pairing-only access.",
+    ].join("\n"),
+    "Mixin allowFrom",
+  );
+  const raw = await params.prompter.text({
+    message: "Allowed Mixin UUIDs",
+    placeholder: "uuid-one, uuid-two",
+    initialValue: current.join(", ") || undefined,
+    validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
+  });
+  const allowFrom = mergeAllowFrom(current, String(raw));
+  return updateMixinAccountConfig(params.cfg, accountId, { allowFrom });
+}
+
+async function promptAccountConfig(params: {
+  cfg: OpenClawConfig;
+  prompter: WizardPrompter;
+  accountId: string;
+}): Promise<OpenClawConfig> {
+  const resolved = resolveAccount(params.cfg, params.accountId);
+  const current = getAccountConfig(params.cfg, params.accountId);
+  let next = params.cfg;
+
+  const appId = String(
+    await params.prompter.text({
+      message: "Mixin appId",
+      initialValue: resolved.appId ?? undefined,
+      validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
+    }),
+  ).trim();
+
+  const sessionId = String(
+    await params.prompter.text({
+      message: "Mixin sessionId",
+      initialValue: resolved.sessionId ?? undefined,
+      validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
+    }),
+  ).trim();
+
+  const serverPublicKey = String(
+    await params.prompter.text({
+      message: "Mixin serverPublicKey",
+      initialValue: resolved.serverPublicKey ?? undefined,
+      validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
+    }),
+  ).trim();
+
+  const sessionPrivateKey = String(
+    await params.prompter.text({
+      message: "Mixin sessionPrivateKey",
+      initialValue: resolved.sessionPrivateKey ?? undefined,
+      validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
+    }),
+  ).trim();
+
+  next = updateMixinAccountConfig(next, params.accountId, {
+    enabled: true,
+    appId,
+    sessionId,
+    serverPublicKey,
+    sessionPrivateKey,
+  });
+
+  const dmPolicy = await params.prompter.select<MixinDmPolicy>({
+    message: "DM policy",
+    initialValue: normalizeDmPolicy(current.dmPolicy),
+    options: [
+      { value: "pairing", label: "Pairing", hint: "Accept DMs after pairing approval" },
+      { value: "allowlist", label: "Allowlist", hint: "Only accept DMs from allowFrom" },
+      { value: "open", label: "Open", hint: "Accept DMs without an allowlist" },
+      { value: "disabled", label: "Disabled", hint: "Disable DMs for this account" },
+    ],
+  });
+  next = setRootDmPolicy(next, dmPolicy);
+  next = updateMixinAccountConfig(next, params.accountId, {
+    dmPolicy,
+  });
+
+  if (dmPolicy === "allowlist") {
+    next = await promptAllowFrom({ cfg: next, prompter: params.prompter, accountId: params.accountId });
+  }
+
+  const groupPolicy = await params.prompter.select<MixinGroupPolicy>({
+    message: "Group policy",
+    initialValue: normalizeGroupPolicy(current.groupPolicy),
+    options: [
+      { value: "open", label: "Open", hint: "Allow all configured group chats" },
+      { value: "allowlist", label: "Allowlist", hint: "Only accept listed group chats" },
+      { value: "disabled", label: "Disabled", hint: "Disable group access" },
+    ],
+  });
+  next = updateMixinAccountConfig(next, params.accountId, {
+    groupPolicy,
+  });
+
+  const addGroupAllowFrom = groupPolicy === "allowlist"
+    ? await params.prompter.confirm({
+        message: "Add initial group allowFrom entries now?",
+        initialValue: true,
+      })
+    : false;
+  if (addGroupAllowFrom) {
+    const groupAllowFrom = String(
+      await params.prompter.text({
+        message: "Group allowFrom",
+        placeholder: "conversation-id-one, conversation-id-two",
+        validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
+      }),
+    )
+      .split(/[\n,;]+/g)
+      .map((entry) => entry.trim())
+      .filter(Boolean);
+    next = updateMixinAccountConfig(next, params.accountId, {
+      groupAllowFrom,
+    });
+  }
+
+  const mixpayEnabled = await params.prompter.confirm({
+    message: "Enable MixPay for this account?",
+    initialValue: Boolean(current.mixpay?.enabled),
+  });
+  if (mixpayEnabled) {
+    next = updateMixinAccountConfig(next, params.accountId, {
+      mixpay: {
+        ...defaultMixpayConfig(current.mixpay),
+        enabled: true,
+      },
+    });
+  }
+
+  return next;
+}
+
+const dmPolicy: ChannelOnboardingDmPolicy = {
+  label: "Mixin",
+  channel,
+  policyKey: "channels.mixin.dmPolicy",
+  allowFromKey: "channels.mixin.allowFrom",
+  getCurrent: (cfg) => normalizeDmPolicy((cfg.channels?.mixin as { dmPolicy?: unknown } | undefined)?.dmPolicy),
+  setPolicy: (cfg, policy) => setRootDmPolicy(cfg, policy as DmPolicy),
+  promptAllowFrom,
+};
+
+export const mixinOnboardingAdapter: ChannelOnboardingAdapter = {
+  channel,
+  getStatus: async ({ cfg }) => {
+    const accountIds = listAccountIds(cfg);
+    const configured = accountIds.some((accountId) => resolveAccount(cfg, accountId).configured);
+    return {
+      channel,
+      configured,
+      statusLines: [
+        `Mixin: ${configured ? "configured" : "needs credentials"}`,
+        `Accounts: ${accountIds.length}`,
+      ],
+      selectionHint: configured ? "configured" : "Blaze WebSocket Mixin bridge",
+      quickstartScore: configured ? 1 : 4,
+    };
+  },
+  configure: async ({ cfg, prompter, accountOverrides, shouldPromptAccountIds }) => {
+    await promptAccountGuide(prompter);
+
+    const mixinOverride = accountOverrides.mixin?.trim();
+    const defaultAccountId = resolveDefaultAccountId(cfg);
+    let accountId = mixinOverride || defaultAccountId;
+    if (shouldPromptAccountIds && !mixinOverride) {
+      accountId = await promptAccountId({
+        cfg,
+        prompter,
+        label: "Mixin",
+        currentId: accountId,
+        listAccountIds,
+        defaultAccountId,
+      });
+    }
+
+    const next = await promptAccountConfig({ cfg, prompter, accountId });
+    await prompter.outro(
+      [
+        `Configured account: ${accountId}`,
+        "Restart the Gateway after saving the config.",
+        "Use /mixin-status to verify the connection.",
+      ].join("\n"),
+    );
+
+    return {
+      cfg: next,
+      accountId,
+    };
+  },
+  dmPolicy,
+};

package/src/plugin-admin.ts

@@ -0,0 +1,161 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { describeAccount, getAccountConfig, listAccountIds, resolveAccount, resolveDefaultAccountId } from "./config.js";
+import { getMixpayStatusSnapshot } from "./mixpay-worker.js";
+import { getOutboxStatus } from "./send-service.js";
+import { resolveMixinStatusSnapshot } from "./status.js";
+
+export type MixinPluginDiagnostics = {
+  defaultAccountId: string;
+  accountIds: string[];
+  accounts: ReturnType<typeof describeAccount>[];
+  outboxPending: number;
+  mixpayPendingOrders: number;
+  outboxDir: string;
+  outboxFile: string;
+  mixpayStoreDir: string | null;
+  mixpayStoreFile: string | null;
+  mediaMaxMb: number | null;
+};
+
+export type MixinSetupMode = "summary" | "single" | "multi";
+
+function formatLine(label: string, value: string | number | boolean | null | undefined): string {
+  return `${label}: ${value ?? "-"}`;
+}
+
+function formatAccountSummary(cfg: OpenClawConfig, accountId: string): string {
+  const account = resolveAccount(cfg, accountId);
+  const accountConfig = getAccountConfig(cfg, accountId);
+  const status = account.enabled ? (account.configured ? "ready" : "missing-credentials") : "disabled";
+  const mixpay = accountConfig.mixpay?.enabled ? "mixpay-on" : "mixpay-off";
+  return [
+    `${account.accountId} (${account.name ?? account.accountId})`,
+    status,
+    mixpay,
+  ].join(" | ");
+}
+
+export async function buildMixinPluginDiagnostics(cfg: OpenClawConfig): Promise<MixinPluginDiagnostics> {
+  const defaultAccountId = resolveDefaultAccountId(cfg);
+  const accountIds = listAccountIds(cfg);
+  const accounts = accountIds.map((accountId) => describeAccount(resolveAccount(cfg, accountId)));
+  const outboxStatus = await getOutboxStatus().catch(() => null);
+  const mixpayStatus = await getMixpayStatusSnapshot().catch(() => null);
+  const snapshot = resolveMixinStatusSnapshot(cfg, defaultAccountId, outboxStatus, mixpayStatus);
+
+  return {
+    defaultAccountId,
+    accountIds,
+    accounts,
+    outboxPending: snapshot.outboxPending,
+    mixpayPendingOrders: snapshot.mixpayPendingOrders,
+    outboxDir: snapshot.outboxDir,
+    outboxFile: snapshot.outboxFile,
+    mixpayStoreDir: snapshot.mixpayStoreDir,
+    mixpayStoreFile: snapshot.mixpayStoreFile,
+    mediaMaxMb: snapshot.mediaMaxMb,
+  };
+}
+
+export function formatMixinStatusText(cfg: OpenClawConfig, diagnostics: MixinPluginDiagnostics): string {
+  const lines = [
+    "Mixin plugin status",
+    formatLine("defaultAccountId", diagnostics.defaultAccountId),
+    formatLine("accounts", diagnostics.accountIds.length),
+    formatLine("outboxPending", diagnostics.outboxPending),
+    formatLine("mixpayPendingOrders", diagnostics.mixpayPendingOrders),
+    formatLine("outboxDir", diagnostics.outboxDir),
+    formatLine("outboxFile", diagnostics.outboxFile),
+    formatLine("mixpayStoreDir", diagnostics.mixpayStoreDir),
+    formatLine("mixpayStoreFile", diagnostics.mixpayStoreFile),
+    formatLine("mediaMaxMb", diagnostics.mediaMaxMb),
+    "",
+    "Accounts",
+    ...diagnostics.accountIds.map((accountId) => `- ${formatAccountSummary(cfg, accountId)}`),
+  ];
+  return lines.join("\n");
+}
+
+export function formatMixinHelpText(): string {
+  return [
+    "Mixin plugin commands",
+    "/setup [summary|single|multi] - open the setup guide",
+    "/mixin-setup [summary|single|multi] - open the setup guide",
+    "/mixin-status - show account and queue status",
+    "/mixin-accounts - list configured accounts",
+    "/mixin-help - show this help text",
+    "",
+    "Configuration",
+    "channels.mixin for the default account",
+    "channels.mixin.accounts.<accountId> for multi-account setups",
+  ].join("\n");
+}
+
+export function buildMixinAccountsText(cfg: OpenClawConfig): string {
+  const accountIds = listAccountIds(cfg);
+  const lines = ["Configured accounts", ...accountIds.map((accountId) => `- ${formatAccountSummary(cfg, accountId)}`)];
+  return lines.join("\n");
+}
+
+export function normalizeMixinSetupMode(input: string | undefined): MixinSetupMode {
+  const mode = input?.trim().toLowerCase() ?? "";
+  if (mode === "single" || mode === "multi" || mode === "summary") {
+    return mode;
+  }
+  return "summary";
+}
+
+export function formatMixinSetupText(
+  cfg: OpenClawConfig,
+  diagnostics?: MixinPluginDiagnostics,
+  mode: MixinSetupMode = "summary",
+): string {
+  const resolved = diagnostics ?? {
+    defaultAccountId: resolveDefaultAccountId(cfg),
+    accountIds: listAccountIds(cfg),
+    accounts: listAccountIds(cfg).map((accountId) => describeAccount(resolveAccount(cfg, accountId))),
+    outboxPending: 0,
+    mixpayPendingOrders: 0,
+    outboxDir: "-",
+    outboxFile: "-",
+    mixpayStoreDir: null,
+    mixpayStoreFile: null,
+    mediaMaxMb: null,
+  };
+
+  return [
+    "Mixin setup",
+    "",
+    mode === "single"
+      ? "Single-account flow"
+      : mode === "multi"
+        ? "Multi-account flow"
+        : "Quick summary",
+    "",
+    mode === "single"
+      ? "1. Put the account fields directly under channels.mixin."
+      : "1. Keep or create the default account under channels.mixin.",
+    mode === "single"
+      ? "2. Fill in appId, sessionId, serverPublicKey, and sessionPrivateKey."
+      : "2. For multi-account setups, use channels.mixin.accounts.<accountId>.",
+    mode === "single"
+      ? "3. Use /mixin-status after restart to confirm the account is ready."
+      : "3. Fill in appId, sessionId, serverPublicKey, and sessionPrivateKey.",
+    mode === "single"
+      ? "4. Use /mixin-help to see the available commands."
+      : "4. Use /mixin-status after restart to confirm the account is ready.",
+    mode === "multi"
+      ? "5. Use /mixin-accounts to verify all configured accounts."
+      : "5. Use /mixin-accounts to verify all configured accounts.",
+    "",
+    `Default account: ${resolved.defaultAccountId}`,
+    `Accounts: ${resolved.accountIds.length}`,
+    ...resolved.accountIds.map((accountId) => `- ${formatAccountSummary(cfg, accountId)}`),
+    "",
+    "Optional fields you can adjust later:",
+    "- dmPolicy / allowFrom",
+    "- groupPolicy / groupAllowFrom",
+    "- mixpay",
+    "- proxy",
+  ].join("\n");
+}

package/src/send-service.ts

@@ -4,6 +4,7 @@ import os from "os";
 import path from "path";
 import type { OpenClawConfig } from "openclaw/plugin-sdk";
 import { getAccountConfig } from "./config.js";
+import { rememberMixinMessage } from "./message-context.js";
 import { getMixinBlazeSender, getMixinRuntime } from "./runtime.js";
 import { buildClient, sleep, type SendLog } from "./shared.js";
 
@@ -623,7 +624,7 @@ export async function sendTextMessage(
   text: string,
   log?: SendLog,
 ): Promise<SendResult> {
-  return sendMixinMessage(cfg, accountId, conversationId, recipientId, "PLAIN_TEXT", text, log);
+  return sendMixinMessage(cfg, accountId, conversationId, recipientId, "PLAIN_TEXT", text, log, text);
 }
 
 export async function sendPostMessage(
@@ -634,7 +635,7 @@ export async function sendPostMessage(
   text: string,
   log?: SendLog,
 ): Promise<SendResult> {
-  return sendMixinMessage(cfg, accountId, conversationId, recipientId, "PLAIN_POST", text, log);
+  return sendMixinMessage(cfg, accountId, conversationId, recipientId, "PLAIN_POST", text, log, text);
 }
 
 export async function sendFileMessage(
@@ -654,7 +655,16 @@ export async function sendFileMessage(
     mimeType,
   } satisfies FileOutboxBody);
 
-  return sendMixinMessage(cfg, accountId, conversationId, recipientId, "PLAIN_DATA", body, log);
+  return sendMixinMessage(
+    cfg,
+    accountId,
+    conversationId,
+    recipientId,
+    "PLAIN_DATA",
+    body,
+    log,
+    `${fileName} (${mimeType})`,
+  );
 }
 
 export async function sendAudioMessage(
@@ -674,7 +684,16 @@ export async function sendAudioMessage(
     waveForm: audio.waveForm,
   } satisfies AudioOutboxBody);
 
-  return sendMixinMessage(cfg, accountId, conversationId, recipientId, "PLAIN_AUDIO", body, log);
+  return sendMixinMessage(
+    cfg,
+    accountId,
+    conversationId,
+    recipientId,
+    "PLAIN_AUDIO",
+    body,
+    log,
+    `${path.basename(audio.filePath)} (${mimeType}${audio.duration ? `, ${audio.duration}s` : ""})`,
+  );
 }
 
 export async function sendButtonGroupMessage(
@@ -718,6 +737,7 @@ async function sendMixinMessage(
   category: MixinSupportedMessageCategory,
   body: string,
   log?: SendLog,
+  contextBody?: string,
 ): Promise<SendResult> {
   updateRuntime(cfg, log);
   await startSendWorker(cfg, log);
@@ -742,6 +762,17 @@ async function sendMixinMessage(
   await persistEntries();
   wakeWorker();
 
+  rememberMixinMessage({
+    accountId,
+    conversationId,
+    messageId: entry.messageId,
+    senderId: accountId,
+    senderName: "Mixin bot",
+    body: contextBody ?? body,
+    timestamp: now,
+    direction: "outbound",
+  });
+
   state.log.info(
     `[mixin] outbox enqueued: jobId=${entry.jobId}, messageId=${entry.messageId}, category=${category}, accountId=${accountId}, conversation=${conversationId}`,
   );