@sparkelf/dsh-patch-document-attachments 0.1.0-rc.10

package/patches/document-attachments.patch

@@ -0,0 +1,2396 @@
+diff --git a/packages/api/session-controller/src/client/sessions/session.ts b/packages/api/session-controller/src/client/sessions/session.ts
+index 815cf89c40e404a32dd1ec8c20568fc15995a73d..9e03894a8d895bc73fd5ea8ac853b0073b7c70dd 100644
+--- a/packages/api/session-controller/src/client/sessions/session.ts
++++ b/packages/api/session-controller/src/client/sessions/session.ts
+@@ -215,27 +215,19 @@ export class Session implements SessionFace {
+     signal?: AbortSignal,
+     requestId?: SessionRequestId,
+   ): Promise<ClientResult<{ accepted: true }>> {
+-    this.promptError = null
+-    this.lastAgentError = null
+-    // Synchronous, before the first await: the blank → engaging edge must be
+-    // visible on the session area's very first frame when a caller sends
+-    // ahead of navigation (first-send flow).
+-    this.promptAttempted = true
+-    if (this.blankBit) this.firstPromptPendingTurn = true
+-    this.notifier.markDirty()
+-    let result: ClientResult<{ accepted: true }>
+-    try {
++    return this.settlePrompt(requestId, async () => {
+       if (this.address === undefined) {
+         const clientTimeZone = resolvedClientTimeZone()
+-        result = toSessionResult(await this.remote.session.prompt({
++        return toSessionResult(await this.remote.session.prompt({
+           requestId: requestId ?? randomUUID() as SessionRequestId,
+           sessionId: this.sessionId,
+           mode,
+           content,
+           clientTimeZone,
+         }, signal))
+-      } else if (this.address.mode === 'one-shot') {
+-        result = {
++      }
++      if (this.address.mode === 'one-shot') {
++        return {
+           ok: false,
+           error: {
+             code: 'subagent-not-resumable',
+@@ -243,30 +235,64 @@ export class Session implements SessionFace {
+             details: { childSessionId: this.address.childSessionId },
+           },
+         }
+-      } else {
+-        if (content.some(part => part.type === 'image')) {
+-          result = {
+-            ok: false,
+-            error: {
+-              code: 'attachment-error',
+-              message: 'Image input is unavailable for subagent continuations.',
+-              details: { reason: 'SUBAGENT_IMAGE_UNSUPPORTED' },
+-            },
+-          }
+-        } else {
+-          const routed = toSessionResult(await this.remote.subagents.prompt({
+-            requestId: randomUUID() as SessionRequestId,
+-            parentSessionId: this.address.parentSessionId,
+-            childSessionId: this.address.childSessionId,
+-            mode: this.address.mode,
+-            content: content.flatMap(part => part.type === 'text'
+-              ? [{ type: 'text' as const, text: part.text }]
+-              : []),
+-            clientTimeZone: resolvedClientTimeZone(),
+-          }, signal))
+-          result = routed.ok ? { ok: true, value: { accepted: true } } : routed
++      }
++      if (content.some(part => part.type === 'image')) {
++        return {
++          ok: false,
++          error: {
++            code: 'attachment-error',
++            message: 'Image input is unavailable for subagent continuations.',
++            details: { reason: 'SUBAGENT_IMAGE_UNSUPPORTED' },
++          },
+         }
+       }
++      const routed = toSessionResult(await this.remote.subagents.prompt({
++        requestId: randomUUID() as SessionRequestId,
++        parentSessionId: this.address.parentSessionId,
++        childSessionId: this.address.childSessionId,
++        mode: this.address.mode,
++        content: content.flatMap(part => part.type === 'text' ? [{ type: 'text' as const, text: part.text }] : []),
++        clientTimeZone: resolvedClientTimeZone(),
++      }, signal))
++      return routed.ok ? { ok: true, value: { accepted: true } } : routed
++    })
++  }
++
++  /**
++   * Run one capability-owned prompt transport through the Session's normal settlement policy.
++   * @param requestId - identity minted by {@link beginSubmission}.
++   * @param submit - authenticated transport operation returning a Session-compatible result.
++   * @returns the settled prompt result.
++   */
++  promptPrepared(
++    requestId: SessionRequestId,
++    submit: () => Promise<ClientResult<{ accepted: true }>>,
++  ): Promise<ClientResult<{ accepted: true }>> {
++    if (this.address !== undefined) {
++      return this.settlePrompt(requestId, async () => ({
++        ok: false,
++        error: {
++          code: 'attachment-error',
++          message: 'Document input is unavailable for subagent continuations.',
++          details: { reason: 'SUBAGENT_DOCUMENT_UNSUPPORTED' },
++        },
++      }))
++    }
++    return this.settlePrompt(requestId, submit)
++  }
++
++  private async settlePrompt(
++    requestId: SessionRequestId | undefined,
++    submit: () => Promise<ClientResult<{ accepted: true }>>,
++  ): Promise<ClientResult<{ accepted: true }>> {
++    this.promptError = null
++    this.lastAgentError = null
++    this.promptAttempted = true
++    if (this.blankBit) this.firstPromptPendingTurn = true
++    this.notifier.markDirty()
++    let result: ClientResult<{ accepted: true }>
++    try {
++      result = await submit()
+     } catch (error) {
+       result = transportResult(error)
+     }
+@@ -276,14 +302,6 @@ export class Session implements SessionFace {
+       this.notifier.markDirty()
+       return result
+     }
+-    // Blank flips on ACCEPTANCE, not attempt: an accepted prompt starts the
+-    // conversation's first turn on the host (the host criterion — a logged
+-    // turn/start — is fact, not optimism; standalone command and projection
+-    // events never flip it), while a rejected first prompt must keep the
+-    // session blank — the client-side blank mirror only ever lowers, so
+-    // flipping early on a failure would surface the session forever and
+-    // strip its connectWorkspace reuse eligibility against the host's
+-    // authority.
+     if (this.blankBit) {
+       this.blankBit = false
+       this.options.onEngaged?.(this)
+diff --git a/packages/api/session-controller/src/commands.ts b/packages/api/session-controller/src/commands.ts
+index 48c41f3aa143d420890a4ad244d5b7b75b7d3eb4..cae9940f2ae4d5b6b8f57b0d88d48629f8b33c0d 100644
+--- a/packages/api/session-controller/src/commands.ts
++++ b/packages/api/session-controller/src/commands.ts
+@@ -281,6 +281,34 @@ export class SessionCommandController {
+    * @returns acknowledgement that the Agent accepted the prompt.
+    */
+   async prompt(request: SessionPromptRequest): Promise<SessionPromptValue> {
++    const hasImage = request.content.some(part => part.type === 'image')
++    try {
++      return await this.promptPrepared(
++        request,
++        hasImage,
++        () => durablePromptContent(this.ctx, request.content),
++      )
++    } catch (error) {
++      if (error instanceof TypertRemoteFailure) throw error
++      if (error instanceof AttachmentError) {
++        reject('attachment-error', error.message, { reason: error.code })
++      }
++      reject('agent-busy', 'prompt rejected', { reason: String(error) })
++    }
++  }
++
++  /**
++   * Submit content prepared by a Host capability while preserving Session prompt policy.
++   * @param request - Session identity, source id, mode, and optional client time zone.
++   * @param hasImage - whether preparation will admit image bytes.
++   * @param prepare - capability-owned validation and durable content preparation.
++   * @returns acceptance after the Agent owns the resulting user message.
++   */
++  async promptPrepared(
++    request: Omit<SessionPromptRequest, 'content'>,
++    hasImage: boolean,
++    prepare: () => Promise<ContentBlock[]>,
++  ): Promise<SessionPromptValue> {
+     const clientTimeZone = request.clientTimeZone === undefined
+       ? undefined
+       : canonicalClientTimeZone(request.clientTimeZone)
+@@ -305,31 +333,21 @@ export class SessionCommandController {
+       rpcId: request.requestId,
+       ...(clientTimeZone === undefined ? {} : { clientTimeZone }),
+     }
+-    const hasImage = request.content.some(part => part.type === 'image')
+     const admit = async (): Promise<SessionPromptValue> => {
+-      try {
+-        if (hasImage) {
+-          const current = this.agents.selectionFor(agent).current
+-          const model = await this.ctx.llm.resolveModelInfo(current.provider, current.model)
+-          if (model.inputModalities !== undefined && !model.inputModalities.includes('image')) {
+-            reject(
+-              'attachment-error',
+-              `Model "${current.model}" does not support image input.`,
+-              { reason: 'MODEL_DOES_NOT_SUPPORT_IMAGES' },
+-            )
+-          }
+-        }
+-        const content = await durablePromptContent(this.ctx, request.content)
+-        const message: UserMessage = createUserMessage({ content, source })
+-        if (request.mode === 'steer') agent.steer(message)
+-        else agent.followup(message)
+-      } catch (error) {
+-        if (error instanceof TypertRemoteFailure) throw error
+-        if (error instanceof AttachmentError) {
+-          reject('attachment-error', error.message, { reason: error.code })
++      if (hasImage) {
++        const current = this.agents.selectionFor(agent).current
++        const model = await this.ctx.llm.resolveModelInfo(current.provider, current.model)
++        if (model.inputModalities !== undefined && !model.inputModalities.includes('image')) {
++          reject(
++            'attachment-error',
++            `Model "${current.model}" does not support image input.`,
++            { reason: 'MODEL_DOES_NOT_SUPPORT_IMAGES' },
++          )
+         }
+-        reject('agent-busy', 'prompt rejected', { reason: String(error) })
+       }
++      const message: UserMessage = createUserMessage({ content: await prepare(), source })
++      if (request.mode === 'steer') agent.steer(message)
++      else agent.followup(message)
+       return { accepted: true }
+     }
+     return hasImage ? this.agents.serializeImageAdmission(agent, admit) : admit()
+diff --git a/packages/api/session-controller/src/index.ts b/packages/api/session-controller/src/index.ts
+index 342dd977ebcb7b12e6c8e4c7f9cb93c72e23261c..f2a42d4e33a450a5874aed5a43bf9184677882a4 100644
+--- a/packages/api/session-controller/src/index.ts
++++ b/packages/api/session-controller/src/index.ts
+@@ -3,6 +3,7 @@
+ import { Context } from '@deepseek-ai/cordis'
+ import z from '@deepseek-ai/schemastery'
+ import { errorChain } from '@deepseek-ai/dsh-llm'
++import type { ContentBlock } from '@deepseek-ai/dsh-llm'
+ import { canOpenNativePath, openNativePath } from '@deepseek-ai/dsh-native-command'
+ import type { SessionEvent, SessionHeader, SessionId } from '@deepseek-ai/dsh-session'
+ import type { SessionObservation } from '@deepseek-ai/dsh-session-query'
+@@ -328,6 +329,21 @@ export class SessionController extends TypertRemoteService {
+     return this.commands.prompt(request)
+   }
+ 
++  /**
++   * Submit content prepared by an authenticated Host capability without widening the Remote prompt schema.
++   * @param request - Session identity, source id, mode, and optional client time zone.
++   * @param hasImage - whether preparation will admit image bytes.
++   * @param prepare - capability-owned validation and durable content preparation.
++   * @returns acknowledgement that the Agent accepted the prompt.
++   */
++  promptPrepared(
++    request: Omit<SessionPromptRequest, 'content'>,
++    hasImage: boolean,
++    prepare: () => Promise<ContentBlock[]>,
++  ): Promise<SessionPromptValue> {
++    return this.commands.promptPrepared(request, hasImage, prepare)
++  }
++
+   /**
+    * Read one image proven reachable from the addressed Session log.
+    * @param request - Session and attachment identities used for authorization.
+diff --git a/packages/api/session-controller/src/list.ts b/packages/api/session-controller/src/list.ts
+index c9a53a6bd0209669b3e7994d0cb1aa29dfeabf2f..f15912a035586dfa324bf220378c6407e6ebcf86 100644
+--- a/packages/api/session-controller/src/list.ts
++++ b/packages/api/session-controller/src/list.ts
+@@ -3,7 +3,7 @@
+ import { stat } from 'node:fs/promises'
+ import type { Context } from '@deepseek-ai/cordis'
+ import type {} from '@deepseek-ai/dsh-agent-presets'
+-import type { ImageAttachmentLimits } from '@deepseek-ai/dsh-attachment'
++import type { DocumentAttachmentLimits, ImageAttachmentLimits } from '@deepseek-ai/dsh-attachment'
+ import type { Session, SessionEvent, SessionHeader, SessionId } from '@deepseek-ai/dsh-session'
+ import type {} from '@deepseek-ai/dsh-session-projection'
+ import type {} from '@deepseek-ai/dsh-session-projection-cache'
+@@ -41,6 +41,13 @@ const imageLimitsSchema = z.object({
+   mediaTypes: z.array(z.string()),
+ }) as unknown as z.ZodType<ImageAttachmentLimits>
+ 
++const documentLimitsSchema = z.object({
++  maxDocumentBytes: z.number().int().positive(),
++  maxDocumentsPerMessage: z.number().int().positive(),
++  maxMessageDocumentBytes: z.number().int().positive(),
++  mediaTypes: z.array(z.string()),
++}) as unknown as z.ZodType<DocumentAttachmentLimits>
++
+ /**
+  * Advance the Session-list metadata projection by one committed event.
+  * @param state - metadata before the event.
+@@ -109,6 +116,17 @@ export class ApiSessionList {
+         },
+         stateVersion: 1,
+       })
++      projectionCtx.sessionProjections.register<'documentLimits', null>({
++        key: 'documentLimits',
++        stateSchema: z.null(),
++        init: () => null,
++        apply: state => state,
++        wire: {
++          viewSchema: documentLimitsSchema,
++          view: () => projectionCtx.attachments.documentLimits,
++        },
++        stateVersion: 1,
++      })
+     })
+   }
+ 
+diff --git a/packages/api/session-controller/src/types.ts b/packages/api/session-controller/src/types.ts
+index 167937e3d3317bdc20878662f337f88b85ea47f8..97fc8315afe139fe7c009e5295ee807ec2b542a5 100644
+--- a/packages/api/session-controller/src/types.ts
++++ b/packages/api/session-controller/src/types.ts
+@@ -1,7 +1,7 @@
+ /** Browser-safe request, result, and lifecycle vocabulary for the Session Remote service. */
+ 
+ import type {
+-  AttachmentIdType, ImageAttachmentLimits, ImageAttachmentRef, ImageMediaType,
++  AttachmentIdType, DocumentAttachmentLimits, ImageAttachmentLimits, ImageAttachmentRef, ImageMediaType,
+ } from '@deepseek-ai/dsh-attachment'
+ import type { Branded } from '@deepseek-ai/dsh-brand'
+ import type { MessageId } from '@deepseek-ai/dsh-llm/brand'
+@@ -18,6 +18,8 @@ declare module '@deepseek-ai/dsh-session-projection/types' {
+     sessionListMetadata: SessionListMetadata
+     /** Host state for the boot-constant image-limit view. */
+     imageLimits: null
++    /** Host state for the boot-constant document-limit view. */
++    documentLimits: null
+     /** Durable model selection already used by a request and still pending for a later request. */
+     modelSelection: ModelSelectionProjectionState
+   }
+@@ -26,6 +28,8 @@ declare module '@deepseek-ai/dsh-session-projection/types' {
+     sessionListMetadata: SessionListMetadata
+     /** Image-intake limits enforced by the Session prompt endpoint. */
+     imageLimits: ImageAttachmentLimits
++    /** Document-intake limits enforced by the Document capability. */
++    documentLimits: DocumentAttachmentLimits
+     /** Durable model selection already used and selected for the next request. */
+     modelSelection: ModelSelectionProjection
+   }
+diff --git a/packages/attachment/attachment-local/src/index.ts b/packages/attachment/attachment-local/src/index.ts
+index 16b963f2259d0fc7e7a0761afb9a73eb1603e7ad..c10fe04f5dd1cf9812c37d814a9ce7c41dc77dba 100644
+--- a/packages/attachment/attachment-local/src/index.ts
++++ b/packages/attachment/attachment-local/src/index.ts
+@@ -5,22 +5,26 @@ import { Context } from '@deepseek-ai/cordis'
+ import z from '@deepseek-ai/schemastery'
+ import { AttachmentStore } from '@deepseek-ai/dsh-attachment'
+ import type {
++  DocumentAttachmentLimits,
++  FileAttachmentRef,
+   ImageAttachmentLimits,
+   ImageAttachmentRef,
+   ImageRequestPolicy,
+   RequestImageAttachment,
++  SaveFileAttachment,
+   SaveImageAttachment,
++  StoredFileAttachment,
+   StoredImageAttachment,
+ } from '@deepseek-ai/dsh-attachment'
+ import { resolveDshHome } from '@deepseek-ai/dsh-home-paths'
+ import type { NormalizationPolicy } from './normalization.ts'
+ import { CompressionLimiter } from './compression-limiter.ts'
+-import { commitPreparedImageFile, normalizedImagePath, prepareImageFile, readImageFile, validateImageFile } from './store.ts'
++import { commitPreparedImageFile, normalizedImagePath, prepareImageFile, readFileObject, readImageFile, saveFileObject, validateImageFile } from './store.ts'
+ import { readRequestImageFile, requestImageVariantId } from './request-image.ts'
+ 
+ export { canPassThroughNormalization, normalizeImage } from './normalization.ts'
+ export type { NormalizedImage, NormalizationPolicy } from './normalization.ts'
+-export { commitPreparedImageFile, prepareImageFile, readImageFile, saveImageFile, validateImageFile } from './store.ts'
++export { commitPreparedImageFile, prepareImageFile, readFileObject, readImageFile, saveFileObject, saveImageFile, validateImageFile } from './store.ts'
+ export type { PreparedImageFile } from './store.ts'
+ export { readRequestImageFile, requestImageVariantId } from './request-image.ts'
+ 
+@@ -34,6 +38,12 @@ export const DEFAULT_MAX_MESSAGE_IMAGE_BYTES = 200 * 1024 * 1024
+ export const DEFAULT_MAX_IMAGE_PIXELS = 64_000_000
+ /** Default per-side pixel cap for one submitted image. */
+ export const DEFAULT_MAX_IMAGE_DIMENSION = 8192
++/** Default maximum encoded bytes for one supported document. */
++export const DEFAULT_MAX_DOCUMENT_BYTES = 16 * 1024 * 1024
++/** Default document count in one submitted message. */
++export const DEFAULT_MAX_DOCUMENTS_PER_MESSAGE = 4
++/** Default aggregate encoded document bytes in one submitted message. */
++export const DEFAULT_MAX_MESSAGE_DOCUMENT_BYTES = 32 * 1024 * 1024
+ /**
+  * Default total-pixel budget of the stored normalized image. A larger source
+  * is admitted and downscaled proportionally, so admission bounds what rides
+@@ -65,6 +75,12 @@ export interface Config {
+   maxImagePixels?: number
+   /** Maximum intrinsic width and maximum intrinsic height accepted for one submitted image. Default: 8192px. */
+   maxImageDimension?: number
++  /** Maximum encoded bytes accepted for one supported document. */
++  maxDocumentBytes?: number
++  /** Maximum document count accepted in one submitted message. */
++  maxDocumentsPerMessage?: number
++  /** Maximum aggregate document bytes accepted in one submitted message. */
++  maxMessageDocumentBytes?: number
+   /** Total-pixel budget of the stored provider-independent normalized image. */
+   normalizedImageMaxPixels?: number
+   /** Long-edge pixel cap of the stored provider-independent normalized image, applied after the total-pixel budget. */
+@@ -148,6 +164,9 @@ export class LocalAttachmentStore extends AttachmentStore {
+     maxMessageImageBytes: z.number().step(1).min(1).default(DEFAULT_MAX_MESSAGE_IMAGE_BYTES),
+     maxImagePixels: z.number().step(1).min(1).default(DEFAULT_MAX_IMAGE_PIXELS),
+     maxImageDimension: z.number().step(1).min(1).default(DEFAULT_MAX_IMAGE_DIMENSION),
++    maxDocumentBytes: z.number().step(1).min(1).default(DEFAULT_MAX_DOCUMENT_BYTES),
++    maxDocumentsPerMessage: z.number().step(1).min(1).default(DEFAULT_MAX_DOCUMENTS_PER_MESSAGE),
++    maxMessageDocumentBytes: z.number().step(1).min(1).default(DEFAULT_MAX_MESSAGE_DOCUMENT_BYTES),
+     normalizedImageMaxPixels: z.number().step(1).min(1).default(DEFAULT_NORMALIZED_IMAGE_MAX_PIXELS),
+     normalizedImageMaxDimension: z.number().step(1).min(1).default(DEFAULT_NORMALIZED_IMAGE_MAX_DIMENSION),
+     normalizedImageMaxBytes: z.number().step(1).min(1).default(DEFAULT_NORMALIZED_IMAGE_MAX_BYTES),
+@@ -158,6 +177,7 @@ export class LocalAttachmentStore extends AttachmentStore {
+   /** Absolute versioned storage root. */
+   readonly root: string
+   readonly imageLimits: ImageAttachmentLimits
++  private readonly resolvedDocumentLimits: DocumentAttachmentLimits
+   /** Resolved provider-independent normalization policy. */
+   readonly normalizationPolicy: Readonly<NormalizationPolicy>
+   /** Resolved instance-level compression limit. */
+@@ -176,6 +196,17 @@ export class LocalAttachmentStore extends AttachmentStore {
+       maxImageDimension: config.maxImageDimension ?? DEFAULT_MAX_IMAGE_DIMENSION,
+       mediaTypes: Object.freeze(['image/png', 'image/jpeg', 'image/webp', 'image/gif'] as const),
+     })
++    this.resolvedDocumentLimits = Object.freeze({
++      maxDocumentBytes: config.maxDocumentBytes ?? DEFAULT_MAX_DOCUMENT_BYTES,
++      maxDocumentsPerMessage: config.maxDocumentsPerMessage ?? DEFAULT_MAX_DOCUMENTS_PER_MESSAGE,
++      maxMessageDocumentBytes: config.maxMessageDocumentBytes ?? DEFAULT_MAX_MESSAGE_DOCUMENT_BYTES,
++      mediaTypes: Object.freeze([
++        'application/pdf',
++        'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
++        'application/vnd.openxmlformats-officedocument.presentationml.presentation',
++        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
++      ] as const),
++    })
+     this.normalizationPolicy = Object.freeze({
+       maxPixels: config.normalizedImageMaxPixels ?? DEFAULT_NORMALIZED_IMAGE_MAX_PIXELS,
+       maxDimension: config.normalizedImageMaxDimension ?? DEFAULT_NORMALIZED_IMAGE_MAX_DIMENSION,
+@@ -193,6 +224,18 @@ export class LocalAttachmentStore extends AttachmentStore {
+     this.compression = new CompressionLimiter(compressionConcurrency)
+   }
+ 
++  override get documentLimits(): DocumentAttachmentLimits {
++    return this.resolvedDocumentLimits
++  }
++
++  override async saveFile(input: SaveFileAttachment): Promise<FileAttachmentRef> {
++    return saveFileObject(this.root, input)
++  }
++
++  override async readFile(ref: FileAttachmentRef, signal?: AbortSignal): Promise<StoredFileAttachment> {
++    return readFileObject(this.root, ref, signal)
++  }
++
+   async validateImage(input: SaveImageAttachment): Promise<void> {
+     await this.compression.run(() => validateImageFile(input, this.imageLimits, this.normalizationPolicy))
+   }
+diff --git a/packages/attachment/attachment-local/src/store.ts b/packages/attachment/attachment-local/src/store.ts
+index e5a979aec14e91ae726b5aef414b307dc0780795..26f8e40e2a97809660f0df1dc7d03f812d2734bc 100644
+--- a/packages/attachment/attachment-local/src/store.ts
++++ b/packages/attachment/attachment-local/src/store.ts
+@@ -9,9 +9,12 @@ import {
+   AttachmentId,
+ } from '@deepseek-ai/dsh-attachment'
+ import type {
++  FileAttachmentRef,
+   ImageAttachmentLimits,
+   ImageAttachmentRef,
++  SaveFileAttachment,
+   SaveImageAttachment,
++  StoredFileAttachment,
+   StoredImageAttachment,
+ } from '@deepseek-ai/dsh-attachment'
+ import { normalizeImage } from './normalization.ts'
+@@ -36,12 +39,16 @@ function displayName(value: string | undefined): string | undefined {
+   return clean === '' ? undefined : clean
+ }
+ 
+-function ensureReference(ref: ImageAttachmentRef): string {
++function ensureReference(ref: Pick<FileAttachmentRef, 'attachmentId'>): string {
+   const match = ID_PATTERN.exec(String(ref.attachmentId))
+   if (match?.[1] === undefined) throw new AttachmentError('Attachment reference is invalid.', 'INVALID_ATTACHMENT_REF')
+   return match[1]
+ }
+ 
++function objectPath(root: string, sha256: string): string {
++  return join(root, 'objects', sha256.slice(0, 2), sha256)
++}
++
+ /**
+  * Derive the absolute immutable-object path for one normalized attachment.
+  * @param root - absolute `DSH_HOME/attachments/v1` root.
+@@ -49,8 +56,7 @@ function ensureReference(ref: ImageAttachmentRef): string {
+  * @returns provider-local path without reading the object.
+  */
+ export function normalizedImagePath(root: string, ref: ImageAttachmentRef): string {
+-  const sha256 = ensureReference(ref)
+-  return join(root, 'objects', sha256.slice(0, 2), sha256)
++  return objectPath(root, ensureReference(ref))
+ }
+ 
+ async function inspectMetadata(
+@@ -183,73 +189,120 @@ async function ensureDurableHome(path: string): Promise<string> {
+ }
+ 
+ /**
+- * Publish one already verified normalized image below a versioned attachment root.
++ * Publish one immutable object after its content digest is known.
++ * 中文约束：返回前必须完成file与directory durability；Session只能记录已经返回的reference。
+  * @param root - absolute `DSH_HOME/attachments/v1` root.
+- * @param prepared - deterministic normalized bytes and reference.
+- * @returns durable content-addressed normalized image reference.
++ * @param data - exact immutable bytes.
++ * @param sha256 - expected lowercase content digest.
++ * @param failureMessage - caller-specific storage failure text.
+  */
+-export async function commitPreparedImageFile(
+-  root: string,
+-  prepared: PreparedImageFile,
+-): Promise<ImageAttachmentRef> {
+-  const normalized = prepared.data
+-  const sha256 = ensureReference(prepared.ref)
+-  if (digest(normalized) !== sha256 || normalized.byteLength !== prepared.ref.bytes) {
+-    throw new AttachmentError('Prepared attachment bytes do not match their reference.', 'ATTACHMENT_CORRUPT')
+-  }
++async function publishObject(root: string, data: Uint8Array, sha256: string, failureMessage: string): Promise<void> {
+   const bucket = join(root, 'objects', sha256.slice(0, 2))
+   const staging = join(root, 'tmp')
+-  // Establish DSH_HOME itself against the filesystem root once per process.
+-  // Every process performs that proof independently, so observing a directory
+-  // another process created can never be mistaken for durable publication.
+   const boundary = await ensureDurableHome(dirname(dirname(resolve(root))))
+   await ensureDurableDirectory(bucket, boundary)
+   await ensureDurableDirectory(staging, boundary)
+   const temporary = join(staging, randomUUID())
+-  const target = normalizedImagePath(root, prepared.ref)
++  const target = objectPath(root, sha256)
+   let handle
+   try {
+     handle = await open(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600)
+-    await handle.writeFile(normalized)
++    await handle.writeFile(data)
+     await handle.sync()
+     await handle.close()
+     handle = undefined
+     try {
+       await link(temporary, target)
+     } catch (error) {
+-      /* v8 ignore next -- Private same-filesystem directories make EEXIST the only recoverable link race. */
+       if (!(error instanceof Error && 'code' in error && error.code === 'EEXIST')) throw error
+       const existing = new Uint8Array(await readFile(target))
+       if (digest(existing) !== sha256) throw new AttachmentError('Stored attachment failed integrity verification.', 'ATTACHMENT_CORRUPT')
+     }
+-    // Windows shares the read-only attribute across hard links and refuses to
+-    // unlink either name once it is set, so discard the staging name first.
+     await unlink(temporary)
+-    // The target remains the sole link for a new object; this also restores
+-    // read-only mode when the deduplication path observes an existing object.
+     await chmod(target, 0o400)
+-    // Persist the target entry and close a concurrent bucket-creation window
+-    // before the reference can reach a session checkpoint. The dedup path
+-    // repeats both syncs because it may observe another writer's link before
+-    // that writer reaches its own durability boundary.
+     await syncDirectory(bucket)
+     await syncDirectory(join(root, 'objects'))
+   } catch (error) {
+-    /* v8 ignore next -- A descriptor can remain open only when the underlying write/sync/close operation fails. */
+-    if (handle !== undefined) await handle.close().catch(
+-      /* v8 ignore next -- Close failure is superseded by the storage operation that entered cleanup. */
+-      () => {},
+-    )
+-    await unlink(temporary).catch(
+-      /* v8 ignore next -- The callback requires a second independent staging-unlink failure. */
+-      (cleanupError: unknown) => {
+-        /* v8 ignore next -- Cleanup is best-effort only for a staging file already removed by a failed operation. */
+-        if (!(cleanupError instanceof Error && 'code' in cleanupError && cleanupError.code === 'ENOENT')) throw cleanupError
+-      },
+-    )
++    console.error('attachment-local: immutable object publication failed', error)
++    if (handle !== undefined) await handle.close().catch((cleanupError: unknown) => {
++      console.error('attachment-local: staging descriptor cleanup failed', cleanupError)
++    })
++    await unlink(temporary).catch((cleanupError: unknown) => {
++      if (!(cleanupError instanceof Error && 'code' in cleanupError && cleanupError.code === 'ENOENT')) {
++        console.error('attachment-local: staging file cleanup failed', cleanupError)
++      }
++    })
+     if (error instanceof AttachmentError) throw error
+-    throw new AttachmentError('Unable to persist image attachment.', 'ATTACHMENT_WRITE_FAILED', { cause: error })
++    throw new AttachmentError(failureMessage, 'ATTACHMENT_WRITE_FAILED', { cause: error })
++  }
++}
++
++/**
++ * Persist format-agnostic immutable bytes for documents and parser artifacts.
++ * @param root - absolute `DSH_HOME/attachments/v1` root.
++ * @param input - already-admitted bytes and metadata.
++ * @returns durable content-addressed reference.
++ */
++export async function saveFileObject(root: string, input: SaveFileAttachment): Promise<FileAttachmentRef> {
++  const sha256 = digest(input.data)
++  await publishObject(root, input.data, sha256, 'Unable to persist attachment.')
++  const name = displayName(input.name)
++  return {
++    attachmentId: AttachmentId(`sha256:${sha256}`),
++    mediaType: input.mediaType,
++    bytes: input.data.byteLength,
++    ...(name !== undefined ? { name } : {}),
++  }
++}
++
++/**
++ * Read one generic immutable object and verify digest and encoded length.
++ * @param root - absolute `DSH_HOME/attachments/v1` root.
++ * @param ref - durable reference recorded by a Document block.
++ * @param signal - optional filesystem cancellation.
++ * @returns verified immutable bytes and canonical reference.
++ */
++export async function readFileObject(
++  root: string,
++  ref: FileAttachmentRef,
++  signal?: AbortSignal,
++): Promise<StoredFileAttachment> {
++  signal?.throwIfAborted()
++  const sha256 = ensureReference(ref)
++  let data: Uint8Array
++  try {
++    data = new Uint8Array(await readFile(objectPath(root, sha256), { signal }))
++  } catch (error) {
++    console.error('attachment-local: immutable file read failed', error)
++    signal?.throwIfAborted()
++    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
++      throw new AttachmentError('Attachment object is missing.', 'ATTACHMENT_NOT_FOUND', { cause: error })
++    }
++    throw new AttachmentError('Unable to read attachment.', 'ATTACHMENT_READ_FAILED', { cause: error })
++  }
++  signal?.throwIfAborted()
++  if (digest(data) !== sha256 || data.byteLength !== ref.bytes) {
++    throw new AttachmentError('Stored attachment failed integrity verification.', 'ATTACHMENT_CORRUPT')
++  }
++  return { ref, data }
++}
++
++/**
++ * Publish one already verified normalized image below a versioned attachment root.
++ * @param root - absolute `DSH_HOME/attachments/v1` root.
++ * @param prepared - deterministic normalized bytes and reference.
++ * @returns durable content-addressed normalized image reference.
++ */
++export async function commitPreparedImageFile(
++  root: string,
++  prepared: PreparedImageFile,
++): Promise<ImageAttachmentRef> {
++  const normalized = prepared.data
++  const sha256 = ensureReference(prepared.ref)
++  if (digest(normalized) !== sha256 || normalized.byteLength !== prepared.ref.bytes) {
++    throw new AttachmentError('Prepared attachment bytes do not match their reference.', 'ATTACHMENT_CORRUPT')
+   }
++  await publishObject(root, normalized, sha256, 'Unable to persist image attachment.')
+   return prepared.ref
+ }
+ 
+diff --git a/packages/attachment/attachment/src/error.ts b/packages/attachment/attachment/src/error.ts
+index c19229872b976dc7e20b32220cd07bcc7d380395..67f9852511845c38e0a8359d85da24b9abeda7d4 100644
+--- a/packages/attachment/attachment/src/error.ts
++++ b/packages/attachment/attachment/src/error.ts
+@@ -24,6 +24,7 @@ export type AttachmentErrorCode =
+   | 'ATTACHMENT_NOT_FOUND'
+   | 'ATTACHMENT_READ_FAILED'
+   | 'ATTACHMENT_PROJECTION_UNSUPPORTED'
++  | 'FILE_ATTACHMENTS_UNSUPPORTED'
+ 
+ /** Runtime membership for structurally compatible errors crossing package boundaries. */
+ const IMAGE_ADMISSION_ERROR_CODE_SET: ReadonlySet<string> = new Set(IMAGE_ADMISSION_ERROR_CODES)
+diff --git a/packages/attachment/attachment/src/index.ts b/packages/attachment/attachment/src/index.ts
+index 4ee001b86c55aaa1da788543477ca670a24f8a5d..9f96b4bf5cdac35afb804e378013cb63eec154ec 100644
+--- a/packages/attachment/attachment/src/index.ts
++++ b/packages/attachment/attachment/src/index.ts
+@@ -3,11 +3,15 @@
+ import { Context, Service } from '@deepseek-ai/cordis'
+ import { AttachmentError } from './error.ts'
+ import type {
++  DocumentAttachmentLimits,
++  FileAttachmentRef,
+   ImageAttachmentLimits,
+   ImageAttachmentRef,
+   ImageRequestPolicy,
+   RequestImageAttachment,
++  SaveFileAttachment,
+   SaveImageAttachment,
++  StoredFileAttachment,
+   StoredImageAttachment,
+ } from './types.ts'
+ 
+@@ -18,13 +22,20 @@ export { admitEncodedImages } from './admission.ts'
+ export { requestImageDimensions } from './request-projection.ts'
+ export type {
+   AttachmentId as AttachmentIdType,
++  DocumentAttachmentLimits,
++  DocumentAttachmentRef,
++  DocumentMediaType,
+   EncodedImageAttachment,
++  FileAttachmentRef,
+   ImageAttachmentLimits,
+   ImageAttachmentRef,
+   ImageRequestPolicy,
+   ImageMediaType,
++  ParsedDocumentRef,
+   RequestImageAttachment,
++  SaveFileAttachment,
+   SaveImageAttachment,
++  StoredFileAttachment,
+   StoredImageAttachment,
+ } from './types.ts'
+ 
+@@ -43,6 +54,42 @@ export abstract class AttachmentStore extends Service {
+   /** Deployment-resolved image policy used by authoritative and fast-path validation. */
+   abstract readonly imageLimits: ImageAttachmentLimits
+ 
++  /** Deployment-resolved document admission policy. Image-only providers fail explicitly. */
++  get documentLimits(): DocumentAttachmentLimits {
++    throw new AttachmentError(
++      'The mounted attachment provider does not support generic file attachments.',
++      'FILE_ATTACHMENTS_UNSUPPORTED',
++    )
++  }
++
++  /**
++   * Persist already-admitted immutable bytes for original documents and parser artifacts.
++   * @param input - exact bytes and caller-owned metadata.
++   * @returns the durable content-addressed reference.
++   */
++  saveFile(input: SaveFileAttachment): Promise<FileAttachmentRef> {
++    void input
++    return Promise.reject(new AttachmentError(
++      'The mounted attachment provider does not support generic file attachments.',
++      'FILE_ATTACHMENTS_UNSUPPORTED',
++    ))
++  }
++
++  /**
++   * Read one generic object and verify its digest, byte length, and recorded metadata.
++   * @param ref - durable reference from a Session document block.
++   * @param signal - optional cancellation for backend read work.
++   * @returns verified immutable bytes and the canonical reference.
++   */
++  readFile(ref: FileAttachmentRef, signal?: AbortSignal): Promise<StoredFileAttachment> {
++    signal?.throwIfAborted()
++    void ref
++    return Promise.reject(new AttachmentError(
++      'The mounted attachment provider does not support generic file attachments.',
++      'FILE_ATTACHMENTS_UNSUPPORTED',
++    ))
++  }
++
+   /**
+    * Validate one image without persisting it.
+    * Batch callers validate every member before saving any member.
+diff --git a/packages/attachment/attachment/src/types.ts b/packages/attachment/attachment/src/types.ts
+index 046444cd76551380a8d1d924f27db9a002d8a93f..146fe3d501b038c8affc61a59c16d727354b9bb8 100644
+--- a/packages/attachment/attachment/src/types.ts
++++ b/packages/attachment/attachment/src/types.ts
+@@ -7,6 +7,47 @@ export type { AttachmentId } from './brand.ts'
+ /** Raster image formats accepted by the version-one attachment path. */
+ export type ImageMediaType = 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif'
+ 
++/** Human-document formats accepted by the durable document path. */
++export type DocumentMediaType =
++  | 'application/pdf'
++  | 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
++  | 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
++  | 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
++
++/** Generic immutable file-object metadata for original documents and parser artifacts. */
++export interface FileAttachmentRef {
++  /** Opaque storage identifier; never a filesystem path or bearer URL. */
++  attachmentId: AttachmentId
++  /** Caller-owned media type for this immutable object. */
++  mediaType: string
++  /** Exact stored byte length. */
++  bytes: number
++  /** Optional display name; storage providers never interpret it as a path. */
++  name?: string
++}
++
++/** Durable parser outputs associated with one original document. */
++export interface ParsedDocumentRef {
++  /** Provider id that produced this immutable parse bundle. */
++  parser: string
++  /** Complete parsed Markdown retained for document tools. */
++  markdown: FileAttachmentRef
++  /** Complete model-visible text, including attachment delimiters and metadata. */
++  modelText: FileAttachmentRef
++  /** Complete parser reading-order content list. */
++  contentList: FileAttachmentRef
++  /** Extracted raster images in parser output order. */
++  images: ImageAttachmentRef[]
++}
++
++/** Durable metadata for one supported user-authored document. */
++export interface DocumentAttachmentRef extends Omit<FileAttachmentRef, 'mediaType' | 'name'> {
++  /** Exact supported document media type admitted with the original bytes. */
++  mediaType: DocumentMediaType
++  /** Display name after path and control-character removal. */
++  name: string
++}
++
+ /** Durable, serializable reference to one immutable normalized image. */
+ export interface ImageAttachmentRef {
+   /** Opaque storage identifier; never a filesystem path or bearer URL. */
+@@ -42,6 +83,14 @@ export interface ImageAttachmentLimits {
+   mediaTypes: readonly ImageMediaType[]
+ }
+ 
++/** Deployment-resolved limits used by document upload admission. */
++export interface DocumentAttachmentLimits {
++  maxDocumentBytes: number
++  maxDocumentsPerMessage: number
++  maxMessageDocumentBytes: number
++  mediaTypes: readonly DocumentMediaType[]
++}
++
+ /** Base64-encoded image upload accompanying one wire request. */
+ export interface EncodedImageAttachment {
+   /** Declared media type, verified against the decoded bytes during admission. */
+@@ -52,6 +101,14 @@ export interface EncodedImageAttachment {
+   name?: string
+ }
+ 
++/** Generic immutable bytes to commit to the shared content-addressed store. */
++export interface SaveFileAttachment {
++  data: Uint8Array
++  mediaType: string
++  /** Optional display name; storage providers never interpret it as a path. */
++  name?: string
++}
++
+ /** Request to validate and durably commit one image. */
+ export interface SaveImageAttachment {
+   data: Uint8Array
+@@ -61,6 +118,12 @@ export interface SaveImageAttachment {
+   name?: string
+ }
+ 
++/** Stored generic file bytes returned after reference and digest verification. */
++export interface StoredFileAttachment {
++  ref: FileAttachmentRef
++  data: Uint8Array
++}
++
+ /** Stored image bytes returned after reference and digest verification. */
+ export interface StoredImageAttachment {
+   ref: ImageAttachmentRef
+diff --git a/packages/client/ui-attachment/src/client/ComposerAttachments.module.css b/packages/client/ui-attachment/src/client/ComposerAttachments.module.css
+index 770a64cef5dba2baded4adb7afe63ae88c7fcffc..1cdfd8c3f5b1138b76ce294db6e0198c2226353d 100644
+--- a/packages/client/ui-attachment/src/client/ComposerAttachments.module.css
++++ b/packages/client/ui-attachment/src/client/ComposerAttachments.module.css
+@@ -1,3 +1,34 @@
++.picker {
++  display: flex;
++  padding: 4px 12px 0;
++}
++
++.fileInput {
++  display: none;
++}
++
++.add {
++  display: grid;
++  place-items: center;
++  width: 28px;
++  height: 28px;
++  padding: 0;
++  border: none;
++  border-radius: 999px;
++  background: var(--dsw-specific-selector);
++  color: var(--dsw-alias-label-primary);
++  cursor: pointer;
++}
++
++.add:hover:not(:disabled) {
++  background: var(--dsw-alias-interactive-bg-hover-solid);
++}
++
++.add:disabled {
++  opacity: 0.5;
++  cursor: default;
++}
++
+ .rail {
+   min-width: 0;
+   padding: 4px 12px 0;
+diff --git a/packages/client/ui-attachment/src/client/ComposerAttachments.tsx b/packages/client/ui-attachment/src/client/ComposerAttachments.tsx
+index 1e45dc6230ac024154822ddca86509bf2850d791..553c6bc24acfb65d11358ebf9fa9f0824469e376 100644
+--- a/packages/client/ui-attachment/src/client/ComposerAttachments.tsx
++++ b/packages/client/ui-attachment/src/client/ComposerAttachments.tsx
+@@ -1,7 +1,10 @@
+ import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
++import type { ChangeEvent } from 'react'
+ import type {
+   ComposerAttachment, ComposerAttachmentsProps,
+ } from '@deepseek-ai/dsh-client-ui-conversation/client'
++import type { PropsRenderSlots } from '@deepseek-ai/dsh-client-ui-slots'
++import { IconPaperclipOutline16, Tooltip } from '@deepseek-ai/dsh-client-ui-primitives'
+ import { AttachmentRail } from '../AttachmentRail.tsx'
+ import type { AttachmentRailItem } from '../AttachmentRail.tsx'
+ import { DropOverlay } from '../DropOverlay.tsx'
+@@ -15,12 +18,16 @@ interface ComposerRailItem extends AttachmentRailItem {
+ }
+ 
+ /** Draft-image rail, document drop target, and original-image preview slot entry. */
++type Props = ComposerAttachmentsProps & PropsRenderSlots<'conversation.input.attachments.documents'>
++
+ export function ComposerAttachments({
+-  attachments, canAcceptDrop, onAddImages, onRemoveImage, dropLimits, t,
+-}: ComposerAttachmentsProps) {
++  attachments, documents, canAcceptDrop, onAddFiles, onRemoveImage, onRemoveDocument,
++  fileDropLabels, dropLimits, t, renderSlot,
++}: Props) {
+   const [preview, setPreview] = useState<ComposerAttachment | null>(null)
+   const [dragActive, setDragActive] = useState(false)
+   const dragDepth = useRef(0)
++  const fileInput = useRef<HTMLInputElement>(null)
+   const closePreview = useCallback(() => { setPreview(null) }, [])
+ 
+   useEffect(() => {
+@@ -62,7 +69,7 @@ export function ComposerAttachments({
+       if (dataTransfer === null) return
+       event.preventDefault()
+       reset()
+-      if (canAcceptDrop) onAddImages([...dataTransfer.files])
++      if (canAcceptDrop) onAddFiles([...dataTransfer.files])
+     }
+     document.addEventListener('dragenter', onDragEnter)
+     document.addEventListener('dragover', onDragOver)
+@@ -76,7 +83,14 @@ export function ComposerAttachments({
+       document.removeEventListener('drop', onDrop)
+       window.removeEventListener('dragend', reset)
+     }
+-  }, [canAcceptDrop, onAddImages])
++  }, [canAcceptDrop, onAddFiles])
++
++  const chooseFiles = useCallback(() => { fileInput.current?.click() }, [])
++  const onFilesChosen = useCallback((event: ChangeEvent<HTMLInputElement>) => {
++    const files = event.currentTarget.files
++    if (files !== null && files.length > 0) onAddFiles([...files])
++    event.currentTarget.value = ''
++  }, [onAddFiles])
+ 
+   const railItems = useMemo<ComposerRailItem[]>(() => attachments.map(attachment => ({
+     id: attachment.id,
+@@ -91,9 +105,28 @@ export function ComposerAttachments({
+       {dragActive && (
+         <DropOverlay
+           disabled={!canAcceptDrop}
+-          labels={dropOverlayLabels(t, canAcceptDrop, dropLimits)}
++          labels={canAcceptDrop && fileDropLabels !== undefined
++          ? fileDropLabels
++          : dropOverlayLabels(t, canAcceptDrop, dropLimits)}
+         />
+       )}
++      <div className={css.picker}>
++        <input
++          ref={fileInput}
++          className={css.fileInput}
++          type="file"
++          multiple
++          accept="image/png,image/jpeg,image/webp,image/gif,.pdf,.docx,.pptx,.xlsx"
++          disabled={!canAcceptDrop}
++          onChange={onFilesChosen}
++        />
++        <Tooltip label={t('attachment.add')} side="top">
++          <button type="button" className={css.add} aria-label={t('attachment.add')} disabled={!canAcceptDrop} onClick={chooseFiles}>
++            <IconPaperclipOutline16 />
++          </button>
++        </Tooltip>
++      </div>
++      {renderSlot('conversation.input.attachments.documents', { documents, onRemoveDocument })}
+       {railItems.length > 0 && (
+         <div className={css.rail}>
+           <AttachmentRail
+diff --git a/packages/client/ui-attachment/src/client/MessageImages.tsx b/packages/client/ui-attachment/src/client/MessageImages.tsx
+index c84914db543de23165732809bbe9c723b34dfa90..70b28eb66089203432df9efed6368923c4409754 100644
+--- a/packages/client/ui-attachment/src/client/MessageImages.tsx
++++ b/packages/client/ui-attachment/src/client/MessageImages.tsx
+@@ -1,8 +1,30 @@
++import type { ReactNode } from 'react'
+ import type { MessageImagesProps } from '@deepseek-ai/dsh-client-ui-chat/client'
++import type { MessageImagesOwnerProps } from '@deepseek-ai/dsh-client-ui-conversation/client'
++import type { PropsLocale, PropsRenderSlots, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots'
++import type {} from '@deepseek-ai/dsh-client-ui-trajectory/client'
+ import { ImageGallery } from '../MessageImage.tsx'
+ import { messageImageLabels } from './labels.ts'
+ 
+-/** Historical message-image slot entry. */
+-export function MessageImages({ images, loadImage, align, t }: MessageImagesProps) {
+-  return <ImageGallery images={images} load={loadImage} align={align} labels={messageImageLabels(t)} />
++function AttachmentGallery({ images, loadImage, align, t, documentCards }: Omit<MessageImagesOwnerProps, 'documents'> & PropsLocale<'conversation'> & { documentCards: ReactNode }) {
++  return (
++    <>
++      {documentCards}
++      <ImageGallery images={images} load={loadImage} align={align} labels={messageImageLabels(t)} />
++    </>
++  )
++}
++
++/** Chat attachment slot entry. */
++export function MessageImages({ images, documents = [], loadImage, align, t, renderSlot }: MessageImagesProps) {
++  return <AttachmentGallery images={images} loadImage={loadImage} align={align} t={t} documentCards={renderSlot('conversation.message.images.documents', { documents })} />
++}
++
++type TrajectoryProps = PropsRuntime<'conversation.trajectory.images'>
++  & PropsRenderSlots<'conversation.trajectory.images.documents'>
++  & PropsLocale<'conversation'>
++
++/** Trajectory attachment slot entry. */
++export function TrajectoryImages({ images, documents = [], loadImage, align, t, renderSlot }: TrajectoryProps) {
++  return <AttachmentGallery images={images} loadImage={loadImage} align={align} t={t} documentCards={renderSlot('conversation.trajectory.images.documents', { documents })} />
+ }
+diff --git a/packages/client/ui-attachment/src/client/index.ts b/packages/client/ui-attachment/src/client/index.ts
+index 8fe94f64ee171798431716e3765e446ca95c935f..a045a3433ef7984df767ce00000ef52deaa9a5d6 100644
+--- a/packages/client/ui-attachment/src/client/index.ts
++++ b/packages/client/ui-attachment/src/client/index.ts
+@@ -5,7 +5,7 @@ import type {} from '@deepseek-ai/dsh-client-ui-conversation/client'
+ import type {} from '@deepseek-ai/dsh-client-ui-renderer/client'
+ import type {} from '@deepseek-ai/dsh-client-ui-trajectory/client'
+ import { ComposerAttachments } from './ComposerAttachments.tsx'
+-import { MessageImages } from './MessageImages.tsx'
++import { MessageImages, TrajectoryImages } from './MessageImages.tsx'
+ 
+ /** Slot registry required by this presentation plugin. */
+ export const inject = ['slots']
+@@ -15,13 +15,22 @@ export function apply(ctx: ClientContext): void {
+   ctx.slots.inject('conversation.input.attachments', () => ctx.slots.register({
+     name: 'conversation.input.attachments',
+     locale: 'conversation',
++    children: {
++      'conversation.input.attachments.documents': { kind: 'single', scope: 'session-maybe' },
++    },
+   }, ComposerAttachments))
+   ctx.slots.inject('conversation.message.images', () => ctx.slots.register({
+     name: 'conversation.message.images',
+     locale: 'conversation',
++    children: {
++      'conversation.message.images.documents': { kind: 'single', scope: 'session' },
++    },
+   }, MessageImages))
+   ctx.slots.inject('conversation.trajectory.images', () => ctx.slots.register({
+     name: 'conversation.trajectory.images',
+     locale: 'conversation',
+-  }, MessageImages))
++    children: {
++      'conversation.trajectory.images.documents': { kind: 'single', scope: 'session' },
++    },
++  }, TrajectoryImages))
+ }
+diff --git a/packages/client/ui-attachment/tests/composer-attachments.client.spec.tsx b/packages/client/ui-attachment/tests/composer-attachments.client.spec.tsx
+index ef77068f7e017845bd400c96bb63340aa0b3cc16..b5f9c55df4a2d75f99df8ab17755b3b20f345a2a 100644
+--- a/packages/client/ui-attachment/tests/composer-attachments.client.spec.tsx
++++ b/packages/client/ui-attachment/tests/composer-attachments.client.spec.tsx
+@@ -53,15 +53,16 @@ function attachment(id: string, name = `${id}.png`): ComposerAttachment {
+   }
+ }
+ 
+-function props(overrides: Partial<ComposerAttachmentsOwnerProps> = {}): ComposerAttachmentsProps {
++function props(overrides: Partial<ComposerAttachmentsOwnerProps> = {}): Parameters<typeof ComposerAttachments>[0] {
+   return {
+     attachments: [],
+     canAcceptDrop: true,
+     onAddImages: () => {},
+     onRemoveImage: () => {},
+     t,
++    renderSlot: () => null,
+     ...overrides,
+-  } as unknown as ComposerAttachmentsProps
++  } as unknown as Parameters<typeof ComposerAttachments>[0]
+ }
+ 
+ describe('ComposerAttachments', () => {
+diff --git a/packages/client/ui-attachment/tests/message-image.client.spec.tsx b/packages/client/ui-attachment/tests/message-image.client.spec.tsx
+index 76a720b983be3c54d4af91435f5b82ecf746685c..62475e6924e1373611d7035b4319329d458d07e7 100644
+--- a/packages/client/ui-attachment/tests/message-image.client.spec.tsx
++++ b/packages/client/ui-attachment/tests/message-image.client.spec.tsx
+@@ -261,6 +261,7 @@ describe('ImageGallery', () => {
+     }
+     const props: MessageImagesProps = {
+       sessionId: 'message-images-test' as MessageImagesProps['sessionId'],
++      SessionProvider: ({ children }) => children,
+       useSession,
+       useSessions,
+       useSessionPendingInteraction,
+@@ -281,6 +282,7 @@ describe('ImageGallery', () => {
+       loadImage,
+       align: 'end',
+       t,
++      renderSlot: () => null,
+     }
+     const view = render(<MessageImages {...props} />)
+     await waitFor(() => { expect(view.getByAltText('history.png')).toBeTruthy() })
+diff --git a/packages/client/ui-chat/src/client/chat/MessageItem.tsx b/packages/client/ui-chat/src/client/chat/MessageItem.tsx
+index 467e486ecb3b28ddf7aa99281ad231032a98a76c..d89c77009fb52bdf7992f8f35c14553bb5e798ed 100644
+--- a/packages/client/ui-chat/src/client/chat/MessageItem.tsx
++++ b/packages/client/ui-chat/src/client/chat/MessageItem.tsx
+@@ -11,14 +11,17 @@ import { MessageIconActions } from './MessageIconActions.tsx'
+ import css from './MessageItem.module.css'
+ 
+ type UserImage = Extract<UserMessageNode['content'][number], { type: 'image' }>
++type UserDocument = Extract<UserMessageNode['content'][number], { type: 'document' }>
+ 
+ function contentParts(content: readonly unknown[]): {
+   text: string
+   images: { attachment: UserImage['attachment'] }[]
++  documents: { name: string; mediaType: string; bytes: number }[]
+   rest: unknown[]
+ } {
+   const texts: string[] = []
+   const images: { attachment: UserImage['attachment'] }[] = []
++  const documents: { name: string; mediaType: string; bytes: number }[] = []
+   const rest: unknown[] = []
+   for (const block of content) {
+     const b = block as { type?: string; text?: string; attachment?: unknown }
+@@ -26,9 +29,13 @@ function contentParts(content: readonly unknown[]): {
+     else if (b.type === 'image' && b.attachment !== undefined) {
+       images.push({ attachment: (b as UserImage).attachment })
+     }
++    else if (b.type === 'document' && b.attachment !== undefined) {
++      const attachment = (b as UserDocument).attachment
++      documents.push({ name: attachment.name, mediaType: attachment.mediaType, bytes: attachment.bytes })
++    }
+     else rest.push(block)
+   }
+-  return { text: texts.join(''), images, rest }
++  return { text: texts.join(''), images, documents, rest }
+ }
+ 
+ function retrySeconds(milliseconds: number): number {
+@@ -164,7 +171,7 @@ function UserStyleBubble({
+   previewImages?: readonly MessageImageSource[]
+   t: ChatViewSlotProps['t']
+ }): ReactNode {
+-  const { text, images: contentImages, rest } = contentParts(content)
++  const { text, images: contentImages, documents, rest } = contentParts(content)
+   const images = previewImages ?? contentImages
+   const truncated = (total: number): string => t('json.truncated', { total })
+   const showBubble = text !== '' || rest.length > 0
+@@ -176,7 +183,7 @@ function UserStyleBubble({
+       data-time-hover-root
+     >
+       <div className={css.userStack}>
+-        {renderMessageImages({ images, align: 'end' })}
++        {renderMessageImages({ images, documents, align: 'end' })}
+         {showBubble && <div className={css.bubble}>
+           {projectUserText(text, referenceLabels)}
+           {rest.map((block, i) => <JsonBlock key={i} label={t('message.extraBlock')} payload={block} truncatedLabel={truncated} />)}
+diff --git a/packages/client/ui-chat/src/client/contract/slots.ts b/packages/client/ui-chat/src/client/contract/slots.ts
+index 307d8f703b013962d19212618c522ef35feec0d2..0183aede0996a91d4de2f17bdf54e0b333708eac 100644
+--- a/packages/client/ui-chat/src/client/contract/slots.ts
++++ b/packages/client/ui-chat/src/client/contract/slots.ts
+@@ -1,7 +1,7 @@
+ /** Chat-owned Slot declarations and composed component props. */
+ import type { MessageId } from '@deepseek-ai/dsh-llm/brand'
+ import type {
+-  ConversationTurnDataMap, MessageImageLoader, MessageImagesOwnerProps, RenderMessageImages, TurnLocation,
++  ConversationTurnDataMap, MessageDocumentSource, MessageImageLoader, MessageImagesOwnerProps, RenderMessageImages, TurnLocation,
+ } from '@deepseek-ai/dsh-client-ui-conversation/client'
+ import type {
+   InjectFace, PropsLocale, PropsRenderSlots, PropsRuntime, PropsStore, SlotHookFactory,
+@@ -136,7 +136,9 @@ export type ChatViewSlotProps =
+   & PropsLocale<'chat'>
+ 
+ /** Full props of the durable-message image renderer. */
+-export type MessageImagesProps = PropsRuntime<'conversation.message.images'> & PropsLocale<'conversation'>
++export type MessageImagesProps = PropsRuntime<'conversation.message.images'>
++  & PropsRenderSlots<'conversation.message.images.documents'>
++  & PropsLocale<'conversation'>
+ 
+ /** Details-panel callbacks. */
+ export interface DetailsInjected {
+@@ -182,6 +184,7 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
+      * registration replaces the shipped gallery; without one, images are omitted.
+      */
+     'conversation.message.images': { kind: 'single'; scope: 'session'; owner: MessageImagesOwnerProps }
++    'conversation.message.images.documents': { kind: 'single'; scope: 'session'; owner: { documents: readonly MessageDocumentSource[] } }
+     /**
+      * Command row keyed by the command name. The component receives the folded
+      * command lifecycle and linked compaction when present. Reusing a key
+diff --git a/packages/client/ui-conversation/src/client/apply.ts b/packages/client/ui-conversation/src/client/apply.ts
+index b154e73f4abc7034d93cac9b4634c65483731a08..8c9c1a2c7a2a7d2a3ea02e7931959065589d19dc 100644
+--- a/packages/client/ui-conversation/src/client/apply.ts
++++ b/packages/client/ui-conversation/src/client/apply.ts
+@@ -254,6 +254,10 @@ export function apply(ctx: Context): void {
+           addImages: undefined,
+           removeImage: undefined,
+           draftImages: undefined,
++          addFiles: undefined,
++          resolveDocumentDropLabels: undefined,
++          removeDocument: undefined,
++          draftDocuments: undefined,
+           resolveSubmitMode: (running, gesture, steeringAvailable) =>
+             submissionPolicy.resolve(running, gesture, steeringAvailable),
+           toggleCommandMenu: undefined,
+@@ -269,25 +273,51 @@ export function apply(ctx: Context): void {
+       const conversation = concreteConversation(ctx)
+       const shell = inputHub.shell(sessionId)
+       const inputTriggers = inputHub.inputTriggers(sessionId)
++      const documentPromptAvailable = ctx.get('documentPrompt') !== undefined
++      const addFiles: NonNullable<ComposerBarInjected['addFiles']> = (imageFiles, documentFiles, limits) => {
++        let images: ReturnType<ConversationController['createDraftImages']> = []
++        let documents: ReturnType<ConversationController['createDraftDocuments']> = []
++        try {
++          if (documentFiles.length > 0) {
++            if (limits === undefined) throw new Error('conversation.addFiles: document limits unavailable')
++            documents = conversation.createDraftDocuments(documentFiles, limits, shell.snapshot.imageIds)
++          }
++          images = conversation.createDraftImages(imageFiles)
++          const ids = [
++            ...images.map(image => image.id),
++            ...documents.map(document => document.id),
++          ]
++          if (!shell.addImages(ids)) {
++            conversation.releaseDraftImages(images)
++            for (const document of documents) conversation.releaseDraftDocument(document.id)
++          }
++          return null
++        } catch (error: unknown) {
++          conversation.releaseDraftImages(images)
++          for (const document of documents) conversation.releaseDraftDocument(document.id)
++          if (error instanceof UnsupportedImageMediaTypeError) return t('image.unsupportedType')
++          return error instanceof Error ? error.message : String(error)
++        }
++      }
+       return {
+         keyboard: shell,
+-        addImages: (files) => {
+-          try {
+-            const images = conversation.createDraftImages(files)
+-            if (!shell.addImages(images.map(image => image.id))) {
+-              conversation.releaseDraftImages(images)
+-            }
+-            return null
+-          } catch (error: unknown) {
+-            if (error instanceof UnsupportedImageMediaTypeError) return t('image.unsupportedType')
+-            return error instanceof Error ? error.message : String(error)
+-          }
+-        },
++        addImages: files => addFiles(files, [], undefined),
++        addFiles,
+         removeImage: (id) => {
+           conversation.releaseDraftImage(id)
+           shell.removeImage(id)
+         },
+         draftImages: ids => conversation.draftImages(ids),
++        resolveDocumentDropLabels: documentPromptAvailable
++          ? limits => conversation.documentDropLabels(limits)
++          : undefined,
++        removeDocument: documentPromptAvailable
++          ? (id) => {
++              conversation.releaseDraftDocument(id)
++              shell.removeImage(id)
++            }
++          : undefined,
++        draftDocuments: documentPromptAvailable ? ids => conversation.draftDocuments(ids) : undefined,
+         resolveSubmitMode: (running, gesture, steeringAvailable) =>
+           submissionPolicy.resolve(running, gesture, steeringAvailable),
+         toggleCommandMenu: inputTriggers === undefined
+diff --git a/packages/client/ui-conversation/src/client/contract/slots.ts b/packages/client/ui-conversation/src/client/contract/slots.ts
+index 377a75ee0019ac0b791bf659ac390df1bd46d81a..9b8cc42deb4c58fc8e00fc54aa244b829f9968f8 100644
+--- a/packages/client/ui-conversation/src/client/contract/slots.ts
++++ b/packages/client/ui-conversation/src/client/contract/slots.ts
+@@ -34,17 +34,45 @@ export interface ComposerAttachment {
+   height?: number
+ }
+ 
++/** Document intake limits projected from the mounted Host attachment provider. */
++export interface ComposerDocumentLimits {
++  readonly maxDocumentBytes: number
++  readonly maxDocumentsPerMessage: number
++  readonly maxMessageDocumentBytes: number
++  readonly mediaTypes: readonly string[]
++}
++
++/** Browser-owned document that has not crossed the durable Host boundary. */
++export interface ComposerDocumentAttachment {
++  kind: 'document'
++  id: DraftAttachmentId
++  file: File
++}
++
+ /** Input state handed to the optional attachment presentation plugin. */
++export interface ComposerDocumentsOwnerProps {
++  documents: readonly ComposerDocumentAttachment[]
++  onRemoveDocument: (id: DraftAttachmentId) => void
++}
++
+ export interface ComposerAttachmentsOwnerProps {
+   /** Browser-owned draft images in input order. */
+   attachments: readonly ComposerAttachment[]
+-  /** Whether a document-level file drop may add images now. */
++  /** Browser-owned draft documents in input order. */
++  documents: readonly ComposerDocumentAttachment[]
++  /** Whether a document-level file drop may add attachments now. */
+   canAcceptDrop: boolean
+   /** Add one dropped batch through the composer's validation path. */
+   onAddImages: (files: readonly File[]) => void
++  /** Add one dropped or pasted file batch as a single draft transaction. */
++  onAddFiles: (files: readonly File[]) => void
+   /** Remove one draft image through the Conversation service. */
+   onRemoveImage: (id: DraftAttachmentId) => void
+-  /** Display-ready limits for the drop invitation. */
++  /** Remove one draft document through the Conversation service. */
++  onRemoveDocument: (id: DraftAttachmentId) => void
++  /** Capability-owned localized copy for mixed file drops. */
++  fileDropLabels?: { readonly title: string; readonly desc?: string } | undefined
++  /** Display-ready limits for the image drop invitation. */
+   dropLimits?: { readonly count: number; readonly size: string } | undefined
+ }
+ 
+@@ -71,10 +99,19 @@ export type MessageImageLoader = ((attachment: ImageAttachmentRef) => Promise<st
+   peek?: (attachment: ImageAttachmentRef) => string | undefined
+ }
+ 
+-/** Message image group handed to the optional attachment presentation plugin. */
++/** Display metadata for one durable Document history card. */
++export interface MessageDocumentSource {
++  readonly name: string
++  readonly mediaType: string
++  readonly bytes: number
++}
++
++/** Message attachment group handed to the optional attachment presentation plugin. */
+ export interface MessageImagesOwnerProps {
+   /** Durable references or submission-echo previews in source order. */
+   images: readonly MessageImageSource[]
++  /** Durable Document cards associated with this user message. */
++  documents?: readonly MessageDocumentSource[]
+   /** Session-authorized image URL loader for the durable arm. */
+   loadImage: MessageImageLoader
+   /** Horizontal placement inside the owning record. */
+@@ -141,6 +178,12 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
+       scope: 'session-maybe'
+       owner: ComposerAttachmentsOwnerProps
+     }
++    /** Document cards rendered inside the shared attachment rail. */
++    'conversation.input.attachments.documents': {
++      kind: 'single'
++      scope: 'session-maybe'
++      owner: ComposerDocumentsOwnerProps
++    }
+     /** Plan control inside the composer tool row. */
+     'conversation.input.plan': { kind: 'single'; scope: 'session'; owner: InputControlOwnerProps }
+     /** Model selector inside the composer tool row. */
+@@ -267,6 +310,14 @@ export interface ComposerBarInjected {
+   addImages: ((files: readonly File[]) => string | null) | undefined
+   removeImage: ((id: DraftAttachmentId) => void) | undefined
+   draftImages: ((ids: readonly DraftAttachmentId[]) => readonly ComposerAttachment[]) | undefined
++  addFiles: ((
++    imageFiles: readonly File[],
++    documentFiles: readonly File[],
++    documentLimits?: ComposerDocumentLimits,
++  ) => string | null) | undefined
++  resolveDocumentDropLabels: ((limits: ComposerDocumentLimits) => { readonly title: string; readonly desc: string }) | undefined
++  removeDocument: ((id: DraftAttachmentId) => void) | undefined
++  draftDocuments: ((ids: readonly DraftAttachmentId[]) => readonly ComposerDocumentAttachment[]) | undefined
+   resolveSubmitMode: (
+     running: boolean,
+     gesture: ComposerSubmitGesture,
+diff --git a/packages/client/ui-conversation/src/client/index.ts b/packages/client/ui-conversation/src/client/index.ts
+index 102b385e8cfedd49b769c45446b31e0b96dd1782..1b08839b96a6a937b3216da2092ca6f2d4981c29 100644
+--- a/packages/client/ui-conversation/src/client/index.ts
++++ b/packages/client/ui-conversation/src/client/index.ts
+@@ -46,14 +46,14 @@ export { ConversationViewRegistry } from './conversation/view-registry.ts'
+ 
+ export type { ConversationKey } from './locales.ts'
+ export type {
+-  ComposerAttachment, ComposerAttachmentsOwnerProps, ComposerAttachmentsProps,
++  ComposerAttachment, ComposerDocumentAttachment, ComposerDocumentLimits, ComposerAttachmentsOwnerProps, ComposerAttachmentsProps,
+   ComposerBarInjected, ComposerBarOwnerProps, ComposerBarProps, ComposerChainProps,
+   ConversationHeaderActionOwnerProps, ConversationHeaderLineageOwnerProps,
+   ConversationInjected, ConversationSessionHeaderInjected, ConversationSessionHeaderSlotProps,
+   ConversationSessionInjected, ConversationSessionSlotProps, ConversationSlotProps,
+   ConversationStore, ConvViewOwnerProps, ConvViewProps, EmptyWorkspaceOwnerProps,
+   HeroAgentPresetOwnerProps, HeroBrandMarkOwnerProps, InputControlOwnerProps, InputZone,
+-  MessageImageLoader, MessageImageSource, MessageImagesOwnerProps, RenderMessageImages, UseConversation,
++  MessageDocumentSource, MessageImageLoader, MessageImageSource, MessageImagesOwnerProps, RenderMessageImages, UseConversation,
+   UseConversationViews,
+ } from './contract/slots.ts'
+ export type {
+diff --git a/packages/client/ui-conversation/src/client/locales.ts b/packages/client/ui-conversation/src/client/locales.ts
+index 9eaf2a82a02fad08032dfc50d2720b8c77d26c69..1cf4726092bea967269029a8bc9c2b335014b457 100644
+--- a/packages/client/ui-conversation/src/client/locales.ts
++++ b/packages/client/ui-conversation/src/client/locales.ts
+@@ -27,6 +27,7 @@ export const zh = {
+   'image.dropDesc': '最多 {count} 张，每张 {size}',
+   'image.dropBlocked': '当前无法添加图片',
+   'image.pending': '待发送图片',
++  'attachment.add': '添加文件',
+   'image.openOriginal': '查看原图',
+   'image.openOriginalLabel': '{label}，点击查看原图',
+   'image.remove': '移除图片 {name}',
+@@ -175,6 +176,7 @@ export const en = {
+   'image.dropDesc': 'Up to {count} images, {size} each',
+   'image.dropBlocked': 'Images cannot be added right now',
+   'image.pending': 'Pending images',
++  'attachment.add': 'Add files',
+   'image.openOriginal': 'View original',
+   'image.openOriginalLabel': '{label}, click to view original',
+   'image.remove': 'Remove image {name}',
+diff --git a/packages/client/ui-conversation/src/client/service.ts b/packages/client/ui-conversation/src/client/service.ts
+index 2fb0c99b51092091815af04a172699de24cd867d..0321824f6ada49487995ec01f4487e2b51d5ef47 100644
+--- a/packages/client/ui-conversation/src/client/service.ts
++++ b/packages/client/ui-conversation/src/client/service.ts
+@@ -18,7 +18,7 @@ import type {
+ } from '@deepseek-ai/dsh-api-session-controller/client'
+ import type { SessionId } from '@deepseek-ai/dsh-session/types'
+ import type { ImageMediaType } from '@deepseek-ai/dsh-attachment'
+-import type { ComposerAttachment } from './contract/slots.ts'
++import type { ComposerAttachment, ComposerDocumentAttachment, ComposerDocumentLimits } from './contract/slots.ts'
+ import type { QueueAction, QueueItemId } from './contract/queue.ts'
+ import type { ComposerBlocks } from './contract/composer-blocks.ts'
+ import type {
+@@ -26,6 +26,35 @@ import type {
+ } from './contract/input.ts'
+ import type { InputSubmitMode } from './contract/composer-submission.ts'
+ 
++type DocumentMediaType =
++  | 'application/pdf'
++  | 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
++  | 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
++  | 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
++
++type DocumentRequestId = ReturnType<SessionFace['beginSubmission']>['requestId']
++
++type SerializedDraftAttachment =
++  | ({ readonly type: 'image' } & SubmitImageAttachment)
++  | { readonly type: 'document'; readonly mediaType: DocumentMediaType; readonly data: string; readonly name: string }
++
++interface DocumentPromptClient {
++  commandUnsupported(): string
++  dropLabels(limits: ComposerDocumentLimits): { readonly title: string; readonly desc: string }
++  validateIntake(
++    files: readonly File[],
++    existing: readonly ComposerDocumentAttachment[],
++    limits: ComposerDocumentLimits,
++  ): string | null
++  submit(request: {
++    readonly sessionId: SessionId
++    readonly requestId: DocumentRequestId
++    readonly mode: InputSubmitMode
++    readonly content: readonly ({ readonly type: 'text'; readonly text: string } | SerializedDraftAttachment)[]
++    readonly signal?: AbortSignal
++  }): Promise<{ readonly ok: true; readonly value: { readonly accepted: true } } | { readonly ok: false; readonly error: { readonly code: string; readonly message: string; readonly details: Record<string, unknown> } }>
++}
++
+ /**
+  * The outward conversation face (`ctx.conversation`): the scope-addressed
+  * verbs and the input registry other plugins may reach — and exactly what a
+@@ -64,7 +93,9 @@ export interface IConversation {
+   loadOlder(): Promise<void>
+ }
+ 
+-/** Create one browser-only draft descriptor; only its id enters input state. */
++type BrowserDraftAttachment = ComposerAttachment | ComposerDocumentAttachment
++
++/** Create one browser-only image descriptor; only its id enters input state. */
+ function browserDraftAttachment(file: File): ComposerAttachment {
+   return {
+     kind: 'image',
+@@ -74,6 +105,10 @@ function browserDraftAttachment(file: File): ComposerAttachment {
+   }
+ }
+ 
++function browserDraftDocument(file: File): ComposerDocumentAttachment {
++  return { kind: 'document', id: randomUUID() as DraftAttachmentId, file }
++}
++
+ /**
+  * Fill the draft's intrinsic dimensions once the browser parses the image
+  * header (a metadata read off the preview URL, not a full decode). Failures
+@@ -149,7 +184,7 @@ export class ConversationController extends Service implements IConversation {
+   readonly input: SessionInputResolver
+   /** The per-session composer-block registry. */
+   readonly blocks: ComposerBlocks
+-  private readonly draftAttachments = new Map<DraftAttachmentId, ComposerAttachment>()
++  private readonly draftAttachments = new Map<DraftAttachmentId, BrowserDraftAttachment>()
+ 
+   /**
+    * @param ctx - owning root context (the plugin apply context; the service
+@@ -164,7 +199,7 @@ export class ConversationController extends Service implements IConversation {
+     this.blocks = config.blocks
+     ctx.effect(() => () => {
+       for (const attachment of this.draftAttachments.values()) {
+-        revokePreview(attachment.previewUrl)
++        if (attachment.kind === 'image') revokePreview(attachment.previewUrl)
+       }
+       this.draftAttachments.clear()
+     }, 'conversation draft attachments')
+@@ -183,15 +218,12 @@ export class ConversationController extends Service implements IConversation {
+   }
+ 
+   /**
+-   * Submit ordered draft images with text through one host admission. A local
+-   * submission echo enters the session snapshot synchronously; serialization
+-   * and the prompt round-trip start after the browser can paint it. On the
+-   * echo's observed retirement the draft images hand their preview URLs to
+-   * the durable image cache and leave the registry; on failure they stay
+-   * registered so the composer can restore them.
++   * Submit ordered draft attachments with text through one Host admission.
++   * Images and documents share the input machine's opaque id list, so failure
++   * restoration and relative order remain one transaction.
+    * @param session - target session.
+    * @param text - serialized prompt text.
+-   * @param imageIds - ordered draft-local attachment ids.
++   * @param attachmentIds - ordered draft-local attachment ids.
+    * @param mode - queue or steer delivery selected by composer policy.
+    * @param signal - optional cancellation for the complete Host admission.
+    * @returns the Host admission outcome; local attachment preparation failures reject.
+@@ -199,48 +231,75 @@ export class ConversationController extends Service implements IConversation {
+   async sendSession(
+     session: SessionFace,
+     text: string,
+-    imageIds: readonly DraftAttachmentId[],
++    attachmentIds: readonly DraftAttachmentId[],
+     mode: InputSubmitMode,
+     signal?: AbortSignal,
+   ): Promise<SubmitOutcome> {
+-    const attachments = this.draftImages(imageIds)
+-    if (attachments.length !== imageIds.length) {
+-      throw new Error('conversation.sendSession: one or more draft images are no longer available')
++    const attachments = this.draftAttachmentList(attachmentIds)
++    if (attachments.length !== attachmentIds.length) {
++      throw new Error('conversation.sendSession: one or more draft attachments are no longer available')
++    }
++    const images = attachments.filter((attachment): attachment is ComposerAttachment => attachment.kind === 'image')
++    const hasDocument = attachments.some(attachment => attachment.kind === 'document')
++    const content = async (): Promise<readonly ({ readonly type: 'text'; readonly text: string } | SerializedDraftAttachment)[]> => [
++      ...await this.serializeAttachments(attachments),
++      ...(text === '' ? [] : [{ type: 'text' as const, text }]),
++    ]
++    const submit = async (requestId: DocumentRequestId): Promise<{ readonly ok: true } | { readonly ok: false; readonly text?: string }> => {
++      if (!hasDocument) {
++        const prepared = await content()
++        const result = await session.prompt(
++          prepared as Parameters<SessionFace['prompt']>[0],
++          mode,
++          signal,
++          requestId,
++        )
++        return result.ok ? { ok: true } : { ok: false }
++      }
++      const result = await this.documentPrompt().submit({
++        sessionId: session.sessionId,
++        requestId,
++        mode,
++        content: await content(),
++        ...(signal === undefined ? {} : { signal }),
++      })
++      return result.ok ? { ok: true } : { ok: false, text: result.error.message }
+     }
++
+     if (session.getSnapshot().subagent !== null) {
+-      const uploaded = await this.serializeImages(attachments.map(attachment => attachment.file))
+-      const content = [...uploaded, ...(text === '' ? [] : [{ type: 'text' as const, text }])]
+-      const result = await session.prompt(content, mode, signal)
+-      return result.ok ? { kind: 'success' } : { kind: 'error' }
++      const result = await submit(randomUUID() as DocumentRequestId)
++      if (!result.ok) return { kind: 'error', ...(result.text === undefined ? {} : { text: result.text }) }
++      this.releaseDraftAttachments(attachments)
++      return { kind: 'success' }
+     }
++
+     let finishRetirement: ((retirement: PendingSubmissionRetirement) => void) | undefined
+     const retirement = attachments.length === 0
+       ? undefined
+       : new Promise<PendingSubmissionRetirement>((resolve) => { finishRetirement = resolve })
+     const submission = session.beginSubmission({
+       text,
+-      images: attachments.map(attachment => ({
++      images: images.map(attachment => ({
+         previewUrl: attachment.previewUrl,
+         ...(attachment.file.name === '' ? {} : { name: attachment.file.name }),
+         ...(attachment.width === undefined ? {} : { width: attachment.width }),
+         ...(attachment.height === undefined ? {} : { height: attachment.height }),
+       })),
+       onRetire: (settlement) => {
+-        this.settleSubmittedImages(session.sessionId, attachments, settlement)
++        this.settleSubmittedAttachments(session.sessionId, attachments, settlement)
+         finishRetirement?.(settlement)
+       },
+     })
+-    let content: Parameters<SessionFace['prompt']>[0]
+     try {
+       await nextPaint()
+-      const uploaded = await this.serializeImages(attachments.map(attachment => attachment.file))
+-      content = [...uploaded, ...(text === '' ? [] : [{ type: 'text' as const, text }])]
++      const result = await submit(submission.requestId)
++      if (!result.ok) {
++        return { kind: 'error', ...(result.text === undefined ? {} : { text: result.text }) }
++      }
+     } catch (error) {
+       submission.abandon()
+       throw error
+     }
+-    const result = await session.prompt(content, mode, signal, submission.requestId)
+-    if (!result.ok) return { kind: 'error' }
+     if (retirement !== undefined && (await retirement).reason !== 'observed') return { kind: 'error' }
+     return { kind: 'success' }
+   }
+@@ -260,6 +319,23 @@ export class ConversationController extends Service implements IConversation {
+     })
+   }
+ 
++  /** Register supported documents without creating object URLs. */
++  createDraftDocuments(
++    files: readonly File[],
++    limits: ComposerDocumentLimits,
++    existingIds: readonly DraftAttachmentId[],
++  ): readonly ComposerDocumentAttachment[] {
++    const existing = this.draftDocuments(existingIds)
++    const rejected = this.documentPrompt().validateIntake(files, existing, limits)
++    if (rejected !== null) throw new Error(rejected)
++    for (const file of files) documentMediaType(file.type)
++    return files.map((file) => {
++      const attachment = browserDraftDocument(file)
++      this.draftAttachments.set(attachment.id, attachment)
++      return attachment
++    })
++  }
++
+   /**
+    * Resolve ordered input-state ids to runtime-owned draft images.
+    * @param ids - draft attachment ids.
+@@ -269,7 +345,7 @@ export class ConversationController extends Service implements IConversation {
+     const attachments: ComposerAttachment[] = []
+     for (const id of ids) {
+       const attachment = this.draftAttachments.get(id)
+-      if (attachment !== undefined) attachments.push(attachment)
++      if (attachment?.kind === 'image') attachments.push(attachment)
+     }
+     return attachments
+   }
+@@ -281,34 +357,63 @@ export class ConversationController extends Service implements IConversation {
+    * @param imageIds - ordered draft-local attachment ids.
+    * @returns base64 payloads in id order.
+    */
++  /** Resolve ordered input-state ids to document drafts only. */
++  draftDocuments(ids: readonly DraftAttachmentId[]): readonly ComposerDocumentAttachment[] {
++    const attachments: ComposerDocumentAttachment[] = []
++    for (const id of ids) {
++      const attachment = this.draftAttachments.get(id)
++      if (attachment?.kind === 'document') attachments.push(attachment)
++    }
++    return attachments
++  }
++
++  /** Resolve every ordered mixed draft attachment; missing ids are omitted for caller detection. */
++  draftAttachmentList(ids: readonly DraftAttachmentId[]): readonly BrowserDraftAttachment[] {
++    const attachments: BrowserDraftAttachment[] = []
++    for (const id of ids) {
++      const attachment = this.draftAttachments.get(id)
++      if (attachment !== undefined) attachments.push(attachment)
++    }
++    return attachments
++  }
++
+   async serializeDraftImages(imageIds: readonly DraftAttachmentId[]): Promise<readonly SubmitImageAttachment[]> {
+     const attachments = this.draftImages(imageIds)
+     if (attachments.length !== imageIds.length) {
+-      throw new Error('conversation.serializeDraftImages: one or more draft images are no longer available')
++      throw new Error(this.documentPrompt().commandUnsupported())
+     }
+-    return Promise.all(attachments.map(attachment => this.encodeImage(attachment.file)))
++    const serialized: SubmitImageAttachment[] = []
++    for (const attachment of attachments) serialized.push(await this.encodeImage(attachment.file))
++    return serialized
+   }
+ 
+-  /**
+-   * Release one browser-owned draft image and preview URL.
+-   * @param id - draft attachment id.
+-   */
+-  releaseDraftImage(id: DraftAttachmentId): void {
++  /** Resolve capability-owned mixed file drop copy in the active locale. */
++  documentDropLabels(limits: ComposerDocumentLimits): { readonly title: string; readonly desc: string } {
++    return this.documentPrompt().dropLabels(limits)
++  }
++
++  /** Release one browser-owned draft attachment. */
++  releaseDraftAttachment(id: DraftAttachmentId): void {
+     const attachment = this.draftAttachments.get(id)
+     if (attachment === undefined) return
+     this.draftAttachments.delete(id)
+-    revokePreview(attachment.previewUrl)
++    if (attachment.kind === 'image') revokePreview(attachment.previewUrl)
+   }
+ 
+-  /**
+-   * Release a set of browser-owned draft images.
+-   * @param attachments - descriptors to release.
+-   */
+-  releaseDraftImages(attachments: readonly ComposerAttachment[]): void {
+-    for (const attachment of attachments) this.releaseDraftImage(attachment.id)
++  /** Release one existing image caller's draft attachment. */
++  releaseDraftImage(id: DraftAttachmentId): void {
++    this.releaseDraftAttachment(id)
+   }
+ 
+-  /** Apply one operation to a pending queue occurrence. */
++  /** Release one document draft through the same registry owner. */
++  releaseDraftDocument(id: DraftAttachmentId): void {
++    this.releaseDraftAttachment(id)
++  }
++
++  /** Release a set of image drafts. */
++  releaseDraftImages(attachments: readonly ComposerAttachment[]): void {
++    for (const attachment of attachments) this.releaseDraftAttachment(attachment.id)
++  }
+   async updateQueue(itemId: QueueItemId, action: QueueAction): Promise<void> {
+     const session = this.scopedSession('updateQueue')
+     const result = await session.updateQueue(itemId, action)
+@@ -358,34 +463,50 @@ export class ConversationController extends Service implements IConversation {
+     return sessions
+   }
+ 
+-  /**
+-   * Settle one submission's draft images when its echo retires. Observed:
+-   * each image leaves the registry, handing its preview URL to the durable
+-   * image cache (seeded under the admitted reference so the transcript node
+-   * renders immediately while the cache reads canonical bytes) or revoking it
+-   * when the cache already holds that reference. Failed: nothing changes;
+-   * the ids stay registered for the composer's rail restore.
+-   */
+-  private settleSubmittedImages(
++  /** Settle one mixed submission after its durable Session event is observed. */
++  private settleSubmittedAttachments(
+     sessionId: SessionId,
+-    attachments: readonly ComposerAttachment[],
++    attachments: readonly BrowserDraftAttachment[],
+     retirement: PendingSubmissionRetirement,
+   ): void {
+     if (retirement.reason !== 'observed') return
+     const uiConversation = this.ctx.get('uiConversation')
+-    attachments.forEach((attachment, index) => {
+-      const live = this.draftAttachments.get(attachment.id)
+-      if (live === undefined) return
++    let imageIndex = 0
++    for (const attachment of attachments) {
++      if (!this.draftAttachments.has(attachment.id)) continue
+       this.draftAttachments.delete(attachment.id)
+-      const ref = retirement.attachments[index]
+-      if (ref !== undefined && uiConversation?.seedImageUrl(sessionId, ref, attachment.previewUrl) === true) return
++      if (attachment.kind === 'document') continue
++      const ref = retirement.attachments[imageIndex++]
++      if (ref !== undefined && uiConversation?.seedImageUrl(sessionId, ref, attachment.previewUrl) === true) continue
+       revokePreview(attachment.previewUrl)
+-    })
++    }
++  }
++
++  private releaseDraftAttachments(attachments: readonly BrowserDraftAttachment[]): void {
++    for (const attachment of attachments) this.releaseDraftAttachment(attachment.id)
++  }
++
++  private documentPrompt(): DocumentPromptClient {
++    const service = this.ctx.get('documentPrompt') as unknown as DocumentPromptClient | undefined
++    if (service === undefined) throw new Error('Document prompt service is unavailable.')
++    return service
+   }
+ 
+-  /** Convert browser files to canonical base64 prompt parts. */
+-  private serializeImages(images: readonly File[]): Promise<Parameters<SessionFace['prompt']>[0]> {
+-    return Promise.all(images.map(async file => ({ type: 'image' as const, ...await this.encodeImage(file) })))
++  private async serializeAttachments(attachments: readonly BrowserDraftAttachment[]): Promise<SerializedDraftAttachment[]> {
++    const serialized: SerializedDraftAttachment[] = []
++    for (const attachment of attachments) {
++      if (attachment.kind === 'image') {
++        serialized.push({ type: 'image', ...await this.encodeImage(attachment.file) })
++      } else {
++        serialized.push({
++          type: 'document',
++          mediaType: documentMediaType(attachment.file.type),
++          data: await base64Of(attachment.file),
++          name: attachment.file.name,
++        })
++      }
++    }
++    return serialized
+   }
+ 
+   /** Canonical base64 wire form of one browser image file. */
+@@ -410,6 +531,18 @@ function imageMediaType(value: string): ImageMediaType {
+   }
+ }
+ 
++function documentMediaType(value: string): DocumentMediaType {
++  switch (value) {
++    case 'application/pdf':
++    case 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
++    case 'application/vnd.openxmlformats-officedocument.presentationml.presentation':
++    case 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet':
++      return value
++    default:
++      throw new Error(`Unsupported document media type: ${value}`)
++  }
++}
++
+ function revokePreview(url: string): void {
+   if (url.startsWith('blob:')) URL.revokeObjectURL(url)
+ }
+diff --git a/packages/client/ui-conversation/src/client/skeleton/InputBar.tsx b/packages/client/ui-conversation/src/client/skeleton/InputBar.tsx
+index d6126acdfd62b2b9be0af3fbb99c63b4435859b8..cf99cdac86bc2f308032de81baa89c040761ff5e 100644
+--- a/packages/client/ui-conversation/src/client/skeleton/InputBar.tsx
++++ b/packages/client/ui-conversation/src/client/skeleton/InputBar.tsx
+@@ -40,7 +40,8 @@ import css from './InputBar.module.css'
+ export type InputBarProps = ComposerBarProps
+ 
+ export function InputBar({
+-  useSession, useInput, inputActions, keyboard, addImages, removeImage, draftImages,
++  useSession, useInput, inputActions, keyboard, removeImage, draftImages,
++  addFiles, resolveDocumentDropLabels, removeDocument, draftDocuments,
+   resolveSubmitMode, toggleCommandMenu, stop, command, t,
+   renderSlot, useNotices, useLexicon, useMenuLauncher,
+   useProjection, sessionId, variant, disabled: inert = false, blocked,
+@@ -69,7 +70,11 @@ export function InputBar({
+     () => input === undefined || draftImages === undefined ? [] : draftImages(input.imageIds),
+     [draftImages, input?.imageIds],
+   )
+-  const empty = draft.trim() === '' && attachments.length === 0
++  const documents = useMemo(
++    () => input === undefined || draftDocuments === undefined ? [] : draftDocuments(input.imageIds),
++    [draftDocuments, input?.imageIds],
++  )
++  const empty = draft.trim() === '' && attachments.length === 0 && documents.length === 0
+   // Transient error banner (machine notices, image-intake rejections, and
+   // prompt failures): the seq keys the Toast so an identical repeated message
+   // restarts the hold-then-fade cycle instead of reusing the faded one.
+@@ -83,6 +88,7 @@ export function InputBar({
+   // The deployment's image-intake limits (absent while no attachment service
+   // is composed — the pre-check below then defers entirely to the host).
+   const imageLimits = useProjection('imageLimits')
++  const documentLimits = useProjection('documentLimits')
+   // Prompt failures are ordinary failures (no create/attach transaction exists
+   // anymore): the toast announces promptError, the draft stays in the machine,
+   // and the user resubmits. A remount over a session whose machine still holds
+@@ -134,10 +140,13 @@ export function InputBar({
+ 
+   useEffect(() => {
+     if (input === undefined || inputActions === undefined) return
+-    if (attachments.length !== input.imageIds.length) {
+-      inputActions.pruneImages(attachments.map(attachment => attachment.id))
++    if (attachments.length + documents.length !== input.imageIds.length) {
++      inputActions.pruneImages([
++        ...attachments.map(attachment => attachment.id),
++        ...documents.map(document => document.id),
++      ])
+     }
+-  }, [attachments, input?.imageIds, inputActions])
++  }, [attachments, documents, input?.imageIds, inputActions])
+ 
+   // Scroll the draft scrollport the minimum that brings the selection focus
+   // into view — the browser's own behavior for typing, performed for the
+@@ -210,46 +219,55 @@ export function InputBar({
+     return () => { el.removeEventListener('wheel', onWheel) }
+   }, [])
+ 
+-  // Intake pre-check: an addition that would break
+-  // a projected limit is refused as a whole batch, announced immediately, and
+-  // never enters the rail — no more submit-time failure rolling the rail
+-  // back. The host enforces the same limits at submit for callers that bypass
+-  // this composer.
+-  const intakeImages = useCallback((files: readonly File[]): void => {
+-    if (addImages === undefined || files.length === 0) return
+-    const rejected = ((): string | null => {
+-      if (imageLimits !== undefined) {
+-        // Format precedes limits: a batch with
+-        // a non-image must announce the format problem, not a count or size
+-        // it could never pass anyway — addImages rejects it authoritatively.
+-        if (files.some(file => !(imageLimits.mediaTypes as readonly string[]).includes(file.type))) {
+-          return addImages(files)
+-        }
+-        if (attachments.length + files.length > imageLimits.maxImagesPerMessage) {
+-          return t('image.tooMany', { count: imageLimits.maxImagesPerMessage })
+-        }
+-        if (files.some(file => file.size > imageLimits.maxImageBytes)) {
+-          return t('image.fileTooLarge', { size: imageSizeText(imageLimits.maxImageBytes) })
+-        }
+-        const total = attachments.reduce((sum, attachment) => sum + attachment.file.size, 0)
+-          + files.reduce((sum, file) => sum + file.size, 0)
+-        if (total > imageLimits.maxMessageImageBytes) {
+-          return t('image.totalTooLarge', { size: imageSizeText(imageLimits.maxMessageImageBytes) })
+-        }
+-      }
+-      return addImages(files)
+-    })()
++  // Intake pre-check: an addition that would break a projected image limit is
++  // refused before the single mixed draft transaction starts. The Host repeats
++  // every admission check for callers that bypass this composer.
++  const imageIntakeError = useCallback((files: readonly File[]): string | null => {
++    if (files.length === 0 || imageLimits === undefined) return null
++    if (files.some(file => !(imageLimits.mediaTypes as readonly string[]).includes(file.type))) {
++      return t('image.unsupportedType')
++    }
++    if (attachments.length + files.length > imageLimits.maxImagesPerMessage) {
++      return t('image.tooMany', { count: imageLimits.maxImagesPerMessage })
++    }
++    if (files.some(file => file.size > imageLimits.maxImageBytes)) {
++      return t('image.fileTooLarge', { size: imageSizeText(imageLimits.maxImageBytes) })
++    }
++    const total = attachments.reduce((sum, attachment) => sum + attachment.file.size, 0)
++      + files.reduce((sum, file) => sum + file.size, 0)
++    return total > imageLimits.maxMessageImageBytes
++      ? t('image.totalTooLarge', { size: imageSizeText(imageLimits.maxMessageImageBytes) })
++      : null
++  }, [attachments, imageLimits, t])
++
++  const intakeFiles = useCallback((files: readonly File[]): void => {
++    if (addFiles === undefined || files.length === 0) return
++    const documentTypes = draftDocuments === undefined || documentLimits === undefined
++      ? []
++      : documentLimits.mediaTypes as readonly string[]
++    const documentFiles = files.filter(file => documentTypes.includes(file.type))
++    const imageFiles = files.filter(file => !documentTypes.includes(file.type))
++    const imageRejected = imageIntakeError(imageFiles)
++    if (imageRejected !== null) {
++      showToast(imageRejected)
++      return
++    }
++    const rejected = addFiles(imageFiles, documentFiles, documentLimits)
+     if (rejected !== null) showToast(rejected)
+-  }, [addImages, attachments, imageLimits, showToast, t])
++  }, [addFiles, documentLimits, draftDocuments, imageIntakeError, showToast])
++
++  const intakeImages = useCallback((files: readonly File[]): void => {
++    intakeFiles(files)
++  }, [intakeFiles])
+ 
+-  const canAcceptDrop = !locked && !machineBusy && addImages !== undefined
++  const canAcceptDrop = !locked && !machineBusy && addFiles !== undefined
+ 
+   // The keymap handlers read live bar state through this ref so the editor
+   // registration survives re-renders without re-arming per keystroke.
+   const gate = useRef({
+-    locked, machineBusy, canSteerQueue, running, subagent, resolveSubmitMode, intakeImages,
++    locked, machineBusy, canSteerQueue, running, subagent, resolveSubmitMode, intakeFiles,
+   })
+-  gate.current = { locked, machineBusy, canSteerQueue, running, subagent, resolveSubmitMode, intakeImages }
++  gate.current = { locked, machineBusy, canSteerQueue, running, subagent, resolveSubmitMode, intakeFiles }
+ 
+   useEffect(() => {
+     if (editor === null || keyboard === undefined) return
+@@ -276,7 +294,7 @@ export function InputBar({
+           g.subagent === null,
+         ))
+       },
+-      intakeFiles: (files) => { gate.current.intakeImages(files) },
++      intakeFiles: (files) => { gate.current.intakeFiles(files) },
+       pasteText: (text) => {
+         if (gate.current.machineBusy || gate.current.locked) return
+         keyboard.paste(text)
+@@ -393,9 +411,13 @@ export function InputBar({
+         {accessory !== undefined && <div className={css.accessory}>{accessory}</div>}
+         {renderSlot('conversation.input.attachments', {
+           attachments,
++          documents,
+           canAcceptDrop,
+           onAddImages: intakeImages,
++          onAddFiles: intakeFiles,
++          fileDropLabels: documentLimits === undefined ? undefined : resolveDocumentDropLabels?.(documentLimits),
+           onRemoveImage: (id) => { removeImage?.(id) },
++          onRemoveDocument: (id) => { removeDocument?.(id) },
+           dropLimits: imageLimits === undefined ? undefined : {
+             count: imageLimits.maxImagesPerMessage,
+             size: imageSizeText(imageLimits.maxImageBytes),
+diff --git a/packages/client/ui-conversation/tests/input-bar.client.spec.tsx b/packages/client/ui-conversation/tests/input-bar.client.spec.tsx
+index 9becd7f1095f135ecd3d24b6a06f52b956fe4834..b00b618d0bd1288a552cc4dcb46760c9e2198129 100644
+--- a/packages/client/ui-conversation/tests/input-bar.client.spec.tsx
++++ b/packages/client/ui-conversation/tests/input-bar.client.spec.tsx
+@@ -173,6 +173,10 @@ function bench(over?: BenchOptions) {
+       const attachment = over?.attachments?.find(candidate => candidate.id === id)
+       return attachment === undefined ? [] : [attachment]
+     }),
++    addFiles: undefined,
++    resolveDocumentDropLabels: undefined,
++    removeDocument: undefined,
++    draftDocuments: undefined,
+     resolveSubmitMode: (running, gesture, steeringAvailable) => {
+       if (!running || !steeringAvailable) return 'queue'
+       const preferred = over?.busyEnter ?? 'queue'
+diff --git a/packages/client/ui-conversation/tests/input-matrix.client.spec.tsx b/packages/client/ui-conversation/tests/input-matrix.client.spec.tsx
+index bdb878672b080e06ec84b065b5bfbfea04a951ee..dc155229a154a0e23384ad821135146b8bf74866 100644
+--- a/packages/client/ui-conversation/tests/input-matrix.client.spec.tsx
++++ b/packages/client/ui-conversation/tests/input-matrix.client.spec.tsx
+@@ -71,6 +71,10 @@ function mountBar(shell: SessionInputShell, over?: { running?: boolean; disabled
+       file: new File([Uint8Array.of(1)], `${id}.png`, { type: 'image/png' }),
+       previewUrl: `blob:${id}`,
+     })),
++    addFiles: undefined,
++    resolveDocumentDropLabels: undefined,
++    removeDocument: undefined,
++    draftDocuments: undefined,
+     resolveSubmitMode: () => 'queue',
+     toggleCommandMenu: vi.fn(),
+     useNotices: bindSnapshotSelector(shell.notices),
+diff --git a/packages/client/ui-conversation/tests/input-scenarios.client.spec.tsx b/packages/client/ui-conversation/tests/input-scenarios.client.spec.tsx
+index ec7f586683f96d9374bc31cc0e6d8b39e4a4df43..266d2e15c742a9eb9dbbea670f98943d83b64198 100644
+--- a/packages/client/ui-conversation/tests/input-scenarios.client.spec.tsx
++++ b/packages/client/ui-conversation/tests/input-scenarios.client.spec.tsx
+@@ -160,6 +160,10 @@ async function scopedBench(register?: (inputTriggers: InputTriggerService) => vo
+       file: new File([Uint8Array.of(1)], `${id}.png`, { type: 'image/png' }),
+       previewUrl: `blob:${id}`,
+     })),
++    addFiles: undefined,
++    resolveDocumentDropLabels: undefined,
++    removeDocument: undefined,
++    draftDocuments: undefined,
+     resolveSubmitMode: () => 'queue',
+     toggleCommandMenu: (selection) => {
+       const snapshot = shell.snapshot
+diff --git a/packages/client/ui-conversation/tests/skeleton.client.spec.tsx b/packages/client/ui-conversation/tests/skeleton.client.spec.tsx
+index 40f6dfda6d1b6d04003b7c210cd600f6cbaa1d83..24632b55e94b1053793b761e047e03db40ddbe14 100644
+--- a/packages/client/ui-conversation/tests/skeleton.client.spec.tsx
++++ b/packages/client/ui-conversation/tests/skeleton.client.spec.tsx
+@@ -250,6 +250,10 @@ function mount(
+           addImages={() => null}
+           removeImage={() => {}}
+           draftImages={() => []}
++          addFiles={undefined}
++          resolveDocumentDropLabels={undefined}
++          removeDocument={undefined}
++          draftDocuments={undefined}
+           resolveSubmitMode={() => 'queue'}
+           toggleCommandMenu={vi.fn()}
+           useNotices={bindSnapshotSelector(wiring.notices)}
+diff --git a/packages/client/ui-trajectory/src/client/TrajectoryTable.tsx b/packages/client/ui-trajectory/src/client/TrajectoryTable.tsx
+index 81a428aa35fada3286b0f7b025347dc6a51a3766..8f40cb75c119394dc32963ce6733775ad7996515 100644
+--- a/packages/client/ui-trajectory/src/client/TrajectoryTable.tsx
++++ b/packages/client/ui-trajectory/src/client/TrajectoryTable.tsx
+@@ -1164,18 +1164,26 @@ function SourceBlocks({
+               gallery per image block, unlike the aggregated record gallery. */}
+           {block.attachment !== undefined
+             ? renderImages({ images: [{ attachment: block.attachment }], align: 'start' })
+-            : <pre className={css.sourceBlockContent}>{block.content}</pre>}
++            : block.document !== undefined
++              ? renderImages({ images: [], documents: [block.document], align: 'start' })
++              : <pre className={css.sourceBlockContent}>{block.content}</pre>}
+         </section>
+       ))}
+     </div>
+   )
+ }
+ 
+-function recordImages(
+-  blocks: readonly TrajectorySourceBlock[] | undefined,
+-): { readonly attachment: ImageAttachmentRef }[] {
+-  return (blocks ?? []).flatMap(block =>
+-    block.attachment !== undefined ? [{ attachment: block.attachment }] : [])
++function recordAttachments(blocks: readonly TrajectorySourceBlock[] | undefined): {
++  images: { readonly attachment: ImageAttachmentRef }[]
++  documents: NonNullable<TrajectorySourceBlock['document']>[]
++} {
++  const images: { readonly attachment: ImageAttachmentRef }[] = []
++  const documents: NonNullable<TrajectorySourceBlock['document']>[] = []
++  for (const block of blocks ?? []) {
++    if (block.attachment !== undefined) images.push({ attachment: block.attachment })
++    if (block.document !== undefined) documents.push(block.document)
++  }
++  return { images, documents }
+ }
+ 
+ function MessageImages({
+@@ -1187,11 +1195,11 @@ function MessageImages({
+   preview: boolean
+   renderImages: RenderMessageImages
+ }) {
+-  const images = recordImages(blocks)
+-  if (images.length === 0) return null
++  const { images, documents } = recordAttachments(blocks)
++  if (images.length === 0 && documents.length === 0) return null
+   return (
+     <div className={preview ? `${css.messageImages} ${css.messageImagesPreview}` : css.messageImages}>
+-      {renderImages({ images, align: 'start' })}
++      {renderImages({ images, documents, align: 'start' })}
+     </div>
+   )
+ }
+@@ -1411,10 +1419,14 @@ function ToolOutputBlocks({
+       {error && errorDetail !== undefined && errorDetail !== ''
+         && <pre className={css.resultBlockText}>{errorDetail}</pre>}
+       {blocks.map((block, index) => (
+-        block.attachment !== undefined
++        block.attachment !== undefined || block.document !== undefined
+           ? (
+             <div className={css.messageImages} key={index}>
+-              {renderImages({ images: [{ attachment: block.attachment }], align: 'start' })}
++              {renderImages({
++                images: block.attachment === undefined ? [] : [{ attachment: block.attachment }],
++                ...(block.document === undefined ? {} : { documents: [block.document] }),
++                align: 'start',
++              })}
+             </div>
+           )
+           : block.content !== ''
+@@ -1513,16 +1525,18 @@ function MarkdownRecordContent({
+     )
+   }
+   const source = markdownSource(record)
+-  const hasImages = record.cell.sourceBlocks?.some(block => block.attachment !== undefined) === true
++  const hasAttachments = record.cell.sourceBlocks?.some(
++    block => block.attachment !== undefined || block.document !== undefined,
++  ) === true
+   const hasToolCalls = record.cell.kind === 'message'
+     && record.cell.sourceBlocks?.some(block => block.type === 'tool-call') === true
+-  if (!source && !hasImages && !hasToolCalls) {
++  if (!source && !hasAttachments && !hasToolCalls) {
+     const emptyLabel = isToolCallOnly(record.cell, t)
+       ? t('record.toolCallOnly')
+       : record.cell.text || t('record.noContent')
+     return <p className={css.noPayload}>{emptyLabel}</p>
+   }
+-  if (!rendered || (!hasImages && !hasToolCalls)) {
++  if (!rendered || (!hasAttachments && !hasToolCalls)) {
+     return <MarkdownFragment text={source ?? ''} rendered={rendered} preview={preview} t={t} />
+   }
+   return (
+diff --git a/packages/client/ui-trajectory/src/client/layout.ts b/packages/client/ui-trajectory/src/client/layout.ts
+index a811e915f20d7a2247726dc6a750bb67e0697304..8676ea46dcf367243f96cf53ffa29b135e8ceffd 100644
+--- a/packages/client/ui-trajectory/src/client/layout.ts
++++ b/packages/client/ui-trajectory/src/client/layout.ts
+@@ -841,6 +841,16 @@ function sourceBlock(value: unknown): TrajectorySourceBlock {
+     // wire-shaped 'other' blocks with an unrelated `attachment` member out.
+     return { type, content: '', attachment: block.attachment as ImageAttachmentRef }
+   }
++  if (type === 'document' && typeof block.attachment === 'object' && block.attachment !== null) {
++    const attachment = block.attachment as Record<string, unknown>
++    if (typeof attachment.name === 'string' && typeof attachment.mediaType === 'string' && typeof attachment.bytes === 'number') {
++      return {
++        type,
++        content: '',
++        document: { name: attachment.name, mediaType: attachment.mediaType, bytes: attachment.bytes },
++      }
++    }
++  }
+   return { type, content: stringifySourceValue(value) }
+ }
+ 
+diff --git a/packages/client/ui-trajectory/src/client/trajectory-contract.ts b/packages/client/ui-trajectory/src/client/trajectory-contract.ts
+index 37571f2b83403944c2cb0e1e8a71b17972461994..1c326ebfca6e1b8636457d04c4517f39630e4d8b 100644
+--- a/packages/client/ui-trajectory/src/client/trajectory-contract.ts
++++ b/packages/client/ui-trajectory/src/client/trajectory-contract.ts
+@@ -1,6 +1,6 @@
+ import type {
+   AssistantMessageNode, ConversationLocation, ConversationNode, ConversationPromptSnapshot,
+-  ConversationViewNode, MessageImagesOwnerProps, PartialAssistant, RequestPromptChange,
++  ConversationViewNode, MessageDocumentSource, MessageImagesOwnerProps, PartialAssistant, RequestPromptChange,
+   RequestView, RunningToolCall, ToolCallBlock,
+ } from '@deepseek-ai/dsh-client-ui-conversation/client'
+ import type { SnapshotSelectorHook } from '@deepseek-ai/dsh-client-ui-slots'
+@@ -93,5 +93,6 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
+      * images are omitted.
+      */
+     'conversation.trajectory.images': { kind: 'single'; scope: 'session'; owner: MessageImagesOwnerProps }
++    'conversation.trajectory.images.documents': { kind: 'single'; scope: 'session'; owner: { documents: readonly MessageDocumentSource[] } }
+   }
+ }
+diff --git a/packages/client/ui-trajectory/src/client/trajectory-record.ts b/packages/client/ui-trajectory/src/client/trajectory-record.ts
+index da330f2ae43a55ca813bfffe867dbfc33a2c15a9..0bb73888c955883403d785e7bcc737c8cb0f7054 100644
+--- a/packages/client/ui-trajectory/src/client/trajectory-record.ts
++++ b/packages/client/ui-trajectory/src/client/trajectory-record.ts
+@@ -2,7 +2,7 @@
+ 
+ import type { HTMLAttributes } from 'react'
+ import type { ImageAttachmentRef } from '@deepseek-ai/dsh-attachment'
+-import type { ConversationPromptSnapshot } from '@deepseek-ai/dsh-client-ui-conversation/client'
++import type { ConversationPromptSnapshot, MessageDocumentSource } from '@deepseek-ai/dsh-client-ui-conversation/client'
+ import type { TrajectoryTranslate } from './locales.ts'
+ 
+ /** Closed set of trajectory record kinds. */
+@@ -30,6 +30,7 @@ export interface TrajectorySourceBlock {
+   type: string
+   content: string
+   attachment?: ImageAttachmentRef
++  document?: MessageDocumentSource
+   callId?: string
+   toolName?: string
+ }
+diff --git a/packages/llm/llm-deepseek/src/adapter.ts b/packages/llm/llm-deepseek/src/adapter.ts
+index e2116556331159ee348aacfb194d46e2ae7b5920..4e468b655b20fd8a7664334be3365be1d1438237 100644
+--- a/packages/llm/llm-deepseek/src/adapter.ts
++++ b/packages/llm/llm-deepseek/src/adapter.ts
+@@ -8,7 +8,7 @@
+  * @module dsh-llm-deepseek/adapter
+  */
+ 
+-import { attributionHeaders, contentHasImage, CONTEXT_WINDOW_EXCEEDED_CODE, isContextWindowExceededError, isQuotaExceededError, LlmAdapter, LlmError, offloadedImageText, offloadRequestImagesWithPolicy, ProviderRequestId, QUOTA_EXCEEDED_CODE, ReasoningEffortId } from '@deepseek-ai/dsh-llm'
++import { attributionHeaders, contentHasDocument, contentHasImage, CONTEXT_WINDOW_EXCEEDED_CODE, isContextWindowExceededError, isQuotaExceededError, LlmAdapter, LlmError, offloadedImageText, offloadRequestImagesWithPolicy, projectRequestDocumentsWithAttachments, ProviderRequestId, QUOTA_EXCEEDED_CODE, ReasoningEffortId } from '@deepseek-ai/dsh-llm'
+ import type {
+   ContentBlock,
+   GenerateOptions,
+@@ -450,20 +450,23 @@ export class DeepSeekAdapter extends LlmAdapter {
+     // never observes a configuration change and the next call re-resolves.
+     // The key resolves *from this snapshot*, so an endpoint and the secret
+     // sent to it can never come from different configuration generations.
++    const hasDocuments = options.messages.some(message => contentHasDocument(message.content))
+     const hasImages = options.messages.some(message => contentHasImage(message.content))
+     let attachments: AttachmentStore | undefined
+-    if (hasImages) {
+-      const model = connection.models.find(entry => entry.id === options.model)
+-      if (model?.inputModalities?.includes('image') !== true) {
++    if (hasDocuments || hasImages) {
++      attachments = this.config.resolveAttachments?.()
++      if (attachments === undefined) {
+         throw new LlmError(
+-          `DeepSeek model "${options.model}" does not accept image input.`,
++          'DeepSeek document and image conversion requires the durable attachment service.',
+           'UNSUPPORTED_CONTENT',
+         )
+       }
+-      attachments = this.config.resolveAttachments?.()
+-      if (attachments === undefined) {
++    }
++    if (hasImages) {
++      const model = connection.models.find(entry => entry.id === options.model)
++      if (model?.inputModalities?.includes('image') !== true) {
+         throw new LlmError(
+-          'DeepSeek image conversion requires the durable attachment service.',
++          `DeepSeek model "${options.model}" does not accept image input.`,
+           'UNSUPPORTED_CONTENT',
+         )
+       }
+@@ -475,13 +478,16 @@ export class DeepSeekAdapter extends LlmAdapter {
+       ? consumer.signal
+       : AbortSignal.any([options.signal, consumer.signal])
+     using watchdog = idleWatchdog(upstream, connection.streamIdleTimeoutMs, STREAM_IDLE_TIMEOUT_CODE)
++    const requestOptions = hasDocuments
++      ? { ...options, messages: await projectRequestDocumentsWithAttachments(options.messages, attachments as AttachmentStore, watchdog.signal) }
++      : options
+     const iterator = this.request(
+-      options,
++      requestOptions,
+       watchdog.signal,
+       connection,
+       apiKey,
+       userId,
+-      attachments,
++      hasImages ? attachments : undefined,
+       () => { watchdog.pulse() },
+     )[Symbol.asyncIterator]()
+     let exhausted = false
+diff --git a/packages/llm/llm-pi-ai/src/adapter.ts b/packages/llm/llm-pi-ai/src/adapter.ts
+index e20b8e00720d52ef9cbb3712884661e8025f3dde..acd9dcda4fd57e0effe1f2bb6c3f406340219b93 100644
+--- a/packages/llm/llm-pi-ai/src/adapter.ts
++++ b/packages/llm/llm-pi-ai/src/adapter.ts
+@@ -40,9 +40,11 @@ import type {
+ } from '@earendil-works/pi-ai'
+ import {
+   attributionHeaders,
++  contentHasDocument,
+   contentHasImage,
+   LlmAdapter,
+   LlmError,
++  projectRequestDocumentsWithAttachments,
+   ReasoningEffortId,
+ } from '@deepseek-ai/dsh-llm'
+ import type {
+@@ -350,20 +352,24 @@ export class PiAiAdapter extends LlmAdapter {
+     using watchdog = idleWatchdog(upstream, streamIdleTimeoutMs, 'LLM_STREAM_IDLE_TIMEOUT')
+ 
+     try {
++      const containsDocument = options.messages.some(message => contentHasDocument(message.content))
+       const containsImage = options.messages.some(message => contentHasImage(message.content))
+       if (containsImage && !model.input.includes('image')) {
+         throw new LlmError(`pi-ai model "${model.id}" does not support image input`, 'UNSUPPORTED_CONTENT')
+       }
+-      const attachments = containsImage ? this.config.resolveAttachments?.() : undefined
+-      if (containsImage && attachments === undefined) {
+-        throw new LlmError('pi-ai image input requires the durable attachment service', 'UNSUPPORTED_CONTENT')
++      const attachments = containsDocument || containsImage ? this.config.resolveAttachments?.() : undefined
++      if ((containsDocument || containsImage) && attachments === undefined) {
++        throw new LlmError('pi-ai document and image input requires the durable attachment service', 'UNSUPPORTED_CONTENT')
+       }
++      const requestOptions = containsDocument
++        ? { ...options, messages: await projectRequestDocumentsWithAttachments(options.messages, attachments as AttachmentStore, watchdog.signal) }
++        : options
+       const onReplayDegrade = (reason: string): void => {
+         this.config.onReplayDegrade?.({ provider: options.provider, model: options.model, reason })
+       }
+       const context = attachments === undefined
+-        ? toPiContext(options, undefined, onReplayDegrade)
+-        : await toPiContext({ ...options, signal: watchdog.signal }, {
++        ? toPiContext(requestOptions, undefined, onReplayDegrade)
++        : await toPiContext({ ...requestOptions, signal: watchdog.signal }, {
+           attachments,
+           resolveImageAccess: ref => this.config.resolveImageAccess?.(attachments, ref),
+           maxRequestImageBytes: profile.maxRequestImageBytes,
+diff --git a/packages/llm/llm/src/content.ts b/packages/llm/llm/src/content.ts
+index 43c392a64129981a1dd99f6f38fcae39df5e4228..96e9fece476649b8e8dfeb13979e40d456f0f903 100644
+--- a/packages/llm/llm/src/content.ts
++++ b/packages/llm/llm/src/content.ts
+@@ -1,10 +1,71 @@
+ /** Content-block structure helpers. @module @deepseek-ai/dsh-llm/content */
+ 
+-import type { ContentBlock } from './types.ts'
++import type { ContentBlock, DocumentBlock } from './types.ts'
+ import type { Message } from './message.ts'
+ import type { AttachmentStore, ImageAttachmentRef, ImageMediaType, RequestImageAttachment } from '@deepseek-ai/dsh-attachment'
+ import { assertNever } from './never.ts'
+ 
++/** Return whether typed model content contains a durable parsed document. */
++export function contentHasDocument(content: readonly ContentBlock[]): boolean {
++  return content.some(block => block.type === 'document'
++    || (block.type === 'tool-result' && contentHasDocument(block.content)))
++}
++
++async function parsedDocumentText(
++  block: DocumentBlock,
++  attachments: AttachmentStore,
++  signal?: AbortSignal,
++): Promise<string> {
++  const stored = await attachments.readFile(block.parsed.modelText, signal)
++  return new TextDecoder('utf-8', { fatal: true }).decode(stored.data)
++}
++
++/** 中文约束：只生成provider request的transient text，不修改Session中的durable reference blocks。 */
++async function projectDocumentsWithAttachments(
++  blocks: readonly ContentBlock[],
++  attachments: AttachmentStore,
++  signal?: AbortSignal,
++): Promise<ContentBlock[]> {
++  let next: ContentBlock[] | undefined
++  for (const [index, block] of blocks.entries()) {
++    if (block.type === 'document') {
++      next ??= blocks.slice(0, index)
++      next.push({ type: 'text', text: await parsedDocumentText(block, attachments, signal) })
++      continue
++    }
++    if (block.type === 'tool-result') {
++      const content = await projectDocumentsWithAttachments(block.content, attachments, signal)
++      if (content !== block.content) {
++        next ??= blocks.slice(0, index)
++        next.push({ ...block, content })
++        continue
++      }
++    }
++    next?.push(block)
++  }
++  return next ?? blocks as ContentBlock[]
++}
++
++/**
++ * Resolve every durable parsed-document Markdown reference for one provider request.
++ * @param messages - durable ref-only request history.
++ * @param attachments - store resolving each complete Markdown object.
++ * @param signal - optional cancellation for durable object reads.
++ * @returns request-only messages with documents replaced by delimited Markdown.
++ */
++export async function projectRequestDocumentsWithAttachments(
++  messages: readonly Message[],
++  attachments: AttachmentStore,
++  signal?: AbortSignal,
++): Promise<Message[]> {
++  const projected: Message[] = []
++  for (const message of messages) {
++    const content = await projectDocumentsWithAttachments(message.content, attachments, signal)
++    projected.push(content === message.content ? message : { ...message, content })
++  }
++  return projected
++}
++
+ /** Execution-world path that model tools can use to read one normalized attachment. */
+ export interface ImageAttachmentAccess {
+   /** Absolute path to immutable normalized bytes; callers must treat it as read-only. */
+diff --git a/packages/llm/llm/src/types.ts b/packages/llm/llm/src/types.ts
+index 438fcaa67baed51a6b1c8f867e802d2a6aa46023..f82ec614c131c23b8810422017ab1e4fd6415b09 100644
+--- a/packages/llm/llm/src/types.ts
++++ b/packages/llm/llm/src/types.ts
+@@ -5,7 +5,7 @@
+  */
+ 
+ import type { Branded } from '@deepseek-ai/dsh-brand'
+-import type { ImageAttachmentRef } from '@deepseek-ai/dsh-attachment'
++import type { DocumentAttachmentRef, ImageAttachmentRef, ParsedDocumentRef } from '@deepseek-ai/dsh-attachment'
+ import type { ToolCallId, ProviderRequestId, ReasoningEffortId } from './brand.ts'
+ import type { Message } from './message.ts'
+ 
+@@ -74,6 +74,15 @@ export interface ImageBlock {
+   attachment: ImageAttachmentRef
+ }
+ 
++/** A durable document with required original and parser-output references. */
++export interface DocumentBlock {
++  type: 'document'
++  /** Immutable original document bytes and display metadata. */
++  attachment: DocumentAttachmentRef
++  /** Immutable provider-neutral parser outputs used by request projection. */
++  parsed: ParsedDocumentRef
++}
++
+ /** A tool invocation requested by the model. */
+ export interface ToolCallBlock {
+   type: 'tool-call'
+@@ -100,6 +109,7 @@ export interface ContentBlockMap {
+   'text': TextBlock
+   'reasoning': ReasoningBlock
+   'image': ImageBlock
++  'document': DocumentBlock
+   'tool-call': ToolCallBlock
+   'tool-result': ToolResultBlock
+ }