From d3bf6bc90a80fbb9d316700a170c6e290266b757 Mon Sep 17 00:00:00 2001
From: BBQ <35603386+HoneyBBQ@users.noreply.github.com>
Date: Thu, 9 Apr 2026 14:36:11 +0800
Subject: [PATCH] fix(channel,attachment): channel quality refactor &
 attachment pipeline fixes (#349)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat(channel): add DingTalk channel adapter

- Add DingTalk channel adapter (`internal/channel/adapters/dingtalk/`) using dingtalk-stream-sdk-go, supporting inbound message receiving and outbound text/markdown reply
- Register DingTalk adapter in cmd/agent and cmd/memoh
- Add go.mod dependency: github.com/memohai/dingtalk-stream-sdk-go
- Add Dingtalk and Wecom SVG icons and Vue components to @memohai/icon
- Refactor existing icon components to remove redundant inline wrappers
- Add `channelTypeDisplayName` util for consistent channel label resolution
- Add DingTalk/WeCom i18n entries (en/zh) for types and typesShort
- Extend channel-icon, bot-channels, channel-settings-panel to support dingtalk/wecom
- Use channelTypeDisplayName in profile page to replace ad-hoc i18n lookup

* fix(channel,attachment): channel quality refactor & attachment pipeline fixes

Channel module:
- Fix RemoveAdapter not cleaning connectionMeta (stale status leak)
- Fix preparedAttachmentTypeFromMime misclassifying image/gif
- Fix sleepWithContext time.After goroutine/timer leak
- Export IsDataURL/IsHTTPURL/IsDataPath, dedup across packages
- Cache OutboundPolicy in managerOutboundStream to avoid repeated lookups
- Split OutboundAttachmentStore: extract ContainerAttachmentIngester interface
- Add ManagerOption funcs (WithInboundQueueSize, WithInboundWorkers, WithRefreshInterval)
- Add thread-safety docs on OutboundStream / managerOutboundStream
- Add debug logs on successful send/edit paths
- Expand outbound_prepare_test.go with 21 new cases
- Convert no-receiver adapter helpers to package-level funcs; drop unused params

DingTalk adapter:
- Implement AttachmentResolver: download inbound media via /v1.0/robot/messageFiles/download
- Fix pure-image inbound messages failing due to missing resolver

Attachment pipeline:
- Fix images invisible to LLM in pipeline (DCP) path: inject InlineImages into
  last user message when cfg.Query is empty
- Fix public_url fallback: skip direct URL-to-LLM when ContentHash is set,
  always prefer inlined persisted asset
- Inject path: carry ImageParts through agent.InjectMessage; inline persisted
  attachments in resolver inject goroutine so mid-stream images reach the model
- Fix ResolveMime for images: prefer content-sniffed MIME over platform-declared
  MIME (fixes Feishu sending image/png header for actual JPEG content → API 400)
---
 .../web/src/components/channel-icon/index.vue |   4 +
 apps/web/src/i18n/locales/en.json             |   9 +
 apps/web/src/i18n/locales/zh.json             |   9 +
 .../pages/bots/components/bot-channels.vue    |  12 +-
 .../components/channel-settings-panel.vue     |  12 +-
 apps/web/src/pages/profile/index.vue          |   6 +-
 apps/web/src/utils/channel-type-label.ts      |  20 +
 cmd/agent/main.go                             |  54 +-
 cmd/memoh/serve.go                            |  44 +-
 go.mod                                        |   1 +
 go.sum                                        |   2 +
 internal/agent/agent.go                       |  13 +-
 internal/agent/types.go                       |   3 +
 internal/attachment/normalize.go              |  12 +-
 internal/attachment/normalize_test.go         |  74 +-
 internal/channel/adapter.go                   |  19 +-
 internal/channel/adapters/dingtalk/client.go  | 326 ++++++++
 internal/channel/adapters/dingtalk/config.go  | 167 ++++
 .../channel/adapters/dingtalk/descriptor.go   |   7 +
 .../channel/adapters/dingtalk/dingtalk.go     | 447 +++++++++++
 internal/channel/adapters/dingtalk/inbound.go | 389 ++++++++++
 .../channel/adapters/dingtalk/outbound.go     | 200 +++++
 internal/channel/adapters/dingtalk/stream.go  | 153 ++++
 internal/channel/adapters/discord/discord.go  | 108 +--
 .../channel/adapters/discord/discord_test.go  |  34 +-
 internal/channel/adapters/discord/stream.go   |  16 +-
 .../channel/adapters/discord/stream_test.go   |   2 +-
 internal/channel/adapters/feishu/feishu.go    | 103 +--
 .../feishu/feishu_integration_test.go         |  14 +-
 internal/channel/adapters/feishu/stream.go    |  44 +-
 internal/channel/adapters/local/hub.go        |   6 +-
 internal/channel/adapters/local/hub_test.go   |   2 +-
 internal/channel/adapters/local/web.go        |   9 +-
 internal/channel/adapters/matrix/matrix.go    | 141 +---
 .../channel/adapters/matrix/matrix_test.go    |  33 +-
 internal/channel/adapters/matrix/stream.go    |  10 +-
 .../channel/adapters/matrix/stream_test.go    |  34 +-
 internal/channel/adapters/qq/send.go          | 150 +---
 internal/channel/adapters/qq/send_test.go     |  87 ++-
 internal/channel/adapters/qq/stream.go        |  69 +-
 internal/channel/adapters/qq/stream_test.go   |  90 ++-
 internal/channel/adapters/telegram/stream.go  |  24 +-
 .../channel/adapters/telegram/stream_test.go  |  42 +-
 .../channel/adapters/telegram/telegram.go     | 122 +--
 .../adapters/telegram/telegram_test.go        | 102 +--
 .../wecom/adapter_integration_test.go         |  14 +-
 internal/channel/adapters/wecom/outbound.go   | 155 +++-
 .../channel/adapters/wecom/outbound_test.go   |  72 ++
 internal/channel/adapters/wecom/wecom.go      |  57 +-
 internal/channel/adapters/weixin/weixin.go    |  78 +-
 internal/channel/channeltest/store.go         | 181 +++++
 internal/channel/connection.go                |  36 +-
 internal/channel/inbound/channel.go           | 242 ++----
 internal/channel/inbound/channel_test.go      |  39 +-
 internal/channel/inbound/dispatcher.go        |  13 +-
 internal/channel/inbound_test.go              |  15 +-
 internal/channel/manager.go                   |  49 +-
 internal/channel/manager_integration_test.go  |   4 +-
 internal/channel/outbound.go                  | 110 ++-
 internal/channel/outbound_prepare.go          | 648 ++++++++++++++++
 internal/channel/outbound_prepare_test.go     | 724 ++++++++++++++++++
 internal/channel/outbound_test.go             |  37 +-
 internal/channel/prepared_outbound.go         | 109 +++
 internal/channel/types.go                     |  14 +
 internal/conversation/flow/resolver.go        |  31 +-
 .../conversation/flow/resolver_attachments.go |  47 +-
 internal/media/service.go                     |   6 +
 internal/messaging/executor.go                |  52 +-
 internal/messaging/executor_test.go           |  22 +-
 internal/pipeline/rendering.go                |  10 -
 packages/icons/icons/dingtalk.svg             |   1 +
 packages/icons/icons/wecom.svg                |   1 +
 packages/icons/scripts/manifest.ts            |   2 +
 packages/icons/src/icons/Dingtalk.vue         |  22 +
 packages/icons/src/icons/Wecom.vue            |  18 +
 packages/icons/src/index.ts                   |   2 +
 76 files changed, 4851 insertions(+), 1185 deletions(-)
 create mode 100644 apps/web/src/utils/channel-type-label.ts
 create mode 100644 internal/channel/adapters/dingtalk/client.go
 create mode 100644 internal/channel/adapters/dingtalk/config.go
 create mode 100644 internal/channel/adapters/dingtalk/descriptor.go
 create mode 100644 internal/channel/adapters/dingtalk/dingtalk.go
 create mode 100644 internal/channel/adapters/dingtalk/inbound.go
 create mode 100644 internal/channel/adapters/dingtalk/outbound.go
 create mode 100644 internal/channel/adapters/dingtalk/stream.go
 create mode 100644 internal/channel/channeltest/store.go
 create mode 100644 internal/channel/outbound_prepare.go
 create mode 100644 internal/channel/outbound_prepare_test.go
 create mode 100644 internal/channel/prepared_outbound.go
 create mode 100644 packages/icons/icons/dingtalk.svg
 create mode 100644 packages/icons/icons/wecom.svg
 create mode 100644 packages/icons/src/icons/Dingtalk.vue
 create mode 100644 packages/icons/src/icons/Wecom.vue

diff --git a/apps/web/src/components/channel-icon/index.vue b/apps/web/src/components/channel-icon/index.vue
index 4f201499..91d79d58 100644
--- a/apps/web/src/components/channel-icon/index.vue
+++ b/apps/web/src/components/channel-icon/index.vue
@@ -14,12 +14,14 @@
 <script setup lang="ts">
 import { computed, type Component } from 'vue'
 import {
+  Dingtalk,
   Qq,
   Telegram,
   Discord,
   Slack,
   Feishu,
   Wechat,
+  Wecom,
   Matrix,
 } from '@memohai/icon'
 
@@ -31,7 +33,9 @@ const channelIcons: Record<string, Component> = {
   feishu: Feishu,
   wechat: Wechat,
   weixin: Wechat,
+  wecom: Wecom,
   matrix: Matrix,
+  dingtalk: Dingtalk,
 }
 
 const props = withDefaults(defineProps<{
diff --git a/apps/web/src/i18n/locales/en.json b/apps/web/src/i18n/locales/en.json
index 2c5fd0de..09050332 100644
--- a/apps/web/src/i18n/locales/en.json
+++ b/apps/web/src/i18n/locales/en.json
@@ -993,6 +993,7 @@
       "feishuWebhookSecurityHint": "For security, webhook mode requires either an Encrypt Key or a Verification Token; an unprotected public callback URL should not be exposed.",
       "feishuWebhookSecretRequired": "For security, configure at least one of Encrypt Key or Verification Token.",
       "noAvailableTypes": "All platform types have been configured",
+      "platformKey": "Platform ID: {key}",
       "weixinQr": {
         "title": "QR Code Login",
         "description": "Scan the QR code with WeChat to connect your account.",
@@ -1011,6 +1012,10 @@
         "matrix": "Matrix",
         "telegram": "Telegram",
         "weixin": "WeChat",
+        "wecom": "WeCom",
+        "dingtalk": "DingTalk",
+        "web": "Web",
+        "cli": "CLI",
         "local": "Local"
       },
       "typesShort": {
@@ -1020,6 +1025,10 @@
         "matrix": "MX",
         "telegram": "TG",
         "weixin": "WX",
+        "wecom": "WC",
+        "dingtalk": "DT",
+        "web": "Web",
+        "cli": "CLI",
         "local": "LC"
       }
     },
diff --git a/apps/web/src/i18n/locales/zh.json b/apps/web/src/i18n/locales/zh.json
index c3f392de..d59da1cb 100644
--- a/apps/web/src/i18n/locales/zh.json
+++ b/apps/web/src/i18n/locales/zh.json
@@ -989,6 +989,7 @@
       "feishuWebhookSecurityHint": "出于安全考虑，Webhook 模式必须配置 Encrypt Key 或 Verification Token 之一；未受保护的回调地址不应直接暴露在公网上。",
       "feishuWebhookSecretRequired": "出于安全考虑，请至少配置 Encrypt Key 或 Verification Token 之一。",
       "noAvailableTypes": "所有平台类型均已配置",
+      "platformKey": "平台标识：{key}",
       "weixinQr": {
         "title": "扫码登录",
         "description": "使用微信扫描二维码以连接微信账号。",
@@ -1007,6 +1008,10 @@
         "matrix": "Matrix",
         "telegram": "Telegram",
         "weixin": "微信",
+        "wecom": "企业微信",
+        "dingtalk": "钉钉",
+        "web": "Web",
+        "cli": "本地 CLI",
         "local": "本地"
       },
       "typesShort": {
@@ -1016,6 +1021,10 @@
         "matrix": "MX",
         "telegram": "TG",
         "weixin": "WX",
+        "wecom": "企微",
+        "dingtalk": "钉",
+        "web": "Web",
+        "cli": "CLI",
         "local": "本地"
       }
     },
diff --git a/apps/web/src/pages/bots/components/bot-channels.vue b/apps/web/src/pages/bots/components/bot-channels.vue
index 29ad048b..d8541f33 100644
--- a/apps/web/src/pages/bots/components/bot-channels.vue
+++ b/apps/web/src/pages/bots/components/bot-channels.vue
@@ -48,7 +48,7 @@
             </span>
             <div class="flex-1 text-left">
               <div class="font-medium">
-                {{ item.meta.display_name }}
+                {{ channelTitle(item.meta) }}
               </div>
               <div class="text-xs">
                 <span
@@ -107,7 +107,7 @@
                   size="1em"
                 />
               </span>
-              <span>{{ item.meta.display_name }}</span>
+              <span>{{ channelTitle(item.meta) }}</span>
             </button>
           </PopoverContent>
         </Popover>
@@ -136,6 +136,7 @@
 <script setup lang="ts">
 import { LoaderCircle, Plus } from 'lucide-vue-next'
 import { computed, ref, watch } from 'vue'
+import { useI18n } from 'vue-i18n'
 import {
   Button,
   Popover,
@@ -148,6 +149,7 @@ import { getChannels, getBotsByIdChannelByPlatform } from '@memohai/sdk'
 import type { HandlersChannelMeta, ChannelChannelConfig } from '@memohai/sdk'
 import ChannelSettingsPanel from './channel-settings-panel.vue'
 import ChannelIcon from '@/components/channel-icon/index.vue'
+import { channelTypeDisplayName } from '@/utils/channel-type-label'
 
 export interface BotChannelItem {
   meta: HandlersChannelMeta
@@ -159,6 +161,12 @@ const props = defineProps<{
   botId: string
 }>()
 
+const { t } = useI18n()
+
+function channelTitle(meta: HandlersChannelMeta) {
+  return channelTypeDisplayName(t, meta.type, meta.display_name)
+}
+
 const botIdRef = computed(() => props.botId)
 
 const { data: channels, isLoading, refetch } = useQuery({
diff --git a/apps/web/src/pages/bots/components/channel-settings-panel.vue b/apps/web/src/pages/bots/components/channel-settings-panel.vue
index 758292c1..0ae68027 100644
--- a/apps/web/src/pages/bots/components/channel-settings-panel.vue
+++ b/apps/web/src/pages/bots/components/channel-settings-panel.vue
@@ -11,10 +11,10 @@
         </span>
         <div>
           <h3 class="text-sm font-semibold">
-            {{ channelItem.meta.display_name }}
+            {{ channelTitle }}
           </h3>
           <p class="text-xs text-muted-foreground">
-            {{ channelItem.meta.type }}
+            {{ platformKeyLine }}
           </p>
         </div>
       </div>
@@ -273,6 +273,7 @@ import { client } from '@memohai/sdk/client'
 import ConfirmPopover from '@/components/confirm-popover/index.vue'
 import ChannelIcon from '@/components/channel-icon/index.vue'
 import WeixinQrLogin from './weixin-qr-login.vue'
+import { channelTypeDisplayName } from '@/utils/channel-type-label'
 
 interface BotChannelItem {
   meta: HandlersChannelMeta
@@ -292,6 +293,13 @@ const emit = defineEmits<{
 const { t } = useI18n()
 const botIdRef = computed(() => props.botId)
 const platformType = computed(() => String(props.channelItem.meta.type || '').trim())
+
+const channelTitle = computed(() =>
+  channelTypeDisplayName(t, props.channelItem.meta.type, props.channelItem.meta.display_name),
+)
+const platformKeyLine = computed(() =>
+  t('bots.channels.platformKey', { key: platformType.value }),
+)
 const queryCache = useQueryCache()
 const { mutateAsync: upsertChannel, isLoading } = useMutation({
   mutation: async ({ platform, data }: { platform: string; data: ChannelUpsertConfigRequest }) => {
diff --git a/apps/web/src/pages/profile/index.vue b/apps/web/src/pages/profile/index.vue
index 1e7e522d..81f41640 100644
--- a/apps/web/src/pages/profile/index.vue
+++ b/apps/web/src/pages/profile/index.vue
@@ -228,6 +228,7 @@ import { resolveApiErrorMessage } from '@/utils/api-error'
 import { formatDateTime } from '@/utils/date-time'
 import { useClipboard } from '@/composables/useClipboard'
 import { useAvatarInitials } from '@/composables/useAvatarInitials'
+import { channelTypeDisplayName } from '@/utils/channel-type-label'
 
 interface IssueBindCodeResponse {
   token: string
@@ -287,10 +288,7 @@ const avatarFallback = useAvatarInitials(() => displayTitle.value, 'U')
 
 function platformLabel(platformKey: string): string {
   if (!platformKey?.trim()) return platformKey ?? ''
-  const key = platformKey.trim().toLowerCase()
-  const i18nKey = `bots.channels.types.${key}`
-  const out = t(i18nKey)
-  return out !== i18nKey ? out : platformKey
+  return channelTypeDisplayName(t, platformKey, null) || platformKey
 }
 
 const platformOptions = computed(() => {
diff --git a/apps/web/src/utils/channel-type-label.ts b/apps/web/src/utils/channel-type-label.ts
new file mode 100644
index 00000000..8bed54e6
--- /dev/null
+++ b/apps/web/src/utils/channel-type-label.ts
@@ -0,0 +1,20 @@
+/**
+ * Localized channel platform title for UI.
+ * Prefer bots.channels.types.{type}; fall back to server display_name, then raw type.
+ */
+export function channelTypeDisplayName(
+  t: (key: string, ...args: unknown[]) => string,
+  channelType: string | undefined | null,
+  serverDisplayName?: string | null,
+): string {
+  const raw = (channelType ?? '').trim().toLowerCase()
+  if (!raw) {
+    return (serverDisplayName ?? '').trim() || ''
+  }
+  const i18nKey = `bots.channels.types.${raw}`
+  const out = t(i18nKey)
+  if (out !== i18nKey) return out
+  const fb = (serverDisplayName ?? '').trim()
+  if (fb) return fb
+  return raw.charAt(0).toUpperCase() + raw.slice(1)
+}
diff --git a/cmd/agent/main.go b/cmd/agent/main.go
index 22c80377..db8787e8 100644
--- a/cmd/agent/main.go
+++ b/cmd/agent/main.go
@@ -30,6 +30,7 @@ import (
 	"github.com/memohai/memoh/internal/bots"
 	"github.com/memohai/memoh/internal/browsercontexts"
 	"github.com/memohai/memoh/internal/channel"
+	"github.com/memohai/memoh/internal/channel/adapters/dingtalk"
 	"github.com/memohai/memoh/internal/channel/adapters/discord"
 	"github.com/memohai/memoh/internal/channel/adapters/feishu"
 	"github.com/memohai/memoh/internal/channel/adapters/local"
@@ -522,6 +523,8 @@ func provideChannelRegistry(log *slog.Logger, hub *local.RouteHub, mediaService
 	feishuAdapter.SetAssetOpener(mediaService)
 	registry.MustRegister(feishuAdapter)
 	registry.MustRegister(wecom.NewWeComAdapter(log))
+	dingTalkAdapter := dingtalk.NewDingTalkAdapter(log)
+	registry.MustRegister(dingTalkAdapter)
 	weixinAdapter := weixin.NewWeixinAdapter(log)
 	weixinAdapter.SetAssetOpener(mediaService)
 	registry.MustRegister(weixinAdapter)
@@ -605,13 +608,14 @@ func provideChannelRouter(
 	return processor
 }
 
-func provideChannelManager(log *slog.Logger, registry *channel.Registry, channelStore *channel.Store, channelRouter *inbound.ChannelInboundProcessor) *channel.Manager {
+func provideChannelManager(log *slog.Logger, registry *channel.Registry, channelStore *channel.Store, channelRouter *inbound.ChannelInboundProcessor, mediaService *media.Service) *channel.Manager {
 	if adapter, ok := registry.Get(matrix.Type); ok {
 		if matrixAdapter, ok := adapter.(*matrix.MatrixAdapter); ok {
 			matrixAdapter.SetSyncStateSaver(channelStore.SaveMatrixSyncSinceToken)
 		}
 	}
 	mgr := channel.NewManager(log, registry, channelStore, channelRouter)
+	mgr.SetAttachmentStore(mediaService)
 	if mw := channelRouter.IdentityMiddleware(); mw != nil {
 		mgr.Use(mw)
 	}
@@ -1151,36 +1155,46 @@ type mediaAssetResolverAdapter struct {
 	media *media.Service
 }
 
+func (a *mediaAssetResolverAdapter) Stat(ctx context.Context, botID, contentHash string) (media.Asset, error) {
+	if a == nil || a.media == nil {
+		return media.Asset{}, errors.New("media service not configured")
+	}
+	return a.media.Stat(ctx, botID, contentHash)
+}
+
+func (a *mediaAssetResolverAdapter) Open(ctx context.Context, botID, contentHash string) (io.ReadCloser, media.Asset, error) {
+	if a == nil || a.media == nil {
+		return nil, media.Asset{}, errors.New("media service not configured")
+	}
+	return a.media.Open(ctx, botID, contentHash)
+}
+
+func (a *mediaAssetResolverAdapter) Ingest(ctx context.Context, input media.IngestInput) (media.Asset, error) {
+	if a == nil || a.media == nil {
+		return media.Asset{}, errors.New("media service not configured")
+	}
+	return a.media.Ingest(ctx, input)
+}
+
 func (a *mediaAssetResolverAdapter) GetByStorageKey(ctx context.Context, botID, storageKey string) (messaging.AssetMeta, error) {
 	if a == nil || a.media == nil {
 		return messaging.AssetMeta{}, errors.New("media service not configured")
 	}
-	asset, err := a.media.GetByStorageKey(ctx, botID, storageKey)
-	if err != nil {
-		return messaging.AssetMeta{}, err
+	return a.media.GetByStorageKey(ctx, botID, storageKey)
+}
+
+func (a *mediaAssetResolverAdapter) AccessPath(asset media.Asset) string {
+	if a == nil || a.media == nil {
+		return ""
 	}
-	return messaging.AssetMeta{
-		ContentHash: asset.ContentHash,
-		Mime:        asset.Mime,
-		SizeBytes:   asset.SizeBytes,
-		StorageKey:  asset.StorageKey,
-	}, nil
+	return a.media.AccessPath(asset)
 }
 
 func (a *mediaAssetResolverAdapter) IngestContainerFile(ctx context.Context, botID, containerPath string) (messaging.AssetMeta, error) {
 	if a == nil || a.media == nil {
 		return messaging.AssetMeta{}, errors.New("media service not configured")
 	}
-	asset, err := a.media.IngestContainerFile(ctx, botID, containerPath)
-	if err != nil {
-		return messaging.AssetMeta{}, err
-	}
-	return messaging.AssetMeta{
-		ContentHash: asset.ContentHash,
-		Mime:        asset.Mime,
-		SizeBytes:   asset.SizeBytes,
-		StorageKey:  asset.StorageKey,
-	}, nil
+	return a.media.IngestContainerFile(ctx, botID, containerPath)
 }
 
 // gatewayAssetLoaderAdapter bridges media service to flow gateway asset loader.
diff --git a/cmd/memoh/serve.go b/cmd/memoh/serve.go
index 4704f3c7..96aadd33 100644
--- a/cmd/memoh/serve.go
+++ b/cmd/memoh/serve.go
@@ -31,6 +31,7 @@ import (
 	"github.com/memohai/memoh/internal/bots"
 	"github.com/memohai/memoh/internal/browsercontexts"
 	"github.com/memohai/memoh/internal/channel"
+	"github.com/memohai/memoh/internal/channel/adapters/dingtalk"
 	"github.com/memohai/memoh/internal/channel/adapters/discord"
 	"github.com/memohai/memoh/internal/channel/adapters/feishu"
 	"github.com/memohai/memoh/internal/channel/adapters/local"
@@ -444,6 +445,8 @@ func provideChannelRegistry(log *slog.Logger, hub *local.RouteHub, mediaService
 	feishuAdapter.SetAssetOpener(mediaService)
 	registry.MustRegister(feishuAdapter)
 	registry.MustRegister(wecom.NewWeComAdapter(log))
+	dingTalkAdapter := dingtalk.NewDingTalkAdapter(log)
+	registry.MustRegister(dingTalkAdapter)
 	weixinAdapter := weixin.NewWeixinAdapter(log)
 	weixinAdapter.SetAssetOpener(mediaService)
 	registry.MustRegister(weixinAdapter)
@@ -493,13 +496,14 @@ func provideChannelRouter(log *slog.Logger, registry *channel.Registry, hub *loc
 	return processor
 }
 
-func provideChannelManager(log *slog.Logger, registry *channel.Registry, channelStore *channel.Store, channelRouter *inbound.ChannelInboundProcessor) *channel.Manager {
+func provideChannelManager(log *slog.Logger, registry *channel.Registry, channelStore *channel.Store, channelRouter *inbound.ChannelInboundProcessor, mediaService *media.Service) *channel.Manager {
 	if adapter, ok := registry.Get(matrix.Type); ok {
 		if matrixAdapter, ok := adapter.(*matrix.MatrixAdapter); ok {
 			matrixAdapter.SetSyncStateSaver(channelStore.SaveMatrixSyncSinceToken)
 		}
 	}
 	mgr := channel.NewManager(log, registry, channelStore, channelRouter)
+	mgr.SetAttachmentStore(mediaService)
 	if mw := channelRouter.IdentityMiddleware(); mw != nil {
 		mgr.Use(mw)
 	}
@@ -1062,26 +1066,46 @@ func (a *skillLoaderAdapter) LoadSkills(ctx context.Context, botID string) ([]fl
 
 type mediaAssetResolverAdapter struct{ media *media.Service }
 
+func (a *mediaAssetResolverAdapter) Stat(ctx context.Context, botID, contentHash string) (media.Asset, error) {
+	if a == nil || a.media == nil {
+		return media.Asset{}, errors.New("media service not configured")
+	}
+	return a.media.Stat(ctx, botID, contentHash)
+}
+
+func (a *mediaAssetResolverAdapter) Open(ctx context.Context, botID, contentHash string) (io.ReadCloser, media.Asset, error) {
+	if a == nil || a.media == nil {
+		return nil, media.Asset{}, errors.New("media service not configured")
+	}
+	return a.media.Open(ctx, botID, contentHash)
+}
+
+func (a *mediaAssetResolverAdapter) Ingest(ctx context.Context, input media.IngestInput) (media.Asset, error) {
+	if a == nil || a.media == nil {
+		return media.Asset{}, errors.New("media service not configured")
+	}
+	return a.media.Ingest(ctx, input)
+}
+
 func (a *mediaAssetResolverAdapter) GetByStorageKey(ctx context.Context, botID, storageKey string) (messaging.AssetMeta, error) {
 	if a == nil || a.media == nil {
 		return messaging.AssetMeta{}, errors.New("media service not configured")
 	}
-	asset, err := a.media.GetByStorageKey(ctx, botID, storageKey)
-	if err != nil {
-		return messaging.AssetMeta{}, err
+	return a.media.GetByStorageKey(ctx, botID, storageKey)
+}
+
+func (a *mediaAssetResolverAdapter) AccessPath(asset media.Asset) string {
+	if a == nil || a.media == nil {
+		return ""
 	}
-	return messaging.AssetMeta{ContentHash: asset.ContentHash, Mime: asset.Mime, SizeBytes: asset.SizeBytes, StorageKey: asset.StorageKey}, nil
+	return a.media.AccessPath(asset)
 }
 
 func (a *mediaAssetResolverAdapter) IngestContainerFile(ctx context.Context, botID, containerPath string) (messaging.AssetMeta, error) {
 	if a == nil || a.media == nil {
 		return messaging.AssetMeta{}, errors.New("media service not configured")
 	}
-	asset, err := a.media.IngestContainerFile(ctx, botID, containerPath)
-	if err != nil {
-		return messaging.AssetMeta{}, err
-	}
-	return messaging.AssetMeta{ContentHash: asset.ContentHash, Mime: asset.Mime, SizeBytes: asset.SizeBytes, StorageKey: asset.StorageKey}, nil
+	return a.media.IngestContainerFile(ctx, botID, containerPath)
 }
 
 type gatewayAssetLoaderAdapter struct{ media *media.Service }
diff --git a/go.mod b/go.mod
index 9ff3a70c..9c89367b 100644
--- a/go.mod
+++ b/go.mod
@@ -26,6 +26,7 @@ require (
 	github.com/larksuite/oapi-sdk-go/v3 v3.5.3
 	github.com/mailgun/mailgun-go/v5 v5.14.0
 	github.com/memohai/acgo v0.0.0-20260221232113-babac0d6acd7
+	github.com/memohai/dingtalk-stream-sdk-go v0.0.0-20260405113102-87e23096b978
 	github.com/memohai/twilight-ai v0.3.4-0.20260402160505-00db38ee4442
 	github.com/modelcontextprotocol/go-sdk v1.4.1
 	github.com/opencontainers/image-spec v1.1.1
diff --git a/go.sum b/go.sum
index f2832a0a..bc746f2a 100644
--- a/go.sum
+++ b/go.sum
@@ -228,6 +228,8 @@ github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D
 github.com/mattn/go-runewidth v0.0.10/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
 github.com/memohai/acgo v0.0.0-20260221232113-babac0d6acd7 h1:beehwOQperqGWj4m4EhcPhnSZKtDiuHK/7ZMoTPaQjw=
 github.com/memohai/acgo v0.0.0-20260221232113-babac0d6acd7/go.mod h1:OvmxM7JmnXBmwJWWVqtreL3HSHSKuzPbtbhlg5MvBg0=
+github.com/memohai/dingtalk-stream-sdk-go v0.0.0-20260405113102-87e23096b978 h1:6gD8DvZkimGmU0e3PjlusJPyw55SyeoE12CZQoYUa8g=
+github.com/memohai/dingtalk-stream-sdk-go v0.0.0-20260405113102-87e23096b978/go.mod h1:2LMgK5QYFlTSvrGY+sI/j+jK2WK+YGHv4IMuiW+iPSc=
 github.com/memohai/twilight-ai v0.3.4-0.20260402160505-00db38ee4442 h1:mTy+OSkMCOvF1S6D5asKRdKx0A+icQvnu6A/f7aZolg=
 github.com/memohai/twilight-ai v0.3.4-0.20260402160505-00db38ee4442/go.mod h1:GZTT9GUT3uSs6zram/FcF24GLTZMFSpiybbYmjr+gH8=
 github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
diff --git a/internal/agent/agent.go b/internal/agent/agent.go
index bddd1990..35010f6f 100644
--- a/internal/agent/agent.go
+++ b/internal/agent/agent.go
@@ -126,15 +126,24 @@ func (a *Agent) runStream(ctx context.Context, cfg RunConfig, ch chan<- StreamEv
 					if text == "" {
 						text = strings.TrimSpace(injected.Text)
 					}
-					if text != "" {
+					if text != "" || (cfg.SupportsImageInput && len(injected.ImageParts) > 0) {
 						insertAfter := len(p.Messages) - initialMsgCount
-						p.Messages = append(p.Messages, sdk.UserMessage(text))
+						var extra []sdk.MessagePart
+						if cfg.SupportsImageInput {
+							for _, img := range injected.ImageParts {
+								if strings.TrimSpace(img.Image) != "" {
+									extra = append(extra, img)
+								}
+							}
+						}
+						p.Messages = append(p.Messages, sdk.UserMessage(text, extra...))
 						if cfg.InjectedRecorder != nil {
 							cfg.InjectedRecorder(text, insertAfter)
 						}
 						a.logger.Info("injected user message into agent stream",
 							slog.String("bot_id", cfg.Identity.BotID),
 							slog.Int("insert_after", insertAfter),
+							slog.Int("image_parts", len(extra)),
 						)
 					}
 					continue
diff --git a/internal/agent/types.go b/internal/agent/types.go
index 26a2d5ce..0a034380 100644
--- a/internal/agent/types.go
+++ b/internal/agent/types.go
@@ -51,6 +51,9 @@ type LoopDetectionConfig struct {
 type InjectMessage struct {
 	Text            string
 	HeaderifiedText string
+	// ImageParts carries inline images (data URL or public URL) to attach
+	// alongside the injected text when the model supports vision input.
+	ImageParts []sdk.ImagePart
 }
 
 // RunConfig holds everything needed for a single agent invocation.
diff --git a/internal/attachment/normalize.go b/internal/attachment/normalize.go
index ebf28731..b1b79fd8 100644
--- a/internal/attachment/normalize.go
+++ b/internal/attachment/normalize.go
@@ -59,18 +59,24 @@ func MimeFromDataURL(raw string) string {
 }
 
 // ResolveMime resolves source MIME and sniffed MIME into final MIME.
+//
+// For image attachments, content sniffing takes precedence over the platform-reported
+// MIME because platforms sometimes declare the wrong image subtype (e.g. "image/png"
+// for a JPEG file). Using the wrong MIME causes multimodal API rejections (HTTP 400).
 func ResolveMime(mediaType media.MediaType, sourceMime, sniffedMime string) string {
 	source := NormalizeMime(sourceMime)
 	sniffed := NormalizeMime(sniffedMime)
 	sourceGeneric := source == "" || source == "application/octet-stream"
 
 	if mediaType == media.MediaTypeImage {
-		if strings.HasPrefix(source, "image/") {
-			return source
-		}
+		// Prefer the sniffed MIME for images: it is derived from the actual file
+		// bytes and is always more accurate than the platform-declared value.
 		if strings.HasPrefix(sniffed, "image/") {
 			return sniffed
 		}
+		if strings.HasPrefix(source, "image/") {
+			return source
+		}
 		if !sourceGeneric {
 			return source
 		}
diff --git a/internal/attachment/normalize_test.go b/internal/attachment/normalize_test.go
index b91c37e2..c7e132bc 100644
--- a/internal/attachment/normalize_test.go
+++ b/internal/attachment/normalize_test.go
@@ -64,17 +64,71 @@ func TestMimeFromDataURL(t *testing.T) {
 }
 
 func TestResolveMime(t *testing.T) {
-	if got := ResolveMime(media.MediaTypeImage, "application/octet-stream", "image/jpeg"); got != "image/jpeg" {
-		t.Fatalf("ResolveMime image unexpected result: %q", got)
+	cases := []struct {
+		name      string
+		mediaType media.MediaType
+		source    string
+		sniffed   string
+		want      string
+	}{
+		{
+			name:      "image: sniffed preferred over generic source",
+			mediaType: media.MediaTypeImage,
+			source:    "application/octet-stream",
+			sniffed:   "image/jpeg",
+			want:      "image/jpeg",
+		},
+		{
+			name:      "image: sniffed preferred over wrong platform mime",
+			mediaType: media.MediaTypeImage,
+			source:    "image/png",
+			sniffed:   "image/jpeg",
+			want:      "image/jpeg",
+		},
+		{
+			name:      "image: fallback to source when sniff fails",
+			mediaType: media.MediaTypeImage,
+			source:    "image/png",
+			sniffed:   "",
+			want:      "image/png",
+		},
+		{
+			name:      "image: both empty returns octet-stream",
+			mediaType: media.MediaTypeImage,
+			source:    "",
+			sniffed:   "",
+			want:      "application/octet-stream",
+		},
+		{
+			name:      "file: source preferred over sniffed",
+			mediaType: media.MediaTypeFile,
+			source:    "application/pdf",
+			sniffed:   "application/octet-stream",
+			want:      "application/pdf",
+		},
+		{
+			name:      "file: sniffed used when source is generic",
+			mediaType: media.MediaTypeFile,
+			source:    "application/octet-stream",
+			sniffed:   "application/pdf",
+			want:      "application/pdf",
+		},
+		{
+			name:      "file: sniffed used when source token is invalid",
+			mediaType: media.MediaTypeFile,
+			source:    "file",
+			sniffed:   "text/plain",
+			want:      "text/plain",
+		},
 	}
-	if got := ResolveMime(media.MediaTypeFile, "application/octet-stream", "application/pdf"); got != "application/pdf" {
-		t.Fatalf("ResolveMime file unexpected result: %q", got)
-	}
-	if got := ResolveMime(media.MediaTypeFile, "file", "text/plain"); got != "text/plain" {
-		t.Fatalf("ResolveMime should prefer sniffed mime for invalid source token, got %q", got)
-	}
-	if got := ResolveMime(media.MediaTypeImage, "", ""); got != "application/octet-stream" {
-		t.Fatalf("ResolveMime empty unexpected result: %q", got)
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := ResolveMime(tc.mediaType, tc.source, tc.sniffed)
+			if got != tc.want {
+				t.Fatalf("ResolveMime(%v, %q, %q) = %q, want %q",
+					tc.mediaType, tc.source, tc.sniffed, got, tc.want)
+			}
+		})
 	}
 }
 
diff --git a/internal/channel/adapter.go b/internal/channel/adapter.go
index 34630bef..104fd152 100644
--- a/internal/channel/adapter.go
+++ b/internal/channel/adapter.go
@@ -20,7 +20,15 @@ type StreamReplySender interface {
 	OpenStream(ctx context.Context, target string, opts StreamOptions) (OutboundStream, error)
 }
 
+// PreparedOutboundStream is the adapter-facing stream session.
+type PreparedOutboundStream interface {
+	Push(ctx context.Context, event PreparedStreamEvent) error
+	Close(ctx context.Context) error
+}
+
 // OutboundStream is a live stream session for emitting outbound events.
+// Implementations are not required to be safe for concurrent use; callers
+// must serialize Push and Close calls within a single goroutine.
 type OutboundStream interface {
 	Push(ctx context.Context, event StreamEvent) error
 	Close(ctx context.Context) error
@@ -105,17 +113,17 @@ type BindingMatcher interface {
 
 // Sender is an adapter capable of sending outbound messages.
 type Sender interface {
-	Send(ctx context.Context, cfg ChannelConfig, msg OutboundMessage) error
+	Send(ctx context.Context, cfg ChannelConfig, msg PreparedOutboundMessage) error
 }
 
 // StreamSender is an adapter capable of opening outbound stream sessions.
 type StreamSender interface {
-	OpenStream(ctx context.Context, cfg ChannelConfig, target string, opts StreamOptions) (OutboundStream, error)
+	OpenStream(ctx context.Context, cfg ChannelConfig, target string, opts StreamOptions) (PreparedOutboundStream, error)
 }
 
 // MessageEditor updates and deletes already-sent messages when supported.
 type MessageEditor interface {
-	Update(ctx context.Context, cfg ChannelConfig, target string, messageID string, msg Message) error
+	Update(ctx context.Context, cfg ChannelConfig, target string, messageID string, msg PreparedMessage) error
 	Unsend(ctx context.Context, cfg ChannelConfig, target string, messageID string) error
 }
 
@@ -186,8 +194,11 @@ func (c *BaseConnection) Stop(ctx context.Context) error {
 	if c.stop == nil {
 		return ErrStopNotSupported
 	}
+	if err := c.stop(ctx); err != nil {
+		return err
+	}
 	c.running.Store(false)
-	return c.stop(ctx)
+	return nil
 }
 
 // Running reports whether the connection is still active.
diff --git a/internal/channel/adapters/dingtalk/client.go b/internal/channel/adapters/dingtalk/client.go
new file mode 100644
index 00000000..32c77b9b
--- /dev/null
+++ b/internal/channel/adapters/dingtalk/client.go
@@ -0,0 +1,326 @@
+package dingtalk
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+)
+
+const (
+	defaultAPIBase = "https://api.dingtalk.com"
+	// tokenTTL is slightly under 2h to avoid races near the expiry boundary.
+	tokenTTL = 110 * time.Minute
+)
+
+// apiClient handles DingTalk OpenAPI authentication and message delivery.
+type apiClient struct {
+	appKey    string
+	appSecret string
+	base      string
+
+	mu       sync.RWMutex
+	token    string
+	tokenExp time.Time
+
+	http *http.Client
+}
+
+func newAPIClient(appKey, appSecret string) *apiClient {
+	return &apiClient{
+		appKey:    appKey,
+		appSecret: appSecret,
+		base:      defaultAPIBase,
+		http: &http.Client{
+			Timeout: 10 * time.Second,
+		},
+	}
+}
+
+type tokenResponse struct {
+	AccessToken string `json:"accessToken"` //nolint:gosec // G117: DingTalk API response field, not a credential stored by us
+	ExpireIn    int    `json:"expireIn"`
+}
+
+// getToken returns a valid access token, refreshing it when necessary.
+func (c *apiClient) getToken(ctx context.Context) (string, error) {
+	c.mu.RLock()
+	if c.token != "" && time.Now().Before(c.tokenExp) {
+		token := c.token
+		c.mu.RUnlock()
+		return token, nil
+	}
+	c.mu.RUnlock()
+
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	// Double-check after acquiring write lock.
+	if c.token != "" && time.Now().Before(c.tokenExp) {
+		return c.token, nil
+	}
+
+	body, _ := json.Marshal(map[string]string{
+		"appKey":    c.appKey,
+		"appSecret": c.appSecret,
+	})
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.base+"/v1.0/oauth2/accessToken", bytes.NewReader(body))
+	if err != nil {
+		return "", fmt.Errorf("dingtalk token request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := c.http.Do(req) //nolint:gosec // G704: URL is the DingTalk OpenAPI endpoint, operator-configured
+	if err != nil {
+		return "", fmt.Errorf("dingtalk token: %w", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("dingtalk token read: %w", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("dingtalk token: status %d: %s", resp.StatusCode, string(data))
+	}
+	var tr tokenResponse
+	if err := json.Unmarshal(data, &tr); err != nil {
+		return "", fmt.Errorf("dingtalk token parse: %w", err)
+	}
+	if strings.TrimSpace(tr.AccessToken) == "" {
+		return "", errors.New("dingtalk token: empty in response")
+	}
+	c.token = tr.AccessToken
+	c.tokenExp = time.Now().Add(tokenTTL)
+	return c.token, nil
+}
+
+// doPost executes an authenticated POST to a DingTalk API path.
+func (c *apiClient) doPost(ctx context.Context, path string, body any) ([]byte, error) {
+	token, err := c.getToken(ctx)
+	if err != nil {
+		return nil, err
+	}
+	raw, _ := json.Marshal(body)
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.base+path, bytes.NewReader(raw))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("x-acs-dingtalk-access-token", token)
+
+	resp, err := c.http.Do(req) //nolint:gosec // G704: URL is the DingTalk OpenAPI endpoint, operator-configured
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = resp.Body.Close() }()
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("dingtalk api %s: status %d: %s", path, resp.StatusCode, string(data))
+	}
+	return data, nil
+}
+
+type sendUserMsgReq struct {
+	RobotCode string   `json:"robotCode"`
+	UserIds   []string `json:"userIds"`
+	MsgKey    string   `json:"msgKey"`
+	MsgParam  string   `json:"msgParam"`
+}
+
+// sendToUser sends a message to one or more DingTalk users via OpenAPI.
+// userIds can contain at most 20 entries per request.
+func (c *apiClient) sendToUser(ctx context.Context, robotCode string, userIds []string, msgKey, msgParam string) error {
+	if len(userIds) == 0 {
+		return errors.New("dingtalk: userIds is required")
+	}
+	_, err := c.doPost(ctx, "/v1.0/robot/oToMessages/batchSend", sendUserMsgReq{
+		RobotCode: robotCode,
+		UserIds:   userIds,
+		MsgKey:    msgKey,
+		MsgParam:  msgParam,
+	})
+	return err
+}
+
+type sendGroupMsgReq struct {
+	RobotCode          string `json:"robotCode"`
+	OpenConversationId string `json:"openConversationId"`
+	MsgKey             string `json:"msgKey"`
+	MsgParam           string `json:"msgParam"`
+}
+
+// sendToGroup sends a message to a DingTalk group via OpenAPI.
+func (c *apiClient) sendToGroup(ctx context.Context, robotCode, openConversationId, msgKey, msgParam string) error {
+	if strings.TrimSpace(openConversationId) == "" {
+		return errors.New("dingtalk: openConversationId is required")
+	}
+	_, err := c.doPost(ctx, "/v1.0/robot/groupMessages/send", sendGroupMsgReq{
+		RobotCode:          robotCode,
+		OpenConversationId: openConversationId,
+		MsgKey:             msgKey,
+		MsgParam:           msgParam,
+	})
+	return err
+}
+
+// sendViaWebhook posts a reply through a session webhook URL.
+// The webhook URL already contains auth; no access_token is required.
+func (c *apiClient) sendViaWebhook(ctx context.Context, webhookURL string, body map[string]any) error {
+	raw, _ := json.Marshal(body)
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, webhookURL, bytes.NewReader(raw))
+	if err != nil {
+		return fmt.Errorf("dingtalk webhook request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := c.http.Do(req) //nolint:gosec // G704: webhook URL is received from DingTalk platform callback, not user-supplied
+	if err != nil {
+		return fmt.Errorf("dingtalk webhook: %w", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	if resp.StatusCode != http.StatusOK {
+		data, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("dingtalk webhook: status %d: %s", resp.StatusCode, string(data))
+	}
+	return nil
+}
+
+// getBotInfo queries basic info for the robot itself (used by DiscoverSelf).
+type botInfoResponse struct {
+	Result struct {
+		Name      string `json:"name"`
+		RobotCode string `json:"robotCode"`
+	} `json:"result"`
+	RequestID string `json:"requestId"`
+}
+
+type uploadMediaResponse struct {
+	MediaID string `json:"media_id"`
+	ErrCode int    `json:"errcode"`
+	ErrMsg  string `json:"errmsg"`
+}
+
+// uploadMedia uploads a media file to DingTalk and returns the resulting mediaId.
+// mediaType must be one of: "image", "voice", "video", "file".
+// filename is used as the multipart filename; Content-Type is determined by the multipart writer.
+func (c *apiClient) uploadMedia(ctx context.Context, mediaType, filename string, data io.Reader) (string, error) {
+	token, err := c.getToken(ctx)
+	if err != nil {
+		return "", err
+	}
+
+	var buf bytes.Buffer
+	mw := multipart.NewWriter(&buf)
+
+	// The "type" field tells DingTalk which media category this is.
+	if err := mw.WriteField("type", mediaType); err != nil {
+		return "", fmt.Errorf("dingtalk upload: write type field: %w", err)
+	}
+
+	// The file part must be named "media".
+	part, err := mw.CreateFormFile("media", filename)
+	if err != nil {
+		return "", fmt.Errorf("dingtalk upload: create form file: %w", err)
+	}
+	if _, err := io.Copy(part, data); err != nil {
+		return "", fmt.Errorf("dingtalk upload: copy media: %w", err)
+	}
+	if err := mw.Close(); err != nil {
+		return "", fmt.Errorf("dingtalk upload: close multipart writer: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost,
+		c.base+"/media/upload?access_token="+token, &buf)
+	if err != nil {
+		return "", fmt.Errorf("dingtalk upload: build request: %w", err)
+	}
+	req.Header.Set("Content-Type", mw.FormDataContentType())
+
+	resp, err := c.http.Do(req) //nolint:gosec // URL is the DingTalk OpenAPI media endpoint
+	if err != nil {
+		return "", fmt.Errorf("dingtalk upload: %w", err)
+	}
+	defer func() { _ = resp.Body.Close() }()
+	raw, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("dingtalk upload: read response: %w", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("dingtalk upload: status %d: %s", resp.StatusCode, string(raw))
+	}
+	var result uploadMediaResponse
+	if err := json.Unmarshal(raw, &result); err != nil {
+		return "", fmt.Errorf("dingtalk upload: parse response: %w", err)
+	}
+	if result.ErrCode != 0 {
+		return "", fmt.Errorf("dingtalk upload: errcode %d: %s", result.ErrCode, result.ErrMsg)
+	}
+	if strings.TrimSpace(result.MediaID) == "" {
+		return "", fmt.Errorf("dingtalk upload: empty media_id in response: %s", string(raw))
+	}
+	return result.MediaID, nil
+}
+
+type downloadFileResponse struct {
+	DownloadURL string `json:"downloadUrl"`
+}
+
+// downloadMessageFile resolves a downloadCode received in an inbound message to a
+// temporary download URL, then streams the file content to the caller.
+// The caller is responsible for closing the returned ReadCloser.
+func (c *apiClient) downloadMessageFile(ctx context.Context, robotCode, downloadCode string) (io.ReadCloser, string, error) {
+	data, err := c.doPost(ctx, "/v1.0/robot/messageFiles/download", map[string]string{
+		"downloadCode": downloadCode,
+		"robotCode":    robotCode,
+	})
+	if err != nil {
+		return nil, "", fmt.Errorf("dingtalk download file: %w", err)
+	}
+	var result downloadFileResponse
+	if err := json.Unmarshal(data, &result); err != nil {
+		return nil, "", fmt.Errorf("dingtalk download file: parse response: %w", err)
+	}
+	downloadURL := strings.TrimSpace(result.DownloadURL)
+	if downloadURL == "" {
+		return nil, "", fmt.Errorf("dingtalk download file: empty downloadUrl in response: %s", string(data))
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL, nil)
+	if err != nil {
+		return nil, "", fmt.Errorf("dingtalk download file: build request: %w", err)
+	}
+	resp, err := c.http.Do(req) //nolint:gosec // G107: URL is returned by DingTalk API, not user-supplied
+	if err != nil {
+		return nil, "", fmt.Errorf("dingtalk download file: fetch: %w", err)
+	}
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		_ = resp.Body.Close()
+		return nil, "", fmt.Errorf("dingtalk download file: status %d", resp.StatusCode)
+	}
+	mimeType := strings.TrimSpace(resp.Header.Get("Content-Type"))
+	return resp.Body, mimeType, nil
+}
+
+// getBotInfo retrieves the bot's own profile via the OpenAPI.
+func (c *apiClient) getBotInfo(ctx context.Context, robotCode string) (botInfoResponse, error) {
+	type req struct {
+		RobotCode string `json:"robotCode"`
+	}
+	data, err := c.doPost(ctx, "/v1.0/robot/robotInfo", req{RobotCode: robotCode})
+	if err != nil {
+		return botInfoResponse{}, err
+	}
+	var info botInfoResponse
+	if err := json.Unmarshal(data, &info); err != nil {
+		return botInfoResponse{}, fmt.Errorf("dingtalk getBotInfo parse: %w", err)
+	}
+	return info, nil
+}
diff --git a/internal/channel/adapters/dingtalk/config.go b/internal/channel/adapters/dingtalk/config.go
new file mode 100644
index 00000000..066f147e
--- /dev/null
+++ b/internal/channel/adapters/dingtalk/config.go
@@ -0,0 +1,167 @@
+package dingtalk
+
+import (
+	"errors"
+	"strings"
+
+	"github.com/memohai/memoh/internal/channel"
+)
+
+type adapterConfig struct {
+	AppKey    string
+	AppSecret string
+}
+
+// UserConfig holds per-user delivery target data for DingTalk.
+type UserConfig struct {
+	// UserID is the recipient's DingTalk userId, used for single/private chat.
+	UserID string
+	// OpenConversationID is the group's openConversationId, used for group chat.
+	OpenConversationID string
+	// DisplayName is an optional human-readable label.
+	DisplayName string
+}
+
+func normalizeConfig(raw map[string]any) (map[string]any, error) {
+	cfg, err := parseConfig(raw)
+	if err != nil {
+		return nil, err
+	}
+	out := map[string]any{
+		"appKey":    cfg.AppKey,
+		"appSecret": cfg.AppSecret,
+	}
+	return out, nil
+}
+
+func normalizeUserConfig(raw map[string]any) (map[string]any, error) {
+	cfg, err := parseUserConfig(raw)
+	if err != nil {
+		return nil, err
+	}
+	out := map[string]any{}
+	if cfg.UserID != "" {
+		out["user_id"] = cfg.UserID
+	}
+	if cfg.OpenConversationID != "" {
+		out["open_conversation_id"] = cfg.OpenConversationID
+	}
+	if cfg.DisplayName != "" {
+		out["display_name"] = cfg.DisplayName
+	}
+	return out, nil
+}
+
+func parseConfig(raw map[string]any) (adapterConfig, error) {
+	cfg := adapterConfig{
+		AppKey:    strings.TrimSpace(channel.ReadString(raw, "appKey", "app_key")),
+		AppSecret: strings.TrimSpace(channel.ReadString(raw, "appSecret", "app_secret")),
+	}
+	if cfg.AppKey == "" || cfg.AppSecret == "" {
+		return adapterConfig{}, errors.New("dingtalk appKey and appSecret are required")
+	}
+	return cfg, nil
+}
+
+func parseUserConfig(raw map[string]any) (UserConfig, error) {
+	cfg := UserConfig{
+		UserID:             strings.TrimSpace(channel.ReadString(raw, "userId", "user_id")),
+		OpenConversationID: strings.TrimSpace(channel.ReadString(raw, "openConversationId", "open_conversation_id")),
+		DisplayName:        strings.TrimSpace(channel.ReadString(raw, "displayName", "display_name")),
+	}
+	if cfg.UserID == "" && cfg.OpenConversationID == "" {
+		return UserConfig{}, errors.New("dingtalk user config requires user_id or open_conversation_id")
+	}
+	return cfg, nil
+}
+
+// resolveTarget converts a UserConfig to the canonical target string.
+func resolveTarget(raw map[string]any) (string, error) {
+	cfg, err := parseUserConfig(raw)
+	if err != nil {
+		return "", err
+	}
+	if cfg.OpenConversationID != "" {
+		return "group:" + cfg.OpenConversationID, nil
+	}
+	return "user:" + cfg.UserID, nil
+}
+
+// normalizeTarget normalizes a raw target string to canonical form.
+func normalizeTarget(raw string) string {
+	kind, id, ok := parseTarget(raw)
+	if !ok {
+		return ""
+	}
+	return kind + ":" + id
+}
+
+// parseTarget parses a target string into (kind, id).
+// kind is "user" or "group".
+func parseTarget(raw string) (kind, id string, ok bool) {
+	v := strings.TrimSpace(raw)
+	if v == "" {
+		return "", "", false
+	}
+	lv := strings.ToLower(v)
+	switch {
+	case strings.HasPrefix(lv, "user:"):
+		id = strings.TrimSpace(v[len("user:"):])
+		return "user", id, id != ""
+	case strings.HasPrefix(lv, "user_id:"):
+		id = strings.TrimSpace(v[len("user_id:"):])
+		return "user", id, id != ""
+	case strings.HasPrefix(lv, "group:"):
+		id = strings.TrimSpace(v[len("group:"):])
+		return "group", id, id != ""
+	case strings.HasPrefix(lv, "open_conversation_id:"):
+		id = strings.TrimSpace(v[len("open_conversation_id:"):])
+		return "group", id, id != ""
+	default:
+		// Bare value: treat as userId (private chat)
+		return "user", v, true
+	}
+}
+
+func matchBinding(raw map[string]any, criteria channel.BindingCriteria) bool {
+	cfg, err := parseUserConfig(raw)
+	if err != nil {
+		return false
+	}
+	// Match against staff_id or user_id to handle both ISV and enterprise bots.
+	if v := strings.TrimSpace(criteria.Attribute("staff_id")); v != "" && v == cfg.UserID {
+		return true
+	}
+	if v := strings.TrimSpace(criteria.Attribute("user_id")); v != "" && v == cfg.UserID {
+		return true
+	}
+	if v := strings.TrimSpace(criteria.Attribute("open_conversation_id")); v != "" && v == cfg.OpenConversationID {
+		return true
+	}
+	if criteria.SubjectID != "" {
+		if criteria.SubjectID == cfg.UserID || criteria.SubjectID == cfg.OpenConversationID {
+			return true
+		}
+	}
+	return false
+}
+
+func buildUserConfig(identity channel.Identity) map[string]any {
+	out := map[string]any{}
+	// Prefer staff_id (DingTalk staffId required by OpenAPI batchSend).
+	// user_id may be senderId/unionId which is rejected by the API in ISV apps.
+	userID := strings.TrimSpace(identity.Attribute("staff_id"))
+	if userID == "" {
+		userID = strings.TrimSpace(identity.Attribute("user_id"))
+	}
+	if userID != "" {
+		out["user_id"] = userID
+	}
+	if v := strings.TrimSpace(identity.Attribute("open_conversation_id")); v != "" {
+		out["open_conversation_id"] = v
+	}
+	if v := strings.TrimSpace(identity.DisplayName); v != "" {
+		out["display_name"] = v
+	}
+	return out
+}
diff --git a/internal/channel/adapters/dingtalk/descriptor.go b/internal/channel/adapters/dingtalk/descriptor.go
new file mode 100644
index 00000000..2b9fcab1
--- /dev/null
+++ b/internal/channel/adapters/dingtalk/descriptor.go
@@ -0,0 +1,7 @@
+// Package dingtalk implements the DingTalk channel adapter.
+package dingtalk
+
+import "github.com/memohai/memoh/internal/channel"
+
+// Type is the registered ChannelType identifier for DingTalk.
+const Type channel.ChannelType = "dingtalk"
diff --git a/internal/channel/adapters/dingtalk/dingtalk.go b/internal/channel/adapters/dingtalk/dingtalk.go
new file mode 100644
index 00000000..44f13c26
--- /dev/null
+++ b/internal/channel/adapters/dingtalk/dingtalk.go
@@ -0,0 +1,447 @@
+package dingtalk
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log/slog"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/memohai/dingtalk-stream-sdk-go/chatbot"
+	dtsdk "github.com/memohai/dingtalk-stream-sdk-go/client"
+
+	"github.com/memohai/memoh/internal/channel"
+)
+
+// DingTalkAdapter implements the Memoh channel adapter for DingTalk bots.
+// It uses the DingTalk Stream SDK (WebSocket) for inbound messages and
+// the DingTalk OpenAPI (HTTP) for outbound messages.
+type DingTalkAdapter struct {
+	logger *slog.Logger
+
+	// mu guards the clients and apiClients maps.
+	mu         sync.RWMutex
+	clients    map[string]*dtsdk.StreamClient
+	apiClients map[string]*apiClient
+
+	// webhookCache stores recent sessionWebhook contexts keyed by msgId.
+	webhookCache *sessionWebhookCache
+}
+
+// NewDingTalkAdapter creates a new DingTalkAdapter.
+func NewDingTalkAdapter(log *slog.Logger) *DingTalkAdapter {
+	if log == nil {
+		log = slog.Default()
+	}
+	return &DingTalkAdapter{
+		logger:       log.With(slog.String("adapter", "dingtalk")),
+		clients:      make(map[string]*dtsdk.StreamClient),
+		apiClients:   make(map[string]*apiClient),
+		webhookCache: newSessionWebhookCache(30 * time.Minute),
+	}
+}
+
+// SetAssetOpener is a no-op placeholder to match the adapter registration pattern.
+func (*DingTalkAdapter) SetAssetOpener(_ any) {}
+
+func (*DingTalkAdapter) Type() channel.ChannelType { return Type }
+
+func (*DingTalkAdapter) Descriptor() channel.Descriptor {
+	return channel.Descriptor{
+		Type:        Type,
+		DisplayName: "DingTalk",
+		Capabilities: channel.ChannelCapabilities{
+			Text:           true,
+			Markdown:       true,
+			Attachments:    true,
+			Media:          true,
+			BlockStreaming: true,
+			// Reply is handled via session webhook (fast path in Send).
+			// The OpenAPI path silently ignores the reply context.
+			Reply:     true,
+			ChatTypes: []string{channel.ConversationTypePrivate, channel.ConversationTypeGroup},
+		},
+		ConfigSchema: channel.ConfigSchema{
+			Version: 1,
+			Fields: map[string]channel.FieldSchema{
+				"appKey":    {Type: channel.FieldString, Required: true, Title: "App Key (Client ID)"},
+				"appSecret": {Type: channel.FieldSecret, Required: true, Title: "App Secret (Client Secret)"},
+			},
+		},
+		UserConfigSchema: channel.ConfigSchema{
+			Version: 1,
+			Fields: map[string]channel.FieldSchema{
+				"user_id":              {Type: channel.FieldString, Title: "User ID (single chat)"},
+				"open_conversation_id": {Type: channel.FieldString, Title: "Open Conversation ID (group chat)"},
+				"display_name":         {Type: channel.FieldString, Title: "Display Name"},
+			},
+		},
+		TargetSpec: channel.TargetSpec{
+			Format: "user:{userId} | group:{openConversationId}",
+			Hints: []channel.TargetHint{
+				{Label: "User", Example: "user:user123"},
+				{Label: "Group", Example: "group:cidXXXXXXXX"},
+			},
+		},
+	}
+}
+
+// NormalizeConfig validates and normalizes a DingTalk channel config map.
+func (*DingTalkAdapter) NormalizeConfig(raw map[string]any) (map[string]any, error) {
+	return normalizeConfig(raw)
+}
+
+// NormalizeUserConfig validates and normalizes a DingTalk user binding config map.
+func (*DingTalkAdapter) NormalizeUserConfig(raw map[string]any) (map[string]any, error) {
+	return normalizeUserConfig(raw)
+}
+
+// NormalizeTarget normalizes a raw target string to canonical form.
+func (*DingTalkAdapter) NormalizeTarget(raw string) string { return normalizeTarget(raw) }
+
+// ResolveTarget converts a user config map to a canonical delivery target string.
+func (*DingTalkAdapter) ResolveTarget(userConfig map[string]any) (string, error) {
+	return resolveTarget(userConfig)
+}
+
+// MatchBinding checks whether a user binding config matches the given criteria.
+func (*DingTalkAdapter) MatchBinding(config map[string]any, criteria channel.BindingCriteria) bool {
+	return matchBinding(config, criteria)
+}
+
+// BuildUserConfig constructs a user config map from a channel Identity.
+func (*DingTalkAdapter) BuildUserConfig(identity channel.Identity) map[string]any {
+	return buildUserConfig(identity)
+}
+
+// DiscoverSelf retrieves the bot's own identity from DingTalk.
+// DiscoverSelf uses AppKey as the OpenAPI robotCode parameter (钉钉统一应用下二者一致)。
+func (a *DingTalkAdapter) DiscoverSelf(ctx context.Context, credentials map[string]any) (map[string]any, string, error) {
+	cfg, err := parseConfig(credentials)
+	if err != nil {
+		return nil, "", err
+	}
+	cli := newAPIClient(cfg.AppKey, cfg.AppSecret)
+	info, err := cli.getBotInfo(ctx, cfg.AppKey)
+	if err != nil {
+		a.logger.Warn("dingtalk: getBotInfo failed, using appKey as identity",
+			slog.String("app_key", cfg.AppKey),
+			slog.Any("error", err),
+		)
+		return map[string]any{"app_key": cfg.AppKey}, cfg.AppKey, nil
+	}
+	externalID := strings.TrimSpace(info.Result.RobotCode)
+	if externalID == "" {
+		externalID = cfg.AppKey
+	}
+	return map[string]any{
+		"app_key": cfg.AppKey,
+		"name":    strings.TrimSpace(info.Result.Name),
+	}, externalID, nil
+}
+
+// Connect establishes a DingTalk Stream WebSocket connection and begins receiving messages.
+func (a *DingTalkAdapter) Connect(ctx context.Context, cfg channel.ChannelConfig, handler channel.InboundHandler) (channel.Connection, error) {
+	parsed, err := parseConfig(cfg.Credentials)
+	if err != nil {
+		return nil, err
+	}
+
+	apiCli := newAPIClient(parsed.AppKey, parsed.AppSecret)
+
+	streamCli := dtsdk.NewStreamClient(
+		dtsdk.WithAppCredential(dtsdk.NewAppCredentialConfig(parsed.AppKey, parsed.AppSecret)),
+		dtsdk.WithAutoReconnect(true),
+	)
+
+	streamCli.RegisterChatBotCallbackRouter(a.newChatBotHandler(cfg, handler))
+
+	key := cfg.ID
+	a.mu.Lock()
+	a.clients[key] = streamCli
+	a.apiClients[key] = apiCli
+	a.mu.Unlock()
+
+	if err := streamCli.Start(ctx); err != nil {
+		a.mu.Lock()
+		delete(a.clients, key)
+		delete(a.apiClients, key)
+		a.mu.Unlock()
+		return nil, err
+	}
+
+	stop := func(context.Context) error {
+		// Disable reconnect before closing to prevent the reconnect loop from restarting.
+		streamCli.AutoReconnect = false
+		streamCli.Close()
+		a.mu.Lock()
+		if current, ok := a.clients[key]; ok && current == streamCli {
+			delete(a.clients, key)
+		}
+		delete(a.apiClients, key)
+		a.mu.Unlock()
+		return nil
+	}
+	return channel.NewConnection(cfg, stop), nil
+}
+
+// Send delivers an outbound message to a DingTalk user or group.
+// It first tries the session webhook (if cached and valid), then falls back to the OpenAPI.
+func (a *DingTalkAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg channel.PreparedOutboundMessage) error {
+	target := strings.TrimSpace(msg.Target)
+	if target == "" {
+		return errors.New("dingtalk: target is required")
+	}
+	logicalMsg := msg.Message.LogicalMessage()
+	if logicalMsg.IsEmpty() && len(msg.Message.Attachments) == 0 {
+		return errors.New("dingtalk: message is empty")
+	}
+
+	// Session webhook fast path: immediate reply without access_token round-trip.
+	// Webhooks only support text/markdown; attachments fall through to the OpenAPI.
+	if len(msg.Message.Attachments) == 0 {
+		if whCtx, ok := a.lookupWebhook(logicalMsg.Reply); ok && whCtx.isValid() {
+			body, bodyErr := buildWebhookBody(logicalMsg)
+			if bodyErr == nil {
+				apiCli := a.getOrNewAPIClient(cfg)
+				if webhookErr := apiCli.sendViaWebhook(ctx, whCtx.SessionWebhook, body); webhookErr == nil {
+					return nil
+				}
+				// Webhook failed (possibly expired mid-flight); fall through to OpenAPI.
+			}
+		}
+	}
+
+	return a.sendViaAPI(ctx, cfg, target, logicalMsg, msg.Message.Attachments)
+}
+
+// sendViaAPI sends a message through the DingTalk OpenAPI.
+func (a *DingTalkAdapter) sendViaAPI(
+	ctx context.Context,
+	cfg channel.ChannelConfig,
+	target string,
+	logicalMsg channel.Message,
+	prepared []channel.PreparedAttachment,
+) error {
+	parsed, err := parseConfig(cfg.Credentials)
+	if err != nil {
+		return err
+	}
+	apiCli := a.getOrNewAPIClient(cfg)
+
+	// For Upload-kind image attachments, upload to DingTalk media first to get a mediaId.
+	// DingTalk's sampleImageMsg requires a publicly accessible photoURL, which is unavailable
+	// when using local filesystem storage. Uploading converts the local asset to a platform mediaId.
+	resolved, err := resolveUploadAttachments(ctx, apiCli, prepared)
+	if err != nil {
+		return err
+	}
+
+	msgKey, msgParam, err := buildAPIPayload(logicalMsg, resolved)
+	if err != nil {
+		return err
+	}
+
+	kind, id, ok := parseTarget(target)
+	if !ok {
+		return errors.New("dingtalk: invalid target")
+	}
+	a.logger.Debug("dingtalk: sendViaAPI",
+		slog.String("target", target),
+		slog.String("kind", kind),
+		slog.String("id", id),
+		slog.String("robot_code", parsed.AppKey),
+	)
+	switch kind {
+	case "user":
+		return apiCli.sendToUser(ctx, parsed.AppKey, []string{id}, msgKey, msgParam)
+	case "group":
+		return apiCli.sendToGroup(ctx, parsed.AppKey, id, msgKey, msgParam)
+	default:
+		return errors.New("dingtalk: unknown target kind: " + kind)
+	}
+}
+
+// resolveUploadAttachments uploads any Upload-kind attachments to DingTalk and
+// returns a new slice where those entries are replaced by NativeRef attachments
+// carrying the resulting mediaId. PublicURL and NativeRef attachments pass through unchanged.
+func resolveUploadAttachments(
+	ctx context.Context,
+	apiCli *apiClient,
+	prepared []channel.PreparedAttachment,
+) ([]channel.PreparedAttachment, error) {
+	if len(prepared) == 0 {
+		return prepared, nil
+	}
+	result := make([]channel.PreparedAttachment, 0, len(prepared))
+	for _, att := range prepared {
+		if att.Kind != channel.PreparedAttachmentUpload || att.Open == nil {
+			result = append(result, att)
+			continue
+		}
+		mediaType := dingtalkMediaType(att)
+		reader, err := att.Open(ctx)
+		if err != nil {
+			return nil, fmt.Errorf("dingtalk: open attachment for upload: %w", err)
+		}
+		mediaID, uploadErr := apiCli.uploadMedia(ctx, mediaType, att.Name, reader)
+		_ = reader.Close()
+		if uploadErr != nil {
+			return nil, fmt.Errorf("dingtalk: upload media: %w", uploadErr)
+		}
+		uploaded := att
+		uploaded.Kind = channel.PreparedAttachmentNativeRef
+		uploaded.NativeRef = mediaID
+		uploaded.Open = nil
+		result = append(result, uploaded)
+	}
+	return result, nil
+}
+
+// dingtalkMediaType maps an attachment to the DingTalk media type string for upload.
+func dingtalkMediaType(att channel.PreparedAttachment) string {
+	switch att.Logical.Type {
+	case channel.AttachmentImage, channel.AttachmentGIF:
+		return "image"
+	case channel.AttachmentAudio, channel.AttachmentVoice:
+		return "voice"
+	case channel.AttachmentVideo:
+		return "video"
+	default:
+		return "file"
+	}
+}
+
+// ResolveAttachment implements channel.AttachmentResolver. It downloads a file
+// received by the bot (identified by its downloadCode stored in PlatformKey)
+// via the DingTalk OpenAPI and returns a readable payload.
+func (a *DingTalkAdapter) ResolveAttachment(ctx context.Context, cfg channel.ChannelConfig, att channel.Attachment) (channel.AttachmentPayload, error) {
+	downloadCode := strings.TrimSpace(att.PlatformKey)
+	if downloadCode == "" {
+		return channel.AttachmentPayload{}, errors.New("dingtalk: attachment has no downloadCode (platform_key)")
+	}
+	parsed, err := parseConfig(cfg.Credentials)
+	if err != nil {
+		return channel.AttachmentPayload{}, fmt.Errorf("dingtalk: resolve attachment config: %w", err)
+	}
+	apiCli := a.getOrNewAPIClient(cfg)
+	reader, mimeType, err := apiCli.downloadMessageFile(ctx, parsed.AppKey, downloadCode)
+	if err != nil {
+		return channel.AttachmentPayload{}, err
+	}
+	if strings.TrimSpace(att.Mime) != "" {
+		mimeType = strings.TrimSpace(att.Mime)
+	}
+	return channel.AttachmentPayload{
+		Reader: reader,
+		Mime:   mimeType,
+		Name:   strings.TrimSpace(att.Name),
+	}, nil
+}
+
+// OpenStream creates a new accumulating outbound stream for the given target.
+func (a *DingTalkAdapter) OpenStream(ctx context.Context, cfg channel.ChannelConfig, target string, opts channel.StreamOptions) (channel.PreparedOutboundStream, error) {
+	select {
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	default:
+	}
+	target = strings.TrimSpace(target)
+	if target == "" {
+		return nil, errors.New("dingtalk: target is required")
+	}
+	reply := opts.Reply
+	if reply == nil && strings.TrimSpace(opts.SourceMessageID) != "" {
+		reply = &channel.ReplyRef{
+			Target:    target,
+			MessageID: strings.TrimSpace(opts.SourceMessageID),
+		}
+	}
+	return &dingtalkOutboundStream{
+		adapter: a,
+		cfg:     cfg,
+		target:  target,
+		reply:   reply,
+	}, nil
+}
+
+// newChatBotHandler returns the DingTalk SDK chatbot callback for the given channel config.
+func (a *DingTalkAdapter) newChatBotHandler(cfg channel.ChannelConfig, handler channel.InboundHandler) chatbot.IChatBotMessageHandler {
+	return func(ctx context.Context, data *chatbot.BotCallbackDataModel) ([]byte, error) {
+		if data == nil {
+			return nil, nil
+		}
+
+		// Cache the session webhook so that Send can use the fast-reply path.
+		if strings.TrimSpace(data.MsgId) != "" && strings.TrimSpace(data.SessionWebhook) != "" {
+			a.rememberWebhook(data.MsgId, sessionWebhookContext{
+				SessionWebhook: data.SessionWebhook,
+				ExpiredTime:    data.SessionWebhookExpiredTime,
+				ConversationID: data.ConversationId,
+				SenderID:       data.SenderId,
+			})
+		}
+
+		a.logger.Debug("dingtalk: inbound callback",
+			slog.String("sender_id", data.SenderId),
+			slog.String("sender_staff_id", data.SenderStaffId),
+			slog.String("sender_corp_id", data.SenderCorpId),
+			slog.String("conversation_type", data.ConversationType),
+			slog.String("conversation_id", data.ConversationId),
+		)
+
+		if handler == nil {
+			return nil, nil
+		}
+		msg, ok := buildInboundMessage(data)
+		if !ok {
+			return nil, nil
+		}
+		msg.BotID = cfg.BotID
+		if err := handler(ctx, cfg, msg); err != nil {
+			a.logger.Error("dingtalk: inbound handler error",
+				slog.String("config_id", cfg.ID),
+				slog.Any("error", err),
+			)
+		}
+		return nil, nil
+	}
+}
+
+func (a *DingTalkAdapter) getOrNewAPIClient(cfg channel.ChannelConfig) *apiClient {
+	a.mu.RLock()
+	cli := a.apiClients[cfg.ID]
+	a.mu.RUnlock()
+	if cli != nil {
+		return cli
+	}
+	parsed, err := parseConfig(cfg.Credentials)
+	if err != nil {
+		return newAPIClient("", "")
+	}
+	return newAPIClient(parsed.AppKey, parsed.AppSecret)
+}
+
+func (a *DingTalkAdapter) lookupWebhook(reply *channel.ReplyRef) (sessionWebhookContext, bool) {
+	if reply == nil {
+		return sessionWebhookContext{}, false
+	}
+	msgID := strings.TrimSpace(reply.MessageID)
+	if msgID == "" {
+		return sessionWebhookContext{}, false
+	}
+	return a.webhookCache.get(msgID)
+}
+
+func (a *DingTalkAdapter) rememberWebhook(msgID string, whCtx sessionWebhookContext) {
+	msgID = strings.TrimSpace(msgID)
+	if msgID == "" || strings.TrimSpace(whCtx.SessionWebhook) == "" {
+		return
+	}
+	if whCtx.CreatedAt.IsZero() {
+		whCtx.CreatedAt = time.Now().UTC()
+	}
+	a.webhookCache.put(msgID, whCtx)
+}
diff --git a/internal/channel/adapters/dingtalk/inbound.go b/internal/channel/adapters/dingtalk/inbound.go
new file mode 100644
index 00000000..dba8b8cd
--- /dev/null
+++ b/internal/channel/adapters/dingtalk/inbound.go
@@ -0,0 +1,389 @@
+package dingtalk
+
+import (
+	"encoding/json"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/memohai/dingtalk-stream-sdk-go/chatbot"
+
+	"github.com/memohai/memoh/internal/channel"
+)
+
+// sessionWebhookContext holds a cached session webhook for a received message.
+type sessionWebhookContext struct {
+	SessionWebhook string
+	ExpiredTime    int64 // unix milliseconds; 0 means never set
+	ConversationID string
+	SenderID       string
+	CreatedAt      time.Time
+}
+
+// isValid reports whether the session webhook is still within its validity window.
+func (w sessionWebhookContext) isValid() bool {
+	if strings.TrimSpace(w.SessionWebhook) == "" {
+		return false
+	}
+	if w.ExpiredTime <= 0 {
+		return false
+	}
+	return time.Now().UnixMilli() < w.ExpiredTime
+}
+
+// sessionWebhookCache stores recent sessionWebhook contexts keyed by msgId.
+type sessionWebhookCache struct {
+	mu    sync.RWMutex
+	items map[string]sessionWebhookContext
+	ttl   time.Duration
+}
+
+func newSessionWebhookCache(ttl time.Duration) *sessionWebhookCache {
+	if ttl <= 0 {
+		ttl = 30 * time.Minute
+	}
+	return &sessionWebhookCache{
+		items: make(map[string]sessionWebhookContext),
+		ttl:   ttl,
+	}
+}
+
+func (c *sessionWebhookCache) put(msgID string, ctx sessionWebhookContext) {
+	key := strings.TrimSpace(msgID)
+	if key == "" {
+		return
+	}
+	if ctx.CreatedAt.IsZero() {
+		ctx.CreatedAt = time.Now().UTC()
+	}
+	c.mu.Lock()
+	c.items[key] = ctx
+	c.gcLocked()
+	c.mu.Unlock()
+}
+
+func (c *sessionWebhookCache) get(msgID string) (sessionWebhookContext, bool) {
+	key := strings.TrimSpace(msgID)
+	if key == "" {
+		return sessionWebhookContext{}, false
+	}
+	c.mu.RLock()
+	item, ok := c.items[key]
+	c.mu.RUnlock()
+	if !ok {
+		return sessionWebhookContext{}, false
+	}
+	if time.Since(item.CreatedAt) > c.ttl {
+		c.mu.Lock()
+		delete(c.items, key)
+		c.mu.Unlock()
+		return sessionWebhookContext{}, false
+	}
+	return item, true
+}
+
+func (c *sessionWebhookCache) gcLocked() {
+	if len(c.items) < 512 {
+		return
+	}
+	now := time.Now().UTC()
+	for key, item := range c.items {
+		if now.Sub(item.CreatedAt) > c.ttl {
+			delete(c.items, key)
+		}
+	}
+}
+
+// richTextItem is an element within a DingTalk richText message payload.
+type richTextItem struct {
+	Type         string `json:"type"`
+	Text         string `json:"text,omitempty"`
+	DownloadCode string `json:"downloadCode,omitempty"`
+	Width        int    `json:"width,omitempty"`
+	Height       int    `json:"height,omitempty"`
+}
+
+// pictureContent is the payload for msgtype="picture".
+type pictureContent struct {
+	DownloadCode string `json:"downloadCode"`
+	Width        int    `json:"width,omitempty"`
+	Height       int    `json:"height,omitempty"`
+}
+
+// fileContent is the payload for msgtype="file".
+type fileContent struct {
+	DownloadCode string `json:"downloadCode"`
+	FileName     string `json:"fileName,omitempty"`
+	FileSize     string `json:"fileSize,omitempty"`
+	FileType     string `json:"fileType,omitempty"`
+}
+
+// audioContent is the payload for msgtype="audio".
+type audioContent struct {
+	DownloadCode string `json:"downloadCode,omitempty"`
+	Duration     int    `json:"duration,omitempty"`
+	Recognition  string `json:"recognition,omitempty"`
+}
+
+// videoContent is the payload for msgtype="video".
+type videoContent struct {
+	VideoMediaId string `json:"videoMediaId"`
+	Duration     int    `json:"duration,omitempty"`
+	VideoType    string `json:"videoType,omitempty"`
+}
+
+// buildInboundMessage converts a DingTalk BotCallbackDataModel to a channel.InboundMessage.
+// Returns false when the message should be silently ignored (e.g. empty content).
+func buildInboundMessage(data *chatbot.BotCallbackDataModel) (channel.InboundMessage, bool) {
+	text, format, attachments := extractContent(data)
+	if strings.TrimSpace(text) == "" && len(attachments) == 0 {
+		return channel.InboundMessage{}, false
+	}
+
+	convType := normalizeDingTalkConversationType(data.ConversationType)
+	convID := strings.TrimSpace(data.ConversationId)
+	if convID == "" {
+		convID = strings.TrimSpace(data.SenderId)
+	}
+
+	// ReplyTarget: for private chat prefer senderStaffId (required by DingTalk OpenAPI),
+	// falling back to senderId (works for session webhook but may be unionId in ISV apps).
+	// For group chat use group:{conversationId}.
+	replyTarget := buildReplyTarget(convType, data.ConversationId, data.SenderId, data.SenderStaffId)
+
+	// Sanitize @ mentions from text body (DingTalk prepends "@botNick " in group messages).
+	if strings.TrimSpace(text) != "" {
+		text = strings.TrimSpace(text)
+	}
+
+	// Use staffId as SubjectID when available: it is the stable employee identifier
+	// accepted by the DingTalk OpenAPI. senderId may be a unionId ($:LWCP_v1:$...)
+	// which the batchSend API rejects with "staffId.notExisted".
+	senderID := strings.TrimSpace(data.SenderId)
+	staffID := strings.TrimSpace(data.SenderStaffId)
+	subjectID := staffID
+	if subjectID == "" {
+		subjectID = senderID
+	}
+
+	return channel.InboundMessage{
+		Channel: Type,
+		Message: channel.Message{
+			ID:          strings.TrimSpace(data.MsgId),
+			Format:      format,
+			Text:        text,
+			Attachments: attachments,
+		},
+		ReplyTarget: replyTarget,
+		Sender: channel.Identity{
+			SubjectID:   subjectID,
+			DisplayName: strings.TrimSpace(data.SenderNick),
+			Attributes: map[string]string{
+				"user_id":         senderID,
+				"staff_id":        staffID,
+				"corp_id":         strings.TrimSpace(data.SenderCorpId),
+				"chatbot_user_id": strings.TrimSpace(data.ChatbotUserId),
+			},
+		},
+		Conversation: channel.Conversation{
+			ID:   convID,
+			Type: convType,
+			Name: strings.TrimSpace(data.ConversationTitle),
+			Metadata: map[string]any{
+				"open_conversation_id": strings.TrimSpace(data.ConversationId),
+			},
+		},
+		ReceivedAt: parseCreateAt(data.CreateAt),
+		Source:     "dingtalk",
+		Metadata: map[string]any{
+			"msg_id":              strings.TrimSpace(data.MsgId),
+			"conversation_id":     strings.TrimSpace(data.ConversationId),
+			"conversation_type":   strings.TrimSpace(data.ConversationType),
+			"chatbot_corp_id":     strings.TrimSpace(data.ChatbotCorpId),
+			"is_admin":            data.IsAdmin,
+			"session_webhook":     strings.TrimSpace(data.SessionWebhook),
+			"session_webhook_exp": data.SessionWebhookExpiredTime,
+		},
+	}, true
+}
+
+// extractContent parses the msgtype-specific payload and returns text, format, and attachments.
+func extractContent(data *chatbot.BotCallbackDataModel) (string, channel.MessageFormat, []channel.Attachment) {
+	msgtype := strings.ToLower(strings.TrimSpace(data.Msgtype))
+	switch msgtype {
+	case "text":
+		return strings.TrimSpace(data.Text.Content), channel.MessageFormatPlain, nil
+
+	case "markdown":
+		content := extractStringField(data.Content, "text")
+		if content == "" {
+			content = strings.TrimSpace(data.Text.Content)
+		}
+		return content, channel.MessageFormatMarkdown, nil
+
+	case "picture", "image":
+		raw, _ := json.Marshal(data.Content)
+		var pic pictureContent
+		if err := json.Unmarshal(raw, &pic); err != nil || strings.TrimSpace(pic.DownloadCode) == "" {
+			return "", channel.MessageFormatPlain, nil
+		}
+		att := channel.Attachment{
+			Type:           channel.AttachmentImage,
+			PlatformKey:    strings.TrimSpace(pic.DownloadCode),
+			SourcePlatform: Type.String(),
+			Width:          pic.Width,
+			Height:         pic.Height,
+		}
+		return "", channel.MessageFormatPlain, []channel.Attachment{channel.NormalizeInboundChannelAttachment(att)}
+
+	case "file":
+		raw, _ := json.Marshal(data.Content)
+		var f fileContent
+		if err := json.Unmarshal(raw, &f); err != nil || strings.TrimSpace(f.DownloadCode) == "" {
+			return "", channel.MessageFormatPlain, nil
+		}
+		att := channel.Attachment{
+			Type:           channel.AttachmentFile,
+			PlatformKey:    strings.TrimSpace(f.DownloadCode),
+			SourcePlatform: Type.String(),
+			Name:           strings.TrimSpace(f.FileName),
+		}
+		return "", channel.MessageFormatPlain, []channel.Attachment{channel.NormalizeInboundChannelAttachment(att)}
+
+	case "audio", "voice":
+		raw, _ := json.Marshal(data.Content)
+		var a audioContent
+		_ = json.Unmarshal(raw, &a)
+		// Prefer voice-recognition text; fall back to attachment if code present.
+		if rec := strings.TrimSpace(a.Recognition); rec != "" {
+			return rec, channel.MessageFormatPlain, nil
+		}
+		if code := strings.TrimSpace(a.DownloadCode); code != "" {
+			att := channel.Attachment{
+				Type:           channel.AttachmentVoice,
+				PlatformKey:    code,
+				SourcePlatform: Type.String(),
+				DurationMs:     int64(a.Duration) * 1000,
+			}
+			return "", channel.MessageFormatPlain, []channel.Attachment{channel.NormalizeInboundChannelAttachment(att)}
+		}
+		return "", channel.MessageFormatPlain, nil
+
+	case "video":
+		raw, _ := json.Marshal(data.Content)
+		var v videoContent
+		if err := json.Unmarshal(raw, &v); err != nil || strings.TrimSpace(v.VideoMediaId) == "" {
+			return "", channel.MessageFormatPlain, nil
+		}
+		att := channel.Attachment{
+			Type:           channel.AttachmentVideo,
+			PlatformKey:    strings.TrimSpace(v.VideoMediaId),
+			SourcePlatform: Type.String(),
+			DurationMs:     int64(v.Duration) * 1000,
+		}
+		return "", channel.MessageFormatPlain, []channel.Attachment{channel.NormalizeInboundChannelAttachment(att)}
+
+	case "richtext":
+		return extractRichText(data.Content)
+
+	default:
+		// Try to extract a text field from Content as a best-effort fallback.
+		if text := extractStringField(data.Content, "content", "text"); text != "" {
+			return text, channel.MessageFormatPlain, nil
+		}
+		return "", channel.MessageFormatPlain, nil
+	}
+}
+
+// extractRichText parses a richText message content into text and attachments.
+func extractRichText(raw any) (string, channel.MessageFormat, []channel.Attachment) {
+	rawJSON, _ := json.Marshal(raw)
+	var payload struct {
+		RichText []richTextItem `json:"richText"`
+	}
+	if err := json.Unmarshal(rawJSON, &payload); err != nil {
+		return "", channel.MessageFormatPlain, nil
+	}
+	var textParts []string
+	var attachments []channel.Attachment
+	for _, item := range payload.RichText {
+		switch strings.ToLower(strings.TrimSpace(item.Type)) {
+		case "text":
+			if v := strings.TrimSpace(item.Text); v != "" {
+				textParts = append(textParts, v)
+			}
+		case "picture", "image":
+			if code := strings.TrimSpace(item.DownloadCode); code != "" {
+				att := channel.Attachment{
+					Type:           channel.AttachmentImage,
+					PlatformKey:    code,
+					SourcePlatform: Type.String(),
+					Width:          item.Width,
+					Height:         item.Height,
+				}
+				attachments = append(attachments, channel.NormalizeInboundChannelAttachment(att))
+			}
+		}
+	}
+	return strings.Join(textParts, "\n"), channel.MessageFormatPlain, attachments
+}
+
+// extractStringField attempts to read a string value from an interface{} map by trying keys in order.
+func extractStringField(raw any, keys ...string) string {
+	m, ok := raw.(map[string]any)
+	if !ok {
+		// Try JSON round-trip for non-map types.
+		b, err := json.Marshal(raw)
+		if err != nil {
+			return ""
+		}
+		if err := json.Unmarshal(b, &m); err != nil {
+			return ""
+		}
+	}
+	for _, key := range keys {
+		if v, ok := m[key]; ok {
+			if s, ok := v.(string); ok {
+				return strings.TrimSpace(s)
+			}
+		}
+	}
+	return ""
+}
+
+// normalizeDingTalkConversationType maps DingTalk conversationType values to Memoh constants.
+// "1" = single/private; "2" = group.
+func normalizeDingTalkConversationType(raw string) string {
+	switch strings.TrimSpace(raw) {
+	case "2", "group":
+		return channel.ConversationTypeGroup
+	default:
+		return channel.ConversationTypePrivate
+	}
+}
+
+// buildReplyTarget produces the canonical reply target for a DingTalk inbound message.
+// For private chat, staffID is preferred over senderID because the DingTalk OpenAPI's
+// batchSend endpoint requires the staffId, while senderId may be a unionId in ISV apps.
+func buildReplyTarget(convType, conversationID, senderID, staffID string) string {
+	if channel.IsPrivateConversationType(convType) {
+		if v := strings.TrimSpace(staffID); v != "" {
+			return "user:" + v
+		}
+		if v := strings.TrimSpace(senderID); v != "" {
+			return "user:" + v
+		}
+	}
+	if v := strings.TrimSpace(conversationID); v != "" {
+		return "group:" + v
+	}
+	return ""
+}
+
+// parseCreateAt converts a DingTalk createAt unix millisecond timestamp to time.Time.
+func parseCreateAt(ms int64) time.Time {
+	if ms <= 0 {
+		return time.Now().UTC()
+	}
+	return time.UnixMilli(ms).UTC()
+}
diff --git a/internal/channel/adapters/dingtalk/outbound.go b/internal/channel/adapters/dingtalk/outbound.go
new file mode 100644
index 00000000..a78bf1dd
--- /dev/null
+++ b/internal/channel/adapters/dingtalk/outbound.go
@@ -0,0 +1,200 @@
+package dingtalk
+
+import (
+	"encoding/json"
+	"errors"
+	"strings"
+
+	"github.com/memohai/memoh/internal/channel"
+)
+
+// buildAPIPayload converts a channel.Message and its prepared attachments to a DingTalk
+// OpenAPI msgKey + msgParam pair. Markdown messages map to sampleMarkdown; all others fall
+// back to sampleText. Attachments map to the corresponding DingTalk media message type.
+//
+// prepared is the adapter-facing attachment list; it is used to get the correct public URL
+// or native ref rather than the local media-store access path stored in the logical message.
+func buildAPIPayload(msg channel.Message, prepared []channel.PreparedAttachment) (msgKey, msgParam string, err error) {
+	// Attachment-only message: use the first attachment to determine message type.
+	if strings.TrimSpace(msg.PlainText()) == "" && len(prepared) > 0 {
+		return buildAttachmentPayload(prepared[0])
+	}
+
+	text := strings.TrimSpace(msg.PlainText())
+	if text == "" {
+		return "", "", errors.New("dingtalk: outbound message text is empty")
+	}
+
+	if msg.Format == channel.MessageFormatMarkdown {
+		return buildMarkdownAPIPayload(text)
+	}
+	return buildTextAPIPayload(text)
+}
+
+func buildTextAPIPayload(text string) (string, string, error) {
+	param, _ := json.Marshal(map[string]string{"content": text})
+	return "sampleText", string(param), nil
+}
+
+func buildMarkdownAPIPayload(text string) (string, string, error) {
+	param, _ := json.Marshal(map[string]string{
+		"title": extractMarkdownTitle(text),
+		"text":  text,
+	})
+	return "sampleMarkdown", string(param), nil
+}
+
+// buildAttachmentPayload converts a PreparedAttachment to a DingTalk API message.
+//
+// Images/GIF: photoURL accepts either a public HTTP URL or a DingTalk mediaId
+// (returned by the media upload API). resolveUploadAttachments pre-uploads local
+// assets and converts Upload kind to NativeRef before this function is called,
+// so here NativeRef carries a valid mediaId for all attachment types.
+func buildAttachmentPayload(att channel.PreparedAttachment) (string, string, error) {
+	logical := att.Logical
+
+	switch logical.Type {
+	case channel.AttachmentImage, channel.AttachmentGIF:
+		var photoURL string
+		switch att.Kind {
+		case channel.PreparedAttachmentPublicURL:
+			photoURL = att.PublicURL
+		case channel.PreparedAttachmentNativeRef:
+			// mediaId returned by DingTalk upload API is accepted as photoURL value.
+			photoURL = att.NativeRef
+		default:
+			// Upload kind should have been resolved to NativeRef by resolveUploadAttachments.
+			// Fallback: use logical URL only if it looks like a public HTTP URL.
+			if u := strings.TrimSpace(logical.URL); strings.HasPrefix(strings.ToLower(u), "http") {
+				photoURL = u
+			}
+		}
+		if photoURL == "" {
+			return "", "", errors.New("dingtalk: image attachment requires a publicly accessible URL or uploaded mediaId")
+		}
+		param, _ := json.Marshal(map[string]string{"photoURL": photoURL})
+		return "sampleImageMsg", string(param), nil
+
+	case channel.AttachmentFile:
+		mediaID := strings.TrimSpace(att.NativeRef)
+		if mediaID == "" {
+			mediaID = strings.TrimSpace(logical.PlatformKey)
+		}
+		fileType := resolveFileType(logical)
+		param, _ := json.Marshal(map[string]string{
+			"mediaId":  mediaID,
+			"fileName": strings.TrimSpace(logical.Name),
+			"fileType": fileType,
+		})
+		return "sampleFile", string(param), nil
+
+	case channel.AttachmentAudio, channel.AttachmentVoice:
+		mediaID := strings.TrimSpace(att.NativeRef)
+		if mediaID == "" {
+			mediaID = strings.TrimSpace(logical.PlatformKey)
+		}
+		param, _ := json.Marshal(map[string]string{
+			"mediaId":  mediaID,
+			"duration": "0",
+		})
+		return "sampleAudio", string(param), nil
+
+	case channel.AttachmentVideo:
+		mediaID := strings.TrimSpace(att.NativeRef)
+		if mediaID == "" {
+			mediaID = strings.TrimSpace(logical.PlatformKey)
+		}
+		param, _ := json.Marshal(map[string]string{
+			"mediaId":   mediaID,
+			"videoType": "mp4",
+		})
+		return "sampleVideo", string(param), nil
+
+	default:
+		return "", "", errors.New("dingtalk: unsupported attachment type for outbound")
+	}
+}
+
+// buildWebhookBody converts a channel.Message to a DingTalk session webhook payload.
+// session webhook uses msgtype/text style instead of msgKey/msgParam.
+func buildWebhookBody(msg channel.Message) (map[string]any, error) {
+	if strings.TrimSpace(msg.PlainText()) == "" && len(msg.Attachments) > 0 {
+		// Webhooks only support text and markdown; fall back to text describing the attachment.
+		return map[string]any{
+			"msgtype": "text",
+			"text": map[string]string{
+				"content": "[attachment]",
+			},
+		}, nil
+	}
+
+	text := strings.TrimSpace(msg.PlainText())
+	if text == "" {
+		return nil, errors.New("dingtalk: webhook message text is empty")
+	}
+
+	if msg.Format == channel.MessageFormatMarkdown {
+		return map[string]any{
+			"msgtype": "markdown",
+			"markdown": map[string]string{
+				"title": extractMarkdownTitle(text),
+				"text":  text,
+			},
+		}, nil
+	}
+	return map[string]any{
+		"msgtype": "text",
+		"text": map[string]string{
+			"content": text,
+		},
+	}, nil
+}
+
+// extractMarkdownTitle tries to extract the first heading from markdown text.
+// Falls back to "消息" if no heading is present.
+func extractMarkdownTitle(text string) string {
+	for _, line := range strings.SplitN(text, "\n", 5) {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "#") {
+			title := strings.TrimLeft(trimmed, "# ")
+			if t := strings.TrimSpace(title); t != "" {
+				if len([]rune(t)) > 20 {
+					r := []rune(t)
+					return string(r[:20])
+				}
+				return t
+			}
+		}
+	}
+	return "消息"
+}
+
+// resolveFileType returns a DingTalk-compatible file type string for file attachments.
+func resolveFileType(att channel.Attachment) string {
+	if ext := fileExtFromName(att.Name); ext != "" {
+		return ext
+	}
+	switch att.Type {
+	case channel.AttachmentImage:
+		return "jpg"
+	case channel.AttachmentVideo:
+		return "mp4"
+	case channel.AttachmentAudio, channel.AttachmentVoice:
+		return "mp3"
+	default:
+		return "doc"
+	}
+}
+
+// fileExtFromName extracts a lowercase extension (without the dot) from a filename.
+func fileExtFromName(name string) string {
+	name = strings.TrimSpace(name)
+	if name == "" {
+		return ""
+	}
+	idx := strings.LastIndex(name, ".")
+	if idx < 0 || idx == len(name)-1 {
+		return ""
+	}
+	return strings.ToLower(name[idx+1:])
+}
diff --git a/internal/channel/adapters/dingtalk/stream.go b/internal/channel/adapters/dingtalk/stream.go
new file mode 100644
index 00000000..17a524a6
--- /dev/null
+++ b/internal/channel/adapters/dingtalk/stream.go
@@ -0,0 +1,153 @@
+package dingtalk
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"sync"
+	"sync/atomic"
+
+	"github.com/memohai/memoh/internal/channel"
+)
+
+// dingtalkOutboundStream accumulates streaming events and flushes the final message
+// to DingTalk when closed. DingTalk has no native streaming API, so the stream
+// is buffered and sent as a single message on Close.
+type dingtalkOutboundStream struct {
+	adapter *DingTalkAdapter
+	cfg     channel.ChannelConfig
+	target  string
+	reply   *channel.ReplyRef
+
+	mu          sync.Mutex
+	closed      atomic.Bool
+	finalSent   atomic.Bool
+	textBuilder strings.Builder
+	attachments []channel.PreparedAttachment
+	final       *channel.PreparedMessage
+}
+
+func (s *dingtalkOutboundStream) Push(ctx context.Context, event channel.PreparedStreamEvent) error {
+	if s.closed.Load() {
+		return errors.New("dingtalk stream is closed")
+	}
+	if s.finalSent.Load() {
+		return nil
+	}
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+	}
+
+	switch event.Type {
+	case channel.StreamEventStatus,
+		channel.StreamEventPhaseStart,
+		channel.StreamEventPhaseEnd,
+		channel.StreamEventToolCallStart,
+		channel.StreamEventToolCallEnd,
+		channel.StreamEventAgentStart,
+		channel.StreamEventAgentEnd,
+		channel.StreamEventProcessingStarted,
+		channel.StreamEventProcessingCompleted,
+		channel.StreamEventProcessingFailed:
+		// Non-content events: no-op.
+		return nil
+
+	case channel.StreamEventDelta:
+		if strings.TrimSpace(event.Delta) == "" || event.Phase == channel.StreamPhaseReasoning {
+			return nil
+		}
+		s.mu.Lock()
+		s.textBuilder.WriteString(event.Delta)
+		s.mu.Unlock()
+		return nil
+
+	case channel.StreamEventAttachment:
+		if len(event.Attachments) == 0 {
+			return nil
+		}
+		s.mu.Lock()
+		s.attachments = append(s.attachments, event.Attachments...)
+		s.mu.Unlock()
+		return nil
+
+	case channel.StreamEventFinal:
+		if event.Final == nil {
+			return nil
+		}
+		s.mu.Lock()
+		final := event.Final.Message
+		s.final = &final
+		s.mu.Unlock()
+		return s.flush(ctx)
+
+	case channel.StreamEventError:
+		text := strings.TrimSpace(event.Error)
+		if text == "" {
+			return nil
+		}
+		s.mu.Lock()
+		s.final = &channel.PreparedMessage{
+			Message: channel.Message{Format: channel.MessageFormatPlain, Text: "Error: " + text},
+		}
+		s.mu.Unlock()
+		return s.flush(ctx)
+	}
+	return nil
+}
+
+func (s *dingtalkOutboundStream) Close(ctx context.Context) error {
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	default:
+	}
+	s.closed.Store(true)
+	if s.finalSent.Load() {
+		return nil
+	}
+	return s.flush(ctx)
+}
+
+func (s *dingtalkOutboundStream) flush(ctx context.Context) error {
+	if s.finalSent.Load() {
+		return nil
+	}
+	prepared := s.snapshotPrepared()
+	if prepared.Message.IsEmpty() && len(prepared.Attachments) == 0 {
+		return nil
+	}
+	if err := s.adapter.Send(ctx, s.cfg, channel.PreparedOutboundMessage{
+		Target:  s.target,
+		Message: prepared,
+	}); err != nil {
+		return err
+	}
+	s.finalSent.Store(true)
+	return nil
+}
+
+func (s *dingtalkOutboundStream) snapshotPrepared() channel.PreparedMessage {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	var prepared channel.PreparedMessage
+	if s.final != nil {
+		prepared = *s.final
+	}
+	if strings.TrimSpace(prepared.Message.Text) == "" {
+		prepared.Message.Text = strings.TrimSpace(s.textBuilder.String())
+	}
+	if len(prepared.Attachments) == 0 && len(s.attachments) > 0 {
+		prepared.Attachments = append(prepared.Attachments, s.attachments...)
+		prepared.Message.Attachments = make([]channel.Attachment, 0, len(s.attachments))
+		for _, att := range s.attachments {
+			prepared.Message.Attachments = append(prepared.Message.Attachments, att.Logical)
+		}
+	}
+	if prepared.Message.Reply == nil && s.reply != nil {
+		prepared.Message.Reply = s.reply
+	}
+	return prepared
+}
diff --git a/internal/channel/adapters/discord/discord.go b/internal/channel/adapters/discord/discord.go
index c1fafebb..4d47dba9 100644
--- a/internal/channel/adapters/discord/discord.go
+++ b/internal/channel/adapters/discord/discord.go
@@ -3,12 +3,10 @@ package discord
 import (
 	"bytes"
 	"context"
-	"encoding/base64"
 	"errors"
 	"fmt"
 	"io"
 	"log/slog"
-	"net/http"
 	"strings"
 	"sync"
 	"time"
@@ -269,7 +267,7 @@ func (a *DiscordAdapter) Connect(ctx context.Context, cfg channel.ChannelConfig,
 	return channel.NewConnection(cfg, stop), nil
 }
 
-func (a *DiscordAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg channel.OutboundMessage) error {
+func (a *DiscordAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg channel.PreparedOutboundMessage) error {
 	discordCfg, err := parseConfig(cfg.Credentials)
 	if err != nil {
 		return err
@@ -284,28 +282,21 @@ func (a *DiscordAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, ms
 	if channelID == "" {
 		return errors.New("discord target is required")
 	}
-
-	// Get botID from config metadata if available
-	botID := ""
-	if cfg.BotID != "" {
-		botID = cfg.BotID
-	}
-
-	return a.sendDiscordMessage(ctx, session, channelID, botID, msg)
+	return sendDiscordMessage(ctx, session, channelID, msg)
 }
 
-func (a *DiscordAdapter) sendDiscordMessage(ctx context.Context, session *discordgo.Session, channelID, _ string, msg channel.OutboundMessage) error {
-	content := truncateDiscordText(msg.Message.Text)
+func sendDiscordMessage(ctx context.Context, session *discordgo.Session, channelID string, msg channel.PreparedOutboundMessage) error {
+	content := truncateDiscordText(msg.Message.Message.Text)
 
 	// Build message send parameters
 	messageSend := &discordgo.MessageSend{
 		Content: content,
 	}
 
-	if msg.Message.Reply != nil && msg.Message.Reply.MessageID != "" {
+	if msg.Message.Message.Reply != nil && msg.Message.Message.Reply.MessageID != "" {
 		messageSend.Reference = &discordgo.MessageReference{
 			ChannelID: channelID,
-			MessageID: msg.Message.Reply.MessageID,
+			MessageID: msg.Message.Message.Reply.MessageID,
 		}
 	}
 
@@ -313,10 +304,11 @@ func (a *DiscordAdapter) sendDiscordMessage(ctx context.Context, session *discor
 	if len(msg.Message.Attachments) > 0 {
 		files := make([]*discordgo.File, 0, len(msg.Message.Attachments))
 		for _, att := range msg.Message.Attachments {
-			file := discordAttachmentToFile(ctx, att, a.assets)
-			if file != nil {
-				files = append(files, file)
+			file, err := discordPreparedAttachmentToFile(ctx, att)
+			if err != nil {
+				return err
 			}
+			files = append(files, file)
 		}
 		messageSend.Files = files
 
@@ -343,8 +335,8 @@ func truncateDiscordText(text string) string {
 	return string(runes[:discordMaxLength-3]) + "..."
 }
 
-// discordAttachmentToFile converts a channel attachment to discordgo.File.
-func discordAttachmentToFile(ctx context.Context, att channel.Attachment, opener assetOpener) *discordgo.File {
+// discordPreparedAttachmentToFile converts a prepared attachment to discordgo.File.
+func discordPreparedAttachmentToFile(ctx context.Context, att channel.PreparedAttachment) (*discordgo.File, error) {
 	// Get file name
 	name := att.Name
 	if name == "" {
@@ -355,73 +347,25 @@ func discordAttachmentToFile(ctx context.Context, att channel.Attachment, opener
 		}
 	}
 
-	var reader io.Reader
-
-	// Prefer bot_id from attachment metadata (allows cross-bot file forwarding)
-	var botID string
-	if att.Metadata != nil {
-		if bid, ok := att.Metadata["bot_id"].(string); ok && bid != "" {
-			botID = bid
-		}
+	if att.Kind != channel.PreparedAttachmentUpload {
+		return nil, fmt.Errorf("discord attachment requires upload source, got %s", att.Kind)
 	}
-
-	// Try asset opener first (for ContentHash from media store)
-	if att.ContentHash != "" && botID != "" && opener != nil {
-		if rc, _, err := opener.Open(ctx, botID, att.ContentHash); err == nil {
-			data, _ := io.ReadAll(rc)
-			_ = rc.Close()
-			if len(data) > 0 {
-				reader = bytes.NewReader(data)
-			}
-		}
+	if att.Open == nil {
+		return nil, errors.New("discord attachment upload is not openable")
 	}
-
-	// Fallback to Base64
-	if reader == nil && att.Base64 != "" {
-		data, err := base64DataURLToBytes(att.Base64)
-		if err == nil {
-			reader = bytes.NewReader(data)
-		}
+	reader, err := att.Open(ctx)
+	if err != nil {
+		return nil, err
 	}
-
-	// Fallback to data URL in URL field (e.g. TTS voice when media ingestion failed)
-	if reader == nil && att.URL != "" && strings.HasPrefix(strings.ToLower(strings.TrimSpace(att.URL)), "data:") {
-		data, err := base64DataURLToBytes(att.URL)
-		if err == nil {
-			reader = bytes.NewReader(data)
-		}
+	defer func() { _ = reader.Close() }()
+	data, err := media.ReadAllWithLimit(reader, media.MaxAssetBytes)
+	if err != nil {
+		return nil, err
 	}
-
-	// Fallback to HTTP URL
-	if reader == nil && att.URL != "" {
-		req, err := http.NewRequestWithContext(ctx, http.MethodGet, att.URL, nil)
-		if err == nil {
-			resp, doErr := http.DefaultClient.Do(req) //nolint:gosec // G704: URL is a Discord attachment URL received from the Discord API
-			if doErr == nil {
-				defer func() { _ = resp.Body.Close() }()
-				data, _ := io.ReadAll(resp.Body)
-				reader = bytes.NewReader(data)
-			}
-		}
-	}
-
-	if reader == nil {
-		return nil
-	}
-
 	return &discordgo.File{
 		Name:   name,
-		Reader: reader,
-	}
-}
-
-// base64DataURLToBytes decodes a base64 data URL to bytes.
-func base64DataURLToBytes(dataURL string) ([]byte, error) {
-	parts := strings.SplitN(dataURL, ",", 2)
-	if len(parts) != 2 {
-		return nil, errors.New("invalid data URL")
-	}
-	return base64.StdEncoding.DecodeString(parts[1])
+		Reader: bytes.NewReader(data),
+	}, nil
 }
 
 // mimeExtension returns file extension for common mime types.
@@ -454,7 +398,7 @@ func mimeExtension(mime string) string {
 	}
 }
 
-func (a *DiscordAdapter) OpenStream(_ context.Context, cfg channel.ChannelConfig, target string, opts channel.StreamOptions) (channel.OutboundStream, error) {
+func (a *DiscordAdapter) OpenStream(_ context.Context, cfg channel.ChannelConfig, target string, opts channel.StreamOptions) (channel.PreparedOutboundStream, error) {
 	target = strings.TrimSpace(target)
 	if target == "" {
 		return nil, errors.New("discord target is required")
diff --git a/internal/channel/adapters/discord/discord_test.go b/internal/channel/adapters/discord/discord_test.go
index 5009cbe7..d5b04081 100644
--- a/internal/channel/adapters/discord/discord_test.go
+++ b/internal/channel/adapters/discord/discord_test.go
@@ -1,7 +1,12 @@
 package discord
 
 import (
+	"context"
+	"io"
+	"strings"
 	"testing"
+
+	"github.com/memohai/memoh/internal/channel"
 )
 
 func TestMimeExtension(t *testing.T) {
@@ -28,19 +33,30 @@ func TestMimeExtension(t *testing.T) {
 	}
 }
 
-func TestBase64DataURLToBytes(t *testing.T) {
-	// Test valid data URL
-	data, err := base64DataURLToBytes("data:text/plain;base64,SGVsbG8=")
+func TestDiscordPreparedAttachmentToFile(t *testing.T) {
+	file, err := discordPreparedAttachmentToFile(context.Background(), channel.PreparedAttachment{
+		Logical: channel.Attachment{Type: channel.AttachmentFile},
+		Kind:    channel.PreparedAttachmentUpload,
+		Name:    "hello.txt",
+		Open: func(context.Context) (io.ReadCloser, error) {
+			return io.NopCloser(strings.NewReader("Hello")), nil
+		},
+	})
 	if err != nil {
-		t.Errorf("base64DataURLToBytes() error = %v", err)
+		t.Fatalf("discordPreparedAttachmentToFile() error = %v", err)
+	}
+	data, err := io.ReadAll(file.Reader)
+	if err != nil {
+		t.Fatalf("read prepared file: %v", err)
 	}
 	if string(data) != "Hello" {
-		t.Errorf("base64DataURLToBytes() = %q, want %q", string(data), "Hello")
+		t.Errorf("prepared attachment data = %q, want %q", string(data), "Hello")
 	}
-
-	// Test invalid data URL
-	_, err = base64DataURLToBytes("invalid")
+	_, err = discordPreparedAttachmentToFile(context.Background(), channel.PreparedAttachment{
+		Logical: channel.Attachment{Type: channel.AttachmentFile},
+		Kind:    channel.PreparedAttachmentPublicURL,
+	})
 	if err == nil {
-		t.Error("base64DataURLToBytes() expected error for invalid URL")
+		t.Error("discordPreparedAttachmentToFile() expected error for non-upload kind")
 	}
 }
diff --git a/internal/channel/adapters/discord/stream.go b/internal/channel/adapters/discord/stream.go
index 5193a9dc..891d5853 100644
--- a/internal/channel/adapters/discord/stream.go
+++ b/internal/channel/adapters/discord/stream.go
@@ -27,7 +27,7 @@ type discordOutboundStream struct {
 	lastUpdate time.Time
 }
 
-func (s *discordOutboundStream) Push(ctx context.Context, event channel.StreamEvent) error {
+func (s *discordOutboundStream) Push(ctx context.Context, event channel.PreparedStreamEvent) error {
 	if s == nil || s.adapter == nil {
 		return errors.New("discord stream not configured")
 	}
@@ -67,8 +67,8 @@ func (s *discordOutboundStream) Push(ctx context.Context, event channel.StreamEv
 		bufText := strings.TrimSpace(s.buffer.String())
 		s.mu.Unlock()
 		finalText := bufText
-		if finalText == "" && event.Final != nil && !event.Final.Message.IsEmpty() {
-			finalText = strings.TrimSpace(event.Final.Message.PlainText())
+		if finalText == "" && event.Final != nil && !event.Final.Message.Message.IsEmpty() {
+			finalText = strings.TrimSpace(event.Final.Message.Message.PlainText())
 		}
 		if finalText != "" {
 			return s.finalizeMessage(finalText)
@@ -207,10 +207,10 @@ func (s *discordOutboundStream) finalizeMessage(text string) error {
 	return err
 }
 
-func (s *discordOutboundStream) sendAttachment(ctx context.Context, att channel.Attachment) error {
-	file := discordAttachmentToFile(ctx, att, s.adapter.assets)
-	if file == nil {
-		return nil
+func (s *discordOutboundStream) sendAttachment(ctx context.Context, att channel.PreparedAttachment) error {
+	file, err := discordPreparedAttachmentToFile(ctx, att)
+	if err != nil {
+		return err
 	}
 
 	messageSend := &discordgo.MessageSend{
@@ -225,6 +225,6 @@ func (s *discordOutboundStream) sendAttachment(ctx context.Context, att channel.
 		}
 	}
 
-	_, err := s.session.ChannelMessageSendComplex(s.target, messageSend)
+	_, err = s.session.ChannelMessageSendComplex(s.target, messageSend)
 	return err
 }
diff --git a/internal/channel/adapters/discord/stream_test.go b/internal/channel/adapters/discord/stream_test.go
index dae64546..a745cded 100644
--- a/internal/channel/adapters/discord/stream_test.go
+++ b/internal/channel/adapters/discord/stream_test.go
@@ -49,7 +49,7 @@ func TestDiscordOutboundStream_PushErrorEventRedactsSecrets(t *testing.T) {
 		session: session,
 	}
 
-	err = stream.Push(context.Background(), channel.StreamEvent{
+	err = stream.Push(context.Background(), channel.PreparedStreamEvent{
 		Type:  channel.StreamEventError,
 		Error: "request failed: " + prefixHalf,
 	})
diff --git a/internal/channel/adapters/feishu/feishu.go b/internal/channel/adapters/feishu/feishu.go
index 3d7550ad..09b61578 100644
--- a/internal/channel/adapters/feishu/feishu.go
+++ b/internal/channel/adapters/feishu/feishu.go
@@ -1,14 +1,12 @@
 package feishu
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"log/slog"
-	"net/http"
 	"strings"
 	"time"
 
@@ -19,7 +17,6 @@ import (
 	larkim "github.com/larksuite/oapi-sdk-go/v3/service/im/v1"
 	larkws "github.com/larksuite/oapi-sdk-go/v3/ws"
 
-	attachmentpkg "github.com/memohai/memoh/internal/attachment"
 	"github.com/memohai/memoh/internal/channel"
 	"github.com/memohai/memoh/internal/channel/adapters/common"
 	"github.com/memohai/memoh/internal/media"
@@ -513,7 +510,7 @@ func (a *FeishuAdapter) Connect(ctx context.Context, cfg channel.ChannelConfig,
 }
 
 // Send delivers an outbound message to Feishu, handling attachments, rich text, and replies.
-func (a *FeishuAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg channel.OutboundMessage) error {
+func (a *FeishuAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg channel.PreparedOutboundMessage) error {
 	feishuCfg, err := parseConfig(cfg.Credentials)
 	if err != nil {
 		if a.logger != nil {
@@ -531,14 +528,14 @@ func (a *FeishuAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg
 
 	if len(msg.Message.Attachments) > 0 {
 		for _, att := range msg.Message.Attachments {
-			if err := a.sendAttachment(ctx, client, receiveID, receiveType, cfg.BotID, att); err != nil {
+			if err := a.sendAttachment(ctx, client, receiveID, receiveType, att); err != nil {
 				return err
 			}
 		}
 		return nil
 	}
 
-	text := strings.TrimSpace(msg.Message.PlainText())
+	text := strings.TrimSpace(msg.Message.Message.PlainText())
 	if text == "" {
 		return errors.New("message is required")
 	}
@@ -559,9 +556,9 @@ func (a *FeishuAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg
 		Body(reqBuilder.Build()).
 		Build()
 
-	if msg.Message.Reply != nil && msg.Message.Reply.MessageID != "" {
+	if msg.Message.Message.Reply != nil && msg.Message.Message.Reply.MessageID != "" {
 		replyReq := larkim.NewReplyMessageReqBuilder().
-			MessageId(msg.Message.Reply.MessageID).
+			MessageId(msg.Message.Message.Reply.MessageID).
 			Body(larkim.NewReplyMessageReqBodyBuilder().
 				Content(content).
 				MsgType(msgType).
@@ -578,7 +575,7 @@ func (a *FeishuAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg
 
 // OpenStream opens a Feishu streaming session.
 // The adapter strategy uses one interactive card and patches it incrementally.
-func (a *FeishuAdapter) OpenStream(ctx context.Context, cfg channel.ChannelConfig, target string, opts channel.StreamOptions) (channel.OutboundStream, error) {
+func (a *FeishuAdapter) OpenStream(ctx context.Context, cfg channel.ChannelConfig, target string, opts channel.StreamOptions) (channel.PreparedOutboundStream, error) {
 	target = strings.TrimSpace(target)
 	if target == "" {
 		return nil, errors.New("feishu target is required")
@@ -659,28 +656,26 @@ func (a *FeishuAdapter) handleResponse(configID string, resp *larkim.CreateMessa
 	return nil
 }
 
-func (a *FeishuAdapter) sendAttachment(ctx context.Context, client *lark.Client, receiveID, receiveType, botID string, att channel.Attachment) error {
+func (a *FeishuAdapter) sendAttachment(ctx context.Context, client *lark.Client, receiveID, receiveType string, att channel.PreparedAttachment) error {
 	var msgType string
 	var contentMap map[string]string
-	sourcePlatform := strings.TrimSpace(att.SourcePlatform)
-	platformKey := strings.TrimSpace(att.PlatformKey)
-	if platformKey != "" && (sourcePlatform == "" || strings.EqualFold(sourcePlatform, Type.String())) {
-		if strings.HasPrefix(att.Mime, "image/") || att.Type == channel.AttachmentImage {
+	if att.Kind == channel.PreparedAttachmentNativeRef && strings.TrimSpace(att.NativeRef) != "" {
+		if strings.HasPrefix(att.Mime, "image/") || att.Logical.Type == channel.AttachmentImage {
 			msgType = larkim.MsgTypeImage
-			contentMap = map[string]string{"image_key": platformKey}
+			contentMap = map[string]string{"image_key": strings.TrimSpace(att.NativeRef)}
 		} else {
 			msgType = larkim.MsgTypeFile
-			contentMap = map[string]string{"file_key": platformKey}
+			contentMap = map[string]string{"file_key": strings.TrimSpace(att.NativeRef)}
 		}
 	} else {
-		reader, resolvedMime, resolvedName, err := a.resolveAttachmentUploadReader(ctx, att, botID)
+		reader, resolvedMime, resolvedName, err := resolveAttachmentUploadReader(ctx, att)
 		if err != nil {
 			return err
 		}
 		defer func() {
 			_ = reader.Close()
 		}()
-		typeProbe := att
+		typeProbe := att.Logical
 		if strings.TrimSpace(typeProbe.Mime) == "" {
 			typeProbe.Mime = strings.TrimSpace(resolvedMime)
 		}
@@ -751,74 +746,18 @@ func (a *FeishuAdapter) sendAttachment(ctx context.Context, client *lark.Client,
 	return a.handleResponse("", sendResp, err)
 }
 
-func (a *FeishuAdapter) resolveAttachmentUploadReader(ctx context.Context, att channel.Attachment, fallbackBotID string) (io.ReadCloser, string, string, error) {
-	assetID := strings.TrimSpace(att.ContentHash)
-	botID := strings.TrimSpace(fallbackBotID)
-	if botID == "" && att.Metadata != nil {
-		if value, ok := att.Metadata["bot_id"].(string); ok {
-			botID = strings.TrimSpace(value)
-		}
+func resolveAttachmentUploadReader(ctx context.Context, att channel.PreparedAttachment) (io.ReadCloser, string, string, error) {
+	if att.Kind != channel.PreparedAttachmentUpload {
+		return nil, "", "", fmt.Errorf("feishu attachment requires upload source, got %s", att.Kind)
 	}
-	if assetID != "" && botID != "" && a.assets != nil {
-		reader, asset, err := a.assets.Open(ctx, botID, assetID)
-		if err == nil {
-			resolvedMime := strings.TrimSpace(att.Mime)
-			if resolvedMime == "" {
-				resolvedMime = strings.TrimSpace(asset.Mime)
-			}
-			return reader, resolvedMime, strings.TrimSpace(att.Name), nil
-		}
-		if a.logger != nil {
-			a.logger.Debug("feishu attachment storage open failed",
-				slog.String("bot_id", botID),
-				slog.String("content_hash", assetID),
-				slog.Any("error", err),
-			)
-		}
+	if att.Open == nil {
+		return nil, "", "", errors.New("feishu attachment upload is not openable")
 	}
-
-	rawBase64 := strings.TrimSpace(att.Base64)
-	downloadURL := strings.TrimSpace(att.URL)
-	if rawBase64 == "" && strings.HasPrefix(strings.ToLower(downloadURL), "data:") {
-		rawBase64 = downloadURL
-	}
-	if rawBase64 != "" {
-		decoded, err := attachmentpkg.DecodeBase64(rawBase64, media.MaxAssetBytes)
-		if err != nil {
-			return nil, "", "", fmt.Errorf("failed to decode attachment base64: %w", err)
-		}
-		data, err := media.ReadAllWithLimit(decoded, media.MaxAssetBytes)
-		if err != nil {
-			return nil, "", "", fmt.Errorf("failed to read attachment base64: %w", err)
-		}
-		resolvedMime := strings.TrimSpace(att.Mime)
-		if resolvedMime == "" {
-			resolvedMime = strings.TrimSpace(attachmentpkg.MimeFromDataURL(rawBase64))
-		}
-		return io.NopCloser(bytes.NewReader(data)), resolvedMime, strings.TrimSpace(att.Name), nil
-	}
-
-	if downloadURL == "" {
-		return nil, "", "", errors.New("attachment reference is required: provide platform_key/content_hash/base64/url")
-	}
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL, nil)
+	reader, err := att.Open(ctx)
 	if err != nil {
-		return nil, "", "", fmt.Errorf("failed to build download request: %w", err)
+		return nil, "", "", err
 	}
-	httpClient := &http.Client{Timeout: 60 * time.Second}
-	resp, err := httpClient.Do(httpReq) //nolint:gosec // G704: URL is a Feishu file download URL from the Feishu API
-	if err != nil {
-		return nil, "", "", fmt.Errorf("failed to download attachment: %w", err)
-	}
-	if resp.StatusCode != http.StatusOK {
-		_ = resp.Body.Close()
-		return nil, "", "", fmt.Errorf("failed to download attachment, status: %d", resp.StatusCode)
-	}
-	if resp.ContentLength > media.MaxAssetBytes {
-		_ = resp.Body.Close()
-		return nil, "", "", fmt.Errorf("%w: max %d bytes", media.ErrAssetTooLarge, media.MaxAssetBytes)
-	}
-	return resp.Body, strings.TrimSpace(att.Mime), strings.TrimSpace(att.Name), nil
+	return reader, strings.TrimSpace(att.Mime), strings.TrimSpace(att.Name), nil
 }
 
 // ResolveAttachment resolves a Feishu attachment reference to a byte stream.
diff --git a/internal/channel/adapters/feishu/feishu_integration_test.go b/internal/channel/adapters/feishu/feishu_integration_test.go
index 9bcaf6b1..547f30e3 100644
--- a/internal/channel/adapters/feishu/feishu_integration_test.go
+++ b/internal/channel/adapters/feishu/feishu_integration_test.go
@@ -64,7 +64,12 @@ func TestFeishuGateway_Integration(t *testing.T) {
 			},
 		}
 
-		if err := adapter.Send(ctx, c, reply); err != nil {
+		if err := adapter.Send(ctx, c, channel.PreparedOutboundMessage{
+			Target: reply.Target,
+			Message: channel.PreparedMessage{
+				Message: reply.Message,
+			},
+		}); err != nil {
 			return fmt.Errorf("failed to send reply: %w", err)
 		}
 
@@ -78,7 +83,12 @@ func TestFeishuGateway_Integration(t *testing.T) {
 			}
 			pushCtx, pushCancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second)
 			defer pushCancel()
-			_ = adapter.Send(pushCtx, c, pushMsg)
+			_ = adapter.Send(pushCtx, c, channel.PreparedOutboundMessage{
+				Target: pushMsg.Target,
+				Message: channel.PreparedMessage{
+					Message: pushMsg.Message,
+				},
+			})
 		}()
 
 		return nil
diff --git a/internal/channel/adapters/feishu/stream.go b/internal/channel/adapters/feishu/stream.go
index a1bed4ea..b399f761 100644
--- a/internal/channel/adapters/feishu/stream.go
+++ b/internal/channel/adapters/feishu/stream.go
@@ -40,7 +40,7 @@ type feishuOutboundStream struct {
 	closed        atomic.Bool
 }
 
-func (s *feishuOutboundStream) Push(ctx context.Context, event channel.StreamEvent) error {
+func (s *feishuOutboundStream) Push(ctx context.Context, event channel.PreparedStreamEvent) error {
 	if s == nil || s.adapter == nil {
 		return errors.New("feishu stream not configured")
 	}
@@ -90,26 +90,28 @@ func (s *feishuOutboundStream) Push(ctx context.Context, event channel.StreamEve
 		if len(event.Attachments) == 0 {
 			return nil
 		}
-		media := channel.Message{
-			Attachments: event.Attachments,
-		}
-		return s.adapter.Send(ctx, s.cfg, channel.OutboundMessage{
-			Target:  s.target,
-			Message: media,
+		return s.adapter.Send(ctx, s.cfg, channel.PreparedOutboundMessage{
+			Target: s.target,
+			Message: channel.PreparedMessage{
+				Message: channel.Message{
+					Attachments: feishuLogicalAttachments(event.Attachments),
+				},
+				Attachments: event.Attachments,
+			},
 		})
 	case channel.StreamEventPhaseStart, channel.StreamEventPhaseEnd:
 		return nil
 	case channel.StreamEventAgentStart, channel.StreamEventAgentEnd, channel.StreamEventProcessingStarted, channel.StreamEventProcessingCompleted, channel.StreamEventProcessingFailed:
 		return nil
 	case channel.StreamEventFinal:
-		if event.Final == nil || event.Final.Message.IsEmpty() {
+		if event.Final == nil || event.Final.Message.Message.IsEmpty() {
 			return nil
 		}
 		msg := event.Final.Message
 		bufText := strings.TrimSpace(s.textBuffer.String())
 		finalText := bufText
 		if finalText == "" {
-			finalText = strings.TrimSpace(msg.PlainText())
+			finalText = strings.TrimSpace(msg.Message.PlainText())
 		}
 		if finalText != "" {
 			if err := s.ensureCard(ctx, feishuStreamThinkingText); err != nil {
@@ -121,12 +123,13 @@ func (s *feishuOutboundStream) Push(ctx context.Context, event channel.StreamEve
 		}
 		if len(msg.Attachments) > 0 {
 			media := msg
-			media.Format = ""
-			media.Text = ""
-			media.Parts = nil
-			media.Actions = nil
-			media.Reply = nil
-			return s.adapter.Send(ctx, s.cfg, channel.OutboundMessage{
+			media.Message.Format = ""
+			media.Message.Text = ""
+			media.Message.Parts = nil
+			media.Message.Actions = nil
+			media.Message.Reply = nil
+			media.Message.Attachments = feishuLogicalAttachments(media.Attachments)
+			return s.adapter.Send(ctx, s.cfg, channel.PreparedOutboundMessage{
 				Target:  s.target,
 				Message: media,
 			})
@@ -146,6 +149,17 @@ func (s *feishuOutboundStream) Push(ctx context.Context, event channel.StreamEve
 	}
 }
 
+func feishuLogicalAttachments(attachments []channel.PreparedAttachment) []channel.Attachment {
+	if len(attachments) == 0 {
+		return nil
+	}
+	logical := make([]channel.Attachment, 0, len(attachments))
+	for _, att := range attachments {
+		logical = append(logical, att.Logical)
+	}
+	return logical
+}
+
 func (s *feishuOutboundStream) Close(ctx context.Context) error {
 	if s == nil {
 		return nil
diff --git a/internal/channel/adapters/local/hub.go b/internal/channel/adapters/local/hub.go
index 935a2f93..e24a8001 100644
--- a/internal/channel/adapters/local/hub.go
+++ b/internal/channel/adapters/local/hub.go
@@ -98,14 +98,14 @@ type localOutboundStream struct {
 	closed atomic.Bool
 }
 
-func newLocalOutboundStream(hub *RouteHub, target string) channel.OutboundStream {
+func newLocalOutboundStream(hub *RouteHub, target string) channel.PreparedOutboundStream {
 	return &localOutboundStream{
 		hub:    hub,
 		target: target,
 	}
 }
 
-func (s *localOutboundStream) Push(ctx context.Context, event channel.StreamEvent) error {
+func (s *localOutboundStream) Push(ctx context.Context, event channel.PreparedStreamEvent) error {
 	if s == nil || s.hub == nil {
 		return errors.New("route hub not configured")
 	}
@@ -117,7 +117,7 @@ func (s *localOutboundStream) Push(ctx context.Context, event channel.StreamEven
 		return ctx.Err()
 	default:
 	}
-	s.hub.PublishEvent(s.target, event)
+	s.hub.PublishEvent(s.target, event.LogicalEvent())
 	return nil
 }
 
diff --git a/internal/channel/adapters/local/hub_test.go b/internal/channel/adapters/local/hub_test.go
index d9814af9..5b321f12 100644
--- a/internal/channel/adapters/local/hub_test.go
+++ b/internal/channel/adapters/local/hub_test.go
@@ -41,7 +41,7 @@ func TestLocalOutboundStreamClose(t *testing.T) {
 	if err := stream.Close(context.Background()); err != nil {
 		t.Fatalf("unexpected close error: %v", err)
 	}
-	if err := stream.Push(context.Background(), channel.StreamEvent{
+	if err := stream.Push(context.Background(), channel.PreparedStreamEvent{
 		Type:  channel.StreamEventDelta,
 		Delta: "should fail",
 	}); err == nil {
diff --git a/internal/channel/adapters/local/web.go b/internal/channel/adapters/local/web.go
index 0a0f9cd5..89d2d898 100644
--- a/internal/channel/adapters/local/web.go
+++ b/internal/channel/adapters/local/web.go
@@ -46,7 +46,7 @@ func (*WebAdapter) Descriptor() channel.Descriptor {
 }
 
 // Send publishes an outbound message to the Web route hub.
-func (a *WebAdapter) Send(_ context.Context, _ channel.ChannelConfig, msg channel.OutboundMessage) error {
+func (a *WebAdapter) Send(_ context.Context, _ channel.ChannelConfig, msg channel.PreparedOutboundMessage) error {
 	if a.hub == nil {
 		return errors.New("web hub not configured")
 	}
@@ -54,15 +54,16 @@ func (a *WebAdapter) Send(_ context.Context, _ channel.ChannelConfig, msg channe
 	if target == "" {
 		return errors.New("web target is required")
 	}
-	if msg.Message.IsEmpty() {
+	logical := msg.LogicalMessage()
+	if logical.Message.IsEmpty() {
 		return errors.New("message is required")
 	}
-	a.hub.Publish(target, msg)
+	a.hub.Publish(target, logical)
 	return nil
 }
 
 // OpenStream opens a local stream session bound to the target route.
-func (a *WebAdapter) OpenStream(ctx context.Context, _ channel.ChannelConfig, target string, _ channel.StreamOptions) (channel.OutboundStream, error) {
+func (a *WebAdapter) OpenStream(ctx context.Context, _ channel.ChannelConfig, target string, _ channel.StreamOptions) (channel.PreparedOutboundStream, error) {
 	if a.hub == nil {
 		return nil, errors.New("web hub not configured")
 	}
diff --git a/internal/channel/adapters/matrix/matrix.go b/internal/channel/adapters/matrix/matrix.go
index 5b38fda6..37805aa0 100644
--- a/internal/channel/adapters/matrix/matrix.go
+++ b/internal/channel/adapters/matrix/matrix.go
@@ -12,7 +12,6 @@ import (
 	"math/big"
 	"net/http"
 	"net/url"
-	pathpkg "path"
 	"regexp"
 	"strconv"
 	"strings"
@@ -377,8 +376,8 @@ func matrixHTTPErrorSummary(statusCode int, data []byte) string {
 	return fmt.Sprintf("%s (HTTP %d)", textutil.TruncateRunes(message, 300), statusCode)
 }
 
-func (a *MatrixAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg channel.OutboundMessage) error {
-	if msg.Message.IsEmpty() {
+func (a *MatrixAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg channel.PreparedOutboundMessage) error {
+	if msg.Message.Message.IsEmpty() {
 		return errors.New("message is required")
 	}
 	parsed, err := parseConfig(cfg.Credentials)
@@ -389,9 +388,9 @@ func (a *MatrixAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg
 	if err != nil {
 		return err
 	}
-	text := strings.TrimSpace(msg.Message.PlainText())
+	text := strings.TrimSpace(msg.Message.Message.PlainText())
 	if text != "" {
-		textMsg := msg.Message
+		textMsg := msg.Message.Message
 		textMsg.Attachments = nil
 		textMsg.Text = text
 		textMsg.Parts = nil
@@ -402,16 +401,16 @@ func (a *MatrixAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg
 	for i, att := range msg.Message.Attachments {
 		mediaMsg := channel.Message{}
 		if text == "" && i == 0 {
-			mediaMsg.Reply = msg.Message.Reply
+			mediaMsg.Reply = msg.Message.Message.Reply
 		}
-		if err := a.sendMediaAttachment(ctx, parsed, roomID, cfg.BotID, mediaMsg, att); err != nil {
+		if err := a.sendMediaAttachment(ctx, parsed, roomID, mediaMsg, att); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func (a *MatrixAdapter) OpenStream(_ context.Context, cfg channel.ChannelConfig, target string, opts channel.StreamOptions) (channel.OutboundStream, error) {
+func (a *MatrixAdapter) OpenStream(_ context.Context, cfg channel.ChannelConfig, target string, opts channel.StreamOptions) (channel.PreparedOutboundStream, error) {
 	if err := validateTarget(target); err != nil {
 		return nil, err
 	}
@@ -431,7 +430,7 @@ func (a *MatrixAdapter) OpenStream(_ context.Context, cfg channel.ChannelConfig,
 	}, nil
 }
 
-func (a *MatrixAdapter) Update(ctx context.Context, cfg channel.ChannelConfig, target string, messageID string, msg channel.Message) error {
+func (a *MatrixAdapter) Update(ctx context.Context, cfg channel.ChannelConfig, target string, messageID string, msg channel.PreparedMessage) error {
 	parsed, err := parseConfig(cfg.Credentials)
 	if err != nil {
 		return err
@@ -440,7 +439,7 @@ func (a *MatrixAdapter) Update(ctx context.Context, cfg channel.ChannelConfig, t
 	if err != nil {
 		return err
 	}
-	_, err = a.sendTextEvent(ctx, parsed, roomID, buildMatrixMessageContent(msg, true, strings.TrimSpace(messageID)))
+	_, err = a.sendTextEvent(ctx, parsed, roomID, buildMatrixMessageContent(msg.Message, true, strings.TrimSpace(messageID)))
 	return err
 }
 
@@ -1283,8 +1282,8 @@ func (a *MatrixAdapter) sendTextEvent(ctx context.Context, cfg Config, roomID st
 	return strings.TrimSpace(resp.EventID), nil
 }
 
-func (a *MatrixAdapter) sendMediaAttachment(ctx context.Context, cfg Config, roomID string, fallbackBotID string, msg channel.Message, att channel.Attachment) error {
-	contentURI, resolved, err := a.resolveMatrixContentURI(ctx, cfg, fallbackBotID, att)
+func (a *MatrixAdapter) sendMediaAttachment(ctx context.Context, cfg Config, roomID string, msg channel.Message, att channel.PreparedAttachment) error {
+	contentURI, resolved, err := a.resolveMatrixContentURI(ctx, cfg, att)
 	if err != nil {
 		return err
 	}
@@ -1292,22 +1291,15 @@ func (a *MatrixAdapter) sendMediaAttachment(ctx context.Context, cfg Config, roo
 	return err
 }
 
-func (a *MatrixAdapter) resolveMatrixContentURI(ctx context.Context, cfg Config, fallbackBotID string, att channel.Attachment) (string, channel.Attachment, error) {
-	if ref := strings.TrimSpace(att.PlatformKey); isMatrixContentURI(ref) {
-		resolved := att
+func (a *MatrixAdapter) resolveMatrixContentURI(ctx context.Context, cfg Config, att channel.PreparedAttachment) (string, channel.Attachment, error) {
+	if ref := strings.TrimSpace(att.NativeRef); att.Kind == channel.PreparedAttachmentNativeRef && isMatrixContentURI(ref) {
+		resolved := att.Logical
 		if resolved.SourcePlatform == "" {
 			resolved.SourcePlatform = Type.String()
 		}
 		return ref, resolved, nil
 	}
-	if ref := strings.TrimSpace(att.URL); isMatrixContentURI(ref) {
-		resolved := att
-		if resolved.SourcePlatform == "" {
-			resolved.SourcePlatform = Type.String()
-		}
-		return ref, resolved, nil
-	}
-	payload, resolved, err := a.prepareMatrixUpload(ctx, fallbackBotID, att)
+	payload, resolved, err := prepareMatrixUpload(ctx, att)
 	if err != nil {
 		return "", channel.Attachment{}, err
 	}
@@ -1329,105 +1321,42 @@ type matrixUploadPayload struct {
 	name string
 }
 
-func (a *MatrixAdapter) prepareMatrixUpload(ctx context.Context, fallbackBotID string, att channel.Attachment) (matrixUploadPayload, channel.Attachment, error) {
-	resolved := att
-	assetID := strings.TrimSpace(att.ContentHash)
-	botID := strings.TrimSpace(fallbackBotID)
-	if att.Metadata != nil {
-		if value, ok := att.Metadata["bot_id"].(string); ok && strings.TrimSpace(value) != "" {
-			botID = strings.TrimSpace(value)
-		}
+func prepareMatrixUpload(ctx context.Context, att channel.PreparedAttachment) (matrixUploadPayload, channel.Attachment, error) {
+	if att.Kind != channel.PreparedAttachmentUpload {
+		return matrixUploadPayload{}, channel.Attachment{}, fmt.Errorf("matrix attachment requires upload source, got %s", att.Kind)
 	}
-	if assetID != "" && a.assets != nil && botID != "" {
-		reader, asset, err := a.assets.Open(ctx, botID, assetID)
-		if err == nil {
-			defer func() { _ = reader.Close() }()
-			data, readErr := media.ReadAllWithLimit(reader, media.MaxAssetBytes)
-			if readErr != nil {
-				return matrixUploadPayload{}, channel.Attachment{}, readErr
-			}
-			if strings.TrimSpace(resolved.Mime) == "" {
-				resolved.Mime = strings.TrimSpace(asset.Mime)
-			}
-			if resolved.Size <= 0 {
-				resolved.Size = asset.SizeBytes
-			}
-			name := deriveMatrixUploadName(resolved, resolved.Mime, "")
-			return matrixUploadPayload{data: data, mime: strings.TrimSpace(resolved.Mime), name: name}, resolved, nil
-		}
+	if att.Open == nil {
+		return matrixUploadPayload{}, channel.Attachment{}, errors.New("matrix attachment upload is not openable")
 	}
-
-	rawBase64 := strings.TrimSpace(att.Base64)
-	refURL := strings.TrimSpace(att.URL)
-	if rawBase64 == "" && strings.HasPrefix(strings.ToLower(refURL), "data:") {
-		rawBase64 = refURL
-	}
-	if rawBase64 != "" {
-		decoded, err := attachmentpkg.DecodeBase64(rawBase64, media.MaxAssetBytes)
-		if err != nil {
-			return matrixUploadPayload{}, channel.Attachment{}, fmt.Errorf("decode matrix attachment base64: %w", err)
-		}
-		data, err := media.ReadAllWithLimit(decoded, media.MaxAssetBytes)
-		if err != nil {
-			return matrixUploadPayload{}, channel.Attachment{}, fmt.Errorf("read matrix attachment base64: %w", err)
-		}
-		if strings.TrimSpace(resolved.Mime) == "" {
-			resolved.Mime = strings.TrimSpace(attachmentpkg.MimeFromDataURL(rawBase64))
-		}
-		if resolved.Size <= 0 {
-			resolved.Size = int64(len(data))
-		}
-		name := deriveMatrixUploadName(resolved, resolved.Mime, "")
-		return matrixUploadPayload{data: data, mime: strings.TrimSpace(resolved.Mime), name: name}, resolved, nil
-	}
-
-	if refURL == "" {
-		return matrixUploadPayload{}, channel.Attachment{}, errors.New("matrix attachment requires content_hash, base64, mxc url, or http(s) url")
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, refURL, nil)
-	if err != nil {
-		return matrixUploadPayload{}, channel.Attachment{}, fmt.Errorf("build matrix attachment download request: %w", err)
-	}
-	resp, err := (&http.Client{Timeout: 60 * time.Second}).Do(req) //nolint:gosec // URL is a user-provided or cross-platform attachment reference.
-	if err != nil {
-		return matrixUploadPayload{}, channel.Attachment{}, fmt.Errorf("download matrix attachment: %w", err)
-	}
-	defer func() { _ = resp.Body.Close() }()
-	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
-		return matrixUploadPayload{}, channel.Attachment{}, fmt.Errorf("download matrix attachment status: %d", resp.StatusCode)
-	}
-	if resp.ContentLength > media.MaxAssetBytes {
-		return matrixUploadPayload{}, channel.Attachment{}, fmt.Errorf("%w: max %d bytes", media.ErrAssetTooLarge, media.MaxAssetBytes)
-	}
-	data, err := media.ReadAllWithLimit(resp.Body, media.MaxAssetBytes)
+	reader, err := att.Open(ctx)
 	if err != nil {
 		return matrixUploadPayload{}, channel.Attachment{}, err
 	}
+	defer func() { _ = reader.Close() }()
+	data, err := media.ReadAllWithLimit(reader, media.MaxAssetBytes)
+	if err != nil {
+		return matrixUploadPayload{}, channel.Attachment{}, err
+	}
+	resolved := att.Logical
 	if strings.TrimSpace(resolved.Mime) == "" {
-		resolved.Mime = strings.TrimSpace(resp.Header.Get("Content-Type"))
-		resolved.Mime = attachmentpkg.NormalizeMime(resolved.Mime)
+		resolved.Mime = strings.TrimSpace(att.Mime)
 	}
 	if resolved.Size <= 0 {
-		if resp.ContentLength > 0 {
-			resolved.Size = resp.ContentLength
-		} else {
+		resolved.Size = att.Size
+		if resolved.Size <= 0 {
 			resolved.Size = int64(len(data))
 		}
 	}
-	name := deriveMatrixUploadName(resolved, resolved.Mime, refURL)
-	return matrixUploadPayload{data: data, mime: strings.TrimSpace(resolved.Mime), name: name}, resolved, nil
+	name := deriveMatrixUploadName(resolved, strings.TrimSpace(att.Mime), att.Name)
+	return matrixUploadPayload{data: data, mime: strings.TrimSpace(att.Mime), name: name}, resolved, nil
 }
 
-func deriveMatrixUploadName(att channel.Attachment, mime, refURL string) string {
+func deriveMatrixUploadName(att channel.Attachment, mime, fallbackName string) string {
 	if name := strings.TrimSpace(att.Name); name != "" {
 		return name
 	}
-	if refURL != "" {
-		if parsed, err := url.Parse(refURL); err == nil {
-			if base := strings.TrimSpace(pathpkg.Base(parsed.Path)); base != "" && base != "." && base != "/" {
-				return base
-			}
-		}
+	if name := strings.TrimSpace(fallbackName); name != "" {
+		return name
 	}
 	return matrixAttachmentBody(channel.Attachment{Type: att.Type, Mime: mime, Caption: att.Caption})
 }
diff --git a/internal/channel/adapters/matrix/matrix_test.go b/internal/channel/adapters/matrix/matrix_test.go
index c6ab65cb..1a1bf79f 100644
--- a/internal/channel/adapters/matrix/matrix_test.go
+++ b/internal/channel/adapters/matrix/matrix_test.go
@@ -863,6 +863,11 @@ func TestMatrixSendUploadsBase64AttachmentAndSendsMediaEvent(t *testing.T) {
 		}, nil
 	})}
 
+	logicalAttachment := channel.Attachment{
+		Type: channel.AttachmentImage,
+		Name: "chart.png",
+		Mime: "image/png",
+	}
 	err := adapter.Send(context.Background(), channel.ChannelConfig{
 		BotID: "bot-1",
 		Credentials: map[string]any{
@@ -870,14 +875,20 @@ func TestMatrixSendUploadsBase64AttachmentAndSendsMediaEvent(t *testing.T) {
 			"userId":        "@memoh:example.com",
 			"accessToken":   "tok",
 		},
-	}, channel.OutboundMessage{
+	}, channel.PreparedOutboundMessage{
 		Target: "!room:example.com",
-		Message: channel.Message{
-			Attachments: []channel.Attachment{{
-				Type:   channel.AttachmentImage,
-				Name:   "chart.png",
-				Mime:   "image/png",
-				Base64: "data:image/png;base64,aGVsbG8=",
+		Message: channel.PreparedMessage{
+			Message: channel.Message{
+				Attachments: []channel.Attachment{logicalAttachment},
+			},
+			Attachments: []channel.PreparedAttachment{{
+				Logical: logicalAttachment,
+				Kind:    channel.PreparedAttachmentUpload,
+				Name:    "chart.png",
+				Mime:    "image/png",
+				Open: func(context.Context) (io.ReadCloser, error) {
+					return io.NopCloser(strings.NewReader("hello")), nil
+				},
 			}},
 		},
 	})
@@ -922,10 +933,12 @@ func TestMatrixSendResolvesRoomAlias(t *testing.T) {
 			"userId":        "@memoh:example.com",
 			"accessToken":   "tok",
 		},
-	}, channel.OutboundMessage{
+	}, channel.PreparedOutboundMessage{
 		Target: "#ops:example.com",
-		Message: channel.Message{
-			Text: "ping",
+		Message: channel.PreparedMessage{
+			Message: channel.Message{
+				Text: "ping",
+			},
 		},
 	})
 	if err != nil {
diff --git a/internal/channel/adapters/matrix/stream.go b/internal/channel/adapters/matrix/stream.go
index f090066d..f4c925d6 100644
--- a/internal/channel/adapters/matrix/stream.go
+++ b/internal/channel/adapters/matrix/stream.go
@@ -28,7 +28,7 @@ type matrixOutboundStream struct {
 	lastEditedAt    time.Time
 }
 
-func (s *matrixOutboundStream) Push(ctx context.Context, event channel.StreamEvent) error {
+func (s *matrixOutboundStream) Push(ctx context.Context, event channel.PreparedStreamEvent) error {
 	if s == nil || s.adapter == nil {
 		return errors.New("matrix stream not configured")
 	}
@@ -82,8 +82,8 @@ func (s *matrixOutboundStream) Push(ctx context.Context, event channel.StreamEve
 		if event.Final == nil {
 			return errors.New("matrix stream final payload is required")
 		}
-		text := strings.TrimSpace(event.Final.Message.PlainText())
-		format := event.Final.Message.Format
+		text := strings.TrimSpace(event.Final.Message.Message.PlainText())
+		format := event.Final.Message.Message.Format
 		if format == "" {
 			format = channel.MessageFormatPlain
 		}
@@ -196,7 +196,7 @@ func (s *matrixOutboundStream) resetMessageState() {
 	s.mu.Unlock()
 }
 
-func (s *matrixOutboundStream) pushAttachments(ctx context.Context, attachments []channel.Attachment) error {
+func (s *matrixOutboundStream) pushAttachments(ctx context.Context, attachments []channel.PreparedAttachment) error {
 	if len(attachments) == 0 {
 		return nil
 	}
@@ -223,7 +223,7 @@ func (s *matrixOutboundStream) pushAttachments(ctx context.Context, attachments
 		if idx == 0 && originalEventID == "" {
 			mediaMsg.Reply = reply
 		}
-		if err := s.adapter.sendMediaAttachment(ctx, s.cfg, roomID, "", mediaMsg, att); err != nil {
+		if err := s.adapter.sendMediaAttachment(ctx, s.cfg, roomID, mediaMsg, att); err != nil {
 			return err
 		}
 	}
diff --git a/internal/channel/adapters/matrix/stream_test.go b/internal/channel/adapters/matrix/stream_test.go
index 0d8247a2..9d81c481 100644
--- a/internal/channel/adapters/matrix/stream_test.go
+++ b/internal/channel/adapters/matrix/stream_test.go
@@ -10,6 +10,18 @@ import (
 	"github.com/memohai/memoh/internal/channel"
 )
 
+func mustPreparedMatrixEvent(t *testing.T, event channel.StreamEvent) channel.PreparedStreamEvent {
+	t.Helper()
+	prepared, err := channel.PrepareStreamEvent(context.Background(), nil, channel.ChannelConfig{
+		BotID:       "bot-test",
+		ChannelType: Type,
+	}, event)
+	if err != nil {
+		t.Fatalf("prepare matrix stream event: %v", err)
+	}
+	return prepared
+}
+
 type roundTripFunc func(*http.Request) (*http.Response, error)
 
 func (f roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
@@ -38,13 +50,13 @@ func TestMatrixStreamDoesNotSendDeltaBeforeTextPhaseEnds(t *testing.T) {
 	}
 
 	ctx := context.Background()
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "draft", Phase: channel.StreamPhaseText}); err != nil {
+	if err := stream.Push(ctx, mustPreparedMatrixEvent(t, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "draft", Phase: channel.StreamPhaseText})); err != nil {
 		t.Fatalf("push delta: %v", err)
 	}
 	if requests != 0 {
 		t.Fatalf("expected no request before text phase ends, got %d", requests)
 	}
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventPhaseEnd, Phase: channel.StreamPhaseText}); err != nil {
+	if err := stream.Push(ctx, mustPreparedMatrixEvent(t, channel.StreamEvent{Type: channel.StreamEventPhaseEnd, Phase: channel.StreamPhaseText})); err != nil {
 		t.Fatalf("push phase end: %v", err)
 	}
 	if requests != 1 {
@@ -74,19 +86,19 @@ func TestMatrixStreamDropsBufferedTextWhenToolStarts(t *testing.T) {
 	}
 
 	ctx := context.Background()
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "I will inspect first", Phase: channel.StreamPhaseText}); err != nil {
+	if err := stream.Push(ctx, mustPreparedMatrixEvent(t, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "I will inspect first", Phase: channel.StreamPhaseText})); err != nil {
 		t.Fatalf("push delta: %v", err)
 	}
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventToolCallStart}); err != nil {
+	if err := stream.Push(ctx, mustPreparedMatrixEvent(t, channel.StreamEvent{Type: channel.StreamEventToolCallStart})); err != nil {
 		t.Fatalf("push tool call start: %v", err)
 	}
 	if requests != 0 {
 		t.Fatalf("expected no request for discarded pre-tool text, got %d", requests)
 	}
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "Final answer", Phase: channel.StreamPhaseText}); err != nil {
+	if err := stream.Push(ctx, mustPreparedMatrixEvent(t, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "Final answer", Phase: channel.StreamPhaseText})); err != nil {
 		t.Fatalf("push final delta: %v", err)
 	}
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventFinal, Final: &channel.StreamFinalizePayload{Message: channel.Message{Text: "Final answer"}}}); err != nil {
+	if err := stream.Push(ctx, mustPreparedMatrixEvent(t, channel.StreamEvent{Type: channel.StreamEventFinal, Final: &channel.StreamFinalizePayload{Message: channel.Message{Text: "Final answer"}}})); err != nil {
 		t.Fatalf("push final: %v", err)
 	}
 	if requests != 1 {
@@ -120,13 +132,13 @@ func TestMatrixStreamFinalMarkdownUpdatesFormattedContent(t *testing.T) {
 	}
 
 	ctx := context.Background()
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "**bold**", Phase: channel.StreamPhaseText}); err != nil {
+	if err := stream.Push(ctx, mustPreparedMatrixEvent(t, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "**bold**", Phase: channel.StreamPhaseText})); err != nil {
 		t.Fatalf("push delta: %v", err)
 	}
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventPhaseEnd, Phase: channel.StreamPhaseText}); err != nil {
+	if err := stream.Push(ctx, mustPreparedMatrixEvent(t, channel.StreamEvent{Type: channel.StreamEventPhaseEnd, Phase: channel.StreamPhaseText})); err != nil {
 		t.Fatalf("push phase end: %v", err)
 	}
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventFinal, Final: &channel.StreamFinalizePayload{Message: channel.Message{Text: "**bold**", Format: channel.MessageFormatMarkdown}}}); err != nil {
+	if err := stream.Push(ctx, mustPreparedMatrixEvent(t, channel.StreamEvent{Type: channel.StreamEventFinal, Final: &channel.StreamFinalizePayload{Message: channel.Message{Text: "**bold**", Format: channel.MessageFormatMarkdown}}})); err != nil {
 		t.Fatalf("push final: %v", err)
 	}
 	if len(bodies) != 2 {
@@ -166,7 +178,7 @@ func TestMatrixStreamFinalSendsAttachments(t *testing.T) {
 	}
 
 	ctx := context.Background()
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventFinal, Final: &channel.StreamFinalizePayload{Message: channel.Message{
+	if err := stream.Push(ctx, mustPreparedMatrixEvent(t, channel.StreamEvent{Type: channel.StreamEventFinal, Final: &channel.StreamFinalizePayload{Message: channel.Message{
 		Text: "done",
 		Attachments: []channel.Attachment{{
 			Type:           channel.AttachmentImage,
@@ -174,7 +186,7 @@ func TestMatrixStreamFinalSendsAttachments(t *testing.T) {
 			Name:           "image.png",
 			SourcePlatform: Type.String(),
 		}},
-	}}}); err != nil {
+	}}})); err != nil {
 		t.Fatalf("push final: %v", err)
 	}
 	if len(bodies) != 2 {
diff --git a/internal/channel/adapters/qq/send.go b/internal/channel/adapters/qq/send.go
index c6d19526..32457bb2 100644
--- a/internal/channel/adapters/qq/send.go
+++ b/internal/channel/adapters/qq/send.go
@@ -5,9 +5,6 @@ import (
 	"encoding/base64"
 	"errors"
 	"fmt"
-	"net/http"
-	"net/url"
-	"path/filepath"
 	"regexp"
 	"strings"
 
@@ -43,7 +40,7 @@ type attachmentUpload struct {
 	Mime     string
 }
 
-func (a *QQAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg channel.OutboundMessage) error {
+func (a *QQAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg channel.PreparedOutboundMessage) error {
 	parsed, err := parseConfig(cfg.Credentials)
 	if err != nil {
 		return err
@@ -58,20 +55,20 @@ func (a *QQAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg cha
 	}
 	client := a.getOrCreateClient(cfg, parsed)
 	replyTo := ""
-	if msg.Message.Reply != nil {
-		replyTo = strings.TrimSpace(msg.Message.Reply.MessageID)
+	if msg.Message.Message.Reply != nil {
+		replyTo = strings.TrimSpace(msg.Message.Message.Reply.MessageID)
 	}
 
-	text := strings.TrimSpace(msg.Message.PlainText())
+	text := strings.TrimSpace(msg.Message.Message.PlainText())
 	if text != "" {
-		useMarkdown := parsed.MarkdownSupport && msg.Message.Format == channel.MessageFormatMarkdown && target.Kind != qqTargetChannel
+		useMarkdown := parsed.MarkdownSupport && msg.Message.Message.Format == channel.MessageFormatMarkdown && target.Kind != qqTargetChannel
 		if err := client.sendText(ctx, target, text, replyTo, useMarkdown); err != nil {
 			return err
 		}
 	}
 
 	for _, att := range msg.Message.Attachments {
-		if err := a.sendAttachment(ctx, cfg, client, target, replyTo, att); err != nil {
+		if err := sendAttachment(ctx, client, target, replyTo, att); err != nil {
 			return err
 		}
 	}
@@ -114,9 +111,9 @@ func validateQQC2CTarget(id string) error {
 	return nil
 }
 
-func (a *QQAdapter) sendAttachment(ctx context.Context, cfg channel.ChannelConfig, client *qqClient, target qqTarget, replyTo string, att channel.Attachment) error {
+func sendAttachment(ctx context.Context, client *qqClient, target qqTarget, replyTo string, att channel.PreparedAttachment) error {
 	if target.Kind == qqTargetChannel {
-		switch att.Type {
+		switch att.Logical.Type {
 		case channel.AttachmentImage, channel.AttachmentGIF:
 			return errors.New("qq channel does not support image attachments")
 		case channel.AttachmentVideo:
@@ -126,28 +123,28 @@ func (a *QQAdapter) sendAttachment(ctx context.Context, cfg channel.ChannelConfi
 		case channel.AttachmentFile, "":
 			return errors.New("qq channel does not support file attachments")
 		default:
-			return fmt.Errorf("unsupported qq attachment type: %s", att.Type)
+			return fmt.Errorf("unsupported qq attachment type: %s", att.Logical.Type)
 		}
 	}
 
-	upload, err := a.prepareAttachmentUpload(ctx, cfg.BotID, att)
+	upload, err := prepareAttachmentUpload(ctx, att)
 	if err != nil {
 		return err
 	}
 
-	switch att.Type {
+	switch att.Logical.Type {
 	case channel.AttachmentImage, channel.AttachmentGIF:
 		fileInfo, err := client.uploadMedia(ctx, target, qqMediaTypeImage, upload.Base64, "")
 		if err != nil {
 			return err
 		}
-		return client.sendMedia(ctx, target, fileInfo, replyTo, att.Caption)
+		return client.sendMedia(ctx, target, fileInfo, replyTo, att.Logical.Caption)
 	case channel.AttachmentVideo:
 		fileInfo, err := client.uploadMedia(ctx, target, qqMediaTypeVideo, upload.Base64, "")
 		if err != nil {
 			return err
 		}
-		return client.sendMedia(ctx, target, fileInfo, replyTo, att.Caption)
+		return client.sendMedia(ctx, target, fileInfo, replyTo, att.Logical.Caption)
 	case channel.AttachmentVoice, channel.AttachmentAudio:
 		if !supportsQQVoiceUpload(att, upload.FileName, upload.Mime) {
 			return errors.New("qq voice attachments require SILK/WAV/MP3/AMR input")
@@ -156,142 +153,47 @@ func (a *QQAdapter) sendAttachment(ctx context.Context, cfg channel.ChannelConfi
 		if err != nil {
 			return err
 		}
-		return client.sendMedia(ctx, target, fileInfo, replyTo, att.Caption)
+		return client.sendMedia(ctx, target, fileInfo, replyTo, att.Logical.Caption)
 	case channel.AttachmentFile, "":
 		fileInfo, err := client.uploadMedia(ctx, target, qqMediaTypeFile, upload.Base64, upload.FileName)
 		if err != nil {
 			return err
 		}
-		return client.sendMedia(ctx, target, fileInfo, replyTo, att.Caption)
+		return client.sendMedia(ctx, target, fileInfo, replyTo, att.Logical.Caption)
 	default:
-		return fmt.Errorf("unsupported qq attachment type: %s", att.Type)
+		return fmt.Errorf("unsupported qq attachment type: %s", att.Logical.Type)
 	}
 }
 
-func (a *QQAdapter) prepareAttachmentUpload(ctx context.Context, fallbackBotID string, att channel.Attachment) (attachmentUpload, error) {
-	if remoteURL := strings.TrimSpace(att.URL); strings.HasPrefix(strings.ToLower(remoteURL), "http://") || strings.HasPrefix(strings.ToLower(remoteURL), "https://") {
-		return a.prepareRemoteAttachmentUpload(ctx, att, remoteURL)
+func prepareAttachmentUpload(ctx context.Context, att channel.PreparedAttachment) (attachmentUpload, error) {
+	if att.Kind != channel.PreparedAttachmentUpload {
+		return attachmentUpload{}, fmt.Errorf("qq attachment requires upload source, got %s", att.Kind)
 	}
-
-	if rawBase64 := extractRawBase64(att); rawBase64 != "" {
-		return attachmentUpload{
-			Base64:   rawBase64,
-			FileName: deriveAttachmentName(att),
-			Mime:     strings.TrimSpace(att.Mime),
-		}, nil
+	if att.Open == nil {
+		return attachmentUpload{}, errors.New("qq attachment upload is not openable")
 	}
-
-	contentHash := strings.TrimSpace(att.ContentHash)
-	if contentHash == "" || a.assets == nil {
-		return attachmentUpload{}, errors.New("qq attachment requires http(s) URL, base64, or content_hash")
-	}
-
-	botID := strings.TrimSpace(fallbackBotID)
-	if att.Metadata != nil {
-		if override, ok := att.Metadata["bot_id"].(string); ok && strings.TrimSpace(override) != "" {
-			botID = strings.TrimSpace(override)
-		}
-	}
-	if botID == "" {
-		return attachmentUpload{}, errors.New("qq attachment content_hash requires bot_id context")
-	}
-
-	reader, asset, err := a.assets.Open(ctx, botID, contentHash)
+	reader, err := att.Open(ctx)
 	if err != nil {
 		return attachmentUpload{}, err
 	}
 	defer func() { _ = reader.Close() }()
-
 	data, err := media.ReadAllWithLimit(reader, media.MaxAssetBytes)
 	if err != nil {
 		return attachmentUpload{}, err
 	}
-
 	fileName := deriveAttachmentName(att)
-	if fileName == "" {
-		fileName = deriveFileNameFromMime(asset.Mime, att.Type)
-	}
 	return attachmentUpload{
 		Base64:   base64.StdEncoding.EncodeToString(data),
 		FileName: fileName,
-		Mime:     strings.TrimSpace(asset.Mime),
+		Mime:     strings.TrimSpace(att.Mime),
 	}, nil
 }
 
-func (a *QQAdapter) prepareRemoteAttachmentUpload(ctx context.Context, att channel.Attachment, remoteURL string) (attachmentUpload, error) {
-	u, err := url.Parse(remoteURL)
-	if err != nil || (u.Scheme != "https" && u.Scheme != "http") || u.Host == "" {
-		return attachmentUpload{}, fmt.Errorf("invalid attachment url: %s", remoteURL)
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, remoteURL, nil)
-	if err != nil {
-		return attachmentUpload{}, err
-	}
-	resp, err := a.httpClient.Do(req) //nolint:gosec // remote URL is validated to http(s) with non-empty host above
-	if err != nil {
-		return attachmentUpload{}, err
-	}
-	defer func() { _ = resp.Body.Close() }()
-
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return attachmentUpload{}, fmt.Errorf("qq attachment fetch failed: status=%d", resp.StatusCode)
-	}
-
-	data, err := media.ReadAllWithLimit(resp.Body, media.MaxAssetBytes)
-	if err != nil {
-		return attachmentUpload{}, err
-	}
-
-	mimeType := strings.TrimSpace(att.Mime)
-	if mimeType == "" {
-		mimeType = strings.TrimSpace(resp.Header.Get("Content-Type"))
-		if idx := strings.Index(mimeType, ";"); idx >= 0 {
-			mimeType = strings.TrimSpace(mimeType[:idx])
-		}
-	}
-
-	fileName := deriveAttachmentName(att)
-	if fileName == "" {
-		fileName = deriveFileNameFromMime(mimeType, att.Type)
-	}
-
-	return attachmentUpload{
-		Base64:   base64.StdEncoding.EncodeToString(data),
-		FileName: fileName,
-		Mime:     mimeType,
-	}, nil
-}
-
-func extractRawBase64(att channel.Attachment) string {
-	if candidate := strings.TrimSpace(att.Base64); candidate != "" {
-		if strings.HasPrefix(strings.ToLower(candidate), "data:") {
-			if idx := strings.Index(candidate, ","); idx >= 0 && idx < len(candidate)-1 {
-				return candidate[idx+1:]
-			}
-			return ""
-		}
-		return candidate
-	}
-
-	candidate := strings.TrimSpace(att.URL)
-	if strings.HasPrefix(strings.ToLower(candidate), "data:") {
-		if idx := strings.Index(candidate, ","); idx >= 0 && idx < len(candidate)-1 {
-			return candidate[idx+1:]
-		}
-	}
-	return ""
-}
-
-func deriveAttachmentName(att channel.Attachment) string {
+func deriveAttachmentName(att channel.PreparedAttachment) string {
 	if name := strings.TrimSpace(att.Name); name != "" {
 		return name
 	}
-	if rawURL := strings.TrimSpace(att.URL); rawURL != "" && !strings.HasPrefix(strings.ToLower(rawURL), "data:") {
-		if base := filepath.Base(rawURL); base != "." && base != "/" && base != "" {
-			return base
-		}
-	}
-	return deriveFileNameFromMime(att.Mime, att.Type)
+	return deriveFileNameFromMime(att.Mime, att.Logical.Type)
 }
 
 func deriveFileNameFromMime(mimeType string, attType channel.AttachmentType) string {
@@ -335,7 +237,7 @@ func mimeExtension(mimeType string) string {
 	}
 }
 
-func supportsQQVoiceUpload(att channel.Attachment, fileName string, resolvedMime string) bool {
+func supportsQQVoiceUpload(att channel.PreparedAttachment, fileName string, resolvedMime string) bool {
 	check := strings.ToLower(strings.TrimSpace(fileName))
 	if check == "" {
 		check = strings.ToLower(strings.TrimSpace(att.Name))
diff --git a/internal/channel/adapters/qq/send_test.go b/internal/channel/adapters/qq/send_test.go
index 7cb39e57..4337dd99 100644
--- a/internal/channel/adapters/qq/send_test.go
+++ b/internal/channel/adapters/qq/send_test.go
@@ -12,9 +12,25 @@ import (
 	"testing"
 
 	"github.com/memohai/memoh/internal/channel"
+	"github.com/memohai/memoh/internal/channel/channeltest"
 	"github.com/memohai/memoh/internal/media"
 )
 
+func sendPreparedQQ(t *testing.T, adapter *QQAdapter, cfg channel.ChannelConfig, store channel.OutboundAttachmentStore, msg channel.OutboundMessage) error {
+	t.Helper()
+	if cfg.ChannelType == "" {
+		cfg.ChannelType = Type
+	}
+	if store == nil {
+		store = channeltest.NewMemoryAttachmentStore()
+	}
+	prepared, err := channel.PrepareOutboundMessage(context.Background(), store, cfg, msg)
+	if err != nil {
+		return err
+	}
+	return adapter.Send(context.Background(), cfg, prepared)
+}
+
 func TestQQSendTextReply(t *testing.T) {
 	t.Parallel()
 
@@ -42,14 +58,14 @@ func TestQQSendTextReply(t *testing.T) {
 	defer server.Close()
 
 	adapter := newTestQQAdapter(server)
-	err := adapter.Send(context.Background(), channel.ChannelConfig{
+	err := sendPreparedQQ(t, adapter, channel.ChannelConfig{
 		ID:    "cfg-1",
 		BotID: "bot-1",
 		Credentials: map[string]any{
 			"appId":        "1024",
 			"clientSecret": "secret",
 		},
-	}, channel.OutboundMessage{
+	}, nil, channel.OutboundMessage{
 		Target: "c2c:user-openid",
 		Message: channel.Message{
 			Text:  "hello",
@@ -118,19 +134,24 @@ func TestQQSendImageAttachment(t *testing.T) {
 			Mime:        "image/png",
 		},
 	})
-	err := adapter.Send(context.Background(), channel.ChannelConfig{
+	store := channeltest.NewMemoryAttachmentStore()
+	asset, err := store.SeedAsset("bot-2", []byte("png-bytes"), "image/png", ".png")
+	if err != nil {
+		t.Fatalf("seed asset: %v", err)
+	}
+	err = sendPreparedQQ(t, adapter, channel.ChannelConfig{
 		ID:    "cfg-2",
 		BotID: "bot-2",
 		Credentials: map[string]any{
 			"appId":        "2048",
 			"clientSecret": "secret",
 		},
-	}, channel.OutboundMessage{
+	}, store, channel.OutboundMessage{
 		Target: "group:group-openid",
 		Message: channel.Message{
 			Attachments: []channel.Attachment{{
 				Type:        channel.AttachmentImage,
-				ContentHash: "hash-1",
+				ContentHash: asset.ContentHash,
 				Name:        "image.png",
 			}},
 			Reply: &channel.ReplyRef{MessageID: "source-msg"},
@@ -202,14 +223,14 @@ func TestQQSendImageAttachmentCaptionUsesMediaContent(t *testing.T) {
 	defer server.Close()
 
 	adapter := newTestQQAdapter(server)
-	err := adapter.Send(context.Background(), channel.ChannelConfig{
+	err := sendPreparedQQ(t, adapter, channel.ChannelConfig{
 		ID:    "cfg-2b",
 		BotID: "bot-2b",
 		Credentials: map[string]any{
 			"appId":        "2049",
 			"clientSecret": "secret",
 		},
-	}, channel.OutboundMessage{
+	}, nil, channel.OutboundMessage{
 		Target: "c2c:user-openid",
 		Message: channel.Message{
 			Attachments: []channel.Attachment{{
@@ -292,19 +313,20 @@ func TestQQSendChannelImageIsUnsupported(t *testing.T) {
 	defer server.Close()
 
 	adapter := newTestQQAdapter(server)
-	err := adapter.Send(context.Background(), channel.ChannelConfig{
+	err := sendPreparedQQ(t, adapter, channel.ChannelConfig{
 		ID:    "cfg-4",
 		BotID: "bot-4",
 		Credentials: map[string]any{
 			"appId":        "8192",
 			"clientSecret": "secret",
 		},
-	}, channel.OutboundMessage{
+	}, nil, channel.OutboundMessage{
 		Target: "channel:channel-1",
 		Message: channel.Message{
 			Attachments: []channel.Attachment{{
-				Type: channel.AttachmentImage,
-				URL:  "https://example.com/output.png",
+				Type:   channel.AttachmentImage,
+				Base64: "iVBORw0KGgo=",
+				Name:   "output.png",
 			}},
 		},
 	})
@@ -339,14 +361,14 @@ func TestQQSendChannelReplyIncludesMessageReference(t *testing.T) {
 	defer server.Close()
 
 	adapter := newTestQQAdapter(server)
-	err := adapter.Send(context.Background(), channel.ChannelConfig{
+	err := sendPreparedQQ(t, adapter, channel.ChannelConfig{
 		ID:    "cfg-5",
 		BotID: "bot-5",
 		Credentials: map[string]any{
 			"appId":        "16384",
 			"clientSecret": "secret",
 		},
-	}, channel.OutboundMessage{
+	}, nil, channel.OutboundMessage{
 		Target: "channel:channel-1",
 		Message: channel.Message{
 			Text:  "hello",
@@ -402,14 +424,14 @@ func TestQQSendGroupFileUsesNativeUpload(t *testing.T) {
 	defer server.Close()
 
 	adapter := newTestQQAdapter(server)
-	err := adapter.Send(context.Background(), channel.ChannelConfig{
+	err := sendPreparedQQ(t, adapter, channel.ChannelConfig{
 		ID:    "cfg-6",
 		BotID: "bot-6",
 		Credentials: map[string]any{
 			"appId":        "32768",
 			"clientSecret": "secret",
 		},
-	}, channel.OutboundMessage{
+	}, nil, channel.OutboundMessage{
 		Target: "group:group-openid",
 		Message: channel.Message{
 			Attachments: []channel.Attachment{{
@@ -455,20 +477,20 @@ func TestQQSendChannelFileIsUnsupported(t *testing.T) {
 	defer server.Close()
 
 	adapter := newTestQQAdapter(server)
-	err := adapter.Send(context.Background(), channel.ChannelConfig{
+	err := sendPreparedQQ(t, adapter, channel.ChannelConfig{
 		ID:    "cfg-7",
 		BotID: "bot-7",
 		Credentials: map[string]any{
 			"appId":        "65536",
 			"clientSecret": "secret",
 		},
-	}, channel.OutboundMessage{
+	}, nil, channel.OutboundMessage{
 		Target: "channel:channel-1",
 		Message: channel.Message{
 			Attachments: []channel.Attachment{{
-				Type: channel.AttachmentFile,
-				URL:  "https://example.com/files/report.pdf",
-				Name: "report.pdf",
+				Type:   channel.AttachmentFile,
+				Base64: "JVBERi0xLjQ=",
+				Name:   "report.pdf",
 			}},
 			Reply: &channel.ReplyRef{MessageID: "source-msg"},
 		},
@@ -504,14 +526,14 @@ func TestQQSendImageWithLocalPathFailsBeforeAPI(t *testing.T) {
 	defer server.Close()
 
 	adapter := newTestQQAdapter(server)
-	err := adapter.Send(context.Background(), channel.ChannelConfig{
+	err := sendPreparedQQ(t, adapter, channel.ChannelConfig{
 		ID:    "cfg-8",
 		BotID: "bot-8",
 		Credentials: map[string]any{
 			"appId":        "131072",
 			"clientSecret": "secret",
 		},
-	}, channel.OutboundMessage{
+	}, nil, channel.OutboundMessage{
 		Target: "group:group-openid",
 		Message: channel.Message{
 			Attachments: []channel.Attachment{{
@@ -524,7 +546,7 @@ func TestQQSendImageWithLocalPathFailsBeforeAPI(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected local path error")
 	}
-	if !strings.Contains(err.Error(), "requires http(s) URL, base64, or content_hash") {
+	if !strings.Contains(err.Error(), "attachment reference is required") {
 		t.Fatalf("unexpected error: %v", err)
 	}
 	if tokenCalls != 0 {
@@ -567,20 +589,25 @@ func TestQQSendChannelImageFromStoredAssetIsUnsupported(t *testing.T) {
 		},
 	}
 	adapter.SetAssetOpener(opener)
+	store := channeltest.NewMemoryAttachmentStore()
+	asset, err := store.SeedAsset("bot-4", []byte("png-bytes"), "image/png", ".png")
+	if err != nil {
+		t.Fatalf("seed asset: %v", err)
+	}
 
-	err := adapter.Send(context.Background(), channel.ChannelConfig{
+	err = sendPreparedQQ(t, adapter, channel.ChannelConfig{
 		ID:    "cfg-4",
 		BotID: "bot-4",
 		Credentials: map[string]any{
 			"appId":        "8192",
 			"clientSecret": "secret",
 		},
-	}, channel.OutboundMessage{
+	}, store, channel.OutboundMessage{
 		Target: "channel:channel-1",
 		Message: channel.Message{
 			Attachments: []channel.Attachment{{
 				Type:        channel.AttachmentImage,
-				ContentHash: "hash-1",
+				ContentHash: asset.ContentHash,
 				Name:        "image.png",
 			}},
 		},
@@ -640,14 +667,14 @@ func TestQQSendVoiceAttachmentFromHTTPURLUsesDetectedMime(t *testing.T) {
 	defer server.Close()
 
 	adapter := newTestQQAdapter(server)
-	err := adapter.Send(context.Background(), channel.ChannelConfig{
+	err := sendPreparedQQ(t, adapter, channel.ChannelConfig{
 		ID:    "cfg-voice",
 		BotID: "bot-voice",
 		Credentials: map[string]any{
 			"appId":        "524288",
 			"clientSecret": "secret",
 		},
-	}, channel.OutboundMessage{
+	}, nil, channel.OutboundMessage{
 		Target: "group:group-openid",
 		Message: channel.Message{
 			Attachments: []channel.Attachment{{
@@ -712,14 +739,14 @@ func TestQQSendImageAttachmentFromHTTPURLUsesFetchedBytes(t *testing.T) {
 	defer server.Close()
 
 	adapter := newTestQQAdapter(server)
-	err := adapter.Send(context.Background(), channel.ChannelConfig{
+	err := sendPreparedQQ(t, adapter, channel.ChannelConfig{
 		ID:    "cfg-9",
 		BotID: "bot-9",
 		Credentials: map[string]any{
 			"appId":        "262144",
 			"clientSecret": "secret",
 		},
-	}, channel.OutboundMessage{
+	}, nil, channel.OutboundMessage{
 		Target: "group:group-openid",
 		Message: channel.Message{
 			Attachments: []channel.Attachment{{
diff --git a/internal/channel/adapters/qq/stream.go b/internal/channel/adapters/qq/stream.go
index 24bfb9e6..a06bfec7 100644
--- a/internal/channel/adapters/qq/stream.go
+++ b/internal/channel/adapters/qq/stream.go
@@ -14,16 +14,16 @@ import (
 type qqOutboundStream struct {
 	target string
 	reply  *channel.ReplyRef
-	send   func(context.Context, channel.OutboundMessage) error
+	send   func(context.Context, channel.PreparedOutboundMessage) error
 
 	closed      atomic.Bool
 	mu          sync.Mutex
 	buffer      strings.Builder
-	attachments []channel.Attachment
+	attachments []channel.PreparedAttachment
 	sentText    bool
 }
 
-func (a *QQAdapter) OpenStream(_ context.Context, cfg channel.ChannelConfig, target string, opts channel.StreamOptions) (channel.OutboundStream, error) {
+func (a *QQAdapter) OpenStream(_ context.Context, cfg channel.ChannelConfig, target string, opts channel.StreamOptions) (channel.PreparedOutboundStream, error) {
 	parsed, err := parseConfig(cfg.Credentials)
 	if err != nil {
 		return nil, fmt.Errorf("qq open stream: %w", err)
@@ -32,19 +32,19 @@ func (a *QQAdapter) OpenStream(_ context.Context, cfg channel.ChannelConfig, tar
 	return &qqOutboundStream{
 		target: target,
 		reply:  opts.Reply,
-		send: func(ctx context.Context, msg channel.OutboundMessage) error {
+		send: func(ctx context.Context, msg channel.PreparedOutboundMessage) error {
 			if msg.Target == "" {
 				msg.Target = target
 			}
-			if msg.Message.Reply == nil && opts.Reply != nil {
-				msg.Message.Reply = opts.Reply
+			if msg.Message.Message.Reply == nil && opts.Reply != nil {
+				msg.Message.Message.Reply = opts.Reply
 			}
 			return a.Send(ctx, cfg, msg)
 		},
 	}, nil
 }
 
-func (s *qqOutboundStream) Push(ctx context.Context, event channel.StreamEvent) error {
+func (s *qqOutboundStream) Push(ctx context.Context, event channel.PreparedStreamEvent) error {
 	if s == nil || s.send == nil {
 		return errors.New("qq stream not configured")
 	}
@@ -90,8 +90,10 @@ func (s *qqOutboundStream) Push(ctx context.Context, event channel.StreamEvent)
 		if errText == "" {
 			return nil
 		}
-		return s.flush(ctx, channel.Message{
-			Text: "Error: " + errText,
+		return s.flush(ctx, channel.PreparedMessage{
+			Message: channel.Message{
+				Text: "Error: " + errText,
+			},
 		})
 	case channel.StreamEventFinal:
 		if event.Final == nil {
@@ -116,43 +118,62 @@ func (s *qqOutboundStream) Close(ctx context.Context) error {
 	return nil
 }
 
-func (s *qqOutboundStream) flush(ctx context.Context, msg channel.Message) error {
+func (s *qqOutboundStream) flush(ctx context.Context, msg channel.PreparedMessage) error {
 	s.mu.Lock()
 	bufferedText := strings.TrimSpace(s.buffer.String())
-	bufferedAttachments := append([]channel.Attachment(nil), s.attachments...)
+	bufferedAttachments := append([]channel.PreparedAttachment(nil), s.attachments...)
 	alreadySentText := s.sentText
 	s.buffer.Reset()
 	s.attachments = nil
 	s.mu.Unlock()
 
+	logicalMsg := msg.LogicalMessage()
 	if bufferedText != "" {
-		msg.Text = bufferedText
-		msg.Parts = nil
-		if msg.Format == "" {
-			msg.Format = channel.MessageFormatPlain
+		logicalMsg.Text = bufferedText
+		logicalMsg.Parts = nil
+		if logicalMsg.Format == "" {
+			logicalMsg.Format = channel.MessageFormatPlain
 		}
-	} else if alreadySentText && len(bufferedAttachments) == 0 && len(msg.Attachments) == 0 && strings.TrimSpace(msg.PlainText()) != "" {
+	} else if alreadySentText && len(bufferedAttachments) == 0 && len(msg.Attachments) == 0 && strings.TrimSpace(logicalMsg.PlainText()) != "" {
 		return nil
 	}
+	preparedAttachments := append([]channel.PreparedAttachment(nil), bufferedAttachments...)
 	if len(bufferedAttachments) > 0 {
-		msg.Attachments = append(bufferedAttachments, msg.Attachments...)
+		logicalMsg.Attachments = append(preparedAttachmentLogicals(bufferedAttachments), logicalMsg.Attachments...)
+		preparedAttachments = append(preparedAttachments, msg.Attachments...)
+	} else {
+		preparedAttachments = append(preparedAttachments, msg.Attachments...)
 	}
-	if msg.Reply == nil && s.reply != nil {
-		msg.Reply = s.reply
+	if logicalMsg.Reply == nil && s.reply != nil {
+		logicalMsg.Reply = s.reply
 	}
-	if msg.IsEmpty() {
+	if logicalMsg.IsEmpty() && len(preparedAttachments) == 0 {
 		return nil
 	}
-	if err := s.send(ctx, channel.OutboundMessage{
-		Target:  s.target,
-		Message: msg,
+	if err := s.send(ctx, channel.PreparedOutboundMessage{
+		Target: s.target,
+		Message: channel.PreparedMessage{
+			Message:     logicalMsg,
+			Attachments: preparedAttachments,
+		},
 	}); err != nil {
 		return err
 	}
-	if strings.TrimSpace(msg.PlainText()) != "" {
+	if strings.TrimSpace(logicalMsg.PlainText()) != "" {
 		s.mu.Lock()
 		s.sentText = true
 		s.mu.Unlock()
 	}
 	return nil
 }
+
+func preparedAttachmentLogicals(attachments []channel.PreparedAttachment) []channel.Attachment {
+	if len(attachments) == 0 {
+		return nil
+	}
+	logical := make([]channel.Attachment, 0, len(attachments))
+	for _, att := range attachments {
+		logical = append(logical, att.Logical)
+	}
+	return logical
+}
diff --git a/internal/channel/adapters/qq/stream_test.go b/internal/channel/adapters/qq/stream_test.go
index 487964d0..e70e01c0 100644
--- a/internal/channel/adapters/qq/stream_test.go
+++ b/internal/channel/adapters/qq/stream_test.go
@@ -2,35 +2,67 @@ package qq
 
 import (
 	"context"
+	"io"
 	"strings"
 	"testing"
 
 	"github.com/memohai/memoh/internal/channel"
 )
 
+func preparedQQEvent(event channel.StreamEvent) channel.PreparedStreamEvent {
+	prepared := channel.PreparedStreamEvent{
+		Type:   event.Type,
+		Delta:  event.Delta,
+		Error:  event.Error,
+		Status: event.Status,
+		Phase:  event.Phase,
+	}
+	if len(event.Attachments) > 0 {
+		prepared.Attachments = make([]channel.PreparedAttachment, 0, len(event.Attachments))
+		for _, att := range event.Attachments {
+			prepared.Attachments = append(prepared.Attachments, channel.PreparedAttachment{
+				Logical:   att,
+				Kind:      channel.PreparedAttachmentUpload,
+				Name:      att.Name,
+				Mime:      att.Mime,
+				PublicURL: att.URL,
+				Open: func(context.Context) (io.ReadCloser, error) {
+					return io.NopCloser(strings.NewReader("test")), nil
+				},
+			})
+		}
+	}
+	if event.Final != nil {
+		prepared.Final = &channel.PreparedStreamFinalizePayload{
+			Message: channel.PreparedMessage{Message: event.Final.Message},
+		}
+	}
+	return prepared
+}
+
 func TestQQOutboundStreamFlushesBufferedTextOnFinal(t *testing.T) {
 	t.Parallel()
 
 	var sent []channel.OutboundMessage
 	stream := &qqOutboundStream{
 		target: "c2c:user-openid",
-		send: func(_ context.Context, msg channel.OutboundMessage) error {
-			sent = append(sent, msg)
+		send: func(_ context.Context, msg channel.PreparedOutboundMessage) error {
+			sent = append(sent, msg.LogicalMessage())
 			return nil
 		},
 	}
 
 	ctx := context.Background()
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventStatus, Status: channel.StreamStatusStarted}); err != nil {
+	if err := stream.Push(ctx, preparedQQEvent(channel.StreamEvent{Type: channel.StreamEventStatus, Status: channel.StreamStatusStarted})); err != nil {
 		t.Fatalf("push status: %v", err)
 	}
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "Hi "}); err != nil {
+	if err := stream.Push(ctx, preparedQQEvent(channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "Hi "})); err != nil {
 		t.Fatalf("push delta1: %v", err)
 	}
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "there"}); err != nil {
+	if err := stream.Push(ctx, preparedQQEvent(channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "there"})); err != nil {
 		t.Fatalf("push delta2: %v", err)
 	}
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventFinal, Final: &channel.StreamFinalizePayload{}}); err != nil {
+	if err := stream.Push(ctx, preparedQQEvent(channel.StreamEvent{Type: channel.StreamEventFinal, Final: &channel.StreamFinalizePayload{}})); err != nil {
 		t.Fatalf("push final: %v", err)
 	}
 
@@ -51,25 +83,25 @@ func TestQQOutboundStreamFinalUsesExplicitMessageAndBufferedAttachments(t *testi
 	var sent []channel.OutboundMessage
 	stream := &qqOutboundStream{
 		target: "group:group-openid",
-		send: func(_ context.Context, msg channel.OutboundMessage) error {
-			sent = append(sent, msg)
+		send: func(_ context.Context, msg channel.PreparedOutboundMessage) error {
+			sent = append(sent, msg.LogicalMessage())
 			return nil
 		},
 	}
 
 	ctx := context.Background()
-	if err := stream.Push(ctx, channel.StreamEvent{
+	if err := stream.Push(ctx, preparedQQEvent(channel.StreamEvent{
 		Type:        channel.StreamEventAttachment,
 		Attachments: []channel.Attachment{{Type: channel.AttachmentImage, URL: "https://example.com/a.png"}},
-	}); err != nil {
+	})); err != nil {
 		t.Fatalf("push attachment: %v", err)
 	}
-	if err := stream.Push(ctx, channel.StreamEvent{
+	if err := stream.Push(ctx, preparedQQEvent(channel.StreamEvent{
 		Type: channel.StreamEventFinal,
 		Final: &channel.StreamFinalizePayload{Message: channel.Message{
 			Text: "done",
 		}},
-	}); err != nil {
+	})); err != nil {
 		t.Fatalf("push final: %v", err)
 	}
 
@@ -90,25 +122,25 @@ func TestQQOutboundStreamFinalPrefersBufferedVisibleText(t *testing.T) {
 	var sent []channel.OutboundMessage
 	stream := &qqOutboundStream{
 		target: "c2c:user-openid",
-		send: func(_ context.Context, msg channel.OutboundMessage) error {
-			sent = append(sent, msg)
+		send: func(_ context.Context, msg channel.PreparedOutboundMessage) error {
+			sent = append(sent, msg.LogicalMessage())
 			return nil
 		},
 	}
 
 	ctx := context.Background()
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "visible "}); err != nil {
+	if err := stream.Push(ctx, preparedQQEvent(channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "visible "})); err != nil {
 		t.Fatalf("push delta1: %v", err)
 	}
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "answer"}); err != nil {
+	if err := stream.Push(ctx, preparedQQEvent(channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "answer"})); err != nil {
 		t.Fatalf("push delta2: %v", err)
 	}
-	if err := stream.Push(ctx, channel.StreamEvent{
+	if err := stream.Push(ctx, preparedQQEvent(channel.StreamEvent{
 		Type: channel.StreamEventFinal,
 		Final: &channel.StreamFinalizePayload{Message: channel.Message{
 			Text: "internal trace\nvisible answer",
 		}},
-	}); err != nil {
+	})); err != nil {
 		t.Fatalf("push final: %v", err)
 	}
 
@@ -126,25 +158,25 @@ func TestQQOutboundStreamIgnoresLaterTextOnlyFinalAfterBufferedReply(t *testing.
 	var sent []channel.OutboundMessage
 	stream := &qqOutboundStream{
 		target: "c2c:user-openid",
-		send: func(_ context.Context, msg channel.OutboundMessage) error {
-			sent = append(sent, msg)
+		send: func(_ context.Context, msg channel.PreparedOutboundMessage) error {
+			sent = append(sent, msg.LogicalMessage())
 			return nil
 		},
 	}
 
 	ctx := context.Background()
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "visible answer"}); err != nil {
+	if err := stream.Push(ctx, preparedQQEvent(channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "visible answer"})); err != nil {
 		t.Fatalf("push delta: %v", err)
 	}
-	if err := stream.Push(ctx, channel.StreamEvent{Type: channel.StreamEventFinal, Final: &channel.StreamFinalizePayload{}}); err != nil {
+	if err := stream.Push(ctx, preparedQQEvent(channel.StreamEvent{Type: channel.StreamEventFinal, Final: &channel.StreamFinalizePayload{}})); err != nil {
 		t.Fatalf("push first final: %v", err)
 	}
-	if err := stream.Push(ctx, channel.StreamEvent{
+	if err := stream.Push(ctx, preparedQQEvent(channel.StreamEvent{
 		Type: channel.StreamEventFinal,
 		Final: &channel.StreamFinalizePayload{Message: channel.Message{
 			Text: "我需要按照用户的要求，在工具调用后完整复述。",
 		}},
-	}); err != nil {
+	})); err != nil {
 		t.Fatalf("push second final: %v", err)
 	}
 
@@ -163,10 +195,10 @@ func TestQQOutboundStreamRejectsAfterClose(t *testing.T) {
 	if err := stream.Close(context.Background()); err != nil {
 		t.Fatalf("close: %v", err)
 	}
-	if err := stream.Push(context.Background(), channel.StreamEvent{
+	if err := stream.Push(context.Background(), preparedQQEvent(channel.StreamEvent{
 		Type:  channel.StreamEventDelta,
 		Delta: "x",
-	}); err == nil {
+	})); err == nil {
 		t.Fatal("expected closed error")
 	}
 }
@@ -182,13 +214,13 @@ func TestQQOutboundStreamErrorRedactsRegisteredTokenFragments(t *testing.T) {
 	var sent []channel.OutboundMessage
 	stream := &qqOutboundStream{
 		target: "c2c:user-openid",
-		send: func(_ context.Context, msg channel.OutboundMessage) error {
-			sent = append(sent, msg)
+		send: func(_ context.Context, msg channel.PreparedOutboundMessage) error {
+			sent = append(sent, msg.LogicalMessage())
 			return nil
 		},
 	}
 
-	err := stream.Push(context.Background(), channel.StreamEvent{Type: channel.StreamEventError, Error: "failed: " + prefixHalf})
+	err := stream.Push(context.Background(), preparedQQEvent(channel.StreamEvent{Type: channel.StreamEventError, Error: "failed: " + prefixHalf}))
 	if err != nil {
 		t.Fatalf("push error: %v", err)
 	}
diff --git a/internal/channel/adapters/telegram/stream.go b/internal/channel/adapters/telegram/stream.go
index 19d3674b..6ca70428 100644
--- a/internal/channel/adapters/telegram/stream.go
+++ b/internal/channel/adapters/telegram/stream.go
@@ -314,7 +314,7 @@ func (s *telegramOutboundStream) pushToolCallStart(ctx context.Context) error {
 	return nil
 }
 
-func (s *telegramOutboundStream) pushAttachment(ctx context.Context, event channel.StreamEvent) error {
+func (s *telegramOutboundStream) pushAttachment(ctx context.Context, event channel.PreparedStreamEvent) error {
 	if len(event.Attachments) == 0 {
 		return nil
 	}
@@ -323,11 +323,11 @@ func (s *telegramOutboundStream) pushAttachment(ctx context.Context, event chann
 		return err
 	}
 	for _, att := range event.Attachments {
-		if sendErr := sendTelegramAttachmentWithAssets(ctx, bot, s.target, att, "", replyTo, "", s.adapter.assets); sendErr != nil {
+		if sendErr := sendTelegramAttachmentWithAssets(ctx, bot, s.target, att, "", replyTo, ""); sendErr != nil {
 			if s.adapter != nil && s.adapter.logger != nil {
 				s.adapter.logger.Warn("telegram: stream attachment send failed",
 					slog.String("config_id", s.cfg.ID),
-					slog.String("type", string(att.Type)),
+					slog.String("type", string(att.Logical.Type)),
 					slog.Any("error", sendErr),
 				)
 			}
@@ -336,7 +336,7 @@ func (s *telegramOutboundStream) pushAttachment(ctx context.Context, event chann
 	return nil
 }
 
-func (s *telegramOutboundStream) pushPhaseEnd(ctx context.Context, event channel.StreamEvent) error {
+func (s *telegramOutboundStream) pushPhaseEnd(ctx context.Context, event channel.PreparedStreamEvent) error {
 	if event.Phase != channel.StreamPhaseText {
 		return nil
 	}
@@ -358,7 +358,7 @@ func (s *telegramOutboundStream) pushPhaseEnd(ctx context.Context, event channel
 	return nil
 }
 
-func (s *telegramOutboundStream) pushDelta(ctx context.Context, event channel.StreamEvent) error {
+func (s *telegramOutboundStream) pushDelta(ctx context.Context, event channel.PreparedStreamEvent) error {
 	if event.Delta == "" || event.Phase == channel.StreamPhaseReasoning {
 		return nil
 	}
@@ -376,7 +376,7 @@ func (s *telegramOutboundStream) pushDelta(ctx context.Context, event channel.St
 	return s.editStreamMessage(ctx, content)
 }
 
-func (s *telegramOutboundStream) pushFinal(ctx context.Context, event channel.StreamEvent) error {
+func (s *telegramOutboundStream) pushFinal(ctx context.Context, event channel.PreparedStreamEvent) error {
 	// In draft mode, read and reset buffer atomically to prevent duplicate
 	// permanent messages when multiple StreamEventFinal events fire
 	// (one per assistant output in multi-tool-call responses).
@@ -387,7 +387,7 @@ func (s *telegramOutboundStream) pushFinal(ctx context.Context, event channel.St
 	}
 	s.mu.Unlock()
 
-	if event.Final == nil || event.Final.Message.IsEmpty() {
+	if event.Final == nil || event.Final.Message.Message.IsEmpty() {
 		if bufText != "" {
 			bufText = s.formatStreamContent(bufText)
 			if err := s.deliverFinalText(ctx, bufText, s.parseMode); err != nil {
@@ -401,13 +401,13 @@ func (s *telegramOutboundStream) pushFinal(ctx context.Context, event channel.St
 
 	msg := event.Final.Message
 	finalText := bufText
-	if authoritative := strings.TrimSpace(msg.PlainText()); authoritative != "" {
+	if authoritative := strings.TrimSpace(msg.Message.PlainText()); authoritative != "" {
 		if !s.isPrivateChat || bufText != "" {
 			finalText = authoritative
 		}
 	}
 	// Convert markdown to Telegram HTML for the final message.
-	formatted, pm := formatTelegramOutput(finalText, msg.Format)
+	formatted, pm := formatTelegramOutput(finalText, msg.Message.Format)
 	if pm != "" {
 		s.mu.Lock()
 		s.parseMode = pm
@@ -431,7 +431,7 @@ func (s *telegramOutboundStream) pushFinal(ctx context.Context, event channel.St
 			if i > 0 {
 				to = 0
 			}
-			if err := sendTelegramAttachmentWithAssets(ctx, bot, s.target, att, "", to, parseMode, s.adapter.assets); err != nil && s.adapter.logger != nil {
+			if err := sendTelegramAttachmentWithAssets(ctx, bot, s.target, att, "", to, parseMode); err != nil && s.adapter.logger != nil {
 				s.adapter.logger.Error("stream final attachment failed", slog.String("config_id", s.cfg.ID), slog.Any("error", err))
 			}
 		}
@@ -439,7 +439,7 @@ func (s *telegramOutboundStream) pushFinal(ctx context.Context, event channel.St
 	return nil
 }
 
-func (s *telegramOutboundStream) pushError(ctx context.Context, event channel.StreamEvent) error {
+func (s *telegramOutboundStream) pushError(ctx context.Context, event channel.PreparedStreamEvent) error {
 	errText := channel.RedactIMErrorText(strings.TrimSpace(event.Error))
 	if errText == "" {
 		return nil
@@ -459,7 +459,7 @@ func (s *telegramOutboundStream) pushError(ctx context.Context, event channel.St
 	return s.editStreamMessage(ctx, display)
 }
 
-func (s *telegramOutboundStream) Push(ctx context.Context, event channel.StreamEvent) error {
+func (s *telegramOutboundStream) Push(ctx context.Context, event channel.PreparedStreamEvent) error {
 	if s == nil || s.adapter == nil {
 		return errors.New("telegram stream not configured")
 	}
diff --git a/internal/channel/adapters/telegram/stream_test.go b/internal/channel/adapters/telegram/stream_test.go
index f2c49659..9d6593f2 100644
--- a/internal/channel/adapters/telegram/stream_test.go
+++ b/internal/channel/adapters/telegram/stream_test.go
@@ -12,6 +12,18 @@ import (
 	"github.com/memohai/memoh/internal/channel"
 )
 
+func mustPreparedTelegramEvent(t *testing.T, event channel.StreamEvent) channel.PreparedStreamEvent {
+	t.Helper()
+	prepared, err := channel.PrepareStreamEvent(context.Background(), nil, channel.ChannelConfig{
+		BotID:       "bot-test",
+		ChannelType: Type,
+	}, event)
+	if err != nil {
+		t.Fatalf("prepare telegram stream event: %v", err)
+	}
+	return prepared
+}
+
 func TestTelegramOutboundStream_CloseNil(t *testing.T) {
 	t.Parallel()
 
@@ -30,7 +42,7 @@ func TestTelegramOutboundStream_PushClosed(t *testing.T) {
 	s.closed.Store(true)
 
 	ctx := context.Background()
-	err := s.Push(ctx, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "x"})
+	err := s.Push(ctx, mustPreparedTelegramEvent(t, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "x"}))
 	if err == nil {
 		t.Fatal("Push on closed stream should return error")
 	}
@@ -46,7 +58,7 @@ func TestTelegramOutboundStream_PushStatusNoOp(t *testing.T) {
 	s := &telegramOutboundStream{adapter: adapter}
 
 	ctx := context.Background()
-	err := s.Push(ctx, channel.StreamEvent{Type: channel.StreamEventStatus})
+	err := s.Push(ctx, mustPreparedTelegramEvent(t, channel.StreamEvent{Type: channel.StreamEventStatus}))
 	if err != nil {
 		t.Fatalf("StreamEventStatus should be no-op: %v", err)
 	}
@@ -57,7 +69,7 @@ func TestTelegramOutboundStream_PushNilAdapter(t *testing.T) {
 
 	s := &telegramOutboundStream{adapter: nil}
 	ctx := context.Background()
-	err := s.Push(ctx, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "x"})
+	err := s.Push(ctx, mustPreparedTelegramEvent(t, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "x"}))
 	if err == nil {
 		t.Fatal("Push with nil adapter should return error")
 	}
@@ -73,7 +85,7 @@ func TestTelegramOutboundStream_PushUnknownEventTypeSkipped(t *testing.T) {
 	s := &telegramOutboundStream{adapter: adapter}
 	ctx := context.Background()
 
-	err := s.Push(ctx, channel.StreamEvent{Type: channel.StreamEventType("unknown")})
+	err := s.Push(ctx, mustPreparedTelegramEvent(t, channel.StreamEvent{Type: channel.StreamEventType("unknown")}))
 	if err != nil {
 		t.Fatalf("Push with unknown event type should be silently skipped: %v", err)
 	}
@@ -86,7 +98,7 @@ func TestTelegramOutboundStream_PushEmptyDeltaNoOp(t *testing.T) {
 	s := &telegramOutboundStream{adapter: adapter}
 	ctx := context.Background()
 
-	err := s.Push(ctx, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: ""})
+	err := s.Push(ctx, mustPreparedTelegramEvent(t, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: ""}))
 	if err != nil {
 		t.Fatalf("empty delta should be no-op: %v", err)
 	}
@@ -99,7 +111,7 @@ func TestTelegramOutboundStream_PushErrorEventEmptyNoOp(t *testing.T) {
 	s := &telegramOutboundStream{adapter: adapter}
 	ctx := context.Background()
 
-	err := s.Push(ctx, channel.StreamEvent{Type: channel.StreamEventError, Error: ""})
+	err := s.Push(ctx, mustPreparedTelegramEvent(t, channel.StreamEvent{Type: channel.StreamEventError, Error: ""}))
 	if err != nil {
 		t.Fatalf("empty error event should be no-op: %v", err)
 	}
@@ -140,7 +152,7 @@ func TestTelegramOutboundStream_PushErrorEventRedactsRegisteredTokenFragments(t
 	}()
 
 	prefixHalf := botToken[:len(botToken)/2]
-	err = s.Push(context.Background(), channel.StreamEvent{Type: channel.StreamEventError, Error: "request failed: " + prefixHalf})
+	err = s.Push(context.Background(), mustPreparedTelegramEvent(t, channel.StreamEvent{Type: channel.StreamEventError, Error: "request failed: " + prefixHalf}))
 	if err != nil {
 		t.Fatalf("push error event: %v", err)
 	}
@@ -504,7 +516,7 @@ func TestDraftMode_DeltaUsesSendDraft(t *testing.T) {
 		sendDraftForTest = origDraft
 	}()
 
-	err := s.Push(ctx, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "Hello "})
+	err := s.Push(ctx, mustPreparedTelegramEvent(t, channel.StreamEvent{Type: channel.StreamEventDelta, Delta: "Hello "}))
 	if err != nil {
 		t.Fatalf("Push delta should succeed: %v", err)
 	}
@@ -532,10 +544,10 @@ func TestDraftMode_PhaseEndTextIsNoOp(t *testing.T) {
 	s.buf.WriteString("some content")
 	ctx := context.Background()
 
-	err := s.Push(ctx, channel.StreamEvent{
+	err := s.Push(ctx, mustPreparedTelegramEvent(t, channel.StreamEvent{
 		Type:  channel.StreamEventPhaseEnd,
 		Phase: channel.StreamPhaseText,
-	})
+	}))
 	if err != nil {
 		t.Fatalf("PhaseEnd in draft mode should be no-op: %v", err)
 	}
@@ -575,7 +587,7 @@ func TestDraftMode_ToolCallStartSendsPermanentMessage(t *testing.T) {
 		sendTextForTest = origSendText
 	}()
 
-	err := s.Push(ctx, channel.StreamEvent{Type: channel.StreamEventToolCallStart})
+	err := s.Push(ctx, mustPreparedTelegramEvent(t, channel.StreamEvent{Type: channel.StreamEventToolCallStart}))
 	if err != nil {
 		t.Fatalf("Push ToolCallStart should succeed: %v", err)
 	}
@@ -624,12 +636,12 @@ func TestDraftMode_FinalEmptyBufferSkipsDuplicate(t *testing.T) {
 		sendTextForTest = origSendText
 	}()
 
-	err := s.Push(ctx, channel.StreamEvent{
+	err := s.Push(ctx, mustPreparedTelegramEvent(t, channel.StreamEvent{
 		Type: channel.StreamEventFinal,
 		Final: &channel.StreamFinalizePayload{
 			Message: channel.Message{Text: "already sent text"},
 		},
-	})
+	}))
 	if err != nil {
 		t.Fatalf("StreamEventFinal with empty buffer in draft mode should succeed: %v", err)
 	}
@@ -672,12 +684,12 @@ func TestDraftMode_MultipleFinalEventsOnlyOneSend(t *testing.T) {
 	// Push 3 StreamEventFinal events (simulating 3 assistant outputs).
 	// Only the first should actually send a message.
 	for i, text := range []string{"intermediate 1", "intermediate 2", "final summary"} {
-		err := s.Push(ctx, channel.StreamEvent{
+		err := s.Push(ctx, mustPreparedTelegramEvent(t, channel.StreamEvent{
 			Type: channel.StreamEventFinal,
 			Final: &channel.StreamFinalizePayload{
 				Message: channel.Message{Text: text},
 			},
-		})
+		}))
 		if err != nil {
 			t.Fatalf("StreamEventFinal #%d should succeed: %v", i+1, err)
 		}
diff --git a/internal/channel/adapters/telegram/telegram.go b/internal/channel/adapters/telegram/telegram.go
index 0dcecd55..848a082d 100644
--- a/internal/channel/adapters/telegram/telegram.go
+++ b/internal/channel/adapters/telegram/telegram.go
@@ -3,7 +3,6 @@ package telegram
 import (
 	"cmp"
 	"context"
-	"encoding/base64"
 	"errors"
 	"fmt"
 	"io"
@@ -581,7 +580,7 @@ func (a *TelegramAdapter) logTelegramInbound(configID string, msg channel.Inboun
 }
 
 // Send delivers an outbound message to Telegram, handling text, attachments, and replies.
-func (a *TelegramAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg channel.OutboundMessage) error {
+func (a *TelegramAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg channel.PreparedOutboundMessage) error {
 	telegramCfg, err := parseConfig(cfg.Credentials)
 	if err != nil {
 		if a.logger != nil {
@@ -597,12 +596,12 @@ func (a *TelegramAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, m
 	if err != nil {
 		return err
 	}
-	if msg.Message.IsEmpty() {
+	if msg.Message.Message.IsEmpty() {
 		return errors.New("message is required")
 	}
-	text := strings.TrimSpace(msg.Message.PlainText())
-	text, parseMode := formatTelegramOutput(text, msg.Message.Format)
-	replyTo := parseReplyToMessageID(msg.Message.Reply)
+	text := strings.TrimSpace(msg.Message.Message.PlainText())
+	text, parseMode := formatTelegramOutput(text, msg.Message.Message.Format)
+	replyTo := parseReplyToMessageID(msg.Message.Message.Reply)
 	if len(msg.Message.Attachments) > 0 {
 		usedCaption := false
 		for i, att := range msg.Message.Attachments {
@@ -615,7 +614,7 @@ func (a *TelegramAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, m
 			if i > 0 {
 				applyReply = 0
 			}
-			if err := sendTelegramAttachmentWithAssets(ctx, bot, to, att, caption, applyReply, parseMode, a.assets); err != nil {
+			if err := sendTelegramAttachmentWithAssets(ctx, bot, to, att, caption, applyReply, parseMode); err != nil {
 				if a.logger != nil {
 					a.logger.Error("send attachment failed", slog.String("config_id", cfg.ID), slog.Any("error", err))
 				}
@@ -635,7 +634,7 @@ func (a *TelegramAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, m
 // animation, then sends a final permanent message via sendMessage.
 // For group/channel chats, sends one message then edits it in place as deltas
 // arrive (editMessageText), avoiding one message per delta and rate limits.
-func (a *TelegramAdapter) OpenStream(ctx context.Context, cfg channel.ChannelConfig, target string, opts channel.StreamOptions) (channel.OutboundStream, error) {
+func (a *TelegramAdapter) OpenStream(ctx context.Context, cfg channel.ChannelConfig, target string, opts channel.StreamOptions) (channel.PreparedOutboundStream, error) {
 	target = strings.TrimSpace(target)
 	if target == "" {
 		return nil, errors.New("telegram target is required")
@@ -861,29 +860,15 @@ func getTelegramRetryAfter(err error) time.Duration {
 	return 0
 }
 
-func sendTelegramAttachmentWithAssets(ctx context.Context, bot *tgbotapi.BotAPI, target string, att channel.Attachment, caption string, replyTo int, parseMode string, opener assetOpener) error {
-	return sendTelegramAttachmentImpl(ctx, bot, target, att, caption, replyTo, parseMode, opener)
+func sendTelegramAttachmentWithAssets(ctx context.Context, bot *tgbotapi.BotAPI, target string, att channel.PreparedAttachment, caption string, replyTo int, parseMode string) error {
+	return sendTelegramAttachmentImpl(ctx, bot, target, att, caption, replyTo, parseMode)
 }
 
-func sendTelegramAttachmentImpl(ctx context.Context, bot *tgbotapi.BotAPI, target string, att channel.Attachment, caption string, replyTo int, parseMode string, opener assetOpener) error {
-	urlRef := strings.TrimSpace(att.URL)
-	keyRef := strings.TrimSpace(att.PlatformKey)
-	sourcePlatform := strings.TrimSpace(att.SourcePlatform)
-	base64Ref := strings.TrimSpace(att.Base64)
-	assetID := strings.TrimSpace(att.ContentHash)
-	if urlRef == "" && keyRef == "" && base64Ref == "" && assetID == "" {
-		return errors.New("attachment reference is required")
+func sendTelegramAttachmentImpl(ctx context.Context, bot *tgbotapi.BotAPI, target string, att channel.PreparedAttachment, caption string, replyTo int, parseMode string) error {
+	if strings.TrimSpace(caption) == "" && strings.TrimSpace(att.Logical.Caption) != "" {
+		caption = strings.TrimSpace(att.Logical.Caption)
 	}
-	if strings.TrimSpace(caption) == "" && strings.TrimSpace(att.Caption) != "" {
-		caption = strings.TrimSpace(att.Caption)
-	}
-	var botID string
-	if att.Metadata != nil {
-		if bid, ok := att.Metadata["bot_id"].(string); ok {
-			botID = bid
-		}
-	}
-	file, err := resolveTelegramFile(ctx, urlRef, keyRef, base64Ref, sourcePlatform, att, assetID, botID, opener)
+	file, err := resolveTelegramFile(ctx, att)
 	if err != nil {
 		return err
 	}
@@ -892,7 +877,7 @@ func sendTelegramAttachmentImpl(ctx context.Context, bot *tgbotapi.BotAPI, targe
 		return targetErr
 	}
 	isChannel := channelUsername != ""
-	switch att.Type {
+	switch att.Logical.Type {
 	case channel.AttachmentImage:
 		var photo tgbotapi.PhotoConfig
 		if isChannel {
@@ -975,67 +960,44 @@ func sendTelegramAttachmentImpl(ctx context.Context, bot *tgbotapi.BotAPI, targe
 		_, err = bot.Send(animation)
 		return err
 	default:
-		return fmt.Errorf("unsupported attachment type: %s", att.Type)
+		return fmt.Errorf("unsupported attachment type: %s", att.Logical.Type)
 	}
 }
 
-// resolveTelegramFile determines the best tgbotapi.RequestFileData for an attachment.
-// Priority: PlatformKey > ContentHash (storage) > public URL > base64 data URL.
-func resolveTelegramFile(ctx context.Context, urlRef, keyRef, base64Ref, sourcePlatform string, att channel.Attachment, assetID, botID string, opener assetOpener) (tgbotapi.RequestFileData, error) {
-	if keyRef != "" && (sourcePlatform == "" || strings.EqualFold(sourcePlatform, Type.String())) {
-		return tgbotapi.FileID(keyRef), nil
-	}
-	if assetID != "" && opener != nil {
-		reader, asset, err := opener.Open(ctx, botID, assetID)
-		if err == nil {
-			data, readErr := io.ReadAll(io.LimitReader(reader, media.MaxAssetBytes+1))
-			_ = reader.Close()
-			if readErr == nil && len(data) > 0 {
-				name := strings.TrimSpace(att.Name)
-				if name == "" {
-					name = fileNameFromMime(asset.Mime, string(att.Type))
-				}
-				return tgbotapi.FileBytes{Name: name, Bytes: data}, nil
-			}
+// resolveTelegramFile maps a prepared attachment into Telegram's file input model.
+func resolveTelegramFile(ctx context.Context, att channel.PreparedAttachment) (tgbotapi.RequestFileData, error) {
+	switch att.Kind {
+	case channel.PreparedAttachmentNativeRef:
+		if strings.TrimSpace(att.NativeRef) == "" {
+			return nil, errors.New("telegram native ref is required")
 		}
-	}
-	if urlRef != "" && !strings.HasPrefix(strings.ToLower(urlRef), "data:") && !strings.HasPrefix(urlRef, "/") {
-		return tgbotapi.FileURL(urlRef), nil
-	}
-	raw := base64Ref
-	if raw == "" {
-		raw = urlRef
-	}
-	if raw != "" && strings.HasPrefix(strings.ToLower(raw), "data:") {
-		decoded, err := decodeDataURLBytes(raw)
+		return tgbotapi.FileID(strings.TrimSpace(att.NativeRef)), nil
+	case channel.PreparedAttachmentPublicURL:
+		if strings.TrimSpace(att.PublicURL) == "" {
+			return nil, errors.New("telegram public url is required")
+		}
+		return tgbotapi.FileURL(strings.TrimSpace(att.PublicURL)), nil
+	case channel.PreparedAttachmentUpload:
+		if att.Open == nil {
+			return nil, errors.New("telegram upload attachment is not openable")
+		}
+		reader, err := att.Open(ctx)
 		if err != nil {
-			return nil, fmt.Errorf("decode data url for telegram upload: %w", err)
+			return nil, err
+		}
+		defer func() { _ = reader.Close() }()
+		data, err := media.ReadAllWithLimit(reader, media.MaxAssetBytes)
+		if err != nil {
+			return nil, err
 		}
 		name := strings.TrimSpace(att.Name)
 		if name == "" {
-			name = fileNameFromMime(att.Mime, string(att.Type))
+			name = fileNameFromMime(att.Mime, string(att.Logical.Type))
 		}
-		return tgbotapi.FileBytes{Name: name, Bytes: decoded}, nil
+		return tgbotapi.FileBytes{Name: name, Bytes: data}, nil
+	default:
+		return nil, fmt.Errorf("unsupported telegram attachment kind: %s", att.Kind)
 	}
-	if urlRef != "" {
-		return tgbotapi.FileURL(urlRef), nil
-	}
-	return nil, errors.New("no usable attachment reference for telegram")
-}
-
-func decodeDataURLBytes(dataURL string) ([]byte, error) {
-	value := dataURL
-	if _, after, ok := strings.Cut(value, ","); ok {
-		value = after
-	}
-	return io.ReadAll(io.LimitReader(
-		base64StdDecoder(strings.NewReader(value)),
-		media.MaxAssetBytes+1,
-	))
-}
-
-func base64StdDecoder(r io.Reader) io.Reader {
-	return base64.NewDecoder(base64.StdEncoding, r)
 }
 
 func fileNameFromMime(mime, fallbackType string) string {
diff --git a/internal/channel/adapters/telegram/telegram_test.go b/internal/channel/adapters/telegram/telegram_test.go
index 772fc099..cf53347a 100644
--- a/internal/channel/adapters/telegram/telegram_test.go
+++ b/internal/channel/adapters/telegram/telegram_test.go
@@ -13,7 +13,6 @@ import (
 	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
 
 	"github.com/memohai/memoh/internal/channel"
-	"github.com/memohai/memoh/internal/media"
 )
 
 func TestResolveTelegramSender(t *testing.T) {
@@ -723,8 +722,11 @@ func TestProcessingFailed_DelegatesToCompleted(t *testing.T) {
 func TestResolveTelegramFile_PlatformKey(t *testing.T) {
 	t.Parallel()
 
-	att := channel.Attachment{Type: channel.AttachmentImage, PlatformKey: "file_id_123"}
-	file, err := resolveTelegramFile(context.Background(), "", "file_id_123", "", "", att, "", "", nil)
+	file, err := resolveTelegramFile(context.Background(), channel.PreparedAttachment{
+		Logical:   channel.Attachment{Type: channel.AttachmentImage},
+		Kind:      channel.PreparedAttachmentNativeRef,
+		NativeRef: "file_id_123",
+	})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -736,8 +738,11 @@ func TestResolveTelegramFile_PlatformKey(t *testing.T) {
 func TestResolveTelegramFile_PublicURL(t *testing.T) {
 	t.Parallel()
 
-	att := channel.Attachment{Type: channel.AttachmentImage}
-	file, err := resolveTelegramFile(context.Background(), "https://example.com/img.png", "", "", "", att, "", "", nil)
+	file, err := resolveTelegramFile(context.Background(), channel.PreparedAttachment{
+		Logical:   channel.Attachment{Type: channel.AttachmentImage},
+		Kind:      channel.PreparedAttachmentPublicURL,
+		PublicURL: "https://example.com/img.png",
+	})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -746,12 +751,18 @@ func TestResolveTelegramFile_PublicURL(t *testing.T) {
 	}
 }
 
-func TestResolveTelegramFile_DataURL(t *testing.T) {
+func TestResolveTelegramFile_Upload(t *testing.T) {
 	t.Parallel()
 
-	dataURL := "data:image/png;base64,iVBORw0KGgo="
-	att := channel.Attachment{Type: channel.AttachmentImage, Mime: "image/png", Name: "test.png"}
-	file, err := resolveTelegramFile(context.Background(), "", "", dataURL, "", att, "", "", nil)
+	file, err := resolveTelegramFile(context.Background(), channel.PreparedAttachment{
+		Logical: channel.Attachment{Type: channel.AttachmentImage},
+		Kind:    channel.PreparedAttachmentUpload,
+		Mime:    "image/png",
+		Name:    "test.png",
+		Open: func(context.Context) (io.ReadCloser, error) {
+			return io.NopCloser(strings.NewReader("png-bytes")), nil
+		},
+	})
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -762,80 +773,31 @@ func TestResolveTelegramFile_DataURL(t *testing.T) {
 	if fb.Name != "test.png" {
 		t.Fatalf("expected name test.png, got %q", fb.Name)
 	}
-	if len(fb.Bytes) == 0 {
-		t.Fatal("expected non-empty bytes")
+	if string(fb.Bytes) != "png-bytes" {
+		t.Fatalf("expected png-bytes, got %q", string(fb.Bytes))
 	}
 }
 
 func TestResolveTelegramFile_NoReference(t *testing.T) {
 	t.Parallel()
 
-	att := channel.Attachment{Type: channel.AttachmentImage}
-	_, err := resolveTelegramFile(context.Background(), "", "", "", "", att, "", "", nil)
+	_, err := resolveTelegramFile(context.Background(), channel.PreparedAttachment{
+		Logical: channel.Attachment{Type: channel.AttachmentImage},
+	})
 	if err == nil {
 		t.Fatal("expected error when no reference available")
 	}
 }
 
-func TestResolveTelegramFile_ContainerPathFallsToBase64(t *testing.T) {
+func TestResolveTelegramFile_UploadRequiresOpen(t *testing.T) {
 	t.Parallel()
 
-	dataURL := "data:image/jpeg;base64,/9j/4AAQ"
-	att := channel.Attachment{Type: channel.AttachmentImage, Mime: "image/jpeg"}
-	file, err := resolveTelegramFile(context.Background(), "/data/media/image/a.jpg", "", dataURL, "", att, "", "", nil)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if _, ok := file.(tgbotapi.FileBytes); !ok {
-		t.Fatalf("expected FileBytes for container path + base64, got %T", file)
-	}
-}
-
-type mockAssetOpener struct {
-	data []byte
-	mime string
-}
-
-func (m *mockAssetOpener) Open(_ context.Context, _, _ string) (io.ReadCloser, media.Asset, error) {
-	return io.NopCloser(strings.NewReader(string(m.data))), media.Asset{Mime: m.mime}, nil
-}
-
-func TestResolveTelegramFile_ContentHash(t *testing.T) {
-	t.Parallel()
-
-	opener := &mockAssetOpener{data: []byte("fake-png-bytes"), mime: "image/png"}
-	att := channel.Attachment{Type: channel.AttachmentImage, ContentHash: "asset-123", Name: "output.png"}
-	file, err := resolveTelegramFile(context.Background(), "", "", "", "", att, "asset-123", "bot-1", opener)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	fb, ok := file.(tgbotapi.FileBytes)
-	if !ok {
-		t.Fatalf("expected FileBytes from asset reader, got %T", file)
-	}
-	if fb.Name != "output.png" {
-		t.Fatalf("expected name output.png, got %q", fb.Name)
-	}
-	if string(fb.Bytes) != "fake-png-bytes" {
-		t.Fatalf("expected fake-png-bytes, got %q", string(fb.Bytes))
-	}
-}
-
-func TestResolveTelegramFile_ContentHashPriorityOverURL(t *testing.T) {
-	t.Parallel()
-
-	opener := &mockAssetOpener{data: []byte("from-storage"), mime: "image/jpeg"}
-	att := channel.Attachment{Type: channel.AttachmentImage, ContentHash: "a1"}
-	file, err := resolveTelegramFile(context.Background(), "https://example.com/fallback.jpg", "", "", "", att, "a1", "bot-1", opener)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	fb, ok := file.(tgbotapi.FileBytes)
-	if !ok {
-		t.Fatalf("expected FileBytes (asset priority over URL), got %T", file)
-	}
-	if string(fb.Bytes) != "from-storage" {
-		t.Fatalf("expected from-storage, got %q", string(fb.Bytes))
+	_, err := resolveTelegramFile(context.Background(), channel.PreparedAttachment{
+		Logical: channel.Attachment{Type: channel.AttachmentImage},
+		Kind:    channel.PreparedAttachmentUpload,
+	})
+	if err == nil {
+		t.Fatal("expected missing upload opener to fail")
 	}
 }
 
diff --git a/internal/channel/adapters/wecom/adapter_integration_test.go b/internal/channel/adapters/wecom/adapter_integration_test.go
index c3d8cc3f..7a999cc3 100644
--- a/internal/channel/adapters/wecom/adapter_integration_test.go
+++ b/internal/channel/adapters/wecom/adapter_integration_test.go
@@ -127,13 +127,15 @@ func TestWeComAdapter_ReplyUsesRespondCmd(t *testing.T) {
 		t.Fatal("timeout waiting inbound callback")
 	}
 
-	err = adapter.Send(context.Background(), cfg, channel.OutboundMessage{
+	err = adapter.Send(context.Background(), cfg, channel.PreparedOutboundMessage{
 		Target: "chat_id:chat_1",
-		Message: channel.Message{
-			Format: channel.MessageFormatPlain,
-			Text:   "reply content",
-			Reply: &channel.ReplyRef{
-				MessageID: "msg_1",
+		Message: channel.PreparedMessage{
+			Message: channel.Message{
+				Format: channel.MessageFormatPlain,
+				Text:   "reply content",
+				Reply: &channel.ReplyRef{
+					MessageID: "msg_1",
+				},
 			},
 		},
 	})
diff --git a/internal/channel/adapters/wecom/outbound.go b/internal/channel/adapters/wecom/outbound.go
index 901a3759..5035c5a5 100644
--- a/internal/channel/adapters/wecom/outbound.go
+++ b/internal/channel/adapters/wecom/outbound.go
@@ -11,6 +11,7 @@ import (
 	"strings"
 
 	"github.com/memohai/memoh/internal/channel"
+	"github.com/memohai/memoh/internal/media"
 )
 
 func (a *WeComAdapter) ResolveAttachment(ctx context.Context, cfg channel.ChannelConfig, attachment channel.Attachment) (channel.AttachmentPayload, error) {
@@ -86,6 +87,10 @@ func buildRespondPayload(msg channel.Message, replyReqID string) (any, string, s
 	return buildRespondPayloadWithStream(msg, replyReqID, "", true)
 }
 
+func buildPreparedRespondPayload(ctx context.Context, msg channel.PreparedMessage, replyReqID string) (any, string, string, error) {
+	return buildPreparedRespondPayloadWithStream(ctx, msg, replyReqID, "", true)
+}
+
 func buildRespondPayloadWithStream(msg channel.Message, replyReqID string, streamID string, finish bool) (any, string, string, error) {
 	reqID := strings.TrimSpace(replyReqID)
 	if reqID == "" {
@@ -118,23 +123,8 @@ func buildRespondPayloadWithStream(msg channel.Message, replyReqID string, strea
 	if feedbackID := readFeedbackID(msg.Metadata); feedbackID != "" {
 		stream.Feedback = &StreamReplyFeedback{ID: feedbackID}
 	}
-	if finish && len(msg.Attachments) > 0 {
-		first := msg.Attachments[0]
-		base64Data := extractBase64Content(first.Base64)
-		if base64Data != "" {
-			raw, err := base64.StdEncoding.DecodeString(base64Data)
-			if err == nil && len(raw) > 0 {
-				stream.MsgItems = []StreamReplyItem{
-					{
-						MsgType: "image",
-						Image: &StreamReplyImage{
-							Base64: base64.StdEncoding.EncodeToString(raw),
-							MD5:    fmt.Sprintf("%x", md5.Sum(raw)), //nolint:gosec // WeCom protocol mandates md5 field for base64 images.
-						},
-					},
-				}
-			}
-		}
+	if finish {
+		stream.MsgItems = buildLegacyStreamReplyItems(msg)
 	}
 	if card, ok := readTemplateCard(msg.Metadata); ok {
 		return StreamWithTemplateCardReplyBody{
@@ -149,6 +139,137 @@ func buildRespondPayloadWithStream(msg channel.Message, replyReqID string, strea
 	}, WSCmdRespond, reqID, nil
 }
 
+func buildPreparedRespondPayloadWithStream(
+	ctx context.Context,
+	msg channel.PreparedMessage,
+	replyReqID string,
+	streamID string,
+	finish bool,
+) (any, string, string, error) {
+	logical := msg.LogicalMessage()
+	reqID := strings.TrimSpace(replyReqID)
+	if reqID == "" {
+		return nil, "", "", errors.New("reply req_id is required")
+	}
+	if finish {
+		if body, ok := buildWelcomePayload(logical); ok {
+			return body, WSCmdRespondWelcome, reqID, nil
+		}
+		if body, ok := readUpdateTemplateCard(logical.Metadata); ok {
+			return body, WSCmdRespondUpdate, reqID, nil
+		}
+	}
+	text := strings.TrimSpace(logical.PlainText())
+	if finish && text == "" && len(logical.Attachments) == 0 && len(msg.Attachments) == 0 {
+		return nil, "", "", errors.New("wecom reply payload is empty")
+	}
+	if !finish && text == "" {
+		return nil, "", "", errors.New("wecom stream delta content is empty")
+	}
+	streamID = strings.TrimSpace(streamID)
+	if streamID == "" {
+		streamID = NewReqID("stream")
+	}
+	stream := StreamReplyBlock{
+		ID:      streamID,
+		Finish:  finish,
+		Content: text,
+	}
+	if feedbackID := readFeedbackID(logical.Metadata); feedbackID != "" {
+		stream.Feedback = &StreamReplyFeedback{ID: feedbackID}
+	}
+	if finish {
+		items, err := buildPreparedStreamReplyItems(ctx, msg)
+		if err != nil {
+			return nil, "", "", err
+		}
+		stream.MsgItems = items
+	}
+	if card, ok := readTemplateCard(logical.Metadata); ok {
+		return StreamWithTemplateCardReplyBody{
+			MsgType:      "stream_with_template_card",
+			Stream:       stream,
+			TemplateCard: card,
+		}, WSCmdRespond, reqID, nil
+	}
+	return StreamReplyBody{
+		MsgType: "stream",
+		Stream:  stream,
+	}, WSCmdRespond, reqID, nil
+}
+
+func buildPreparedStreamReplyItems(ctx context.Context, msg channel.PreparedMessage) ([]StreamReplyItem, error) {
+	if len(msg.Attachments) == 0 {
+		return buildLegacyStreamReplyItems(msg.Message), nil
+	}
+	item, err := buildPreparedStreamReplyItem(ctx, msg.Attachments[0])
+	if err != nil {
+		return nil, err
+	}
+	return []StreamReplyItem{item}, nil
+}
+
+func buildPreparedStreamReplyItem(ctx context.Context, att channel.PreparedAttachment) (StreamReplyItem, error) {
+	if !isWeComReplyImageAttachment(att) {
+		return StreamReplyItem{}, errors.New("wecom reply attachments only support images")
+	}
+	if att.Open == nil {
+		return StreamReplyItem{}, errors.New("wecom reply attachment reader is required")
+	}
+	reader, err := att.Open(ctx)
+	if err != nil {
+		return StreamReplyItem{}, err
+	}
+	defer func() { _ = reader.Close() }()
+
+	raw, err := media.ReadAllWithLimit(reader, media.MaxAssetBytes)
+	if err != nil {
+		return StreamReplyItem{}, err
+	}
+	if len(raw) == 0 {
+		return StreamReplyItem{}, errors.New("wecom reply attachment is empty")
+	}
+	return StreamReplyItem{
+		MsgType: "image",
+		Image: &StreamReplyImage{
+			Base64: base64.StdEncoding.EncodeToString(raw),
+			MD5:    fmt.Sprintf("%x", md5.Sum(raw)), //nolint:gosec // WeCom protocol mandates md5 field for base64 images.
+		},
+	}, nil
+}
+
+func buildLegacyStreamReplyItems(msg channel.Message) []StreamReplyItem {
+	if len(msg.Attachments) == 0 {
+		return nil
+	}
+	first := msg.Attachments[0]
+	base64Data := extractBase64Content(first.Base64)
+	if base64Data == "" {
+		return nil
+	}
+	raw, err := base64.StdEncoding.DecodeString(base64Data)
+	if err != nil || len(raw) == 0 {
+		return nil
+	}
+	return []StreamReplyItem{
+		{
+			MsgType: "image",
+			Image: &StreamReplyImage{
+				Base64: base64.StdEncoding.EncodeToString(raw),
+				MD5:    fmt.Sprintf("%x", md5.Sum(raw)), //nolint:gosec // WeCom protocol mandates md5 field for base64 images.
+			},
+		},
+	}
+}
+
+func isWeComReplyImageAttachment(att channel.PreparedAttachment) bool {
+	switch att.Logical.Type {
+	case channel.AttachmentImage, channel.AttachmentGIF:
+		return true
+	}
+	return strings.HasPrefix(strings.ToLower(strings.TrimSpace(att.Mime)), "image/")
+}
+
 func buildWelcomePayload(msg channel.Message) (any, bool) {
 	if !readBool(msg.Metadata, "wecom_welcome") {
 		return nil, false
diff --git a/internal/channel/adapters/wecom/outbound_test.go b/internal/channel/adapters/wecom/outbound_test.go
index 82a80772..c8579025 100644
--- a/internal/channel/adapters/wecom/outbound_test.go
+++ b/internal/channel/adapters/wecom/outbound_test.go
@@ -1,6 +1,12 @@
 package wecom
 
 import (
+	"context"
+	"crypto/md5" //nolint:gosec // test verifies protocol checksum formatting.
+	"encoding/base64"
+	"fmt"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/memohai/memoh/internal/channel"
@@ -237,3 +243,69 @@ func TestBuildRespondPayload_WelcomeTemplateCard(t *testing.T) {
 		t.Fatalf("unexpected msg type: %q", p.MsgType)
 	}
 }
+
+func TestBuildPreparedRespondPayloadWithStream_ImageAttachment(t *testing.T) {
+	const rawImage = "image-bytes"
+
+	payload, cmd, reqID, err := buildPreparedRespondPayloadWithStream(context.Background(), channel.PreparedMessage{
+		Message: channel.Message{
+			Reply: &channel.ReplyRef{MessageID: "msg_1"},
+		},
+		Attachments: []channel.PreparedAttachment{
+			{
+				Logical: channel.Attachment{Type: channel.AttachmentImage},
+				Kind:    channel.PreparedAttachmentUpload,
+				Mime:    "image/png",
+				Open: func(context.Context) (io.ReadCloser, error) {
+					return io.NopCloser(strings.NewReader(rawImage)), nil
+				},
+			},
+		},
+	}, "req_abc", "stream_1", true)
+	if err != nil {
+		t.Fatalf("buildPreparedRespondPayloadWithStream error = %v", err)
+	}
+	if cmd != WSCmdRespond {
+		t.Fatalf("unexpected cmd: %q", cmd)
+	}
+	if reqID != "req_abc" {
+		t.Fatalf("unexpected req id: %q", reqID)
+	}
+	p, ok := payload.(StreamReplyBody)
+	if !ok {
+		t.Fatalf("unexpected payload type: %T", payload)
+	}
+	if p.Stream.ID != "stream_1" || !p.Stream.Finish {
+		t.Fatalf("unexpected stream block: %+v", p.Stream)
+	}
+	if len(p.Stream.MsgItems) != 1 || p.Stream.MsgItems[0].Image == nil {
+		t.Fatalf("expected one image item, got %+v", p.Stream.MsgItems)
+	}
+	if got := p.Stream.MsgItems[0].Image.Base64; got != base64.StdEncoding.EncodeToString([]byte(rawImage)) {
+		t.Fatalf("unexpected image base64: %q", got)
+	}
+	if got := p.Stream.MsgItems[0].Image.MD5; got != fmt.Sprintf("%x", md5.Sum([]byte(rawImage))) { //nolint:gosec
+		t.Fatalf("unexpected image md5: %q", got)
+	}
+}
+
+func TestBuildPreparedRespondPayloadWithStream_RejectsNonImageAttachment(t *testing.T) {
+	_, _, _, err := buildPreparedRespondPayloadWithStream(context.Background(), channel.PreparedMessage{
+		Attachments: []channel.PreparedAttachment{
+			{
+				Logical: channel.Attachment{Type: channel.AttachmentFile},
+				Kind:    channel.PreparedAttachmentUpload,
+				Mime:    "application/pdf",
+				Open: func(context.Context) (io.ReadCloser, error) {
+					return io.NopCloser(strings.NewReader("pdf")), nil
+				},
+			},
+		},
+	}, "req_abc", "stream_1", true)
+	if err == nil {
+		t.Fatal("expected non-image attachment error")
+	}
+	if !strings.Contains(err.Error(), "only support images") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
diff --git a/internal/channel/adapters/wecom/wecom.go b/internal/channel/adapters/wecom/wecom.go
index 66d14ddf..c26d6f3e 100644
--- a/internal/channel/adapters/wecom/wecom.go
+++ b/internal/channel/adapters/wecom/wecom.go
@@ -175,8 +175,9 @@ func (a *WeComAdapter) Connect(ctx context.Context, cfg channel.ChannelConfig, h
 	return channel.NewConnection(cfg, stop), nil
 }
 
-func (a *WeComAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg channel.OutboundMessage) error {
-	targetKind, targetID, ok := parseTarget(msg.Target)
+func (a *WeComAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg channel.PreparedOutboundMessage) error {
+	logical := msg.LogicalMessage()
+	targetKind, targetID, ok := parseTarget(logical.Target)
 	if !ok {
 		return errors.New("wecom target is required")
 	}
@@ -188,7 +189,7 @@ func (a *WeComAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg
 	if client == nil {
 		return errors.New("wecom connection is not active")
 	}
-	if msg.Message.IsEmpty() {
+	if logical.Message.IsEmpty() {
 		return errors.New("message is required")
 	}
 	var (
@@ -197,11 +198,11 @@ func (a *WeComAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg
 		reqID    string
 		buildErr error
 	)
-	if ctxMeta, ok := a.lookupCallbackContext(msg.Message.Reply); ok {
-		payload, cmd, reqID, buildErr = buildRespondPayload(msg.Message, ctxMeta.ReqID)
+	if ctxMeta, ok := a.lookupCallbackContext(msg.Message.Message.Reply); ok {
+		payload, cmd, reqID, buildErr = buildPreparedRespondPayload(ctx, msg.Message, ctxMeta.ReqID)
 	} else {
 		_ = targetKind
-		payload, cmd, reqID, buildErr = buildSendPayload(msg.Message, targetID)
+		payload, cmd, reqID, buildErr = buildSendPayload(logical.Message, targetID)
 	}
 	if buildErr != nil {
 		return buildErr
@@ -216,7 +217,7 @@ func (a *WeComAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg
 	return nil
 }
 
-func (a *WeComAdapter) OpenStream(ctx context.Context, cfg channel.ChannelConfig, target string, opts channel.StreamOptions) (channel.OutboundStream, error) {
+func (a *WeComAdapter) OpenStream(ctx context.Context, cfg channel.ChannelConfig, target string, opts channel.StreamOptions) (channel.PreparedOutboundStream, error) {
 	select {
 	case <-ctx.Done():
 		return nil, ctx.Err()
@@ -251,13 +252,13 @@ type wecomOutboundStream struct {
 	closed      atomic.Bool
 	finalSent   atomic.Bool
 	textBuilder strings.Builder
-	attachments []channel.Attachment
-	final       *channel.Message
+	attachments []channel.PreparedAttachment
+	final       *channel.PreparedMessage
 	streamID    string
 	lastPreview string
 }
 
-func (s *wecomOutboundStream) Push(ctx context.Context, event channel.StreamEvent) error {
+func (s *wecomOutboundStream) Push(ctx context.Context, event channel.PreparedStreamEvent) error {
 	if s.adapter == nil {
 		return errors.New("wecom stream not configured")
 	}
@@ -315,7 +316,9 @@ func (s *wecomOutboundStream) Push(ctx context.Context, event channel.StreamEven
 			return nil
 		}
 		s.mu.Lock()
-		s.final = &channel.Message{Format: channel.MessageFormatPlain, Text: "Error: " + text}
+		s.final = &channel.PreparedMessage{
+			Message: channel.Message{Format: channel.MessageFormatPlain, Text: "Error: " + text},
+		}
 		s.mu.Unlock()
 		return s.flush(ctx)
 	}
@@ -340,17 +343,17 @@ func (s *wecomOutboundStream) flush(ctx context.Context) error {
 		return nil
 	}
 	msg, streamID := s.snapshotMessage(true)
-	if msg.IsEmpty() {
+	if msg.LogicalMessage().IsEmpty() {
 		return nil
 	}
-	if ctxMeta, ok := s.adapter.lookupCallbackContext(msg.Reply); ok {
+	if ctxMeta, ok := s.adapter.lookupCallbackContext(msg.Message.Reply); ok {
 		if err := s.adapter.sendRespondStream(ctx, s.cfg, msg, ctxMeta.ReqID, streamID, true); err != nil {
 			return err
 		}
 		s.finalSent.Store(true)
 		return nil
 	}
-	if err := s.adapter.Send(ctx, s.cfg, channel.OutboundMessage{
+	if err := s.adapter.Send(ctx, s.cfg, channel.PreparedOutboundMessage{
 		Target:  s.target,
 		Message: msg,
 	}); err != nil {
@@ -365,7 +368,7 @@ func (s *wecomOutboundStream) pushPreview(ctx context.Context) error {
 		return nil
 	}
 	msg, streamID := s.snapshotMessage(false)
-	text := strings.TrimSpace(msg.PlainText())
+	text := strings.TrimSpace(msg.LogicalMessage().PlainText())
 	if text == "" {
 		return nil
 	}
@@ -375,7 +378,7 @@ func (s *wecomOutboundStream) pushPreview(ctx context.Context) error {
 		return nil
 	}
 	s.mu.Unlock()
-	if ctxMeta, ok := s.adapter.lookupCallbackContext(msg.Reply); ok {
+	if ctxMeta, ok := s.adapter.lookupCallbackContext(msg.Message.Reply); ok {
 		if err := s.adapter.sendRespondStream(ctx, s.cfg, msg, ctxMeta.ReqID, streamID, false); err != nil {
 			return err
 		}
@@ -386,21 +389,27 @@ func (s *wecomOutboundStream) pushPreview(ctx context.Context) error {
 	return nil
 }
 
-func (s *wecomOutboundStream) snapshotMessage(includeAttachments bool) (channel.Message, string) {
+func (s *wecomOutboundStream) snapshotMessage(includeAttachments bool) (channel.PreparedMessage, string) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
-	msg := channel.Message{}
+	msg := channel.PreparedMessage{}
 	if s.final != nil {
 		msg = *s.final
 	}
-	if strings.TrimSpace(msg.Text) == "" {
-		msg.Text = strings.TrimSpace(s.textBuilder.String())
+	if strings.TrimSpace(msg.Message.Text) == "" {
+		msg.Message.Text = strings.TrimSpace(s.textBuilder.String())
 	}
 	if includeAttachments && len(msg.Attachments) == 0 && len(s.attachments) > 0 {
 		msg.Attachments = append(msg.Attachments, s.attachments...)
 	}
-	if msg.Reply == nil && s.reply != nil {
-		msg.Reply = s.reply
+	if len(msg.Message.Attachments) == 0 && len(msg.Attachments) > 0 {
+		msg.Message.Attachments = make([]channel.Attachment, 0, len(msg.Attachments))
+		for _, att := range msg.Attachments {
+			msg.Message.Attachments = append(msg.Message.Attachments, att.Logical)
+		}
+	}
+	if msg.Message.Reply == nil && s.reply != nil {
+		msg.Message.Reply = s.reply
 	}
 	if s.streamID == "" {
 		s.streamID = NewReqID("stream")
@@ -408,7 +417,7 @@ func (s *wecomOutboundStream) snapshotMessage(includeAttachments bool) (channel.
 	return msg, s.streamID
 }
 
-func (a *WeComAdapter) sendRespondStream(ctx context.Context, cfg channel.ChannelConfig, msg channel.Message, reqID string, streamID string, finish bool) error {
+func (a *WeComAdapter) sendRespondStream(ctx context.Context, cfg channel.ChannelConfig, msg channel.PreparedMessage, reqID string, streamID string, finish bool) error {
 	parsed, err := parseConfig(cfg.Credentials)
 	if err != nil {
 		return err
@@ -417,7 +426,7 @@ func (a *WeComAdapter) sendRespondStream(ctx context.Context, cfg channel.Channe
 	if client == nil {
 		return errors.New("wecom connection is not active")
 	}
-	payload, cmd, ackReqID, err := buildRespondPayloadWithStream(msg, reqID, streamID, finish)
+	payload, cmd, ackReqID, err := buildPreparedRespondPayloadWithStream(ctx, msg, reqID, streamID, finish)
 	if err != nil {
 		return err
 	}
diff --git a/internal/channel/adapters/weixin/weixin.go b/internal/channel/adapters/weixin/weixin.go
index 0bd08480..fe94a87d 100644
--- a/internal/channel/adapters/weixin/weixin.go
+++ b/internal/channel/adapters/weixin/weixin.go
@@ -10,7 +10,6 @@ import (
 	"strings"
 	"time"
 
-	attachmentpkg "github.com/memohai/memoh/internal/attachment"
 	"github.com/memohai/memoh/internal/channel"
 )
 
@@ -240,7 +239,7 @@ func (a *WeixinAdapter) pollLoop(ctx context.Context, cfg channel.ChannelConfig,
 
 // -- StreamSender (block-streaming: buffer deltas, send final as one message) --
 
-func (a *WeixinAdapter) OpenStream(_ context.Context, cfg channel.ChannelConfig, target string, _ channel.StreamOptions) (channel.OutboundStream, error) {
+func (a *WeixinAdapter) OpenStream(_ context.Context, cfg channel.ChannelConfig, target string, _ channel.StreamOptions) (channel.PreparedOutboundStream, error) {
 	target = strings.TrimSpace(target)
 	if target == "" {
 		return nil, errors.New("weixin target is required")
@@ -254,7 +253,7 @@ func (a *WeixinAdapter) OpenStream(_ context.Context, cfg channel.ChannelConfig,
 
 // -- Sender --
 
-func (a *WeixinAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg channel.OutboundMessage) error {
+func (a *WeixinAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg channel.PreparedOutboundMessage) error {
 	parsed, err := parseConfig(cfg.Credentials)
 	if err != nil {
 		return err
@@ -272,18 +271,18 @@ func (a *WeixinAdapter) Send(ctx context.Context, cfg channel.ChannelConfig, msg
 
 	// Send attachments first if present (media + text in one flow).
 	if len(msg.Message.Attachments) > 0 {
-		return a.sendWithAttachments(ctx, parsed, cfg.BotID, target, contextToken, msg.Message)
+		return a.sendWithAttachments(ctx, parsed, target, contextToken, msg.Message)
 	}
 
-	text := strings.TrimSpace(msg.Message.PlainText())
+	text := strings.TrimSpace(msg.Message.Message.PlainText())
 	if text == "" {
 		return errors.New("weixin: message is empty")
 	}
 	return sendText(ctx, a.client, parsed, target, text, contextToken)
 }
 
-func (a *WeixinAdapter) sendWithAttachments(ctx context.Context, cfg adapterConfig, botID, target, contextToken string, msg channel.Message) error {
-	text := strings.TrimSpace(msg.PlainText())
+func (a *WeixinAdapter) sendWithAttachments(ctx context.Context, cfg adapterConfig, target, contextToken string, msg channel.PreparedMessage) error {
+	text := strings.TrimSpace(msg.Message.PlainText())
 
 	for i, att := range msg.Attachments {
 		caption := ""
@@ -291,16 +290,12 @@ func (a *WeixinAdapter) sendWithAttachments(ctx context.Context, cfg adapterConf
 			caption = text
 		}
 
-		r, err := a.openAttachment(ctx, botID, att)
+		r, err := openAttachment(ctx, att)
 		if err != nil {
-			a.logger.Error("weixin: open attachment failed",
-				slog.String("type", string(att.Type)),
-				slog.Any("error", err),
-			)
-			continue
+			return fmt.Errorf("weixin: open attachment: %w", err)
 		}
 
-		switch att.Type {
+		switch att.Logical.Type {
 		case channel.AttachmentImage, channel.AttachmentGIF:
 			if err := sendImageFromReader(ctx, a.client, cfg, target, contextToken, caption, r, a.logger); err != nil {
 				_ = r.Close()
@@ -328,32 +323,17 @@ func (a *WeixinAdapter) sendWithAttachments(ctx context.Context, cfg adapterConf
 		_ = r.Close()
 	}
 
-	// If there are attachments but no text was sent as caption and there is text, send separately.
-	if len(msg.Attachments) == 0 && text != "" {
-		return sendText(ctx, a.client, cfg, target, text, contextToken)
-	}
 	return nil
 }
 
-func (a *WeixinAdapter) openAttachment(ctx context.Context, botID string, att channel.Attachment) (io.ReadCloser, error) {
-	// Try content hash first (from media store).
-	if strings.TrimSpace(att.ContentHash) != "" && a.assets != nil {
-		r, _, err := a.assets.Open(ctx, botID, att.ContentHash)
-		if err == nil {
-			return r, nil
-		}
+func openAttachment(ctx context.Context, att channel.PreparedAttachment) (io.ReadCloser, error) {
+	if att.Kind != channel.PreparedAttachmentUpload {
+		return nil, fmt.Errorf("weixin attachment requires upload source, got %s", att.Kind)
 	}
-	// Try base64 data URL.
-	if strings.TrimSpace(att.Base64) != "" {
-		r, err := attachmentpkg.DecodeBase64(att.Base64, 100*1024*1024)
-		if err == nil {
-			data, readErr := io.ReadAll(r)
-			if readErr == nil {
-				return io.NopCloser(bytes.NewReader(data)), nil
-			}
-		}
+	if att.Open == nil {
+		return nil, errors.New("weixin attachment upload is not openable")
 	}
-	return nil, errors.New("weixin: cannot open attachment (no content_hash or base64)")
+	return att.Open(ctx)
 }
 
 // -- AttachmentResolver (for inbound media download/decrypt) --
@@ -465,12 +445,12 @@ type weixinBlockStream struct {
 	cfg         channel.ChannelConfig
 	target      string
 	textBuilder strings.Builder
-	attachments []channel.Attachment
-	final       *channel.Message
+	attachments []channel.PreparedAttachment
+	final       *channel.PreparedMessage
 	closed      bool
 }
 
-func (s *weixinBlockStream) Push(_ context.Context, event channel.StreamEvent) error {
+func (s *weixinBlockStream) Push(_ context.Context, event channel.PreparedStreamEvent) error {
 	if s.closed {
 		return nil
 	}
@@ -496,25 +476,37 @@ func (s *weixinBlockStream) Close(ctx context.Context) error {
 	}
 	s.closed = true
 
-	msg := channel.Message{Format: channel.MessageFormatPlain}
+	msg := channel.PreparedMessage{Message: channel.Message{Format: channel.MessageFormatPlain}}
 	if s.final != nil {
 		msg = *s.final
 	}
-	if strings.TrimSpace(msg.Text) == "" {
-		msg.Text = strings.TrimSpace(s.textBuilder.String())
+	if strings.TrimSpace(msg.Message.Text) == "" {
+		msg.Message.Text = strings.TrimSpace(s.textBuilder.String())
 	}
 	if len(msg.Attachments) == 0 && len(s.attachments) > 0 {
 		msg.Attachments = append(msg.Attachments, s.attachments...)
+		msg.Message.Attachments = weixinLogicalAttachments(msg.Attachments)
 	}
-	if msg.IsEmpty() {
+	if msg.Message.IsEmpty() && len(msg.Attachments) == 0 {
 		return nil
 	}
-	return s.adapter.Send(ctx, s.cfg, channel.OutboundMessage{
+	return s.adapter.Send(ctx, s.cfg, channel.PreparedOutboundMessage{
 		Target:  s.target,
 		Message: msg,
 	})
 }
 
+func weixinLogicalAttachments(attachments []channel.PreparedAttachment) []channel.Attachment {
+	if len(attachments) == 0 {
+		return nil
+	}
+	logical := make([]channel.Attachment, 0, len(attachments))
+	for _, att := range attachments {
+		logical = append(logical, att.Logical)
+	}
+	return logical
+}
+
 // sleepCtx sleeps for the given duration or until the context is cancelled.
 func sleepCtx(ctx context.Context, d time.Duration) {
 	t := time.NewTimer(d)
diff --git a/internal/channel/channeltest/store.go b/internal/channel/channeltest/store.go
new file mode 100644
index 00000000..c598caf4
--- /dev/null
+++ b/internal/channel/channeltest/store.go
@@ -0,0 +1,181 @@
+package channeltest
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"io"
+	"mime"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"github.com/memohai/memoh/internal/media"
+)
+
+type storedAsset struct {
+	asset media.Asset
+	data  []byte
+}
+
+type storedContainerFile struct {
+	botID string
+	path  string
+	data  []byte
+	mime  string
+	name  string
+}
+
+// MemoryAttachmentStore is a lightweight in-memory store for attachment preparation tests.
+type MemoryAttachmentStore struct {
+	mu             sync.Mutex
+	assets         map[string]storedAsset
+	storageIndex   map[string]string
+	containerFiles map[string]storedContainerFile
+}
+
+func NewMemoryAttachmentStore() *MemoryAttachmentStore {
+	return &MemoryAttachmentStore{
+		assets:         make(map[string]storedAsset),
+		storageIndex:   make(map[string]string),
+		containerFiles: make(map[string]storedContainerFile),
+	}
+}
+
+func (s *MemoryAttachmentStore) Stat(_ context.Context, botID, contentHash string) (media.Asset, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	stored, ok := s.assets[s.assetKey(botID, contentHash)]
+	if !ok {
+		return media.Asset{}, media.ErrAssetNotFound
+	}
+	return stored.asset, nil
+}
+
+func (s *MemoryAttachmentStore) Open(_ context.Context, botID, contentHash string) (io.ReadCloser, media.Asset, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	stored, ok := s.assets[s.assetKey(botID, contentHash)]
+	if !ok {
+		return nil, media.Asset{}, media.ErrAssetNotFound
+	}
+	return io.NopCloser(bytes.NewReader(stored.data)), stored.asset, nil
+}
+
+func (s *MemoryAttachmentStore) Ingest(_ context.Context, input media.IngestInput) (media.Asset, error) {
+	if strings.TrimSpace(input.BotID) == "" {
+		return media.Asset{}, errors.New("bot id is required")
+	}
+	if input.Reader == nil {
+		return media.Asset{}, errors.New("reader is required")
+	}
+	maxBytes := input.MaxBytes
+	if maxBytes <= 0 {
+		maxBytes = media.MaxAssetBytes
+	}
+	data, err := media.ReadAllWithLimit(input.Reader, maxBytes)
+	if err != nil {
+		return media.Asset{}, err
+	}
+	return s.ingestBytes(input.BotID, data, input.Mime, input.OriginalExt)
+}
+
+func (s *MemoryAttachmentStore) GetByStorageKey(_ context.Context, botID, storageKey string) (media.Asset, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	contentHash, ok := s.storageIndex[s.storageKey(botID, storageKey)]
+	if !ok {
+		return media.Asset{}, media.ErrAssetNotFound
+	}
+	stored, ok := s.assets[s.assetKey(botID, contentHash)]
+	if !ok {
+		return media.Asset{}, media.ErrAssetNotFound
+	}
+	return stored.asset, nil
+}
+
+func (*MemoryAttachmentStore) AccessPath(asset media.Asset) string {
+	return "/data/media/" + strings.TrimSpace(asset.StorageKey)
+}
+
+func (s *MemoryAttachmentStore) IngestContainerFile(_ context.Context, botID, containerPath string) (media.Asset, error) {
+	s.mu.Lock()
+	containerFile, ok := s.containerFiles[s.containerKey(botID, containerPath)]
+	s.mu.Unlock()
+	if !ok {
+		return media.Asset{}, media.ErrAssetNotFound
+	}
+	return s.ingestBytes(containerFile.botID, containerFile.data, containerFile.mime, filepath.Ext(containerFile.name))
+}
+
+func (s *MemoryAttachmentStore) SeedAsset(botID string, data []byte, mimeType, originalExt string) (media.Asset, error) {
+	return s.ingestBytes(botID, data, mimeType, originalExt)
+}
+
+func (s *MemoryAttachmentStore) SeedContainerFile(botID, containerPath string, data []byte, mimeType, name string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.containerFiles[s.containerKey(botID, containerPath)] = storedContainerFile{
+		botID: botID,
+		path:  containerPath,
+		data:  append([]byte(nil), data...),
+		mime:  strings.TrimSpace(mimeType),
+		name:  strings.TrimSpace(name),
+	}
+}
+
+func (s *MemoryAttachmentStore) ingestBytes(botID string, data []byte, mimeType, originalExt string) (media.Asset, error) {
+	sum := sha256.Sum256(data)
+	contentHash := hex.EncodeToString(sum[:])
+	ext := strings.TrimSpace(originalExt)
+	if ext == "" {
+		ext = firstExtension(strings.TrimSpace(mimeType))
+	}
+	if ext == "" {
+		ext = ".bin"
+	}
+	mimeType = strings.TrimSpace(mimeType)
+	if mimeType == "" {
+		mimeType = "application/octet-stream"
+	}
+	asset := media.Asset{
+		ContentHash: contentHash,
+		BotID:       botID,
+		Mime:        mimeType,
+		SizeBytes:   int64(len(data)),
+		StorageKey:  contentHash[:2] + "/" + contentHash + ext,
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.assets[s.assetKey(botID, contentHash)] = storedAsset{
+		asset: asset,
+		data:  append([]byte(nil), data...),
+	}
+	s.storageIndex[s.storageKey(botID, asset.StorageKey)] = contentHash
+	return asset, nil
+}
+
+func (*MemoryAttachmentStore) assetKey(botID, contentHash string) string {
+	return strings.TrimSpace(botID) + ":" + strings.TrimSpace(contentHash)
+}
+
+func (*MemoryAttachmentStore) storageKey(botID, storageKey string) string {
+	return strings.TrimSpace(botID) + ":" + strings.TrimSpace(storageKey)
+}
+
+func (*MemoryAttachmentStore) containerKey(botID, containerPath string) string {
+	return strings.TrimSpace(botID) + ":" + strings.TrimSpace(containerPath)
+}
+
+func firstExtension(mimeType string) string {
+	if mimeType == "" {
+		return ""
+	}
+	exts, err := mime.ExtensionsByType(mimeType)
+	if err != nil || len(exts) == 0 {
+		return ""
+	}
+	return exts[0]
+}
diff --git a/internal/channel/connection.go b/internal/channel/connection.go
index e48cfba1..48bf322a 100644
--- a/internal/channel/connection.go
+++ b/internal/channel/connection.go
@@ -329,16 +329,16 @@ func (m *Manager) Stop(ctx context.Context, configID string) error {
 	}
 	m.mu.Lock()
 	entry := m.connections[configID]
+	if entry != nil {
+		delete(m.connections, configID)
+		delete(m.connectionMeta, configID)
+	}
 	m.mu.Unlock()
+
 	if entry == nil || entry.connection == nil {
 		return nil
 	}
-	err := entry.connection.Stop(ctx)
-	if err != nil {
-		return err
-	}
-	m.markConnectionStatus(entry.config, false, nil)
-	return nil
+	return entry.connection.Stop(ctx)
 }
 
 // StopByBot terminates all connections belonging to the given bot.
@@ -348,16 +348,32 @@ func (m *Manager) StopByBot(ctx context.Context, botID string) error {
 		return errors.New("bot id is required")
 	}
 	m.mu.Lock()
-	defer m.mu.Unlock()
+	var toStop []*connectionEntry
 	for id, entry := range m.connections {
 		if entry != nil && entry.config.BotID == botID {
-			if entry.connection != nil {
-				_ = entry.connection.Stop(ctx)
-			}
+			toStop = append(toStop, entry)
 			delete(m.connections, id)
 			delete(m.connectionMeta, id)
 		}
 	}
+	m.mu.Unlock()
+
+	for _, entry := range toStop {
+		if entry.connection == nil {
+			continue
+		}
+		if err := entry.connection.Stop(ctx); err != nil && !errors.Is(err, ErrStopNotSupported) {
+			if m.logger != nil {
+				m.logger.Warn(
+					"connection stop failed",
+					slog.String("bot_id", botID),
+					slog.String("channel", entry.config.ChannelType.String()),
+					slog.String("config_id", entry.config.ID),
+					slog.Any("error", err),
+				)
+			}
+		}
+	}
 	return nil
 }
 
diff --git a/internal/channel/inbound/channel.go b/internal/channel/inbound/channel.go
index 03b86539..64e2526b 100644
--- a/internal/channel/inbound/channel.go
+++ b/internal/channel/inbound/channel.go
@@ -54,13 +54,8 @@ type chatACL interface {
 }
 
 type mediaIngestor interface {
-	Ingest(ctx context.Context, input media.IngestInput) (media.Asset, error)
-	// GetByStorageKey resolves an asset by reading its sidecar JSON.
-	GetByStorageKey(ctx context.Context, botID, storageKey string) (media.Asset, error)
-	// AccessPath returns a consumer-accessible reference for a persisted asset.
-	AccessPath(asset media.Asset) string
-	// IngestContainerFile reads a file from /data/ and ingests it into media store.
-	IngestContainerFile(ctx context.Context, botID, containerPath string) (media.Asset, error)
+	channel.OutboundAttachmentStore
+	channel.ContainerAttachmentIngester
 }
 
 // ttsSynthesizer synthesizes text to speech audio.
@@ -245,7 +240,7 @@ func (p *ChannelInboundProcessor) HandleInbound(ctx context.Context, cfg channel
 	if sender == nil {
 		return errors.New("reply sender not configured")
 	}
-	text := buildInboundQuery(msg.Message, nil)
+	text := strings.TrimSpace(msg.Message.PlainText())
 	if p.logger != nil {
 		p.logger.Debug("inbound handle start",
 			slog.String("channel", msg.Channel.String()),
@@ -319,7 +314,7 @@ func (p *ChannelInboundProcessor) HandleInbound(ctx context.Context, cfg channel
 
 	resolvedAttachments := p.ingestInboundAttachments(ctx, cfg, msg, strings.TrimSpace(identity.BotID), msg.Message.Attachments)
 	attachments := mapChannelToChatAttachments(resolvedAttachments)
-	text = buildInboundQuery(msg.Message, attachments)
+	text = strings.TrimSpace(msg.Message.PlainText())
 
 	// Detect inbound mode from message prefix (/btw, /now, /next).
 	// Only applies to non-local channels; WebUI always uses the default flow.
@@ -670,28 +665,13 @@ startStream:
 	// can be injected or queued. Produces the inject channel for this stream.
 	// Parallel mode (/now) skips the dispatcher entirely — it must not
 	// interfere with the active flag or drain the queue of another stream.
-	var injectCh <-chan InjectMessage
+	var injectCh <-chan conversation.InjectMessage
 	if p.dispatcher != nil && !isLocalChannelType(msg.Channel) && inboundMode != ModeParallel {
 		injectCh = p.dispatcher.MarkActive(routeID)
 		defer func() {
 			p.drainQueue(context.WithoutCancel(ctx), routeID)
 		}()
 	}
-	// Convert inbound InjectMessage channel to conversation.InjectMessage channel.
-	var convInjectCh chan conversation.InjectMessage
-	if injectCh != nil {
-		convInjectCh = make(chan conversation.InjectMessage, injectChBuffer)
-		go func() {
-			for im := range injectCh {
-				convInjectCh <- conversation.InjectMessage{
-					Text:            im.Text,
-					Attachments:     im.Attachments,
-					HeaderifiedText: im.HeaderifiedText,
-				}
-			}
-			close(convInjectCh)
-		}()
-	}
 
 	chatReq := conversation.ChatRequest{
 		BotID:                   identity.BotID,
@@ -715,8 +695,8 @@ startStream:
 		OutboundAssetCollector:  assetCollector,
 		EventID:                 eventID,
 	}
-	if convInjectCh != nil {
-		chatReq.InjectCh = convInjectCh
+	if injectCh != nil {
+		chatReq.InjectCh = injectCh
 	}
 	if mid, _ := msg.Metadata["model_id"].(string); strings.TrimSpace(mid) != "" {
 		chatReq.Model = strings.TrimSpace(mid)
@@ -760,7 +740,7 @@ startStream:
 			}
 			for i, event := range events {
 				if event.Type == channel.StreamEventAttachment && len(event.Attachments) > 0 {
-					ingested := p.ingestOutboundAttachments(ctx, strings.TrimSpace(identity.BotID), event.Attachments)
+					ingested := p.ingestOutboundAttachments(ctx, strings.TrimSpace(identity.BotID), msg.Channel, event.Attachments)
 					events[i].Attachments = ingested
 					assetMu.Lock()
 					outboundAssetRefs = append(outboundAssetRefs, buildAssetRefs(ingested, len(outboundAssetRefs))...)
@@ -771,7 +751,7 @@ startStream:
 					continue
 				}
 				if event.Type == channel.StreamEventSpeech && len(event.Speeches) > 0 {
-					p.synthesizeAndPushVoice(ctx, strings.TrimSpace(identity.BotID), event.Speeches, stream, &outboundAssetRefs, &assetMu)
+					p.synthesizeAndPushVoice(ctx, strings.TrimSpace(identity.BotID), msg.Channel, event.Speeches, stream, &outboundAssetRefs, &assetMu)
 					continue
 				}
 				if pushErr := stream.Push(ctx, events[i]); pushErr != nil {
@@ -1070,7 +1050,7 @@ func (p *ChannelInboundProcessor) persistPassiveMessage(
 		if ch == "" {
 			continue
 		}
-		assets = append(assets, messagepkg.AssetRef{
+		ref := messagepkg.AssetRef{
 			ContentHash: ch,
 			Role:        "attachment",
 			Ordinal:     i,
@@ -1078,7 +1058,13 @@ func (p *ChannelInboundProcessor) persistPassiveMessage(
 			SizeBytes:   att.Size,
 			Name:        strings.TrimSpace(att.Name),
 			Metadata:    att.Metadata,
-		})
+		}
+		if att.Metadata != nil {
+			if sk, ok := att.Metadata["storage_key"].(string); ok {
+				ref.StorageKey = sk
+			}
+		}
+		assets = append(assets, ref)
 	}
 
 	if _, err := p.message.Persist(ctx, messagepkg.PersistInput{
@@ -1347,10 +1333,6 @@ func mapStreamChunkToChannelEvents(chunk conversation.StreamChunk) ([]channel.St
 	}
 }
 
-func buildInboundQuery(message channel.Message, _ []conversation.ChatAttachment) string {
-	return strings.TrimSpace(message.PlainText())
-}
-
 func normalizeContentPartType(raw string) channel.MessagePartType {
 	switch strings.TrimSpace(strings.ToLower(raw)) {
 	case "link":
@@ -1568,11 +1550,18 @@ func isMessagingToolDuplicate(text string, sentTexts []string) bool {
 	return false
 }
 
-// requireIdentity resolves identity for the current message. Always resolves from msg so each sender is identified correctly (no reuse of context state across messages).
+// requireIdentity resolves identity for the current message.
+// It first checks whether the middleware chain already resolved and stored an
+// IdentityState in the context (via IdentityResolver.Middleware), and reuses
+// that result to avoid a redundant round-trip to the identity store. If no
+// cached state is found it falls back to a fresh Resolve call.
 func (p *ChannelInboundProcessor) requireIdentity(ctx context.Context, cfg channel.ChannelConfig, msg channel.InboundMessage) (IdentityState, error) {
 	if p.identity == nil {
 		return IdentityState{}, errors.New("identity resolver not configured")
 	}
+	if state, ok := IdentityStateFromContext(ctx); ok {
+		return state, nil
+	}
 	return p.identity.Resolve(ctx, cfg, msg)
 }
 
@@ -1892,175 +1881,32 @@ func (p *ChannelInboundProcessor) resolveAttachmentResolver(channelType channel.
 // media service, replacing ephemeral data URLs with stable asset references.
 // For container-internal paths (non-HTTP), it attempts to resolve the existing
 // asset by matching the storage key extracted from the path.
-func (p *ChannelInboundProcessor) ingestOutboundAttachments(ctx context.Context, botID string, attachments []channel.Attachment) []channel.Attachment {
+func (p *ChannelInboundProcessor) ingestOutboundAttachments(ctx context.Context, botID string, channelType channel.ChannelType, attachments []channel.Attachment) []channel.Attachment {
 	if len(attachments) == 0 || p.mediaService == nil || strings.TrimSpace(botID) == "" {
 		return attachments
 	}
-	result := make([]channel.Attachment, 0, len(attachments))
-	for _, att := range attachments {
-		item := att
-		rawURL := strings.TrimSpace(item.URL)
-		if strings.TrimSpace(item.ContentHash) != "" {
-			if item.Metadata == nil {
-				item.Metadata = make(map[string]any)
-			}
-			if _, ok := item.Metadata["bot_id"]; !ok {
-				item.Metadata["bot_id"] = botID
-			}
-			result = append(result, item)
-			continue
+	prepared, err := channel.PrepareStreamEvent(ctx, p.mediaService, channel.ChannelConfig{
+		BotID:       botID,
+		ChannelType: channelType,
+	}, channel.StreamEvent{
+		Type:        channel.StreamEventAttachment,
+		Attachments: attachments,
+	})
+	if err != nil {
+		if p.logger != nil {
+			p.logger.Warn("prepare outbound attachments failed", slog.Any("error", err))
 		}
-		// Non-data-URL, non-HTTP path: try to resolve as an existing asset via storage key.
-		if rawURL != "" && !isDataURL(rawURL) && !isHTTPURL(rawURL) {
-			if resolved := p.resolveContainerPathAsset(ctx, botID, rawURL, &item); resolved {
-				result = append(result, item)
-				continue
-			}
-			result = append(result, item)
-			continue
-		}
-		if !isDataURL(rawURL) {
-			result = append(result, item)
-			continue
-		}
-		decoded, err := attachment.DecodeBase64(rawURL, media.MaxAssetBytes)
-		if err != nil {
-			if p.logger != nil {
-				p.logger.Warn("decode outbound attachment data url failed", slog.Any("error", err))
-			}
-			result = append(result, item)
-			continue
-		}
-		mimeType := attachment.NormalizeMime(item.Mime)
-		if mimeType == "" {
-			mimeType = attachment.MimeFromDataURL(rawURL)
-		}
-		asset, err := p.mediaService.Ingest(ctx, media.IngestInput{
-			BotID:    botID,
-			Mime:     mimeType,
-			Reader:   decoded,
-			MaxBytes: media.MaxAssetBytes,
-		})
-		if err != nil {
-			if p.logger != nil {
-				p.logger.Warn("ingest outbound attachment failed", slog.Any("error", err))
-			}
-			result = append(result, item)
-			continue
-		}
-		sourceURL := item.URL
-		item.ContentHash = asset.ContentHash
-		item.URL = ""
-		item.Base64 = ""
-		if item.Metadata == nil {
-			item.Metadata = make(map[string]any)
-		}
-		item.Metadata["bot_id"] = botID
-		item.Metadata["storage_key"] = asset.StorageKey
-		if n := strings.TrimSpace(item.Name); n != "" {
-			item.Metadata["name"] = n
-		}
-		if su := strings.TrimSpace(sourceURL); su != "" && !isDataURL(su) {
-			item.Metadata["source_url"] = su
-		}
-		if strings.TrimSpace(item.Mime) == "" {
-			item.Mime = attachment.NormalizeMime(asset.Mime)
-		}
-		if item.Size == 0 && asset.SizeBytes > 0 {
-			item.Size = asset.SizeBytes
-		}
-		result = append(result, item)
+		return attachments
 	}
-	return result
+	return prepared.LogicalEvent().Attachments
 }
 
 func isDataURL(raw string) bool {
-	return strings.HasPrefix(strings.ToLower(strings.TrimSpace(raw)), "data:")
+	return channel.IsDataURL(raw)
 }
 
 func isHTTPURL(raw string) bool {
-	lower := strings.ToLower(strings.TrimSpace(raw))
-	return strings.HasPrefix(lower, "http://") || strings.HasPrefix(lower, "https://")
-}
-
-// resolveContainerPathAsset attempts to match a container-internal file path
-// to an existing media asset by extracting the storage key from the path.
-// For non-media-marker paths, it ingests the file into the media store first.
-// Returns true if the asset was resolved and item was updated.
-func (p *ChannelInboundProcessor) resolveContainerPathAsset(ctx context.Context, botID, accessPath string, item *channel.Attachment) bool {
-	sourcePath := accessPath
-
-	// Try media marker lookup first.
-	storageKey := extractStorageKey(accessPath, botID)
-	if storageKey != "" {
-		asset, err := p.mediaService.GetByStorageKey(ctx, botID, storageKey)
-		if err == nil {
-			applyAssetToAttachment(asset, botID, item, sourcePath)
-			return true
-		}
-	}
-
-	// For any path starting with data mount, ingest the file into media store.
-	dataPrefix := "/data"
-	if !strings.HasSuffix(dataPrefix, "/") {
-		dataPrefix += "/"
-	}
-	if strings.HasPrefix(accessPath, dataPrefix) {
-		asset, err := p.mediaService.IngestContainerFile(ctx, botID, accessPath)
-		if err != nil {
-			if p.logger != nil {
-				p.logger.Warn("ingest container file for stream failed", slog.String("path", accessPath), slog.Any("error", err))
-			}
-			return false
-		}
-		applyAssetToAttachment(asset, botID, item, sourcePath)
-		return true
-	}
-
-	return false
-}
-
-func applyAssetToAttachment(asset media.Asset, botID string, item *channel.Attachment, sourcePath string) {
-	sourceURL := item.URL
-	item.ContentHash = asset.ContentHash
-	item.URL = ""
-	if item.Metadata == nil {
-		item.Metadata = make(map[string]any)
-	}
-	item.Metadata["bot_id"] = botID
-	item.Metadata["storage_key"] = asset.StorageKey
-	if n := strings.TrimSpace(item.Name); n != "" {
-		item.Metadata["name"] = n
-	}
-	if sp := strings.TrimSpace(sourcePath); sp != "" {
-		item.Metadata["source_path"] = sp
-	}
-	if su := strings.TrimSpace(sourceURL); su != "" && !isDataURL(su) {
-		item.Metadata["source_url"] = su
-	}
-	if strings.TrimSpace(item.Mime) == "" {
-		item.Mime = attachment.NormalizeMime(asset.Mime)
-	}
-	if item.Size == 0 && asset.SizeBytes > 0 {
-		item.Size = asset.SizeBytes
-	}
-	if item.Type == channel.AttachmentFile || item.Type == "" {
-		item.Type = inferAttachmentTypeFromMime(strings.TrimSpace(item.Mime))
-	}
-}
-
-func inferAttachmentTypeFromMime(mime string) channel.AttachmentType {
-	mime = strings.ToLower(strings.TrimSpace(mime))
-	switch {
-	case strings.HasPrefix(mime, "image/"):
-		return channel.AttachmentImage
-	case strings.HasPrefix(mime, "audio/"):
-		return channel.AttachmentAudio
-	case strings.HasPrefix(mime, "video/"):
-		return channel.AttachmentVideo
-	default:
-		return channel.AttachmentFile
-	}
+	return channel.IsHTTPURL(raw)
 }
 
 // extractStorageKey derives the media storage key from a container-internal
@@ -2140,7 +1986,8 @@ func (p *ChannelInboundProcessor) broadcastInboundMessage(
 }
 
 // channelAttachmentsToAssetRefs converts channel Attachments to message AssetRefs
-// with full metadata for denormalized persistence.
+// for denormalized persistence. Only attachments with a non-empty ContentHash are
+// included. StorageKey is extracted from Metadata when present.
 func channelAttachmentsToAssetRefs(attachments []channel.Attachment, role string) []messagepkg.AssetRef {
 	if len(attachments) == 0 {
 		return nil
@@ -2157,6 +2004,8 @@ func channelAttachmentsToAssetRefs(attachments []channel.Attachment, role string
 			Ordinal:     idx,
 			Mime:        strings.TrimSpace(att.Mime),
 			SizeBytes:   att.Size,
+			Name:        strings.TrimSpace(att.Name),
+			Metadata:    att.Metadata,
 		}
 		if att.Metadata != nil {
 			if sk, ok := att.Metadata["storage_key"].(string); ok {
@@ -2245,6 +2094,7 @@ func parseAttachmentDelta(raw json.RawMessage) []channel.Attachment {
 func (p *ChannelInboundProcessor) synthesizeAndPushVoice(
 	ctx context.Context,
 	botID string,
+	channelType channel.ChannelType,
 	speeches []channel.SpeechRequest,
 	stream channel.OutboundStream,
 	outboundAssetRefs *[]conversation.OutboundAssetRef,
@@ -2287,7 +2137,7 @@ func (p *ChannelInboundProcessor) synthesizeAndPushVoice(
 				},
 			},
 		}
-		ingested := p.ingestOutboundAttachments(ctx, botID, voiceEvent.Attachments)
+		ingested := p.ingestOutboundAttachments(ctx, botID, channelType, voiceEvent.Attachments)
 		voiceEvent.Attachments = ingested
 		assetMu.Lock()
 		*outboundAssetRefs = append(*outboundAssetRefs, buildAssetRefs(ingested, len(*outboundAssetRefs))...)
diff --git a/internal/channel/inbound/channel_test.go b/internal/channel/inbound/channel_test.go
index 2a437fa6..965ffc51 100644
--- a/internal/channel/inbound/channel_test.go
+++ b/internal/channel/inbound/channel_test.go
@@ -205,6 +205,30 @@ type fakeMediaIngestor struct {
 	storageKeyErr   error
 }
 
+func (f *fakeMediaIngestor) Stat(_ context.Context, _, contentHash string) (media.Asset, error) {
+	asset := f.storageKeyAsset
+	if asset.ContentHash == "" {
+		asset = media.Asset{
+			ContentHash: contentHash,
+			Mime:        "application/octet-stream",
+			StorageKey:  "test/" + contentHash,
+		}
+	}
+	return asset, nil
+}
+
+func (f *fakeMediaIngestor) Open(_ context.Context, _, contentHash string) (io.ReadCloser, media.Asset, error) {
+	asset := f.storageKeyAsset
+	if asset.ContentHash == "" {
+		asset = media.Asset{
+			ContentHash: contentHash,
+			Mime:        "application/octet-stream",
+			StorageKey:  "test/" + contentHash,
+		}
+	}
+	return io.NopCloser(bytes.NewReader([]byte("test"))), asset, nil
+}
+
 func (f *fakeMediaIngestor) Ingest(_ context.Context, input media.IngestInput) (media.Asset, error) {
 	f.calls++
 	f.inputs = append(f.inputs, input)
@@ -533,7 +557,7 @@ func TestBuildInboundQueryAttachmentOnlyReturnsEmpty(t *testing.T) {
 			{Type: channel.AttachmentImage},
 		},
 	}
-	if got := buildInboundQuery(msg, nil); got != "" {
+	if got := strings.TrimSpace(msg.PlainText()); got != "" {
 		t.Fatalf("expected empty query for attachment-only message, got %q", got)
 	}
 }
@@ -1525,7 +1549,7 @@ func TestIngestOutboundAttachments_DataURL(t *testing.T) {
 		{Type: channel.AttachmentImage, URL: "data:image/png;base64,iVBORw0KGgo=", Mime: "image/png"},
 	}
 	// Without media service, attachments pass through unchanged.
-	result := p.ingestOutboundAttachments(context.Background(), "bot-1", attachments)
+	result := p.ingestOutboundAttachments(context.Background(), "bot-1", channel.ChannelType("telegram"), attachments)
 	if len(result) != 1 {
 		t.Fatalf("expected 1 attachment, got %d", len(result))
 	}
@@ -1542,7 +1566,7 @@ func TestIngestOutboundAttachments_NonDataURL(t *testing.T) {
 		{Type: channel.AttachmentImage, URL: "https://example.com/img.png"},
 		{Type: channel.AttachmentImage, ContentHash: "existing-asset", URL: "/data/media/img.png"},
 	}
-	result := p.ingestOutboundAttachments(context.Background(), "bot-1", attachments)
+	result := p.ingestOutboundAttachments(context.Background(), "bot-1", channel.ChannelType("telegram"), attachments)
 	if len(result) != 2 {
 		t.Fatalf("expected 2 attachments, got %d", len(result))
 	}
@@ -1644,7 +1668,7 @@ func TestIngestOutboundAttachments_ContainerPath(t *testing.T) {
 	attachments := []channel.Attachment{
 		{Type: channel.AttachmentImage, URL: "/data/media/26da/26da0cc7.jpg"},
 	}
-	result := p.ingestOutboundAttachments(context.Background(), "bot-1", attachments)
+	result := p.ingestOutboundAttachments(context.Background(), "bot-1", channel.ChannelType("telegram"), attachments)
 	if len(result) != 1 {
 		t.Fatalf("expected 1 attachment, got %d", len(result))
 	}
@@ -1666,9 +1690,12 @@ func TestIngestOutboundAttachments_ContainerPathNotFound(t *testing.T) {
 	attachments := []channel.Attachment{
 		{Type: channel.AttachmentImage, URL: "/data/media/26da/missing.jpg"},
 	}
-	result := p.ingestOutboundAttachments(context.Background(), "bot-1", attachments)
+	result := p.ingestOutboundAttachments(context.Background(), "bot-1", channel.ChannelType("telegram"), attachments)
 	if len(result) != 1 {
-		t.Fatalf("expected 1 attachment, got %d", len(result))
+		t.Fatalf("expected unresolved container attachment to remain unchanged, got %d", len(result))
+	}
+	if result[0].URL != "/data/media/26da/missing.jpg" {
+		t.Fatalf("expected original path preserved, got %q", result[0].URL)
 	}
 	if result[0].ContentHash != "" {
 		t.Fatalf("expected empty content_hash for unresolved path, got %q", result[0].ContentHash)
diff --git a/internal/channel/inbound/dispatcher.go b/internal/channel/inbound/dispatcher.go
index ba46e316..5e9ae12e 100644
--- a/internal/channel/inbound/dispatcher.go
+++ b/internal/channel/inbound/dispatcher.go
@@ -11,6 +11,11 @@ import (
 	"github.com/memohai/memoh/internal/conversation"
 )
 
+// InjectMessage is an alias for conversation.InjectMessage, re-exported so
+// callers within this package do not need to import the conversation package
+// directly for inject-related types.
+type InjectMessage = conversation.InjectMessage
+
 // InboundMode determines how a new inbound message is handled when an agent
 // stream is already active for the same route.
 type InboundMode int
@@ -28,14 +33,6 @@ const (
 	ModeQueue
 )
 
-// InjectMessage carries a user message to be injected into a running agent stream.
-type InjectMessage struct {
-	Text        string
-	Attachments []conversation.ChatAttachment
-	// HeaderifiedText is the formatted user header text ready for SDK injection.
-	HeaderifiedText string
-}
-
 // QueuedTask holds everything needed to start an agent stream for a queued message.
 type QueuedTask struct {
 	Ctx     context.Context
diff --git a/internal/channel/inbound_test.go b/internal/channel/inbound_test.go
index 68445f69..e63000d7 100644
--- a/internal/channel/inbound_test.go
+++ b/internal/channel/inbound_test.go
@@ -26,12 +26,12 @@ func (*mockAdapter) Descriptor() Descriptor {
 	}
 }
 
-func (m *mockAdapter) Send(_ context.Context, _ ChannelConfig, msg OutboundMessage) error {
-	m.sentMessages = append(m.sentMessages, msg)
+func (m *mockAdapter) Send(_ context.Context, _ ChannelConfig, msg PreparedOutboundMessage) error {
+	m.sentMessages = append(m.sentMessages, msg.LogicalMessage())
 	return nil
 }
 
-func (m *mockAdapter) OpenStream(_ context.Context, _ ChannelConfig, _ string, _ StreamOptions) (OutboundStream, error) {
+func (m *mockAdapter) OpenStream(_ context.Context, _ ChannelConfig, _ string, _ StreamOptions) (PreparedOutboundStream, error) {
 	return &mockAdapterStream{adapter: m}, nil
 }
 
@@ -39,15 +39,16 @@ type mockAdapterStream struct {
 	adapter *mockAdapter
 }
 
-func (s *mockAdapterStream) Push(_ context.Context, event StreamEvent) error {
+func (s *mockAdapterStream) Push(_ context.Context, event PreparedStreamEvent) error {
 	if s == nil || s.adapter == nil {
 		return nil
 	}
-	s.adapter.streamEvents = append(s.adapter.streamEvents, event)
-	if event.Type == StreamEventFinal && event.Final != nil && !event.Final.Message.IsEmpty() {
+	logical := event.LogicalEvent()
+	s.adapter.streamEvents = append(s.adapter.streamEvents, logical)
+	if logical.Type == StreamEventFinal && logical.Final != nil && !logical.Final.Message.IsEmpty() {
 		s.adapter.sentMessages = append(s.adapter.sentMessages, OutboundMessage{
 			Target:  "stream-target",
-			Message: event.Final.Message,
+			Message: logical.Final.Message,
 		})
 	}
 	return nil
diff --git a/internal/channel/manager.go b/internal/channel/manager.go
index ad510875..cd2b9af4 100644
--- a/internal/channel/manager.go
+++ b/internal/channel/manager.go
@@ -62,6 +62,7 @@ type Manager struct {
 	registry        *Registry
 	service         ManagerStore
 	processor       InboundProcessor
+	attachmentStore OutboundAttachmentStore
 	refreshInterval time.Duration
 	logger          *slog.Logger
 	middlewares     []Middleware
@@ -77,15 +78,48 @@ type Manager struct {
 	connectionMeta map[string]ConnectionStatus
 }
 
+// ManagerOption configures a Manager during construction.
+type ManagerOption func(*Manager)
+
+// WithInboundQueueSize sets the capacity of the inbound message queue.
+// The default is 256. Larger values trade memory for lower drop rate under burst load.
+func WithInboundQueueSize(size int) ManagerOption {
+	return func(m *Manager) {
+		if size > 0 {
+			m.inboundQueue = make(chan inboundTask, size)
+		}
+	}
+}
+
+// WithInboundWorkers sets the number of goroutines that process inbound messages
+// concurrently. The default is 4.
+func WithInboundWorkers(n int) ManagerOption {
+	return func(m *Manager) {
+		if n > 0 {
+			m.inboundWorkers = n
+		}
+	}
+}
+
+// WithRefreshInterval overrides the periodic connection reconcile interval.
+// The default is 5 minutes.
+func WithRefreshInterval(d time.Duration) ManagerOption {
+	return func(m *Manager) {
+		if d > 0 {
+			m.refreshInterval = d
+		}
+	}
+}
+
 // NewManager creates a Manager with the given logger, registry, config store, and inbound processor.
-func NewManager(log *slog.Logger, registry *Registry, service ManagerStore, processor InboundProcessor) *Manager {
+func NewManager(log *slog.Logger, registry *Registry, service ManagerStore, processor InboundProcessor, opts ...ManagerOption) *Manager {
 	if log == nil {
 		log = slog.Default()
 	}
 	if registry == nil {
 		registry = NewRegistry()
 	}
-	return &Manager{
+	m := &Manager{
 		registry:        registry,
 		service:         service,
 		processor:       processor,
@@ -97,6 +131,10 @@ func NewManager(log *slog.Logger, registry *Registry, service ManagerStore, proc
 		inboundQueue:    make(chan inboundTask, 256),
 		inboundWorkers:  4,
 	}
+	for _, opt := range opts {
+		opt(m)
+	}
+	return m
 }
 
 // Registry returns the adapter registry used by this manager.
@@ -109,6 +147,12 @@ func (m *Manager) Use(mw ...Middleware) {
 	m.middlewares = append(m.middlewares, mw...)
 }
 
+// SetAttachmentStore wires the shared outbound attachment store used by the
+// prepared outbound layer.
+func (m *Manager) SetAttachmentStore(store OutboundAttachmentStore) {
+	m.attachmentStore = store
+}
+
 // RegisterAdapter adds an adapter to the registry and logs the registration.
 func (m *Manager) RegisterAdapter(adapter Adapter) {
 	if adapter == nil {
@@ -144,6 +188,7 @@ func (m *Manager) RemoveAdapter(ctx context.Context, channelType ChannelType) {
 				}
 			}
 			delete(m.connections, id)
+			delete(m.connectionMeta, id)
 		}
 	}
 	m.mu.Unlock()
diff --git a/internal/channel/manager_integration_test.go b/internal/channel/manager_integration_test.go
index c396ec15..47c3c418 100644
--- a/internal/channel/manager_integration_test.go
+++ b/internal/channel/manager_integration_test.go
@@ -113,9 +113,9 @@ func (f *fakeAdapter) Connect(ctx context.Context, cfg ChannelConfig, _ InboundH
 	return NewConnection(cfg, stop), nil
 }
 
-func (f *fakeAdapter) Send(_ context.Context, _ ChannelConfig, msg OutboundMessage) error {
+func (f *fakeAdapter) Send(_ context.Context, _ ChannelConfig, msg PreparedOutboundMessage) error {
 	f.mu.Lock()
-	f.sent = append(f.sent, msg)
+	f.sent = append(f.sent, msg.LogicalMessage())
 	f.mu.Unlock()
 	return nil
 }
diff --git a/internal/channel/outbound.go b/internal/channel/outbound.go
index e42f9d4b..21de9eec 100644
--- a/internal/channel/outbound.go
+++ b/internal/channel/outbound.go
@@ -161,7 +161,7 @@ func ChunkMarkdownText(text string, limit int) []string {
 }
 
 func runeLen(value string) int {
-	return len([]rune(value))
+	return utf8.RuneCountInString(value)
 }
 
 func splitLongLine(line string, limit int) []string {
@@ -224,10 +224,16 @@ func buildOutboundMessages(msg OutboundMessage, policy OutboundPolicy) ([]Outbou
 			if len(chunks) > 1 && idx < len(chunks)-1 {
 				actions = nil
 			}
+			// Message.ID signals an edit operation; only the first chunk carries it
+			// so subsequent chunks are delivered as new messages rather than repeated edits.
+			var messageID string
+			if idx == 0 {
+				messageID = base.ID
+			}
 			item := OutboundMessage{
 				Target: msg.Target,
 				Message: Message{
-					ID:          base.ID,
+					ID:          messageID,
 					Format:      base.Format,
 					Text:        chunk,
 					Parts:       base.Parts,
@@ -360,6 +366,13 @@ func (m *Manager) sendWithConfig(ctx context.Context, sender Sender, cfg Channel
 	if err := validateMessageCapabilities(m.registry, cfg.ChannelType, normalized.Message); err != nil {
 		return err
 	}
+	prepared, err := PrepareOutboundMessage(ctx, m.attachmentStore, cfg, OutboundMessage{
+		Target:  target,
+		Message: normalized.Message,
+	})
+	if err != nil {
+		return err
+	}
 	editor, _ := m.registry.GetMessageEditor(cfg.ChannelType)
 	if strings.TrimSpace(normalized.Message.ID) != "" {
 		if editor == nil {
@@ -367,8 +380,15 @@ func (m *Manager) sendWithConfig(ctx context.Context, sender Sender, cfg Channel
 		}
 		var lastErr error
 		for i := 0; i < policy.RetryMax; i++ {
-			err := editor.Update(ctx, cfg, target, strings.TrimSpace(normalized.Message.ID), normalized.Message)
+			err := editor.Update(ctx, cfg, target, strings.TrimSpace(normalized.Message.ID), prepared.Message)
 			if err == nil {
+				if m.logger != nil {
+					m.logger.Debug("edit outbound success",
+						slog.String("channel", cfg.ChannelType.String()),
+						slog.String("bot_id", cfg.BotID),
+						slog.String("target", target),
+					)
+				}
 				return nil
 			}
 			lastErr = err
@@ -378,14 +398,23 @@ func (m *Manager) sendWithConfig(ctx context.Context, sender Sender, cfg Channel
 					slog.Int("attempt", i+1),
 					slog.Any("error", err))
 			}
-			time.Sleep(time.Duration(i+1) * time.Duration(policy.RetryBackoffMs) * time.Millisecond)
+			if !sleepWithContext(ctx, time.Duration(i+1)*time.Duration(policy.RetryBackoffMs)*time.Millisecond) {
+				return fmt.Errorf("edit outbound cancelled: %w", ctx.Err())
+			}
 		}
 		return fmt.Errorf("edit outbound failed after retries: %w", lastErr)
 	}
 	var lastErr error
 	for i := 0; i < policy.RetryMax; i++ {
-		err := sender.Send(ctx, cfg, OutboundMessage{Target: target, Message: normalized.Message})
+		err := sender.Send(ctx, cfg, prepared)
 		if err == nil {
+			if m.logger != nil {
+				m.logger.Debug("send outbound success",
+					slog.String("channel", cfg.ChannelType.String()),
+					slog.String("bot_id", cfg.BotID),
+					slog.String("target", target),
+				)
+			}
 			return nil
 		}
 		lastErr = err
@@ -395,7 +424,9 @@ func (m *Manager) sendWithConfig(ctx context.Context, sender Sender, cfg Channel
 				slog.Int("attempt", i+1),
 				slog.Any("error", err))
 		}
-		time.Sleep(time.Duration(i+1) * time.Duration(policy.RetryBackoffMs) * time.Millisecond)
+		if !sleepWithContext(ctx, time.Duration(i+1)*time.Duration(policy.RetryBackoffMs)*time.Millisecond) {
+			return fmt.Errorf("send outbound cancelled: %w", ctx.Err())
+		}
 	}
 	return fmt.Errorf("send outbound failed after retries: %w", lastErr)
 }
@@ -548,13 +579,15 @@ func (s *managerReplySender) OpenStream(ctx context.Context, target string, opts
 	}
 	return &managerOutboundStream{
 		manager:     s.manager,
+		config:      s.config,
 		stream:      stream,
 		channelType: s.channelType,
+		policy:      s.manager.resolveOutboundPolicy(s.channelType),
 		send: func(ctx context.Context, msg OutboundMessage) error {
 			msg.Target = target
 			return s.Send(ctx, msg)
 		},
-		reopen: func(ctx context.Context) (OutboundStream, error) {
+		reopen: func(ctx context.Context) (PreparedOutboundStream, error) {
 			return s.streamSender.OpenStream(ctx, s.config, target, StreamOptions{
 				SourceMessageID: opts.SourceMessageID,
 				Metadata:        opts.Metadata,
@@ -563,12 +596,19 @@ func (s *managerReplySender) OpenStream(ctx context.Context, target string, opts
 	}, nil
 }
 
+// managerOutboundStream wraps a PreparedOutboundStream and adds text-chunking,
+// stream-splitting, and attachment fallback on top of the raw adapter stream.
+//
+// Push and Close must be called from a single goroutine; this type is not
+// safe for concurrent use.
 type managerOutboundStream struct {
 	manager     *Manager
-	stream      OutboundStream
+	config      ChannelConfig
+	stream      PreparedOutboundStream
 	channelType ChannelType
+	policy      OutboundPolicy // cached at open time; immutable after creation
 	send        func(ctx context.Context, msg OutboundMessage) error
-	reopen      func(ctx context.Context) (OutboundStream, error)
+	reopen      func(ctx context.Context) (PreparedOutboundStream, error)
 	deltaRunes  int
 	deltaText   strings.Builder
 	splitCount  int
@@ -592,7 +632,7 @@ func (s *managerOutboundStream) Push(ctx context.Context, event StreamEvent) err
 		}
 		return s.pushFinalWithChunking(ctx, event)
 	}
-	return s.stream.Push(ctx, event)
+	return s.pushPrepared(ctx, event)
 }
 
 // streamSplitSoftRatio controls the soft-limit window. The soft limit is
@@ -606,10 +646,10 @@ const streamSplitSoftRatio = 4
 // the soft and hard limits it looks for natural break points (sentence ends,
 // line breaks) so messages don't get cut mid-sentence.
 func (s *managerOutboundStream) pushDelta(ctx context.Context, event StreamEvent) error {
-	policy := s.manager.resolveOutboundPolicy(s.channelType)
+	policy := s.policy
 	if policy.TextChunkLimit <= 0 || s.reopen == nil {
 		s.deltaRunes += runeLen(event.Delta)
-		return s.stream.Push(ctx, event)
+		return s.pushPrepared(ctx, event)
 	}
 
 	newRunes := runeLen(event.Delta)
@@ -620,13 +660,13 @@ func (s *managerOutboundStream) pushDelta(ctx context.Context, event StreamEvent
 	if afterRunes <= softLimit {
 		s.deltaRunes = afterRunes
 		s.deltaText.WriteString(event.Delta)
-		return s.stream.Push(ctx, event)
+		return s.pushPrepared(ctx, event)
 	}
 
 	if afterRunes <= hardLimit {
 		s.deltaRunes = afterRunes
 		s.deltaText.WriteString(event.Delta)
-		if err := s.stream.Push(ctx, event); err != nil {
+		if err := s.pushPrepared(ctx, event); err != nil {
 			return err
 		}
 		if isNaturalBreakPoint(s.deltaText.String()) {
@@ -643,14 +683,14 @@ func (s *managerOutboundStream) pushDelta(ctx context.Context, event StreamEvent
 	s.deltaRunes = newRunes
 	s.deltaText.Reset()
 	s.deltaText.WriteString(event.Delta)
-	return s.stream.Push(ctx, event)
+	return s.pushPrepared(ctx, event)
 }
 
 // splitStream finalizes the current adapter stream, opens a continuation
 // stream, and sends Status(Started) so the adapter creates a new platform
 // message before the first delta arrives.
 func (s *managerOutboundStream) splitStream(ctx context.Context) error {
-	if err := s.stream.Push(ctx, StreamEvent{
+	if err := s.pushPrepared(ctx, StreamEvent{
 		Type:  StreamEventFinal,
 		Final: &StreamFinalizePayload{},
 	}); err != nil {
@@ -667,7 +707,7 @@ func (s *managerOutboundStream) splitStream(ctx context.Context) error {
 	s.stream = newStream
 	s.splitCount++
 
-	return s.stream.Push(ctx, StreamEvent{
+	return s.pushPrepared(ctx, StreamEvent{
 		Type:   StreamEventStatus,
 		Status: StreamStatusStarted,
 	})
@@ -699,7 +739,7 @@ func (s *managerOutboundStream) pushFinalAfterSplit(ctx context.Context, event S
 		Final:    &StreamFinalizePayload{},
 		Metadata: event.Metadata,
 	}
-	if err := s.stream.Push(ctx, bufferFinal); err != nil {
+	if err := s.pushPrepared(ctx, bufferFinal); err != nil {
 		return err
 	}
 
@@ -723,7 +763,7 @@ func (s *managerOutboundStream) pushFinalAfterSplit(ctx context.Context, event S
 }
 
 func (s *managerOutboundStream) pushFinalWithChunking(ctx context.Context, event StreamEvent) error {
-	policy := s.manager.resolveOutboundPolicy(s.channelType)
+	policy := s.policy
 	if policy.TextChunkLimit <= 0 {
 		if s.manager.logger != nil {
 			s.manager.logger.Debug("stream final chunking skipped: non-positive chunk limit",
@@ -731,7 +771,7 @@ func (s *managerOutboundStream) pushFinalWithChunking(ctx context.Context, event
 				slog.Int("chunk_limit", policy.TextChunkLimit),
 			)
 		}
-		return s.stream.Push(ctx, event)
+		return s.pushPrepared(ctx, event)
 	}
 	msg := normalizeOutboundMessage(event.Final.Message)
 	text := strings.TrimSpace(msg.PlainText())
@@ -753,7 +793,7 @@ func (s *managerOutboundStream) pushFinalWithChunking(ctx context.Context, event
 				slog.Int("chunk_limit", policy.TextChunkLimit),
 			)
 		}
-		return s.stream.Push(ctx, event)
+		return s.pushPrepared(ctx, event)
 	}
 
 	chunker := policy.Chunker
@@ -768,7 +808,7 @@ func (s *managerOutboundStream) pushFinalWithChunking(ctx context.Context, event
 				slog.Int("chunks", len(chunks)),
 			)
 		}
-		return s.stream.Push(ctx, event)
+		return s.pushPrepared(ctx, event)
 	}
 
 	hasAttachments := len(msg.Attachments) > 0
@@ -792,7 +832,7 @@ func (s *managerOutboundStream) pushFinalWithChunking(ctx context.Context, event
 	}
 	firstChunkCtx, cancelFirstChunk := context.WithTimeout(ctx, streamFinalFirstChunkTimeout)
 	defer cancelFirstChunk()
-	if err := s.stream.Push(firstChunkCtx, firstChunkEvent); err != nil {
+	if err := s.pushPrepared(firstChunkCtx, firstChunkEvent); err != nil {
 		if s.manager.logger != nil {
 			s.manager.logger.Warn("stream final first chunk push failed, fallback to direct sends",
 				slog.String("channel", s.channelType.String()),
@@ -805,6 +845,17 @@ func (s *managerOutboundStream) pushFinalWithChunking(ctx context.Context, event
 	return s.sendChunkedFinal(ctx, msg, chunks, 1, hasAttachments)
 }
 
+func (s *managerOutboundStream) pushPrepared(ctx context.Context, event StreamEvent) error {
+	if s.manager == nil || s.stream == nil {
+		return errors.New("stream is not configured")
+	}
+	prepared, err := PrepareStreamEvent(ctx, s.manager.attachmentStore, s.config, event)
+	if err != nil {
+		return err
+	}
+	return s.stream.Push(ctx, prepared)
+}
+
 func (s *managerOutboundStream) sendChunkedFinal(ctx context.Context, msg Message, chunks []string, startIndex int, hasAttachments bool) error {
 	if startIndex < 0 {
 		startIndex = 0
@@ -878,3 +929,16 @@ func (s *managerOutboundStream) Close(ctx context.Context) error {
 	}
 	return s.stream.Close(ctx)
 }
+
+// sleepWithContext waits for d or until ctx is cancelled.
+// It returns true if the sleep completed normally, false if ctx was cancelled.
+func sleepWithContext(ctx context.Context, d time.Duration) bool {
+	timer := time.NewTimer(d)
+	defer timer.Stop()
+	select {
+	case <-ctx.Done():
+		return false
+	case <-timer.C:
+		return true
+	}
+}
diff --git a/internal/channel/outbound_prepare.go b/internal/channel/outbound_prepare.go
new file mode 100644
index 00000000..d06aefd5
--- /dev/null
+++ b/internal/channel/outbound_prepare.go
@@ -0,0 +1,648 @@
+package channel
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"mime"
+	"net/http"
+	neturl "net/url"
+	"path"
+	"path/filepath"
+	"strings"
+	"time"
+
+	attachmentpkg "github.com/memohai/memoh/internal/attachment"
+	"github.com/memohai/memoh/internal/media"
+)
+
+// sharedHTTPClient is reused across attachment downloads to benefit from connection pooling.
+var sharedHTTPClient = &http.Client{Timeout: 20 * time.Second}
+
+// OutboundAttachmentStore provides the storage operations required by the
+// outbound attachment preparer.
+type OutboundAttachmentStore interface {
+	// Stat returns asset metadata by content hash without opening the file.
+	Stat(ctx context.Context, botID, contentHash string) (media.Asset, error)
+	Open(ctx context.Context, botID, contentHash string) (io.ReadCloser, media.Asset, error)
+	Ingest(ctx context.Context, input media.IngestInput) (media.Asset, error)
+	GetByStorageKey(ctx context.Context, botID, storageKey string) (media.Asset, error)
+	AccessPath(asset media.Asset) string
+}
+
+// ContainerAttachmentIngester is an optional extension of OutboundAttachmentStore
+// for stores that can read files directly from a bot's container filesystem.
+// Implementations must be safe for concurrent use.
+type ContainerAttachmentIngester interface {
+	IngestContainerFile(ctx context.Context, botID, containerPath string) (media.Asset, error)
+}
+
+// PrepareOutboundMessage resolves the logical outbound message into the
+// adapter-facing prepared model.
+func PrepareOutboundMessage(
+	ctx context.Context,
+	store OutboundAttachmentStore,
+	cfg ChannelConfig,
+	msg OutboundMessage,
+) (PreparedOutboundMessage, error) {
+	preparedMessage, err := prepareMessage(ctx, store, cfg, msg.Message)
+	if err != nil {
+		return PreparedOutboundMessage{}, err
+	}
+	return PreparedOutboundMessage{
+		Target:  strings.TrimSpace(msg.Target),
+		Message: preparedMessage,
+	}, nil
+}
+
+// PrepareStreamEvent resolves logical stream payloads before they enter an adapter.
+func PrepareStreamEvent(
+	ctx context.Context,
+	store OutboundAttachmentStore,
+	cfg ChannelConfig,
+	event StreamEvent,
+) (PreparedStreamEvent, error) {
+	prepared := PreparedStreamEvent{
+		Type:      event.Type,
+		Status:    event.Status,
+		Delta:     event.Delta,
+		Error:     event.Error,
+		ToolCall:  event.ToolCall,
+		Phase:     event.Phase,
+		Reactions: event.Reactions,
+		Speeches:  event.Speeches,
+		Metadata:  event.Metadata,
+	}
+
+	if len(event.Attachments) > 0 {
+		_, attachments, err := prepareAttachments(ctx, store, cfg, event.Attachments)
+		if err != nil {
+			return PreparedStreamEvent{}, err
+		}
+		prepared.Attachments = attachments
+	}
+
+	if event.Final != nil {
+		preparedMessage, err := prepareMessage(ctx, store, cfg, event.Final.Message)
+		if err != nil {
+			return PreparedStreamEvent{}, err
+		}
+		prepared.Final = &PreparedStreamFinalizePayload{Message: preparedMessage}
+	}
+
+	return prepared, nil
+}
+
+func prepareMessage(
+	ctx context.Context,
+	store OutboundAttachmentStore,
+	cfg ChannelConfig,
+	msg Message,
+) (PreparedMessage, error) {
+	prepared := PreparedMessage{Message: msg}
+	if len(msg.Attachments) == 0 {
+		return prepared, nil
+	}
+	logical, attachments, err := prepareAttachments(ctx, store, cfg, msg.Attachments)
+	if err != nil {
+		return PreparedMessage{}, err
+	}
+	prepared.Message.Attachments = logical
+	prepared.Attachments = attachments
+	return prepared, nil
+}
+
+func prepareAttachments(
+	ctx context.Context,
+	store OutboundAttachmentStore,
+	cfg ChannelConfig,
+	attachments []Attachment,
+) ([]Attachment, []PreparedAttachment, error) {
+	normalized, err := normalizeAttachmentRefs(attachments, cfg.ChannelType)
+	if err != nil {
+		return nil, nil, err
+	}
+	logical := make([]Attachment, 0, len(normalized))
+	prepared := make([]PreparedAttachment, 0, len(normalized))
+	for _, att := range normalized {
+		item, preparedAtt, prepareErr := prepareAttachment(ctx, store, cfg, att)
+		if prepareErr != nil {
+			return nil, nil, prepareErr
+		}
+		logical = append(logical, item)
+		prepared = append(prepared, preparedAtt)
+	}
+	return logical, prepared, nil
+}
+
+func prepareAttachment(
+	ctx context.Context,
+	store OutboundAttachmentStore,
+	cfg ChannelConfig,
+	att Attachment,
+) (Attachment, PreparedAttachment, error) {
+	item := att
+	item.Name = strings.TrimSpace(item.Name)
+	item.Mime = attachmentpkg.NormalizeMime(item.Mime)
+
+	if ref, ok := resolvePreparedNativeRef(cfg.ChannelType, item); ok {
+		item.SourcePlatform = preparedNativeSourcePlatform(cfg.ChannelType, item.SourcePlatform)
+		return item, PreparedAttachment{
+			Logical:   item,
+			Kind:      PreparedAttachmentNativeRef,
+			NativeRef: ref,
+			Name:      preparedAttachmentName(item, ""),
+			Mime:      preparedAttachmentMime(item, ""),
+			Size:      item.Size,
+		}, nil
+	}
+
+	if urlRef := strings.TrimSpace(item.URL); IsHTTPURL(urlRef) && allowsPreparedPublicURL(cfg.ChannelType, item) {
+		return item, PreparedAttachment{
+			Logical:   item,
+			Kind:      PreparedAttachmentPublicURL,
+			PublicURL: urlRef,
+			Name:      preparedAttachmentName(item, urlRef),
+			Mime:      preparedAttachmentMime(item, mimeFromPath(urlRef)),
+			Size:      item.Size,
+		}, nil
+	}
+
+	botID := preparedAttachmentBotID(cfg.BotID, item.Metadata)
+	switch {
+	case strings.TrimSpace(item.ContentHash) != "":
+		return preparePersistedAttachment(ctx, store, botID, item, "")
+	case strings.TrimSpace(item.Base64) != "" || IsDataURL(item.URL):
+		return prepareBase64Attachment(ctx, store, botID, item)
+	case IsHTTPURL(item.URL):
+		return prepareHTTPAttachment(ctx, store, botID, item)
+	case IsDataPath(item.URL):
+		return prepareContainerAttachment(ctx, store, botID, item)
+	default:
+		return Attachment{}, PreparedAttachment{}, errors.New("attachment reference is required")
+	}
+}
+
+func preparePersistedAttachment(
+	ctx context.Context,
+	store OutboundAttachmentStore,
+	botID string,
+	item Attachment,
+	sourcePath string,
+) (Attachment, PreparedAttachment, error) {
+	if store == nil {
+		return Attachment{}, PreparedAttachment{}, errors.New("attachment store is not configured")
+	}
+	if strings.TrimSpace(botID) == "" {
+		return Attachment{}, PreparedAttachment{}, errors.New("bot id is required for persisted attachments")
+	}
+	asset, err := store.Stat(ctx, botID, strings.TrimSpace(item.ContentHash))
+	if err != nil {
+		return Attachment{}, PreparedAttachment{}, fmt.Errorf("stat content hash attachment: %w", err)
+	}
+	applyPreparedAsset(store, asset, botID, &item, sourcePath)
+	return item, preparedUploadAttachment(store, botID, item), nil
+}
+
+func prepareBase64Attachment(
+	ctx context.Context,
+	store OutboundAttachmentStore,
+	botID string,
+	item Attachment,
+) (Attachment, PreparedAttachment, error) {
+	if store == nil {
+		return Attachment{}, PreparedAttachment{}, errors.New("attachment store is not configured")
+	}
+	if strings.TrimSpace(botID) == "" {
+		return Attachment{}, PreparedAttachment{}, errors.New("bot id is required for base64 attachments")
+	}
+	raw := strings.TrimSpace(item.Base64)
+	if raw == "" {
+		raw = strings.TrimSpace(item.URL)
+	}
+	reader, err := attachmentpkg.DecodeBase64(raw, media.MaxAssetBytes)
+	if err != nil {
+		return Attachment{}, PreparedAttachment{}, fmt.Errorf("decode base64 attachment: %w", err)
+	}
+	sourceMime := attachmentpkg.NormalizeMime(item.Mime)
+	if sourceMime == "" {
+		sourceMime = attachmentpkg.MimeFromDataURL(raw)
+	}
+	if item.Name == "" {
+		item.Name = preparedAttachmentName(item, "")
+	}
+	return ingestPreparedAttachment(
+		ctx,
+		store,
+		botID,
+		item,
+		io.NopCloser(reader),
+		sourceMime,
+		"",
+	)
+}
+
+func prepareHTTPAttachment(
+	ctx context.Context,
+	store OutboundAttachmentStore,
+	botID string,
+	item Attachment,
+) (Attachment, PreparedAttachment, error) {
+	if store == nil {
+		return Attachment{}, PreparedAttachment{}, errors.New("attachment store is not configured")
+	}
+	if strings.TrimSpace(botID) == "" {
+		return Attachment{}, PreparedAttachment{}, errors.New("bot id is required for remote attachments")
+	}
+	payload, err := openPreparedAttachmentURL(ctx, strings.TrimSpace(item.URL))
+	if err != nil {
+		return Attachment{}, PreparedAttachment{}, err
+	}
+	sourceMime := preparedAttachmentMime(item, payload.mime)
+	if item.Name == "" {
+		item.Name = preparedAttachmentName(item, payload.name)
+	}
+	if item.Size == 0 && payload.size > 0 {
+		item.Size = payload.size
+	}
+	return ingestPreparedAttachment(ctx, store, botID, item, payload.reader, sourceMime, "")
+}
+
+func prepareContainerAttachment(
+	ctx context.Context,
+	store OutboundAttachmentStore,
+	botID string,
+	item Attachment,
+) (Attachment, PreparedAttachment, error) {
+	if store == nil {
+		return Attachment{}, PreparedAttachment{}, errors.New("attachment store is not configured")
+	}
+	if strings.TrimSpace(botID) == "" {
+		return Attachment{}, PreparedAttachment{}, errors.New("bot id is required for container attachments")
+	}
+	sourcePath := strings.TrimSpace(item.URL)
+	if item.Name == "" {
+		item.Name = preparedAttachmentName(item, sourcePath)
+	}
+	var (
+		asset media.Asset
+		err   error
+	)
+	if storageKey := extractPreparedStorageKey(sourcePath); storageKey != "" {
+		asset, err = store.GetByStorageKey(ctx, botID, storageKey)
+		if err == nil {
+			applyPreparedAsset(store, asset, botID, &item, sourcePath)
+			return item, preparedUploadAttachment(store, botID, item), nil
+		}
+	}
+	ingester, ok := store.(ContainerAttachmentIngester)
+	if !ok {
+		if err != nil {
+			return Attachment{}, PreparedAttachment{}, fmt.Errorf("prepare container attachment: lookup asset: %w", err)
+		}
+		return Attachment{}, PreparedAttachment{}, errors.New("attachment store does not support container file ingestion")
+	}
+	asset, ingestErr := ingester.IngestContainerFile(ctx, botID, sourcePath)
+	if ingestErr != nil {
+		if err != nil {
+			return Attachment{}, PreparedAttachment{}, fmt.Errorf("prepare container attachment: lookup asset: %w; ingest container file: %w", err, ingestErr)
+		}
+		return Attachment{}, PreparedAttachment{}, fmt.Errorf("prepare container attachment: %w", ingestErr)
+	}
+	applyPreparedAsset(store, asset, botID, &item, sourcePath)
+	return item, preparedUploadAttachment(store, botID, item), nil
+}
+
+func ingestPreparedAttachment(
+	ctx context.Context,
+	store OutboundAttachmentStore,
+	botID string,
+	item Attachment,
+	reader io.ReadCloser,
+	sourceMime string,
+	sourcePath string,
+) (Attachment, PreparedAttachment, error) {
+	if reader == nil {
+		return Attachment{}, PreparedAttachment{}, errors.New("attachment reader is required")
+	}
+	defer func() {
+		_ = reader.Close()
+	}()
+
+	mediaType := attachmentpkg.MapMediaType(string(item.Type))
+	preparedReader, finalMime, err := attachmentpkg.PrepareReaderAndMime(reader, mediaType, sourceMime)
+	if err != nil {
+		return Attachment{}, PreparedAttachment{}, fmt.Errorf("prepare attachment mime: %w", err)
+	}
+	asset, err := store.Ingest(ctx, media.IngestInput{
+		BotID:       botID,
+		Mime:        finalMime,
+		Reader:      preparedReader,
+		MaxBytes:    media.MaxAssetBytes,
+		OriginalExt: preparedAttachmentExt(item, sourcePath),
+	})
+	if err != nil {
+		return Attachment{}, PreparedAttachment{}, fmt.Errorf("ingest attachment: %w", err)
+	}
+	item.Mime = attachmentpkg.NormalizeMime(finalMime)
+	applyPreparedAsset(store, asset, botID, &item, sourcePath)
+	return item, preparedUploadAttachment(store, botID, item), nil
+}
+
+func preparedUploadAttachment(store OutboundAttachmentStore, botID string, item Attachment) PreparedAttachment {
+	contentHash := strings.TrimSpace(item.ContentHash)
+	return PreparedAttachment{
+		Logical: item,
+		Kind:    PreparedAttachmentUpload,
+		Name:    preparedAttachmentName(item, ""),
+		Mime:    preparedAttachmentMime(item, ""),
+		Size:    item.Size,
+		Open: func(ctx context.Context) (io.ReadCloser, error) {
+			reader, _, err := store.Open(ctx, botID, contentHash)
+			if err != nil {
+				return nil, err
+			}
+			return reader, nil
+		},
+	}
+}
+
+type preparedAttachmentPayload struct {
+	reader io.ReadCloser
+	mime   string
+	name   string
+	size   int64
+}
+
+func openPreparedAttachmentURL(ctx context.Context, rawURL string) (preparedAttachmentPayload, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil)
+	if err != nil {
+		return preparedAttachmentPayload{}, fmt.Errorf("build attachment request: %w", err)
+	}
+	resp, err := sharedHTTPClient.Do(req) //nolint:gosec // G107: attachment URLs are user-controlled channel payloads
+	if err != nil {
+		return preparedAttachmentPayload{}, fmt.Errorf("download attachment: %w", err)
+	}
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		_ = resp.Body.Close()
+		return preparedAttachmentPayload{}, fmt.Errorf("download attachment status: %d", resp.StatusCode)
+	}
+	if resp.ContentLength > media.MaxAssetBytes {
+		_ = resp.Body.Close()
+		return preparedAttachmentPayload{}, fmt.Errorf("%w: max %d bytes", media.ErrAssetTooLarge, media.MaxAssetBytes)
+	}
+	mimeType := attachmentpkg.NormalizeMime(resp.Header.Get("Content-Type"))
+	name := contentDispositionFilename(resp.Header.Get("Content-Disposition"))
+	if name == "" {
+		name = preparedPathBase(rawURL)
+	}
+	return preparedAttachmentPayload{
+		reader: resp.Body,
+		mime:   mimeType,
+		name:   name,
+		size:   resp.ContentLength,
+	}, nil
+}
+
+func resolvePreparedNativeRef(channelType ChannelType, item Attachment) (string, bool) {
+	ref := strings.TrimSpace(item.PlatformKey)
+	if ref != "" && preparedPlatformMatches(channelType, item.SourcePlatform) {
+		switch channelType {
+		case ChannelTypeTelegram, ChannelTypeFeishu:
+			return ref, true
+		case ChannelTypeDingtalk:
+			switch item.Type {
+			case AttachmentImage, AttachmentGIF:
+				return "", false
+			default:
+				return ref, true
+			}
+		case ChannelTypeMatrix:
+			if strings.HasPrefix(strings.ToLower(ref), "mxc://") {
+				return ref, true
+			}
+		}
+	}
+	if channelType == ChannelTypeMatrix {
+		urlRef := strings.TrimSpace(item.URL)
+		if strings.HasPrefix(strings.ToLower(urlRef), "mxc://") {
+			return urlRef, true
+		}
+	}
+	return "", false
+}
+
+func allowsPreparedPublicURL(channelType ChannelType, item Attachment) bool {
+	switch channelType {
+	case ChannelTypeTelegram:
+		return true
+	case ChannelTypeDingtalk:
+		return item.Type == AttachmentImage || item.Type == AttachmentGIF
+	default:
+		return false
+	}
+}
+
+func applyPreparedAsset(store OutboundAttachmentStore, asset media.Asset, botID string, item *Attachment, sourcePath string) {
+	if item == nil {
+		return
+	}
+	sourceURL := strings.TrimSpace(item.URL)
+	item.ContentHash = asset.ContentHash
+	item.URL = store.AccessPath(asset)
+	item.PlatformKey = ""
+	item.SourcePlatform = ""
+	item.Base64 = ""
+	if item.Metadata == nil {
+		item.Metadata = make(map[string]any)
+	}
+	item.Metadata["bot_id"] = botID
+	item.Metadata["storage_key"] = asset.StorageKey
+	if n := strings.TrimSpace(item.Name); n != "" {
+		item.Metadata["name"] = n
+	}
+	if sp := strings.TrimSpace(sourcePath); sp != "" {
+		item.Metadata["source_path"] = sp
+	}
+	if su := strings.TrimSpace(sourceURL); su != "" && !IsDataURL(su) && !IsDataPath(su) {
+		item.Metadata["source_url"] = su
+	}
+	if strings.TrimSpace(item.Mime) == "" {
+		item.Mime = attachmentpkg.NormalizeMime(asset.Mime)
+	}
+	if item.Size == 0 && asset.SizeBytes > 0 {
+		item.Size = asset.SizeBytes
+	}
+	if item.Type == AttachmentFile || item.Type == "" {
+		item.Type = preparedAttachmentTypeFromMime(item.Mime)
+	}
+}
+
+func preparedAttachmentBotID(defaultBotID string, metadata map[string]any) string {
+	if botID := strings.TrimSpace(defaultBotID); botID != "" {
+		return botID
+	}
+	if metadata == nil {
+		return ""
+	}
+	raw, ok := metadata["bot_id"]
+	if !ok || raw == nil {
+		return ""
+	}
+	if value, ok := raw.(string); ok {
+		return strings.TrimSpace(value)
+	}
+	return ""
+}
+
+func preparedAttachmentMime(item Attachment, fallback string) string {
+	if mimeType := attachmentpkg.NormalizeMime(item.Mime); mimeType != "" {
+		return mimeType
+	}
+	return attachmentpkg.NormalizeMime(fallback)
+}
+
+func preparedAttachmentName(item Attachment, fallback string) string {
+	if name := strings.TrimSpace(item.Name); name != "" {
+		return name
+	}
+	if name := preparedPathBase(fallback); name != "" {
+		return name
+	}
+	base := "file"
+	switch item.Type {
+	case AttachmentImage, AttachmentGIF:
+		base = "image"
+	case AttachmentAudio, AttachmentVoice:
+		base = "audio"
+	case AttachmentVideo:
+		base = "video"
+	}
+	if ext := preparedMimeExtension(preparedAttachmentMime(item, "")); ext != "" {
+		return base + ext
+	}
+	return base
+}
+
+func preparedAttachmentExt(item Attachment, fallback string) string {
+	if ext := filepath.Ext(strings.TrimSpace(item.Name)); ext != "" {
+		return ext
+	}
+	if ext := filepath.Ext(preparedPathBase(fallback)); ext != "" {
+		return ext
+	}
+	return preparedMimeExtension(preparedAttachmentMime(item, ""))
+}
+
+func preparedAttachmentTypeFromMime(mimeType string) AttachmentType {
+	mimeType = strings.ToLower(strings.TrimSpace(mimeType))
+	switch {
+	case mimeType == "image/gif":
+		return AttachmentGIF
+	case strings.HasPrefix(mimeType, "image/"):
+		return AttachmentImage
+	case strings.HasPrefix(mimeType, "audio/"):
+		return AttachmentAudio
+	case strings.HasPrefix(mimeType, "video/"):
+		return AttachmentVideo
+	default:
+		return AttachmentFile
+	}
+}
+
+func preparedPlatformMatches(channelType ChannelType, sourcePlatform string) bool {
+	sourcePlatform = strings.TrimSpace(sourcePlatform)
+	return sourcePlatform == "" || strings.EqualFold(sourcePlatform, channelType.String())
+}
+
+func preparedNativeSourcePlatform(channelType ChannelType, sourcePlatform string) string {
+	sourcePlatform = strings.TrimSpace(sourcePlatform)
+	if sourcePlatform != "" {
+		return sourcePlatform
+	}
+	return channelType.String()
+}
+
+func preparedPathBase(raw string) string {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return ""
+	}
+	if parsed, err := neturl.Parse(raw); err == nil && parsed != nil && parsed.Path != "" {
+		if base := filepath.Base(parsed.Path); base != "." && base != "/" {
+			return strings.TrimSpace(base)
+		}
+	}
+	base := filepath.Base(raw)
+	if base == "." || base == "/" {
+		return ""
+	}
+	return strings.TrimSpace(base)
+}
+
+func preparedMimeExtension(mimeType string) string {
+	mimeType = attachmentpkg.NormalizeMime(mimeType)
+	if mimeType == "" {
+		return ""
+	}
+	exts, err := mime.ExtensionsByType(mimeType)
+	if err != nil || len(exts) == 0 {
+		return ""
+	}
+	return exts[0]
+}
+
+func mimeFromPath(raw string) string {
+	ext := filepath.Ext(preparedPathBase(raw))
+	if ext == "" {
+		return ""
+	}
+	return attachmentpkg.NormalizeMime(mime.TypeByExtension(ext))
+}
+
+func contentDispositionFilename(raw string) string {
+	if strings.TrimSpace(raw) == "" {
+		return ""
+	}
+	_, params, err := mime.ParseMediaType(raw)
+	if err != nil {
+		return ""
+	}
+	if filename := strings.TrimSpace(params["filename*"]); filename != "" {
+		if idx := strings.LastIndex(filename, "''"); idx >= 0 {
+			filename = filename[idx+2:]
+		}
+		if decoded, err := neturl.QueryUnescape(filename); err == nil {
+			return strings.TrimSpace(decoded)
+		}
+		return filename
+	}
+	return strings.TrimSpace(params["filename"])
+}
+
+// IsDataURL reports whether raw is a data: URL (e.g. "data:image/png;base64,...").
+func IsDataURL(raw string) bool {
+	return strings.HasPrefix(strings.ToLower(strings.TrimSpace(raw)), "data:")
+}
+
+// IsHTTPURL reports whether raw is an http:// or https:// URL.
+func IsHTTPURL(raw string) bool {
+	lower := strings.ToLower(strings.TrimSpace(raw))
+	return strings.HasPrefix(lower, "http://") || strings.HasPrefix(lower, "https://")
+}
+
+// IsDataPath reports whether raw is a container-internal data path (/data/...).
+func IsDataPath(raw string) bool {
+	return strings.HasPrefix(strings.TrimSpace(raw), "/data/")
+}
+
+func extractPreparedStorageKey(accessPath string) string {
+	// Use path.Join (not filepath.Join) to ensure forward slashes on all platforms.
+	marker := path.Join("/data", "media") + "/"
+	idx := strings.Index(accessPath, marker)
+	if idx < 0 {
+		return ""
+	}
+	return accessPath[idx+len(marker):]
+}
diff --git a/internal/channel/outbound_prepare_test.go b/internal/channel/outbound_prepare_test.go
new file mode 100644
index 00000000..c57ebdc2
--- /dev/null
+++ b/internal/channel/outbound_prepare_test.go
@@ -0,0 +1,724 @@
+package channel
+
+import (
+	"context"
+	"encoding/base64"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/memohai/memoh/internal/channel/channeltest"
+	"github.com/memohai/memoh/internal/media"
+)
+
+func TestPrepareOutboundMessage_ContainerPathFallsBackToIngestContainerFile(t *testing.T) {
+	t.Parallel()
+
+	store := channeltest.NewMemoryAttachmentStore()
+	const sourcePath = "/data/media/26da/missing.png"
+	store.SeedContainerFile("bot-1", sourcePath, []byte("image-bytes"), "image/png", "missing.png")
+
+	prepared, err := PrepareOutboundMessage(context.Background(), store, ChannelConfig{
+		BotID:       "bot-1",
+		ChannelType: ChannelType("qq"),
+	}, OutboundMessage{
+		Target: "chat-1",
+		Message: Message{
+			Attachments: []Attachment{{
+				Type: AttachmentImage,
+				URL:  sourcePath,
+			}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("PrepareOutboundMessage failed: %v", err)
+	}
+	if len(prepared.Message.Attachments) != 1 {
+		t.Fatalf("expected 1 prepared attachment, got %d", len(prepared.Message.Attachments))
+	}
+	if len(prepared.Message.Message.Attachments) != 1 {
+		t.Fatalf("expected 1 logical attachment, got %d", len(prepared.Message.Message.Attachments))
+	}
+	logical := prepared.Message.Message.Attachments[0]
+	if logical.ContentHash == "" {
+		t.Fatal("expected content hash after container fallback ingest")
+	}
+	if logical.URL == sourcePath {
+		t.Fatalf("expected prepared access path, got original path %q", logical.URL)
+	}
+	if logical.Metadata["source_path"] != sourcePath {
+		t.Fatalf("expected source_path metadata, got %#v", logical.Metadata["source_path"])
+	}
+
+	reader, err := prepared.Message.Attachments[0].Open(context.Background())
+	if err != nil {
+		t.Fatalf("open prepared attachment: %v", err)
+	}
+	defer func() { _ = reader.Close() }()
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		t.Fatalf("read prepared attachment: %v", err)
+	}
+	if string(data) != "image-bytes" {
+		t.Fatalf("unexpected prepared attachment bytes: %q", string(data))
+	}
+}
+
+func TestPrepareStreamEvent_FailsFastOnAttachmentPreparationError(t *testing.T) {
+	t.Parallel()
+
+	_, err := PrepareStreamEvent(context.Background(), nil, ChannelConfig{
+		BotID:       "bot-1",
+		ChannelType: ChannelType("qq"),
+	}, StreamEvent{
+		Type: StreamEventAttachment,
+		Attachments: []Attachment{{
+			Type: AttachmentImage,
+			URL:  "https://example.com/image.png",
+		}},
+	})
+	if err == nil {
+		t.Fatal("expected attachment preparation error")
+	}
+	if !strings.Contains(err.Error(), "attachment store is not configured") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestPrepareStreamEvent_FailsFastOnFinalAttachmentPreparationError(t *testing.T) {
+	t.Parallel()
+
+	_, err := PrepareStreamEvent(context.Background(), nil, ChannelConfig{
+		BotID:       "bot-1",
+		ChannelType: ChannelType("qq"),
+	}, StreamEvent{
+		Type: StreamEventFinal,
+		Final: &StreamFinalizePayload{
+			Message: Message{
+				Attachments: []Attachment{{
+					Type: AttachmentImage,
+					URL:  "https://example.com/image.png",
+				}},
+			},
+		},
+	})
+	if err == nil {
+		t.Fatal("expected final attachment preparation error")
+	}
+	if !strings.Contains(err.Error(), "attachment store is not configured") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+// --- NativeRef ---
+
+func TestPrepareOutboundMessage_TelegramNativeRef(t *testing.T) {
+	t.Parallel()
+
+	store := channeltest.NewMemoryAttachmentStore()
+	prepared, err := PrepareOutboundMessage(context.Background(), store, ChannelConfig{
+		BotID:       "bot-1",
+		ChannelType: ChannelTypeTelegram,
+	}, OutboundMessage{
+		Target: "chat-1",
+		Message: Message{
+			Attachments: []Attachment{{
+				Type:           AttachmentImage,
+				PlatformKey:    "AgACAgIAAxkB",
+				SourcePlatform: "telegram",
+			}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("PrepareOutboundMessage failed: %v", err)
+	}
+	att := prepared.Message.Attachments[0]
+	if att.Kind != PreparedAttachmentNativeRef {
+		t.Fatalf("expected native_ref, got %s", att.Kind)
+	}
+	if att.NativeRef != "AgACAgIAAxkB" {
+		t.Fatalf("unexpected native ref: %q", att.NativeRef)
+	}
+}
+
+func TestPrepareOutboundMessage_DingtalkNativeRefSkipsImageAndGIF(t *testing.T) {
+	t.Parallel()
+
+	store := channeltest.NewMemoryAttachmentStore()
+	_, seedErr := store.SeedAsset("bot-1", []byte("gif-data"), "image/gif", ".gif")
+	if seedErr != nil {
+		t.Fatalf("seed asset: %v", seedErr)
+	}
+
+	for _, attType := range []AttachmentType{AttachmentImage, AttachmentGIF} {
+		attType := attType
+		t.Run(string(attType), func(t *testing.T) {
+			t.Parallel()
+
+			asset, err := store.SeedAsset("bot-1", []byte("data-"+string(attType)), "image/png", ".png")
+			if err != nil {
+				t.Fatalf("seed: %v", err)
+			}
+
+			prepared, err := PrepareOutboundMessage(context.Background(), store, ChannelConfig{
+				BotID:       "bot-1",
+				ChannelType: ChannelTypeDingtalk,
+			}, OutboundMessage{
+				Target: "chat-1",
+				Message: Message{
+					Attachments: []Attachment{{
+						Type:           attType,
+						ContentHash:    asset.ContentHash,
+						PlatformKey:    "dingtalk-key",
+						SourcePlatform: "dingtalk",
+					}},
+				},
+			})
+			if err != nil {
+				t.Fatalf("PrepareOutboundMessage failed: %v", err)
+			}
+			att := prepared.Message.Attachments[0]
+			if att.Kind == PreparedAttachmentNativeRef {
+				t.Fatalf("DingTalk image/gif should NOT use native ref, got native_ref")
+			}
+		})
+	}
+}
+
+func TestPrepareOutboundMessage_MatrixNativeRefFromMXCURL(t *testing.T) {
+	t.Parallel()
+
+	store := channeltest.NewMemoryAttachmentStore()
+	prepared, err := PrepareOutboundMessage(context.Background(), store, ChannelConfig{
+		BotID:       "bot-1",
+		ChannelType: ChannelTypeMatrix,
+	}, OutboundMessage{
+		Target: "!room:matrix.org",
+		Message: Message{
+			Attachments: []Attachment{{
+				Type: AttachmentImage,
+				URL:  "mxc://matrix.org/AbcDef",
+			}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("PrepareOutboundMessage failed: %v", err)
+	}
+	att := prepared.Message.Attachments[0]
+	if att.Kind != PreparedAttachmentNativeRef {
+		t.Fatalf("expected native_ref for mxc:// URL, got %s", att.Kind)
+	}
+	if att.NativeRef != "mxc://matrix.org/AbcDef" {
+		t.Fatalf("unexpected native ref: %q", att.NativeRef)
+	}
+}
+
+// --- PublicURL ---
+
+func TestPrepareOutboundMessage_TelegramPublicURLPassthrough(t *testing.T) {
+	t.Parallel()
+
+	store := channeltest.NewMemoryAttachmentStore()
+	const rawURL = "https://example.com/photo.jpg"
+	prepared, err := PrepareOutboundMessage(context.Background(), store, ChannelConfig{
+		BotID:       "bot-1",
+		ChannelType: ChannelTypeTelegram,
+	}, OutboundMessage{
+		Target: "chat-1",
+		Message: Message{
+			Attachments: []Attachment{{
+				Type: AttachmentImage,
+				URL:  rawURL,
+			}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("PrepareOutboundMessage failed: %v", err)
+	}
+	att := prepared.Message.Attachments[0]
+	if att.Kind != PreparedAttachmentPublicURL {
+		t.Fatalf("expected public_url, got %s", att.Kind)
+	}
+	if att.PublicURL != rawURL {
+		t.Fatalf("unexpected public URL: %q", att.PublicURL)
+	}
+}
+
+func TestPrepareOutboundMessage_DingtalkPublicURLOnlyForImageAndGIF(t *testing.T) {
+	t.Parallel()
+
+	store := channeltest.NewMemoryAttachmentStore()
+
+	t.Run("image allowed", func(t *testing.T) {
+		t.Parallel()
+		prepared, err := PrepareOutboundMessage(context.Background(), store, ChannelConfig{
+			BotID:       "bot-1",
+			ChannelType: ChannelTypeDingtalk,
+		}, OutboundMessage{
+			Target: "chat-1",
+			Message: Message{
+				Attachments: []Attachment{{
+					Type: AttachmentImage,
+					URL:  "https://example.com/img.png",
+				}},
+			},
+		})
+		if err != nil {
+			t.Fatalf("unexpected error: %v", err)
+		}
+		if prepared.Message.Attachments[0].Kind != PreparedAttachmentPublicURL {
+			t.Fatalf("expected public_url for DingTalk image, got %s", prepared.Message.Attachments[0].Kind)
+		}
+	})
+
+	t.Run("file not allowed", func(t *testing.T) {
+		t.Parallel()
+		_, err := PrepareOutboundMessage(context.Background(), store, ChannelConfig{
+			BotID:       "bot-1",
+			ChannelType: ChannelTypeDingtalk,
+		}, OutboundMessage{
+			Target: "chat-1",
+			Message: Message{
+				Attachments: []Attachment{{
+					Type: AttachmentFile,
+					URL:  "https://example.com/doc.pdf",
+				}},
+			},
+		})
+		// File with HTTP URL on DingTalk without store support should fail.
+		if err == nil {
+			t.Fatal("expected error for DingTalk file with public URL")
+		}
+	})
+}
+
+// --- Base64 ---
+
+func TestPrepareOutboundMessage_Base64Attachment(t *testing.T) {
+	t.Parallel()
+
+	store := channeltest.NewMemoryAttachmentStore()
+	raw := []byte("png-data")
+	encoded := base64.StdEncoding.EncodeToString(raw)
+	dataURL := "data:image/png;base64," + encoded
+
+	prepared, err := PrepareOutboundMessage(context.Background(), store, ChannelConfig{
+		BotID:       "bot-1",
+		ChannelType: ChannelTypeDiscord,
+	}, OutboundMessage{
+		Target: "chan-1",
+		Message: Message{
+			Attachments: []Attachment{{
+				Type: AttachmentImage,
+				URL:  dataURL,
+			}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("PrepareOutboundMessage failed: %v", err)
+	}
+	att := prepared.Message.Attachments[0]
+	if att.Kind != PreparedAttachmentUpload {
+		t.Fatalf("expected upload, got %s", att.Kind)
+	}
+	if att.Mime != "image/png" {
+		t.Fatalf("expected image/png mime, got %q", att.Mime)
+	}
+	reader, err := att.Open(context.Background())
+	if err != nil {
+		t.Fatalf("open: %v", err)
+	}
+	defer func() { _ = reader.Close() }()
+	got, err := io.ReadAll(reader)
+	if err != nil {
+		t.Fatalf("read: %v", err)
+	}
+	if string(got) != string(raw) {
+		t.Fatalf("unexpected bytes: %q", got)
+	}
+}
+
+func TestPrepareOutboundMessage_Base64FieldAttachment(t *testing.T) {
+	t.Parallel()
+
+	store := channeltest.NewMemoryAttachmentStore()
+	raw := []byte("audio-data")
+	encoded := base64.StdEncoding.EncodeToString(raw)
+
+	prepared, err := PrepareOutboundMessage(context.Background(), store, ChannelConfig{
+		BotID:       "bot-1",
+		ChannelType: ChannelTypeDiscord,
+	}, OutboundMessage{
+		Target: "chan-1",
+		Message: Message{
+			Attachments: []Attachment{{
+				Type:   AttachmentAudio,
+				Base64: encoded,
+				Mime:   "audio/mpeg",
+			}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("PrepareOutboundMessage failed: %v", err)
+	}
+	att := prepared.Message.Attachments[0]
+	if att.Kind != PreparedAttachmentUpload {
+		t.Fatalf("expected upload, got %s", att.Kind)
+	}
+}
+
+// --- HTTP download ---
+
+func TestPrepareOutboundMessage_HTTPAttachmentDownload(t *testing.T) {
+	t.Parallel()
+
+	imgData := []byte("fake-image-content")
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "image/jpeg")
+		w.Header().Set("Content-Disposition", `attachment; filename="photo.jpg"`)
+		_, _ = w.Write(imgData)
+	}))
+	defer srv.Close()
+
+	store := channeltest.NewMemoryAttachmentStore()
+	prepared, err := PrepareOutboundMessage(context.Background(), store, ChannelConfig{
+		BotID:       "bot-1",
+		ChannelType: ChannelTypeDiscord,
+	}, OutboundMessage{
+		Target: "chan-1",
+		Message: Message{
+			Attachments: []Attachment{{
+				Type: AttachmentImage,
+				URL:  srv.URL + "/photo.jpg",
+			}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("PrepareOutboundMessage failed: %v", err)
+	}
+	att := prepared.Message.Attachments[0]
+	if att.Kind != PreparedAttachmentUpload {
+		t.Fatalf("expected upload after HTTP download, got %s", att.Kind)
+	}
+	if att.Mime != "image/jpeg" {
+		t.Fatalf("expected image/jpeg, got %q", att.Mime)
+	}
+	if att.Name != "photo.jpg" {
+		t.Fatalf("expected filename from Content-Disposition, got %q", att.Name)
+	}
+
+	reader, err := att.Open(context.Background())
+	if err != nil {
+		t.Fatalf("open: %v", err)
+	}
+	defer func() { _ = reader.Close() }()
+	got, err := io.ReadAll(reader)
+	if err != nil {
+		t.Fatalf("read: %v", err)
+	}
+	if string(got) != string(imgData) {
+		t.Fatalf("unexpected bytes: %q", got)
+	}
+}
+
+func TestPrepareOutboundMessage_HTTPAttachmentBadStatus(t *testing.T) {
+	t.Parallel()
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		http.Error(w, "not found", http.StatusNotFound)
+	}))
+	defer srv.Close()
+
+	store := channeltest.NewMemoryAttachmentStore()
+	_, err := PrepareOutboundMessage(context.Background(), store, ChannelConfig{
+		BotID:       "bot-1",
+		ChannelType: ChannelTypeDiscord,
+	}, OutboundMessage{
+		Target: "chan-1",
+		Message: Message{
+			Attachments: []Attachment{{
+				Type: AttachmentImage,
+				URL:  srv.URL + "/missing.jpg",
+			}},
+		},
+	})
+	if err == nil {
+		t.Fatal("expected error for HTTP 404")
+	}
+	if !strings.Contains(err.Error(), "404") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+// --- ContentHash (persisted asset) ---
+
+func TestPrepareOutboundMessage_PersistedContentHash(t *testing.T) {
+	t.Parallel()
+
+	store := channeltest.NewMemoryAttachmentStore()
+	asset, err := store.SeedAsset("bot-1", []byte("video-data"), "video/mp4", ".mp4")
+	if err != nil {
+		t.Fatalf("seed: %v", err)
+	}
+
+	prepared, err := PrepareOutboundMessage(context.Background(), store, ChannelConfig{
+		BotID:       "bot-1",
+		ChannelType: ChannelTypeDiscord,
+	}, OutboundMessage{
+		Target: "chan-1",
+		Message: Message{
+			Attachments: []Attachment{{
+				Type:        AttachmentVideo,
+				ContentHash: asset.ContentHash,
+			}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("PrepareOutboundMessage failed: %v", err)
+	}
+	att := prepared.Message.Attachments[0]
+	if att.Kind != PreparedAttachmentUpload {
+		t.Fatalf("expected upload for persisted hash, got %s", att.Kind)
+	}
+	logical := prepared.Message.Message.Attachments[0]
+	if logical.ContentHash != asset.ContentHash {
+		t.Fatalf("content hash mismatch: got %q, want %q", logical.ContentHash, asset.ContentHash)
+	}
+}
+
+// --- Container path (already stored) ---
+
+func TestPrepareOutboundMessage_ContainerPathHitStorageKey(t *testing.T) {
+	t.Parallel()
+
+	store := channeltest.NewMemoryAttachmentStore()
+	asset, err := store.SeedAsset("bot-1", []byte("already-ingested"), "image/png", ".png")
+	if err != nil {
+		t.Fatalf("seed: %v", err)
+	}
+	accessPath := store.AccessPath(asset)
+
+	prepared, err := PrepareOutboundMessage(context.Background(), store, ChannelConfig{
+		BotID:       "bot-1",
+		ChannelType: ChannelTypeDiscord,
+	}, OutboundMessage{
+		Target: "chan-1",
+		Message: Message{
+			Attachments: []Attachment{{
+				Type: AttachmentImage,
+				URL:  accessPath,
+			}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("PrepareOutboundMessage failed: %v", err)
+	}
+	if prepared.Message.Attachments[0].Kind != PreparedAttachmentUpload {
+		t.Fatalf("expected upload, got %s", prepared.Message.Attachments[0].Kind)
+	}
+	if prepared.Message.Message.Attachments[0].ContentHash != asset.ContentHash {
+		t.Fatal("content hash should match the already-ingested asset")
+	}
+}
+
+// --- GIF type inference ---
+
+func TestPreparedAttachmentTypeFromMime_GIFIsDistinctFromImage(t *testing.T) {
+	t.Parallel()
+
+	got := preparedAttachmentTypeFromMime("image/gif")
+	if got != AttachmentGIF {
+		t.Fatalf("expected AttachmentGIF for image/gif, got %s", got)
+	}
+	got = preparedAttachmentTypeFromMime("image/png")
+	if got != AttachmentImage {
+		t.Fatalf("expected AttachmentImage for image/png, got %s", got)
+	}
+}
+
+// --- Helper utilities ---
+
+func TestExtractPreparedStorageKey(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		path string
+		want string
+	}{
+		{"/data/media/ab/abcdef.png", "ab/abcdef.png"},
+		{"/other/media/ab/abcdef.png", ""},
+		{"/data/media/", ""},
+		{"/data/media", ""},
+		{"ab/abcdef.png", ""},
+	}
+	for _, tc := range cases {
+		got := extractPreparedStorageKey(tc.path)
+		if got != tc.want {
+			t.Errorf("extractPreparedStorageKey(%q) = %q, want %q", tc.path, got, tc.want)
+		}
+	}
+}
+
+func TestIsDataURL(t *testing.T) {
+	t.Parallel()
+
+	if !IsDataURL("data:image/png;base64,abc") {
+		t.Error("expected true for data: URL")
+	}
+	if !IsDataURL("DATA:image/png;base64,abc") {
+		t.Error("expected true for uppercase DATA: URL")
+	}
+	if IsDataURL("https://example.com") {
+		t.Error("expected false for https URL")
+	}
+	if IsDataURL("") {
+		t.Error("expected false for empty string")
+	}
+}
+
+func TestIsHTTPURL(t *testing.T) {
+	t.Parallel()
+
+	if !IsHTTPURL("http://example.com") {
+		t.Error("expected true for http://")
+	}
+	if !IsHTTPURL("HTTPS://example.com") {
+		t.Error("expected true for HTTPS://")
+	}
+	if IsHTTPURL("data:image/png;base64,abc") {
+		t.Error("expected false for data: URL")
+	}
+	if IsHTTPURL("/data/media/file.png") {
+		t.Error("expected false for local path")
+	}
+}
+
+func TestIsDataPath(t *testing.T) {
+	t.Parallel()
+
+	if !IsDataPath("/data/media/file.png") {
+		t.Error("expected true for /data/ path")
+	}
+	if IsDataPath("/tmp/file.png") {
+		t.Error("expected false for /tmp/ path")
+	}
+}
+
+// --- PrepareStreamEvent happy path ---
+
+func TestPrepareStreamEvent_FinalWithAttachment(t *testing.T) {
+	t.Parallel()
+
+	store := channeltest.NewMemoryAttachmentStore()
+	asset, err := store.SeedAsset("bot-1", []byte("img"), "image/png", ".png")
+	if err != nil {
+		t.Fatalf("seed: %v", err)
+	}
+
+	ev, err := PrepareStreamEvent(context.Background(), store, ChannelConfig{
+		BotID:       "bot-1",
+		ChannelType: ChannelTypeDiscord,
+	}, StreamEvent{
+		Type: StreamEventFinal,
+		Final: &StreamFinalizePayload{
+			Message: Message{
+				Text: "done",
+				Attachments: []Attachment{{
+					Type:        AttachmentImage,
+					ContentHash: asset.ContentHash,
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("PrepareStreamEvent failed: %v", err)
+	}
+	if ev.Final == nil {
+		t.Fatal("expected non-nil Final")
+	}
+	if len(ev.Final.Message.Attachments) != 1 {
+		t.Fatalf("expected 1 prepared attachment in Final, got %d", len(ev.Final.Message.Attachments))
+	}
+	if ev.Final.Message.Attachments[0].Kind != PreparedAttachmentUpload {
+		t.Fatalf("expected upload kind, got %s", ev.Final.Message.Attachments[0].Kind)
+	}
+}
+
+func TestPrepareStreamEvent_AttachmentEventHappyPath(t *testing.T) {
+	t.Parallel()
+
+	store := channeltest.NewMemoryAttachmentStore()
+	asset, err := store.SeedAsset("bot-1", []byte("audio"), "audio/mpeg", ".mp3")
+	if err != nil {
+		t.Fatalf("seed: %v", err)
+	}
+
+	ev, err := PrepareStreamEvent(context.Background(), store, ChannelConfig{
+		BotID:       "bot-1",
+		ChannelType: ChannelTypeDiscord,
+	}, StreamEvent{
+		Type: StreamEventAttachment,
+		Attachments: []Attachment{{
+			Type:        AttachmentAudio,
+			ContentHash: asset.ContentHash,
+		}},
+	})
+	if err != nil {
+		t.Fatalf("PrepareStreamEvent failed: %v", err)
+	}
+	if len(ev.Attachments) != 1 {
+		t.Fatalf("expected 1 prepared attachment, got %d", len(ev.Attachments))
+	}
+}
+
+// --- ContainerAttachmentIngester optional interface ---
+
+// noContainerIngesterStore satisfies OutboundAttachmentStore but deliberately
+// does NOT implement ContainerAttachmentIngester. GetByStorageKey always
+// returns not-found so prepareContainerAttachment reaches the type assertion.
+type noContainerIngesterStore struct{}
+
+func (noContainerIngesterStore) Stat(_ context.Context, _, _ string) (media.Asset, error) {
+	return media.Asset{}, media.ErrAssetNotFound
+}
+
+func (noContainerIngesterStore) Open(_ context.Context, _, _ string) (io.ReadCloser, media.Asset, error) {
+	return nil, media.Asset{}, media.ErrAssetNotFound
+}
+
+func (noContainerIngesterStore) Ingest(_ context.Context, _ media.IngestInput) (media.Asset, error) {
+	return media.Asset{}, nil
+}
+
+func (noContainerIngesterStore) GetByStorageKey(_ context.Context, _, _ string) (media.Asset, error) {
+	return media.Asset{}, media.ErrAssetNotFound
+}
+func (noContainerIngesterStore) AccessPath(_ media.Asset) string { return "" }
+
+func TestPrepareContainerAttachment_StoreWithoutIngesterFails(t *testing.T) {
+	t.Parallel()
+
+	var store OutboundAttachmentStore = noContainerIngesterStore{}
+
+	_, err := PrepareOutboundMessage(context.Background(), store, ChannelConfig{
+		BotID:       "bot-1",
+		ChannelType: ChannelTypeDiscord,
+	}, OutboundMessage{
+		Target: "chan-1",
+		Message: Message{
+			Attachments: []Attachment{{
+				Type: AttachmentImage,
+				// Path that won't match any storage key so it falls through to IngestContainerFile.
+				URL: "/data/nonexistent/unique/file.png",
+			}},
+		},
+	})
+	if err == nil {
+		t.Fatal("expected error when store does not implement ContainerAttachmentIngester")
+	}
+	if !strings.Contains(err.Error(), "does not support container file ingestion") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
diff --git a/internal/channel/outbound_test.go b/internal/channel/outbound_test.go
index 9c1b0e2e..c4a03ff0 100644
--- a/internal/channel/outbound_test.go
+++ b/internal/channel/outbound_test.go
@@ -6,6 +6,8 @@ import (
 	"strings"
 	"sync"
 	"testing"
+
+	"github.com/memohai/memoh/internal/channel/channeltest"
 )
 
 type streamValidationAdapter struct {
@@ -112,10 +114,10 @@ type recordingStream struct {
 	events []StreamEvent
 }
 
-func (r *recordingStream) Push(_ context.Context, event StreamEvent) error {
+func (r *recordingStream) Push(_ context.Context, event PreparedStreamEvent) error {
 	r.mu.Lock()
 	defer r.mu.Unlock()
-	r.events = append(r.events, event)
+	r.events = append(r.events, event.LogicalEvent())
 	return nil
 }
 
@@ -133,7 +135,7 @@ type failingFinalStream struct {
 	recordingStream
 }
 
-func (f *failingFinalStream) Push(ctx context.Context, event StreamEvent) error {
+func (f *failingFinalStream) Push(ctx context.Context, event PreparedStreamEvent) error {
 	if event.Type == StreamEventFinal {
 		return context.DeadlineExceeded
 	}
@@ -142,15 +144,16 @@ func (f *failingFinalStream) Push(ctx context.Context, event StreamEvent) error
 
 func newChunkingTestStream(t *testing.T, chunkLimit int) (*managerOutboundStream, *recordingStream, *[]OutboundMessage) {
 	t.Helper()
+	channelType := ChannelType("telegram")
 	registry := NewRegistry()
 	adapter := &streamValidationAdapter{
-		channelType:    ChannelType("test"),
+		channelType:    channelType,
 		outboundPolicy: OutboundPolicy{TextChunkLimit: chunkLimit},
 	}
 	if err := registry.Register(adapter); err != nil {
 		t.Fatalf("register adapter failed: %v", err)
 	}
-	manager := &Manager{registry: registry}
+	manager := &Manager{registry: registry, attachmentStore: channeltest.NewMemoryAttachmentStore()}
 
 	rec := &recordingStream{}
 	var sent []OutboundMessage
@@ -158,8 +161,10 @@ func newChunkingTestStream(t *testing.T, chunkLimit int) (*managerOutboundStream
 
 	stream := &managerOutboundStream{
 		manager:     manager,
+		config:      ChannelConfig{BotID: "bot-1", ChannelType: channelType},
 		stream:      rec,
-		channelType: ChannelType("test"),
+		channelType: channelType,
+		policy:      manager.resolveOutboundPolicy(channelType),
 		send: func(_ context.Context, msg OutboundMessage) error {
 			mu.Lock()
 			defer mu.Unlock()
@@ -507,22 +512,25 @@ func TestPushFinalWithChunking_ThreadPropagated(t *testing.T) {
 func TestPushFinalWithChunking_FirstChunkPushFailureFallback(t *testing.T) {
 	t.Parallel()
 
+	channelType := ChannelType("telegram")
 	registry := NewRegistry()
 	adapter := &streamValidationAdapter{
-		channelType:    ChannelType("test"),
+		channelType:    channelType,
 		outboundPolicy: OutboundPolicy{TextChunkLimit: 100},
 	}
 	if err := registry.Register(adapter); err != nil {
 		t.Fatalf("register adapter failed: %v", err)
 	}
-	manager := &Manager{registry: registry}
+	manager := &Manager{registry: registry, attachmentStore: channeltest.NewMemoryAttachmentStore()}
 
 	rec := &failingFinalStream{}
 	var sent []OutboundMessage
 	stream := &managerOutboundStream{
 		manager:     manager,
+		config:      ChannelConfig{BotID: "bot-1", ChannelType: channelType},
 		stream:      rec,
-		channelType: ChannelType("test"),
+		channelType: channelType,
+		policy:      manager.resolveOutboundPolicy(channelType),
 		send: func(_ context.Context, msg OutboundMessage) error {
 			sent = append(sent, msg)
 			return nil
@@ -572,7 +580,7 @@ func (r *reopenableStream) current() *recordingStream {
 	return r.streams[r.idx]
 }
 
-func (r *reopenableStream) reopen(_ context.Context) (OutboundStream, error) {
+func (r *reopenableStream) reopen(_ context.Context) (PreparedOutboundStream, error) {
 	r.idx++
 	if r.idx >= len(r.streams) {
 		return nil, errors.New("no more streams")
@@ -582,15 +590,16 @@ func (r *reopenableStream) reopen(_ context.Context) (OutboundStream, error) {
 
 func newDeltaSplitTestStream(t *testing.T, chunkLimit int, streamCount int) (*managerOutboundStream, *reopenableStream, *[]OutboundMessage) {
 	t.Helper()
+	channelType := ChannelType("telegram")
 	registry := NewRegistry()
 	adapter := &streamValidationAdapter{
-		channelType:    ChannelType("test"),
+		channelType:    channelType,
 		outboundPolicy: OutboundPolicy{TextChunkLimit: chunkLimit},
 	}
 	if err := registry.Register(adapter); err != nil {
 		t.Fatalf("register adapter failed: %v", err)
 	}
-	manager := &Manager{registry: registry}
+	manager := &Manager{registry: registry, attachmentStore: channeltest.NewMemoryAttachmentStore()}
 
 	streams := make([]*recordingStream, streamCount)
 	for i := range streams {
@@ -603,8 +612,10 @@ func newDeltaSplitTestStream(t *testing.T, chunkLimit int, streamCount int) (*ma
 
 	stream := &managerOutboundStream{
 		manager:     manager,
+		config:      ChannelConfig{BotID: "bot-1", ChannelType: channelType},
 		stream:      streams[0],
-		channelType: ChannelType("test"),
+		channelType: channelType,
+		policy:      manager.resolveOutboundPolicy(channelType),
 		send: func(_ context.Context, msg OutboundMessage) error {
 			mu.Lock()
 			defer mu.Unlock()
diff --git a/internal/channel/prepared_outbound.go b/internal/channel/prepared_outbound.go
new file mode 100644
index 00000000..510bfd5a
--- /dev/null
+++ b/internal/channel/prepared_outbound.go
@@ -0,0 +1,109 @@
+package channel
+
+import (
+	"context"
+	"io"
+)
+
+// PreparedAttachmentKind identifies how an attachment should be delivered.
+type PreparedAttachmentKind string
+
+const (
+	PreparedAttachmentNativeRef PreparedAttachmentKind = "native_ref"
+	PreparedAttachmentPublicURL PreparedAttachmentKind = "public_url"
+	PreparedAttachmentUpload    PreparedAttachmentKind = "upload"
+)
+
+// PreparedAttachment is the adapter-facing attachment model after preparation.
+type PreparedAttachment struct {
+	Logical   Attachment
+	Kind      PreparedAttachmentKind
+	NativeRef string
+	PublicURL string
+	Name      string
+	Mime      string
+	Size      int64
+	// Open must return a fresh reader each time so retries are safe.
+	Open func(ctx context.Context) (io.ReadCloser, error)
+}
+
+// PreparedMessage is the adapter-facing form of a Message.
+type PreparedMessage struct {
+	Message     Message
+	Attachments []PreparedAttachment
+}
+
+// LogicalMessage converts the prepared message back to the logical channel message.
+func (m PreparedMessage) LogicalMessage() Message {
+	msg := m.Message
+	if len(m.Attachments) == 0 {
+		return msg
+	}
+	attachments := make([]Attachment, 0, len(m.Attachments))
+	for _, att := range m.Attachments {
+		attachments = append(attachments, att.Logical)
+	}
+	msg.Attachments = attachments
+	return msg
+}
+
+// PreparedOutboundMessage is the adapter-facing form of OutboundMessage.
+type PreparedOutboundMessage struct {
+	Target  string
+	Message PreparedMessage
+}
+
+// LogicalMessage converts the prepared outbound message back to the logical model.
+func (m PreparedOutboundMessage) LogicalMessage() OutboundMessage {
+	return OutboundMessage{
+		Target:  m.Target,
+		Message: m.Message.LogicalMessage(),
+	}
+}
+
+// PreparedStreamFinalizePayload is the adapter-facing stream final payload.
+type PreparedStreamFinalizePayload struct {
+	Message PreparedMessage
+}
+
+// PreparedStreamEvent is the adapter-facing form of StreamEvent.
+type PreparedStreamEvent struct {
+	Type        StreamEventType
+	Status      StreamStatus
+	Delta       string
+	Final       *PreparedStreamFinalizePayload
+	Error       string
+	ToolCall    *StreamToolCall
+	Phase       StreamPhase
+	Attachments []PreparedAttachment
+	Reactions   []ReactRequest
+	Speeches    []SpeechRequest
+	Metadata    map[string]any
+}
+
+// LogicalEvent converts the prepared stream event back to the logical model.
+func (e PreparedStreamEvent) LogicalEvent() StreamEvent {
+	result := StreamEvent{
+		Type:      e.Type,
+		Status:    e.Status,
+		Delta:     e.Delta,
+		Error:     e.Error,
+		ToolCall:  e.ToolCall,
+		Phase:     e.Phase,
+		Reactions: e.Reactions,
+		Speeches:  e.Speeches,
+		Metadata:  e.Metadata,
+	}
+	if len(e.Attachments) > 0 {
+		result.Attachments = make([]Attachment, 0, len(e.Attachments))
+		for _, att := range e.Attachments {
+			result.Attachments = append(result.Attachments, att.Logical)
+		}
+	}
+	if e.Final != nil {
+		result.Final = &StreamFinalizePayload{
+			Message: e.Final.Message.LogicalMessage(),
+		}
+	}
+	return result
+}
diff --git a/internal/channel/types.go b/internal/channel/types.go
index 941f6eee..d08b680b 100644
--- a/internal/channel/types.go
+++ b/internal/channel/types.go
@@ -432,3 +432,17 @@ type ReactRequest struct {
 	Emoji     string `json:"emoji"`
 	Remove    bool   `json:"remove,omitempty"`
 }
+
+// Well-known ChannelType values for platforms with special handling in the core channel package.
+// Adapter packages define their own identical constant as their package-local Type.
+const (
+	ChannelTypeTelegram ChannelType = "telegram"
+	ChannelTypeFeishu   ChannelType = "feishu"
+	ChannelTypeDingtalk ChannelType = "dingtalk"
+	ChannelTypeMatrix   ChannelType = "matrix"
+	ChannelTypeDiscord  ChannelType = "discord"
+	ChannelTypeQQ       ChannelType = "qq"
+	ChannelTypeWecom    ChannelType = "wecom"
+	ChannelTypeWeixin   ChannelType = "weixin"
+	ChannelTypeLocal    ChannelType = "local"
+)
diff --git a/internal/conversation/flow/resolver.go b/internal/conversation/flow/resolver.go
index d593388c..0089baf5 100644
--- a/internal/conversation/flow/resolver.go
+++ b/internal/conversation/flow/resolver.go
@@ -257,10 +257,16 @@ func (r *Resolver) resolve(ctx context.Context, req conversation.ChatRequest) (r
 		agentInjectCh := make(chan agentpkg.InjectMessage, cap(req.InjectCh))
 		go func() {
 			for msg := range req.InjectCh {
-				agentInjectCh <- agentpkg.InjectMessage{
+				agentMsg := agentpkg.InjectMessage{
 					Text:            msg.Text,
 					HeaderifiedText: msg.HeaderifiedText,
 				}
+				// Inline any image attachments from the injected message so the
+				// model receives them as vision input alongside the text.
+				if runCfg.SupportsImageInput && len(msg.Attachments) > 0 {
+					agentMsg.ImageParts = r.inlineInjectAttachments(ctx, req.BotID, msg.Attachments)
+				}
+				agentInjectCh <- agentMsg
 			}
 			close(agentInjectCh)
 		}()
@@ -500,6 +506,29 @@ func (r *Resolver) prepareRunConfig(ctx context.Context, cfg agentpkg.RunConfig)
 			}
 		}
 		cfg.Messages = append(cfg.Messages, sdk.UserMessage(cfg.Query, extra...))
+	} else if len(cfg.InlineImages) > 0 {
+		// Pipeline path: the user query is already embedded in the RC messages,
+		// but image parts are not rendered by the pipeline renderer. Inject the
+		// inline images into the last user message so the model receives them.
+		imageParts := make([]sdk.MessagePart, 0, len(cfg.InlineImages))
+		for _, img := range cfg.InlineImages {
+			if strings.TrimSpace(img.Image) != "" {
+				imageParts = append(imageParts, img)
+			}
+		}
+		if len(imageParts) > 0 {
+			injected := false
+			for i := len(cfg.Messages) - 1; i >= 0; i-- {
+				if cfg.Messages[i].Role == sdk.MessageRoleUser {
+					cfg.Messages[i].Content = append(cfg.Messages[i].Content, imageParts...)
+					injected = true
+					break
+				}
+			}
+			if !injected {
+				cfg.Messages = append(cfg.Messages, sdk.UserMessage("", imageParts...))
+			}
+		}
 	}
 
 	return cfg
diff --git a/internal/conversation/flow/resolver_attachments.go b/internal/conversation/flow/resolver_attachments.go
index f4a9e9ce..5fcf003a 100644
--- a/internal/conversation/flow/resolver_attachments.go
+++ b/internal/conversation/flow/resolver_attachments.go
@@ -10,6 +10,8 @@ import (
 	"net/http"
 	"strings"
 
+	sdk "github.com/memohai/twilight-ai/sdk"
+
 	attachmentpkg "github.com/memohai/memoh/internal/attachment"
 	"github.com/memohai/memoh/internal/conversation"
 	"github.com/memohai/memoh/internal/models"
@@ -75,14 +77,24 @@ func (r *Resolver) prepareGatewayAttachments(ctx context.Context, req conversati
 			transport = gatewayTransportInlineDataURL
 		} else {
 			rawURL := strings.TrimSpace(raw.URL)
+			contentHash := strings.TrimSpace(raw.ContentHash)
 			switch {
 			case isDataURL(rawURL):
 				payload = rawURL
 				transport = gatewayTransportInlineDataURL
-			case isLikelyPublicURL(rawURL):
+			case isLikelyPublicURL(rawURL) && contentHash == "":
+				// Only treat a public HTTP URL as direct vision input when the
+				// attachment has not been persisted yet. If ContentHash is set,
+				// the file is already in the media store and will be inlined
+				// by inlineImageAttachmentAssetIfNeeded below — prefer that path
+				// so we never expose ephemeral or credentialed platform URLs
+				// directly to the model.
 				payload = rawURL
 				transport = gatewayTransportPublicURL
 			case rawURL != "" && fallbackPath == "":
+				// URL is either a persisted local path (contentHash set) or an
+				// unresolvable reference; store it as fallbackPath so the agent
+				// can access it via the file tool if needed.
 				fallbackPath = rawURL
 			}
 		}
@@ -140,6 +152,39 @@ func isDataURL(raw string) bool {
 	return strings.HasPrefix(trimmed, "data:")
 }
 
+// inlineInjectAttachments converts image attachments from an injected message
+// into sdk.ImagePart values for direct vision input. Non-image attachments and
+// images that cannot be inlined are silently skipped.
+func (r *Resolver) inlineInjectAttachments(ctx context.Context, botID string, atts []conversation.ChatAttachment) []sdk.ImagePart {
+	var parts []sdk.ImagePart
+	for _, att := range atts {
+		if strings.ToLower(strings.TrimSpace(att.Type)) != "image" {
+			continue
+		}
+		contentHash := strings.TrimSpace(att.ContentHash)
+		if contentHash == "" {
+			continue
+		}
+		dataURL, mime, err := r.inlineAssetAsDataURL(ctx, botID, contentHash, "image", strings.TrimSpace(att.Mime))
+		if err != nil {
+			if r != nil && r.logger != nil {
+				r.logger.Warn(
+					"inline inject image attachment failed",
+					slog.Any("error", err),
+					slog.String("bot_id", botID),
+					slog.String("content_hash", contentHash),
+				)
+			}
+			continue
+		}
+		parts = append(parts, sdk.ImagePart{
+			Image:     dataURL,
+			MediaType: mime,
+		})
+	}
+	return parts
+}
+
 func (r *Resolver) inlineImageAttachmentAssetIfNeeded(ctx context.Context, botID string, item gatewayAttachment) gatewayAttachment {
 	if item.Type != "image" {
 		return item
diff --git a/internal/media/service.go b/internal/media/service.go
index 53a16f70..785c94ac 100644
--- a/internal/media/service.go
+++ b/internal/media/service.go
@@ -99,6 +99,12 @@ func (s *Service) Resolve(ctx context.Context, botID, contentHash string) (Asset
 	return s.resolveByContentHash(ctx, botID, contentHash)
 }
 
+// Stat returns asset metadata for the given content hash without opening the file.
+// It satisfies the channel.OutboundAttachmentStore interface.
+func (s *Service) Stat(ctx context.Context, botID, contentHash string) (Asset, error) {
+	return s.Resolve(ctx, botID, contentHash)
+}
+
 // Open returns a reader for the media asset identified by content hash.
 // It locates the file by scanning extensions under the hash prefix and derives MIME from the extension.
 func (s *Service) Open(ctx context.Context, botID, contentHash string) (io.ReadCloser, Asset, error) {
diff --git a/internal/messaging/executor.go b/internal/messaging/executor.go
index 0f2978ed..be19f5a9 100644
--- a/internal/messaging/executor.go
+++ b/internal/messaging/executor.go
@@ -9,6 +9,7 @@ import (
 	"strings"
 
 	"github.com/memohai/memoh/internal/channel"
+	"github.com/memohai/memoh/internal/media"
 )
 
 // SessionContext carries request-scoped identity for tool execution.
@@ -35,17 +36,13 @@ type ChannelTypeResolver interface {
 }
 
 // AssetMeta holds resolved metadata for a media asset.
-type AssetMeta struct {
-	ContentHash string
-	Mime        string
-	SizeBytes   int64
-	StorageKey  string
-}
+type AssetMeta = media.Asset
 
-// AssetResolver looks up persisted media assets by storage key.
+// AssetResolver looks up persisted media assets by storage key and can
+// optionally ingest files from a bot's container filesystem.
 type AssetResolver interface {
-	GetByStorageKey(ctx context.Context, botID, storageKey string) (AssetMeta, error)
-	IngestContainerFile(ctx context.Context, botID, containerPath string) (AssetMeta, error)
+	channel.OutboundAttachmentStore
+	channel.ContainerAttachmentIngester
 }
 
 // Executor provides send and react operations for channel messaging.
@@ -139,7 +136,7 @@ func (e *Executor) sendWithMode(
 	}
 
 	if mode.promoteDataAttachments {
-		e.promoteDataPathAttachmentsToAssets(ctx, plan.botID, &plan.message)
+		e.promoteDataPathAttachmentsToAssets(ctx, plan.botID, plan.channelType, &plan.message)
 	}
 
 	if err := e.Sender.Send(ctx, plan.botID, plan.channelType, channel.SendRequest{
@@ -315,33 +312,20 @@ func resolveSameConversationAttachments(rawAttachments any) []channel.Attachment
 // promoteDataPathAttachmentsToAssets converts /data/* attachment references
 // into content_hash-backed attachments before channel send.
 // This avoids adapters treating local container paths as HTTP URLs.
-func (e *Executor) promoteDataPathAttachmentsToAssets(ctx context.Context, botID string, msg *channel.Message) {
+func (e *Executor) promoteDataPathAttachmentsToAssets(ctx context.Context, botID string, channelType channel.ChannelType, msg *channel.Message) {
 	if e.AssetResolver == nil || msg == nil || len(msg.Attachments) == 0 {
 		return
 	}
-	for i := range msg.Attachments {
-		att := msg.Attachments[i]
-		if strings.TrimSpace(att.ContentHash) != "" {
-			continue
-		}
-		ref := strings.TrimSpace(att.URL)
-		if !strings.HasPrefix(ref, "/data/") {
-			continue
-		}
-		asset, err := e.AssetResolver.IngestContainerFile(ctx, botID, ref)
-		if err != nil {
-			continue
-		}
-		converted := AssetMetaToAttachment(asset, botID, string(att.Type), strings.TrimSpace(att.Name))
-		if converted == nil {
-			continue
-		}
-		// Preserve explicit type if caller already provided one.
-		if att.Type != "" {
-			converted.Type = att.Type
-		}
-		msg.Attachments[i] = *converted
+	prepared, err := channel.PrepareOutboundMessage(ctx, e.AssetResolver, channel.ChannelConfig{
+		BotID:       botID,
+		ChannelType: channelType,
+	}, channel.OutboundMessage{
+		Message: *msg,
+	})
+	if err != nil {
+		return
 	}
+	msg.Attachments = prepared.Message.Message.Attachments
 }
 
 // React executes a react action. args are the tool call arguments.
@@ -571,7 +555,7 @@ func ParseOutboundMessage(arguments map[string]any, fallbackText string) (channe
 }
 
 // AssetMetaToAttachment converts an AssetMeta to a channel.Attachment.
-func AssetMetaToAttachment(asset AssetMeta, botID, attType, name string) *channel.Attachment {
+func AssetMetaToAttachment(asset media.Asset, botID, attType, name string) *channel.Attachment {
 	t := channel.AttachmentType(attType)
 	if t == "" {
 		t = InferAttachmentTypeFromMime(asset.Mime)
diff --git a/internal/messaging/executor_test.go b/internal/messaging/executor_test.go
index 248c2ebf..2c516736 100644
--- a/internal/messaging/executor_test.go
+++ b/internal/messaging/executor_test.go
@@ -2,9 +2,11 @@ package messaging
 
 import (
 	"context"
+	"io"
 	"testing"
 
 	"github.com/memohai/memoh/internal/channel"
+	"github.com/memohai/memoh/internal/media"
 )
 
 type testSender struct {
@@ -29,10 +31,26 @@ type testAssetResolver struct {
 	lastPath     string
 }
 
+func (*testAssetResolver) Stat(_ context.Context, _, _ string) (AssetMeta, error) {
+	return AssetMeta{}, context.Canceled
+}
+
 func (*testAssetResolver) GetByStorageKey(_ context.Context, _, _ string) (AssetMeta, error) {
 	return AssetMeta{}, context.Canceled
 }
 
+func (*testAssetResolver) Open(_ context.Context, _, _ string) (io.ReadCloser, media.Asset, error) {
+	return nil, media.Asset{}, context.Canceled
+}
+
+func (*testAssetResolver) Ingest(_ context.Context, _ media.IngestInput) (media.Asset, error) {
+	return media.Asset{}, context.Canceled
+}
+
+func (*testAssetResolver) AccessPath(asset media.Asset) string {
+	return "https://example.com/media/" + asset.ContentHash
+}
+
 func (r *testAssetResolver) IngestContainerFile(_ context.Context, _, containerPath string) (AssetMeta, error) {
 	r.ingestCalled++
 	r.lastPath = containerPath
@@ -164,7 +182,7 @@ func TestSendDirectPromotesDataPathAttachmentToContentHash(t *testing.T) {
 	if att.ContentHash != "hash_1" {
 		t.Fatalf("expected promoted content hash, got %q", att.ContentHash)
 	}
-	if att.URL != "" {
-		t.Fatalf("expected URL cleared after promotion, got %q", att.URL)
+	if att.URL != "https://example.com/media/hash_1" {
+		t.Fatalf("expected public access URL after promotion, got %q", att.URL)
 	}
 }
diff --git a/internal/pipeline/rendering.go b/internal/pipeline/rendering.go
index 1b4afe29..54493fcf 100644
--- a/internal/pipeline/rendering.go
+++ b/internal/pipeline/rendering.go
@@ -140,16 +140,6 @@ func renderMessage(msg *ICMessage, params RenderParams) RenderedSegment {
 
 	pieces := []RenderedContentPiece{{Type: "text", Text: text}}
 
-	// Append thumbnail images as separate content pieces for multimodal models.
-	for _, att := range msg.Attachments {
-		if att.AltText == "" && att.ThumbnailB64 != "" {
-			pieces = append(pieces, RenderedContentPiece{
-				Type: "image",
-				URL:  "data:image/webp;base64," + att.ThumbnailB64,
-			})
-		}
-	}
-
 	return RenderedSegment{
 		ReceivedAtMs: msg.ReceivedAtMs,
 		Content:      pieces,
diff --git a/packages/icons/icons/dingtalk.svg b/packages/icons/icons/dingtalk.svg
new file mode 100644
index 00000000..ff98ae5c
--- /dev/null
+++ b/packages/icons/icons/dingtalk.svg
@@ -0,0 +1 @@
+<svg t="1775466278875" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="1655" width="200" height="200"><path d="M512 512m-512 0a512 512 0 1 0 1024 0 512 512 0 1 0-1024 0Z" fill="#3296FA" p-id="1656"></path><path d="M772.064 431.2c-1.376 5.44-4.096 10.944-8.192 20.48v1.376c-23.264 47.872-83.424 140.864-83.424 140.864l-17.792 30.08h84.8l-161.376 207.872 36.928-142.208h-67.008l23.232-94.4c-19.136 4.128-41.024 10.976-67.008 19.2 0 0-35.52 20.48-101.184-38.304 0 0-45.12-38.304-19.136-47.872 10.944-4.096 53.312-9.6 87.52-13.696 45.12-5.44 73.856-9.568 73.856-9.568s-139.52 1.376-172.32-2.72c-32.832-5.472-75.2-58.816-84.8-106.656 0 0-13.664-25.984 30.08-13.696 43.776 12.32 224.32 47.872 224.32 47.872S313.92 358.72 298.88 340.928c-16.416-16.416-46.496-92.992-42.4-139.488 0 0 1.376-12.288 13.664-8.192 0 0 173.696 77.952 292.672 120.32 118.976 41.024 222.88 62.912 209.216 117.632z" fill="#FFFFFF" p-id="1657"></path></svg>
\ No newline at end of file
diff --git a/packages/icons/icons/wecom.svg b/packages/icons/icons/wecom.svg
new file mode 100644
index 00000000..d1646968
--- /dev/null
+++ b/packages/icons/icons/wecom.svg
@@ -0,0 +1 @@
+<svg t="1775466349847" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="3541" width="200" height="200"><path d="M512 2c281.7 0 510 228.3 510 510s-228.3 510-510 510S2 793.7 2 512 230.3 2 512 2z m159.8 680.3c-4 3.9-4 10.2-0.2 14.1 0.4 0.5 0.9 0.9 1.5 1.2 22.1 20.4 36.4 47.9 40.4 77.7 6.2 22.4 29.7 35.7 52.4 29.5 22.5-5.9 35.9-28.9 30-51.3 0-0.1-0.1-0.2-0.1-0.4-4.7-16.8-19.3-29.1-36.7-30.8-28-5.1-53.5-19.2-72.8-40.1-4.1-3.8-10.5-3.8-14.5 0.1z m-225.7-483c-76.4 8.3-145.8 40.6-195.6 91-19.4 19.4-35.5 41.8-47.8 66.3-37.7 74.9-31.4 164.4 16.5 233.2 13.5 20.2 35.8 45.4 56.1 63.3l-9.2 71.3-1 3c-0.3 0.9-0.3 1.9-0.4 2.8l-0.2 2.3 0.2 2.3c1.2 12.7 12.5 22 25.2 20.9 3.5-0.3 6.8-1.4 9.8-3.1h0.4l1.4-1 22-10.8 65.5-32.5c31.1 8.8 63.4 13.2 95.8 13 40 0.1 79.8-6.7 117.5-20.2-18.8-6-30.9-24.3-29-44-39 12.4-80.2 16.4-120.8 11.9l-6.5-0.9c-14.7-1.9-29.2-4.9-43.4-8.9-7.8-2.4-16.1-1.5-23.3 2.4l-1.8 0.9-53.9 31.3-2.3 1.4c-1.3 0.7-1.9 1-2.6 1-2-0.1-3.5-1.8-3.4-3.8l2-8.2 2.4-8.9 3.9-14.7 4.5-16.4c3-9.2-0.3-19.2-8.2-24.8-21.1-15.5-39.5-34.4-54.4-56-37.9-54.2-43-124.8-13.3-183.8 9.9-19.5 22.9-37.4 38.4-52.9 40.9-41.6 98.3-68.1 161.9-74.9 22-2.4 44.2-2.4 66.2 0 63.2 7.2 120.4 34 161.1 75.4 15.4 15.7 28.2 33.6 37.9 53.2 12.5 24.8 19 52.3 19.1 80.1 0 2.9-0.3 5.8-0.4 8.6 16.8-10.2 38.4-7.7 52.4 6.1l1.9 2.3c3.3-41.2-4.8-82.5-23.3-119.5-12.1-24.5-28.1-46.8-47.3-66.3-52.5-52-121.4-84.3-194.9-91.7-26.4-3.4-52.9-3.5-79.1-0.7z m418.2 405.4c-7.2 1.9-13.8 5.7-19.2 11h-0.1c-6.9 6.8-11.2 15.7-12.2 25.3-5.2 27.8-19.5 53.1-40.5 72-4 3.8-4.1 10.1-0.3 14.1l0.1 0.1c4 4 10.5 4.1 14.6 0.1 0.5-0.5 0.9-0.9 1.2-1.5 20.9-21.9 48.7-36 78.7-39.8 22.8-6.1 36.2-29.2 30.1-51.6-6.2-22.5-29.6-35.8-52.4-29.7z m-160.4-42l-0.7 0.7c-20.9 22.7-49.2 37.3-79.9 41.2-22.6 5.9-36.2 28.7-30.2 51.1 1.9 7.3 5.9 14 11.3 19.3 16.7 16.4 43.7 16.4 60.4-0.1 6.8-6.8 11.1-15.7 12.2-25.2 5.3-27.8 19.6-53.1 40.7-72 4.1-3.7 4.5-10 0.9-14.1l-0.1-0.1c-4-4.2-10.4-4.5-14.6-0.8z m39.6-76.6c-7.1 1.9-13.6 5.7-18.7 10.8-16.4 16.2-16.6 42.6-0.4 59l0.5 0.5c6.9 6.8 15.9 11 25.5 12.1 28 5.1 53.6 19.1 72.9 39.9 4 4 10.4 4 14.4 0.1 4-3.8 4.1-10.1 0.3-14.1-0.5-0.5-1.1-1-1.7-1.4-22.1-20.4-36.4-47.8-40.4-77.6-6.1-22.4-29.6-35.5-52.4-29.3z" fill="#0082EF" p-id="3542"></path></svg>
\ No newline at end of file
diff --git a/packages/icons/scripts/manifest.ts b/packages/icons/scripts/manifest.ts
index e9de9857..e9b6b2a3 100644
--- a/packages/icons/scripts/manifest.ts
+++ b/packages/icons/scripts/manifest.ts
@@ -82,7 +82,9 @@ const channelPlatforms: string[] = [
   'slack',
   'feishu',
   'wechat',
+  'wecom',
   'matrix',
+  'dingtalk',
 ]
 
 // ---------------------------------------------------------------------------
diff --git a/packages/icons/src/icons/Dingtalk.vue b/packages/icons/src/icons/Dingtalk.vue
new file mode 100644
index 00000000..79d0324d
--- /dev/null
+++ b/packages/icons/src/icons/Dingtalk.vue
@@ -0,0 +1,22 @@
+<template>
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    :width="size"
+    :height="size"
+    viewBox="0 0 1024 1024"
+    v-bind="$attrs"
+  ><path
+    d="M512 512m-512 0a512 512 0 1 0 1024 0 512 512 0 1 0-1024 0Z"
+    fill="#3296FA"
+    p-id="1656"
+  /><path
+    d="M772.064 431.2c-1.376 5.44-4.096 10.944-8.192 20.48v1.376c-23.264 47.872-83.424 140.864-83.424 140.864l-17.792 30.08h84.8l-161.376 207.872 36.928-142.208h-67.008l23.232-94.4c-19.136 4.128-41.024 10.976-67.008 19.2 0 0-35.52 20.48-101.184-38.304 0 0-45.12-38.304-19.136-47.872 10.944-4.096 53.312-9.6 87.52-13.696 45.12-5.44 73.856-9.568 73.856-9.568s-139.52 1.376-172.32-2.72c-32.832-5.472-75.2-58.816-84.8-106.656 0 0-13.664-25.984 30.08-13.696 43.776 12.32 224.32 47.872 224.32 47.872S313.92 358.72 298.88 340.928c-16.416-16.416-46.496-92.992-42.4-139.488 0 0 1.376-12.288 13.664-8.192 0 0 173.696 77.952 292.672 120.32 118.976 41.024 222.88 62.912 209.216 117.632z"
+    fill="#FFFFFF"
+    p-id="1657"
+  /></svg>
+</template>
+
+<script setup lang="ts">
+withDefaults(defineProps<{ size?: string | number }>(), { size: '1em' })
+defineOptions({ inheritAttrs: false })
+</script>
diff --git a/packages/icons/src/icons/Wecom.vue b/packages/icons/src/icons/Wecom.vue
new file mode 100644
index 00000000..d30cfdc2
--- /dev/null
+++ b/packages/icons/src/icons/Wecom.vue
@@ -0,0 +1,18 @@
+<template>
+  <svg
+    xmlns="http://www.w3.org/2000/svg"
+    :width="size"
+    :height="size"
+    viewBox="0 0 1024 1024"
+    v-bind="$attrs"
+  ><path
+    d="M512 2c281.7 0 510 228.3 510 510s-228.3 510-510 510S2 793.7 2 512 230.3 2 512 2z m159.8 680.3c-4 3.9-4 10.2-0.2 14.1 0.4 0.5 0.9 0.9 1.5 1.2 22.1 20.4 36.4 47.9 40.4 77.7 6.2 22.4 29.7 35.7 52.4 29.5 22.5-5.9 35.9-28.9 30-51.3 0-0.1-0.1-0.2-0.1-0.4-4.7-16.8-19.3-29.1-36.7-30.8-28-5.1-53.5-19.2-72.8-40.1-4.1-3.8-10.5-3.8-14.5 0.1z m-225.7-483c-76.4 8.3-145.8 40.6-195.6 91-19.4 19.4-35.5 41.8-47.8 66.3-37.7 74.9-31.4 164.4 16.5 233.2 13.5 20.2 35.8 45.4 56.1 63.3l-9.2 71.3-1 3c-0.3 0.9-0.3 1.9-0.4 2.8l-0.2 2.3 0.2 2.3c1.2 12.7 12.5 22 25.2 20.9 3.5-0.3 6.8-1.4 9.8-3.1h0.4l1.4-1 22-10.8 65.5-32.5c31.1 8.8 63.4 13.2 95.8 13 40 0.1 79.8-6.7 117.5-20.2-18.8-6-30.9-24.3-29-44-39 12.4-80.2 16.4-120.8 11.9l-6.5-0.9c-14.7-1.9-29.2-4.9-43.4-8.9-7.8-2.4-16.1-1.5-23.3 2.4l-1.8 0.9-53.9 31.3-2.3 1.4c-1.3 0.7-1.9 1-2.6 1-2-0.1-3.5-1.8-3.4-3.8l2-8.2 2.4-8.9 3.9-14.7 4.5-16.4c3-9.2-0.3-19.2-8.2-24.8-21.1-15.5-39.5-34.4-54.4-56-37.9-54.2-43-124.8-13.3-183.8 9.9-19.5 22.9-37.4 38.4-52.9 40.9-41.6 98.3-68.1 161.9-74.9 22-2.4 44.2-2.4 66.2 0 63.2 7.2 120.4 34 161.1 75.4 15.4 15.7 28.2 33.6 37.9 53.2 12.5 24.8 19 52.3 19.1 80.1 0 2.9-0.3 5.8-0.4 8.6 16.8-10.2 38.4-7.7 52.4 6.1l1.9 2.3c3.3-41.2-4.8-82.5-23.3-119.5-12.1-24.5-28.1-46.8-47.3-66.3-52.5-52-121.4-84.3-194.9-91.7-26.4-3.4-52.9-3.5-79.1-0.7z m418.2 405.4c-7.2 1.9-13.8 5.7-19.2 11h-0.1c-6.9 6.8-11.2 15.7-12.2 25.3-5.2 27.8-19.5 53.1-40.5 72-4 3.8-4.1 10.1-0.3 14.1l0.1 0.1c4 4 10.5 4.1 14.6 0.1 0.5-0.5 0.9-0.9 1.2-1.5 20.9-21.9 48.7-36 78.7-39.8 22.8-6.1 36.2-29.2 30.1-51.6-6.2-22.5-29.6-35.8-52.4-29.7z m-160.4-42l-0.7 0.7c-20.9 22.7-49.2 37.3-79.9 41.2-22.6 5.9-36.2 28.7-30.2 51.1 1.9 7.3 5.9 14 11.3 19.3 16.7 16.4 43.7 16.4 60.4-0.1 6.8-6.8 11.1-15.7 12.2-25.2 5.3-27.8 19.6-53.1 40.7-72 4.1-3.7 4.5-10 0.9-14.1l-0.1-0.1c-4-4.2-10.4-4.5-14.6-0.8z m39.6-76.6c-7.1 1.9-13.6 5.7-18.7 10.8-16.4 16.2-16.6 42.6-0.4 59l0.5 0.5c6.9 6.8 15.9 11 25.5 12.1 28 5.1 53.6 19.1 72.9 39.9 4 4 10.4 4 14.4 0.1 4-3.8 4.1-10.1 0.3-14.1-0.5-0.5-1.1-1-1.7-1.4-22.1-20.4-36.4-47.8-40.4-77.6-6.1-22.4-29.6-35.5-52.4-29.3z"
+    fill="#0082EF"
+    p-id="3542"
+  /></svg>
+</template>
+
+<script setup lang="ts">
+withDefaults(defineProps<{ size?: string | number }>(), { size: '1em' })
+defineOptions({ inheritAttrs: false })
+</script>
diff --git a/packages/icons/src/index.ts b/packages/icons/src/index.ts
index 63d0e2dd..24d607c7 100644
--- a/packages/icons/src/index.ts
+++ b/packages/icons/src/index.ts
@@ -17,6 +17,7 @@ export { default as Cohere } from './icons/Cohere.vue'
 export { default as CohereColor } from './icons/CohereColor.vue'
 export { default as Deepseek } from './icons/Deepseek.vue'
 export { default as DeepseekColor } from './icons/DeepseekColor.vue'
+export { default as Dingtalk } from './icons/Dingtalk.vue'
 export { default as Discord } from './icons/Discord.vue'
 export { default as Doubao } from './icons/Doubao.vue'
 export { default as DoubaoColor } from './icons/DoubaoColor.vue'
@@ -80,6 +81,7 @@ export { default as VertexaiColor } from './icons/VertexaiColor.vue'
 export { default as Volcengine } from './icons/Volcengine.vue'
 export { default as VolcengineColor } from './icons/VolcengineColor.vue'
 export { default as Wechat } from './icons/Wechat.vue'
+export { default as Wecom } from './icons/Wecom.vue'
 export { default as Xai } from './icons/Xai.vue'
 export { default as Yandex } from './icons/Yandex.vue'
 export { default as Yi } from './icons/Yi.vue'