From 128faf145fbbccf1f8b95c5262829a69f1ee3ebb Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 14:28:41 +0800
Subject: [PATCH 01/45] feat: send prompt-attached videos directly with the
 prompt
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Videos attached to a prompt (pasted in the TUI, uploaded in the web UI)
previously reached the model only after it opened the file with
ReadMediaFile — an extra tool round trip that could leave the video
unseen when the model never made that call. They are now uploaded
through the model provider's file channel and embedded directly in the
user message as the provider-issued reference; ReadMediaFile stays as
the fallback and as the model's own way to open video files.

- agent-core: new uploadVideo agent RPC and Session.uploadVideo in the
  SDK; the TUI uploads pasted videos at submit time, falling back to
  the file-tag form on failure
- kap-server: inline file-source video prompt parts at the REST edge
  and map provider file ids back to local uploads behind
  GET /files/llm/{llm_id}
- kimi-web: play provider-referenced prompt videos after reload/resume
---
 .changeset/prompt-video-inline.md             |   5 +
 .changeset/sdk-session-upload-video.md        |   5 +
 .changeset/web-video-playback-after-reload.md |   5 +
 apps/kimi-code/src/tui/kimi-tui.ts            |  64 +++++--
 .../src/tui/utils/image-placeholder.ts        | 153 ++++++++++++++++-
 .../test/tui/input/image-placeholder.test.ts  | 109 ++++++++++++
 .../test/tui/kimi-tui-message-flow.test.ts    |  65 ++++++-
 apps/kimi-web/src/api/daemon/client.ts        |   4 +
 apps/kimi-web/src/api/types.ts                |   3 +
 .../src/composables/client/useSideChat.ts     |   2 +
 .../src/composables/messagesToTurns.ts        |  43 ++++-
 .../src/composables/useKimiWebClient.ts       |   1 +
 apps/kimi-web/test/turn-logic.test.ts         |  81 +++++++++
 .../agent/contextMemory/protocolMessage.ts    |   8 +-
 packages/agent-core/src/agent/index.ts        |  46 ++++-
 packages/agent-core/src/agent/tool/index.ts   |  10 ++
 packages/agent-core/src/rpc/core-api.ts       |  13 +-
 packages/agent-core/src/rpc/core-impl.ts      |   5 +
 packages/agent-core/src/session/rpc.ts        |   5 +
 .../src/tools/builtin/file/read-media.ts      |   2 +-
 packages/agent-core/test/agent/basic.test.ts  | 120 ++++++++++++-
 packages/kap-server/src/lib/llmVideoRefs.ts   |  35 ++++
 packages/kap-server/src/protocol/rest-file.ts |   6 +
 packages/kap-server/src/routes/files.ts       |  37 ++++
 packages/kap-server/src/routes/prompts.ts     | 101 ++++++++++-
 .../apiSurface.snapshot.test.ts.snap          |   4 +
 packages/kap-server/test/files.test.ts        |  12 ++
 packages/kap-server/test/prompts.test.ts      | 162 +++++++++++++++++-
 packages/node-sdk/src/rpc.ts                  |  10 ++
 packages/node-sdk/src/session.ts              |  13 ++
 packages/node-sdk/src/types.ts                |   2 +-
 .../test/session-prompt-input.test.ts         |  17 ++
 32 files changed, 1112 insertions(+), 36 deletions(-)
 create mode 100644 .changeset/prompt-video-inline.md
 create mode 100644 .changeset/sdk-session-upload-video.md
 create mode 100644 .changeset/web-video-playback-after-reload.md
 create mode 100644 packages/kap-server/src/lib/llmVideoRefs.ts

diff --git a/.changeset/prompt-video-inline.md b/.changeset/prompt-video-inline.md
new file mode 100644
index 0000000000..a24770dd6d
--- /dev/null
+++ b/.changeset/prompt-video-inline.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": minor
+---
+
+Send pasted videos to the model directly with the prompt instead of routing them through a ReadMediaFile tool call, so video input is faster and no longer depends on an extra tool round trip.
diff --git a/.changeset/sdk-session-upload-video.md b/.changeset/sdk-session-upload-video.md
new file mode 100644
index 0000000000..aafd048f2e
--- /dev/null
+++ b/.changeset/sdk-session-upload-video.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code-sdk": patch
+---
+
+Add Session.uploadVideo to upload a local video through the session's current model and embed the returned reference as a prompt part.
diff --git a/.changeset/web-video-playback-after-reload.md b/.changeset/web-video-playback-after-reload.md
new file mode 100644
index 0000000000..23bd3115d8
--- /dev/null
+++ b/.changeset/web-video-playback-after-reload.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+web: Keep uploaded videos playable in the chat after reloading or resuming a session.
diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 9d03f9395b..62f7427992 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -133,7 +133,7 @@ import { isDeadTerminalError } from './utils/dead-terminal';
 import { formatErrorMessage } from './utils/event-payload';
 import { pickForegroundTasks } from './utils/foreground-task';
 import { ImageAttachmentStore, type ImageAttachment } from './utils/image-attachment-store';
-import { extractMediaAttachments, rewriteMediaPlaceholders } from './utils/image-placeholder';
+import { extractMediaSegments, materializeMediaSegments, rewriteMediaPlaceholders, segmentsToPromptParts } from './utils/image-placeholder';
 import { hasPatchChanges } from './utils/object-patch';
 import { sessionRowsForPicker } from './utils/session-picker-rows';
 import { formatBashOutputForDisplay } from './utils/shell-output';
@@ -1121,30 +1121,70 @@ export class KimiTUI {
     this.updateQueueDisplay();
   }
 
+  // Submits chained behind an in-flight video upload (see sendNormalUserInput).
+  private pendingSubmits = 0;
+  private inputSubmitChain: Promise<void> = Promise.resolve();
+
   sendNormalUserInput(text: string): void {
     if (this.btwPanelController.sendUserInput(text)) return;
     if (this.state.appState.model.trim().length === 0) {
       this.showError(LLM_NOT_SET_MESSAGE);
       return;
     }
-    const extraction = extractMediaAttachments(text, this.imageStore);
+    const extraction = extractMediaSegments(text, this.imageStore);
     if (!this.validateMediaCapabilities(extraction)) return;
     const session = this.session;
     if (session === undefined) {
       this.showError(LLM_NOT_SET_MESSAGE);
       return;
     }
-    if (extraction.hasMedia) {
-      this.sendMessage(session, text, {
-        hasMedia: true,
-        parts: extraction.parts,
-        imageAttachmentIds: extraction.imageAttachmentIds,
-      });
-    } else {
-      this.sendMessage(session, text);
+    const hasVideo = extraction.videoAttachmentIds.length > 0;
+    if (!hasVideo && this.pendingSubmits === 0) {
+      // Fully synchronous path: nothing to upload, nothing queued behind an
+      // upload, so ordering is trivially safe.
+      if (extraction.hasMedia) {
+        this.sendMessage(session, text, {
+          hasMedia: true,
+          parts: segmentsToPromptParts(extraction.segments),
+          imageAttachmentIds: extraction.imageAttachmentIds,
+        });
+      } else {
+        this.sendMessage(session, text);
+      }
+      this.updateQueueDisplay();
+      this.state.ui.requestRender();
+      return;
     }
-    this.updateQueueDisplay();
-    this.state.ui.requestRender();
+    // Video attachments upload asynchronously before the prompt goes out.
+    // Chain this submit (and any submitted while an upload is in flight) so
+    // a slow upload cannot be overtaken by a later message.
+    this.pendingSubmits += 1;
+    this.inputSubmitChain = this.inputSubmitChain.then(async () => {
+      try {
+        if (extraction.hasMedia) {
+          const parts = hasVideo
+            ? await materializeMediaSegments(extraction.segments, (attachment) =>
+                session.uploadVideo(attachment.sourcePath),
+              )
+            : segmentsToPromptParts(extraction.segments);
+          this.sendMessage(session, text, {
+            hasMedia: true,
+            parts,
+            imageAttachmentIds: extraction.imageAttachmentIds,
+          });
+        } else {
+          this.sendMessage(session, text);
+        }
+      } catch (error) {
+        // The tag fallback itself could not be prepared (unwritable cache
+        // dir, vanished video source…); nothing was dispatched.
+        this.showError(`Failed to prepare media attachment: ${formatErrorMessage(error)}`);
+      } finally {
+        this.pendingSubmits -= 1;
+      }
+      this.updateQueueDisplay();
+      this.state.ui.requestRender();
+    });
   }
 
   validateMediaCapabilities(extraction: {
diff --git a/apps/kimi-code/src/tui/utils/image-placeholder.ts b/apps/kimi-code/src/tui/utils/image-placeholder.ts
index 56edcee88b..7c15201f57 100644
--- a/apps/kimi-code/src/tui/utils/image-placeholder.ts
+++ b/apps/kimi-code/src/tui/utils/image-placeholder.ts
@@ -1,17 +1,30 @@
 /**
- * Scan submitted text for media placeholders and produce
- * the `PromptPart[]` we'll send to the SDK prompt endpoint.
+ * Scan submitted text for media placeholders and produce the prompt content
+ * we'll send to the SDK prompt endpoint.
  *
- * Rules:
+ * Two extraction paths share the same placeholder scan:
+ *
+ *   - `extractMediaAttachments` (sync): image placeholders expand to image
+ *     content parts; video placeholders are copied into the shared cache
+ *     (`getCacheDir()`) and expand to `<video path="…">` file tags, so the
+ *     model opens them with `ReadMediaFile`. Used by channels that cannot
+ *     upload first (steer splice, `/skill` args via rewriteMediaPlaceholders,
+ *     plugin commands) and as the fallback when a prompt-time video upload
+ *     fails.
+ *   - `extractMediaSegments` + `materializeMediaSegments` (async): video
+ *     placeholders stay unresolved references until `materializeMediaSegments`
+ *     uploads each one through the session's video upload channel and embeds
+ *     the provider-issued `video_url` part directly in the prompt — the model
+ *     receives the video with the user message, no tool call needed. An
+ *     upload that fails falls back to the file-tag form above.
+ *
+ * Rules for both:
  *   - Only placeholders that resolve against `store` get extracted.
  *     A literal `[image #999 ...]` the user typed themselves stays in
  *     the text (we can't hallucinate files for it).
  *   - Order is preserved for text/image/video segments. Image placeholders
  *     expand to image content parts so the prompt reaches the provider
- *     without relying on a model tool call. Video placeholders are copied
- *     into the shared cache (`getCacheDir()`) and expand to file-path tags,
- *     so `ReadMediaFile` — and the provider's `VideoUploader` — own video
- *     upload behavior instead of base64-inlining here.
+ *     without relying on a model tool call.
  *   - Adjacent text segments are flattened — empty / whitespace-only
  *     segments drop out so we never emit `{type:'text', text:' '}`
  *     noise between two media parts.
@@ -101,6 +114,118 @@ export function extractMediaAttachments(
   };
 }
 
+export interface MediaSegmentPart {
+  readonly kind: 'part';
+  readonly part: PromptPart;
+}
+
+export interface MediaSegmentVideo {
+  readonly kind: 'video';
+  readonly attachment: VideoAttachment;
+}
+
+export type MediaSegment = MediaSegmentPart | MediaSegmentVideo;
+
+export interface SegmentExtractionResult {
+  /** Ordered segments: text/image parts inline, videos as unresolved refs. */
+  readonly segments: MediaSegment[];
+  readonly hasMedia: boolean;
+  readonly imageAttachmentIds: number[];
+  readonly videoAttachmentIds: number[];
+}
+
+/**
+ * Variant of `extractMediaAttachments` that leaves video placeholders
+ * unresolved: the returned segments keep the `VideoAttachment` so the caller
+ * can upload it (async) before deciding the final part shape. No cache copy
+ * happens here, so unlike `extractMediaAttachments` this never throws for a
+ * vanished video source — that surfaces only if the tag fallback runs.
+ */
+export function extractMediaSegments(
+  text: string,
+  store: ImageAttachmentStore,
+): SegmentExtractionResult {
+  const segments: MediaSegment[] = [];
+  const imageAttachmentIds: number[] = [];
+  const videoAttachmentIds: number[] = [];
+  let cursor = 0;
+  let hasMedia = false;
+
+  PLACEHOLDER_REGEX.lastIndex = 0;
+  let match: RegExpExecArray | null;
+  while ((match = PLACEHOLDER_REGEX.exec(text)) !== null) {
+    const [literal, kind, idStr] = match;
+    if (kind !== 'image' && kind !== 'video') continue;
+    if (idStr === undefined) continue;
+    const id = Number.parseInt(idStr, 10);
+    const attachment = store.get(id);
+    if (attachment === undefined) continue; // stale / user-typed — leave as text
+    if (attachment.kind !== kind) continue;
+    const before = text.slice(cursor, match.index);
+    pushTextPart(segments, before);
+    if (attachment.kind === 'video') {
+      segments.push({ kind: 'video', attachment });
+      videoAttachmentIds.push(id);
+    } else {
+      if (attachment.original !== undefined) {
+        pushTextPart(segments, captionForCompressedImage(attachment));
+      }
+      segments.push({ kind: 'part', part: imagePartForAttachment(attachment) });
+      imageAttachmentIds.push(id);
+    }
+    hasMedia = true;
+    cursor = match.index + literal.length;
+  }
+  pushTextPart(segments, text.slice(cursor));
+
+  return {
+    segments: hasMedia ? segments : [],
+    hasMedia,
+    imageAttachmentIds,
+    videoAttachmentIds,
+  };
+}
+
+/**
+ * Resolve extracted segments into final prompt parts. Text and image
+ * segments pass through; each video attachment is uploaded through `upload`
+ * (the session's video upload channel) so the prompt embeds the
+ * provider-issued `video_url` part directly. When an upload fails the video
+ * degrades to a `<video path="…">` tag pointing at a cache copy, which the
+ * model can open with `ReadMediaFile` — uploads run concurrently, order is
+ * preserved. Throws only when a fallback cache copy itself fails.
+ */
+export async function materializeMediaSegments(
+  segments: readonly MediaSegment[],
+  upload: (attachment: VideoAttachment) => Promise<PromptPart>,
+): Promise<PromptPart[]> {
+  const resolved = await Promise.all(
+    segments.map(async (segment): Promise<PromptPart[]> => {
+      if (segment.kind === 'part') return [segment.part];
+      try {
+        return [await upload(segment.attachment)];
+      } catch {
+        // Fall back to the file-tag form: the model reads the video itself.
+        const cachePath = materializeVideoToCache(segment.attachment);
+        return [{ type: 'text', text: formatMediaTag('video', cachePath) }];
+      }
+    }),
+  );
+  return resolved.flat();
+}
+
+/**
+ * Resolve already-extracted segments that contain no video placeholders into
+ * prompt parts synchronously (all segments are inline parts by then).
+ */
+export function segmentsToPromptParts(segments: readonly MediaSegment[]): PromptPart[] {
+  const parts: PromptPart[] = [];
+  for (const segment of segments) {
+    if (segment.kind === 'part') parts.push(segment.part);
+  }
+  return parts;
+}
+
 export interface MediaTagRewriteResult {
   /** Input text with resolved placeholders replaced by media references. */
   text: string;
@@ -187,6 +312,20 @@ function pushText(parts: PromptPart[], segment: string): void {
   parts.push({ type: 'text', text: segment });
 }
 
+function pushTextPart(segments: MediaSegment[], segment: string): void {
+  if (segment.length === 0) return;
+  if (segment.trim().length === 0) return;
+  const last = segments.at(-1);
+  if (last?.kind === 'part' && last.part.type === 'text') {
+    segments[segments.length - 1] = {
+      kind: 'part',
+      part: { type: 'text', text: last.part.text + segment },
+    };
+    return;
+  }
+  segments.push({ kind: 'part', part: { type: 'text', text: segment } });
+}
+
 function imagePartForAttachment(att: ImageAttachment): PromptPart {
   const base64 = Buffer.from(att.bytes).toString('base64');
   return {
diff --git a/apps/kimi-code/test/tui/input/image-placeholder.test.ts b/apps/kimi-code/test/tui/input/image-placeholder.test.ts
index 477727293a..5a6de196e2 100644
--- a/apps/kimi-code/test/tui/input/image-placeholder.test.ts
+++ b/apps/kimi-code/test/tui/input/image-placeholder.test.ts
@@ -8,6 +8,8 @@ import { KIMI_CODE_HOME_ENV } from '#/constant/app';
 import { ImageAttachmentStore } from '#/tui/utils/image-attachment-store';
 import {
   extractMediaAttachments,
+  extractMediaSegments,
+  materializeMediaSegments,
   rewriteMediaPlaceholders,
 } from '#/tui/utils/image-placeholder';
 import { getCacheDir } from '#/utils/paths';
@@ -369,3 +371,110 @@ describe('rewriteMediaPlaceholders', () => {
     }
   });
 });
+
+describe('extractMediaSegments + materializeMediaSegments', () => {
+  it('returns no segments and hasMedia=false for plain text', () => {
+    const store = new ImageAttachmentStore();
+    const r = extractMediaSegments('hello world', store);
+    expect(r.hasMedia).toBe(false);
+    expect(r.segments).toEqual([]);
+    expect(r.imageAttachmentIds).toEqual([]);
+    expect(r.videoAttachmentIds).toEqual([]);
+  });
+
+  it('keeps a video as an unresolved reference and inlines it via the upload result', async () => {
+    const srcDir = makeTempDir();
+    try {
+      const srcVideo = join(srcDir, 'clip.mp4');
+      writeFileSync(srcVideo, 'video-bytes');
+      const store = new ImageAttachmentStore();
+      const vid = store.addVideo('video/mp4', srcVideo);
+      const r = extractMediaSegments(`look ${vid.placeholder} now`, store);
+      expect(r.hasMedia).toBe(true);
+      expect(r.videoAttachmentIds).toEqual([1]);
+      expect(r.segments.map((s) => s.kind)).toEqual(['part', 'video', 'part']);
+
+      const parts = await materializeMediaSegments(r.segments, async () => ({
+        type: 'video_url',
+        videoUrl: { url: 'ms://file-1', id: 'file-1' },
+      }));
+      expect(parts).toEqual([
+        { type: 'text', text: 'look ' },
+        { type: 'video_url', videoUrl: { url: 'ms://file-1', id: 'file-1' } },
+        { type: 'text', text: ' now' },
+      ]);
+    } finally {
+      rmSync(srcDir, { recursive: true, force: true });
+    }
+  });
+
+  it('inlines images directly while videos wait for the upload result', async () => {
+    const srcDir = makeTempDir();
+    try {
+      const srcVideo = join(srcDir, 'clip.mp4');
+      writeFileSync(srcVideo, 'video-bytes');
+      const store = new ImageAttachmentStore();
+      const img = store.addImage(new Uint8Array([1]), 'image/png', 10, 10);
+      const vid = store.addVideo('video/mp4', srcVideo);
+      const r = extractMediaSegments(`${img.placeholder} then ${vid.placeholder}`, store);
+      expect(r.imageAttachmentIds).toEqual([1]);
+      expect(r.videoAttachmentIds).toEqual([2]);
+
+      const parts = await materializeMediaSegments(r.segments, async () => ({
+        type: 'video_url',
+        videoUrl: { url: 'ms://file-2', id: 'file-2' },
+      }));
+      expect(parts.map((p) => p.type)).toEqual(['image_url', 'text', 'video_url']);
+    } finally {
+      rmSync(srcDir, { recursive: true, force: true });
+    }
+  });
+
+  it('preserves video order across concurrent uploads', async () => {
+    const srcDir = makeTempDir();
+    try {
+      const srcA = join(srcDir, 'a.mp4');
+      const srcB = join(srcDir, 'b.mp4');
+      writeFileSync(srcA, 'a');
+      writeFileSync(srcB, 'b');
+      const store = new ImageAttachmentStore();
+      const vidA = store.addVideo('video/mp4', srcA);
+      const vidB = store.addVideo('video/mp4', srcB);
+      const r = extractMediaSegments(`${vidA.placeholder} and ${vidB.placeholder}`, store);
+
+      const parts = await materializeMediaSegments(r.segments, async (att) => ({
+        type: 'video_url',
+        videoUrl: { url: `ms://${att.sourcePath}` },
+      }));
+
+      expect(parts.map((p) => p.type)).toEqual(['video_url', 'text', 'video_url']);
+      expect(parts[0]).toEqual({ type: 'video_url', videoUrl: { url: `ms://${srcA}` } });
+      expect(parts[2]).toEqual({ type: 'video_url', videoUrl: { url: `ms://${srcB}` } });
+    } finally {
+      rmSync(srcDir, { recursive: true, force: true });
+    }
+  });
+
+  it('falls back to a cache-path tag when the upload fails', async () => {
+    const { cleanup } = setupTempCache();
+    const srcDir = makeTempDir();
+    try {
+      const srcVideo = join(srcDir, 'clip.mp4');
+      writeFileSync(srcVideo, 'video-bytes');
+      const store = new ImageAttachmentStore();
+      const vid = store.addVideo('video/mp4', srcVideo);
+      const r = extractMediaSegments(vid.placeholder, store);
+
+      const parts = await materializeMediaSegments(r.segments, async () => {
+        throw new Error('upload failed');
+      });
+
+      const cachePath = videoPathFromParts(parts);
+      expect(cachePath.startsWith(getCacheDir())).toBe(true);
+      expect(readFileSync(cachePath, 'utf8')).toBe('video-bytes');
+    } finally {
+      cleanup();
+      rmSync(srcDir, { recursive: true, force: true });
+    }
+  });
+});
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index 2dc5ca9302..ae0ea985b4 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -13,7 +13,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { ApprovalPanelComponent } from '#/tui/components/dialogs/approval-panel';
 import { EffortSelectorComponent } from '#/tui/components/dialogs/effort-selector';
-import { KIMI_CODE_PLUGIN_MARKETPLACE_URL } from '#/constant/app';
+import { KIMI_CODE_HOME_ENV, KIMI_CODE_PLUGIN_MARKETPLACE_URL } from '#/constant/app';
 import { MOON_SPINNER_FRAMES } from '#/tui/constant/rendering';
 import {
   AgentSwarmProgressComponent,
@@ -148,6 +148,10 @@ function makeSession(overrides: Record<string, unknown> = {}) {
     model: 'k2',
     summary: { title: null },
     prompt: vi.fn(async () => {}),
+    uploadVideo: vi.fn(async () => ({
+      type: 'video_url',
+      videoUrl: { url: 'ms://stub-video', id: 'stub-video' },
+    })),
     steer: vi.fn(async () => {}),
     init: vi.fn(async () => {}),
     startBtw: vi.fn(async () => 'agent-btw'),
@@ -1544,6 +1548,65 @@ command = "vim"
     expect(transcript).not.toContain('review');
   });
 
+  it('uploads pasted videos and sends the issued video_url part', async () => {
+    const { driver, session } = await makeDriver();
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
+    try {
+      const srcVideo = join(dir, 'clip.mp4');
+      await writeFile(srcVideo, 'video-bytes');
+      const attachment = imageStore.addVideo('video/mp4', srcVideo);
+
+      driver.handleUserInput(`watch ${attachment.placeholder}`);
+
+      await vi.waitFor(() => {
+        expect(session.prompt).toHaveBeenCalledWith([
+          { type: 'text', text: 'watch ' },
+          { type: 'video_url', videoUrl: { url: 'ms://stub-video', id: 'stub-video' } },
+        ]);
+      });
+      expect(session.uploadVideo).toHaveBeenCalledWith(srcVideo);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('falls back to a cache-path video tag when the upload fails', async () => {
+    const { driver, session } = await makeDriver();
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
+    const home = await mkdtemp(join(tmpdir(), 'tui-video-home-'));
+    const prevHome = process.env[KIMI_CODE_HOME_ENV];
+    process.env[KIMI_CODE_HOME_ENV] = home;
+    try {
+      const srcVideo = join(dir, 'clip.mp4');
+      await writeFile(srcVideo, 'video-bytes');
+      const attachment = imageStore.addVideo('video/mp4', srcVideo);
+      vi.mocked(session.uploadVideo).mockRejectedValueOnce(new Error('upload failed'));
+
+      driver.handleUserInput(`watch ${attachment.placeholder}`);
+
+      await vi.waitFor(() => {
+        expect(session.prompt).toHaveBeenCalled();
+      });
+      const promptCalls = vi.mocked(session.prompt).mock.calls as unknown as ReadonlyArray<
+        [Array<{ type: string; text?: string }>]
+      >;
+      const parts = promptCalls[0]?.[0] ?? [];
+      const text = parts
+        .filter((p) => p.type === 'text')
+        .map((p) => p.text)
+        .join('');
+      expect(text).toContain('watch ');
+      expect(text).toMatch(/<video path="[^"]+clip\.mp4"><\/video>/);
+    } finally {
+      if (prevHome === undefined) delete process.env[KIMI_CODE_HOME_ENV];
+      else process.env[KIMI_CODE_HOME_ENV] = prevHome;
+      await rm(dir, { recursive: true, force: true });
+      await rm(home, { recursive: true, force: true });
+    }
+  });
+
   it('sends pasted image placeholders as image content parts', async () => {
     const { driver, session } = await makeDriver();
     const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
diff --git a/apps/kimi-web/src/api/daemon/client.ts b/apps/kimi-web/src/api/daemon/client.ts
index d8b1833edf..9c68a83ead 100644
--- a/apps/kimi-web/src/api/daemon/client.ts
+++ b/apps/kimi-web/src/api/daemon/client.ts
@@ -1389,6 +1389,10 @@ export class DaemonKimiWebApi implements KimiWebApi {
     return this.http.getBlob(`/files/${encodeURIComponent(fileId)}`);
   }
 
+  getLlmFileUrl(llmFileId: string): string {
+    return buildRestUrl(this.config.serverHttpUrl, `/files/llm/${encodeURIComponent(llmFileId)}`);
+  }
+
   // -------------------------------------------------------------------------
   // WebSocket events
   // -------------------------------------------------------------------------
diff --git a/apps/kimi-web/src/api/types.ts b/apps/kimi-web/src/api/types.ts
index 5c34d26ccb..ed7d1a1b82 100644
--- a/apps/kimi-web/src/api/types.ts
+++ b/apps/kimi-web/src/api/types.ts
@@ -781,6 +781,9 @@ export interface KimiWebApi {
   getFileUrl(fileId: string): string;
   /** Fetch a file's bytes with auth — feed the resulting Blob to a blob URL for <video>/<img> src. */
   getFileBlob(fileId: string): Promise<Blob>;
+  /** URL of the daemon redirect that maps a provider-issued video file id
+   *  (`ms://<llmFileId>`) back to the local upload it was produced from. */
+  getLlmFileUrl(llmFileId: string): string;
 
   // Config — REAL endpoints
   getConfig(): Promise<AppConfig>;
diff --git a/apps/kimi-web/src/composables/client/useSideChat.ts b/apps/kimi-web/src/composables/client/useSideChat.ts
index 10322ae46a..c5d686d841 100644
--- a/apps/kimi-web/src/composables/client/useSideChat.ts
+++ b/apps/kimi-web/src/composables/client/useSideChat.ts
@@ -78,6 +78,8 @@ export function useSideChat(rawState: ExtendedState, deps: UseSideChatDeps) {
       [],
       (fileId) => getKimiWebApi().getFileUrl(fileId),
       sideChatRunning.value,
+      undefined,
+      (llmFileId) => getKimiWebApi().getLlmFileUrl(llmFileId),
     );
   });
 
diff --git a/apps/kimi-web/src/composables/messagesToTurns.ts b/apps/kimi-web/src/composables/messagesToTurns.ts
index aaa2a67a9a..b7c183916f 100644
--- a/apps/kimi-web/src/composables/messagesToTurns.ts
+++ b/apps/kimi-web/src/composables/messagesToTurns.ts
@@ -22,6 +22,26 @@ const MEDIA_PATH_TAG_RE = /^<(image|video|audio)\s+path="([^"]+)">$/;
 // matching; the closing tag is optional because ReadMediaFile emits the bare
 // opening tag as a standalone part.
 const USER_MEDIA_PATH_TAG_RE = /^<(image|video|audio)\s+path="([^"]+)">(?:<\/\1>)?$/;
+// A user-uploaded video the server inlined as a provider file reference is
+// persisted as a `video_url` part, which the daemon's message projection
+// flattens into a self-contained `[video:ms://<llmFileId>]` text part. Like
+// the media path tag above, it is its own content part, so anchoring keeps
+// ordinary prose from matching.
+const LLM_VIDEO_REF_TAG_RE = /^\[video:ms:\/\/([^\]]+)\]$/;
+const MS_URL_PREFIX = 'ms://';
+
+/** The provider-issued file id behind a `ms://` url, undefined for any other scheme. */
+function llmFileIdFromMsUrl(url: string): string | undefined {
+  if (!url.startsWith(MS_URL_PREFIX)) return undefined;
+  const id = url.slice(MS_URL_PREFIX.length);
+  return id.length > 0 ? id : undefined;
+}
+
+/** Parse a `[video:ms://<llmFileId>]` text part (see LLM_VIDEO_REF_TAG_RE). */
+function llmVideoRefTag(text: string): string | null {
+  return LLM_VIDEO_REF_TAG_RE.exec(text.trim())?.[1] ?? null;
+}
+
 const SYSTEM_MIME_RE = /Mime type:\s*([^.\s]+)/i;
 const SYSTEM_SIZE_RE = /Size:\s*(\d+)\s*bytes/i;
 const SYSTEM_DIMENSIONS_RE = /Original dimensions:\s*(\d+)x(\d+)\s*pixels/i;
@@ -587,6 +607,10 @@ export function messagesToTurns(
   /** Preserved `plan_review` displays keyed by toolCallId — used to link the
    *  ExitPlanMode tool card back to the plan file after the approval resolves. */
   planReviewByToolCallId: Record<string, { plan: string; path?: string }> = {},
+  /** Maps a provider-issued video file id (`ms://<llmFileId>`) to the daemon
+   *  redirect that serves the local bytes (`/files/llm/<id>`). Without it an
+   *  ms:// reference can't produce a playable URL and stays as raw text. */
+  getLlmFileUrl?: (llmFileId: string) => string,
 ): ChatTurn[] {
   const turns: ChatTurn[] = [];
   let no = 1;
@@ -729,7 +753,15 @@ export function messagesToTurns(
     if (c.type === 'image' || c.type === 'video') {
       const kind = c.type;
       const src = c.source;
-      if (src.kind === 'url') return { url: src.url, kind };
+      if (src.kind === 'url') {
+        // A `ms://<llmFileId>` source is the provider-issued reference of an
+        // uploaded video; the daemon serves the local bytes at /files/llm/<id>.
+        const llmFileId = llmFileIdFromMsUrl(src.url);
+        if (llmFileId !== undefined && getLlmFileUrl) {
+          return { url: getLlmFileUrl(llmFileId), kind };
+        }
+        return { url: src.url, kind };
+      }
       if (src.kind === 'base64') return { url: `data:${src.mediaType};base64,${src.data}`, kind };
       if (src.kind === 'file' && getFileUrl) return { url: getFileUrl(src.fileId), kind, fileId: src.fileId };
     }
@@ -825,6 +857,15 @@ export function messagesToTurns(
                 continue;
               }
             }
+            // A video the server inlined as a provider file reference comes
+            // back (after a reload) as a `[video:ms://…]` text part — recover
+            // the same video attachment via the daemon's llm-file redirect
+            // instead of dumping the raw reference into the bubble.
+            const llmFileId = llmVideoRefTag(c.text);
+            if (llmFileId !== null && getLlmFileUrl) {
+              attachments.push({ url: getLlmFileUrl(llmFileId), kind: 'video' });
+              continue;
+            }
             // A generic file upload comes back as an "Attached file …" notice;
             // recover the chip the same way (see attachedFileNotice).
             const attached = attachedFileNotice(c.text);
diff --git a/apps/kimi-web/src/composables/useKimiWebClient.ts b/apps/kimi-web/src/composables/useKimiWebClient.ts
index f6e3f6a694..6d742de2c9 100644
--- a/apps/kimi-web/src/composables/useKimiWebClient.ts
+++ b/apps/kimi-web/src/composables/useKimiWebClient.ts
@@ -1973,6 +1973,7 @@ const turns = computed<ChatTurn[]>(() => {
     (fileId) => getKimiWebApi().getFileUrl(fileId),
     turnActive.value,
     rawState.planReviewByToolCallId,
+    (llmFileId) => getKimiWebApi().getLlmFileUrl(llmFileId),
   );
 });
 
diff --git a/apps/kimi-web/test/turn-logic.test.ts b/apps/kimi-web/test/turn-logic.test.ts
index 83d2445384..69d104cb35 100644
--- a/apps/kimi-web/test/turn-logic.test.ts
+++ b/apps/kimi-web/test/turn-logic.test.ts
@@ -217,6 +217,87 @@ describe('messagesToTurns', () => {
     ]);
   });
 
+  it('renders a `[video:ms://…]` text part as a video attachment via the llm-file redirect', () => {
+    // A video the server inlined as a provider file reference is persisted as a
+    // video_url part and comes back from the message projection as this
+    // self-contained text part. It must render like the upload did — not as raw
+    // text — with the bytes served by the daemon's /files/llm redirect.
+    const llmFileId = 'file-abc123';
+    const turns = messagesToTurns(
+      [
+        message('u1', 'user', [
+          { type: 'text', text: 'look at this' },
+          { type: 'text', text: `[video:ms://${llmFileId}]` },
+        ]),
+      ],
+      [],
+      (id) => `/api/v1/files/${id}`,
+      false,
+      undefined,
+      (id) => `/api/v1/files/llm/${id}`,
+    );
+
+    expect(turns).toHaveLength(1);
+    expect(turns[0]).toMatchObject({ role: 'user', text: 'look at this' });
+    expect(turns[0]?.attachments).toEqual([
+      { url: `/api/v1/files/llm/${llmFileId}`, kind: 'video' },
+    ]);
+  });
+
+  it('maps an ms:// url-source video part to the llm-file redirect', () => {
+    const turns = messagesToTurns(
+      [
+        message('u1', 'user', [
+          { type: 'video', source: { kind: 'url', url: 'ms://file-abc123' } },
+        ]),
+      ],
+      [],
+      (id) => `/api/v1/files/${id}`,
+      false,
+      undefined,
+      (id) => `/api/v1/files/llm/${id}`,
+    );
+
+    expect(turns[0]?.attachments).toEqual([
+      { url: '/api/v1/files/llm/file-abc123', kind: 'video' },
+    ]);
+  });
+
+  it('leaves non-ms video urls untouched', () => {
+    const dataUrl = 'data:video/mp4;base64,AAAA';
+    const turns = messagesToTurns(
+      [
+        message('u1', 'user', [
+          { type: 'video', source: { kind: 'url', url: 'https://example.com/clip.mp4' } },
+          { type: 'video', source: { kind: 'url', url: dataUrl } },
+        ]),
+      ],
+      [],
+      (id) => `/api/v1/files/${id}`,
+      false,
+      undefined,
+      (id) => `/api/v1/files/llm/${id}`,
+    );
+
+    expect(turns[0]?.attachments).toEqual([
+      { url: 'https://example.com/clip.mp4', kind: 'video' },
+      { url: dataUrl, kind: 'video' },
+    ]);
+  });
+
+  it('keeps the `[video:ms://…]` text when no llm-file resolver is provided', () => {
+    const text = '[video:ms://file-abc123]';
+    const turns = messagesToTurns(
+      [message('u1', 'user', [{ type: 'text', text }])],
+      [],
+      (id) => `/api/v1/files/${id}`,
+      false,
+    );
+
+    expect(turns[0]).toMatchObject({ role: 'user', text });
+    expect(turns[0]?.attachments).toBeUndefined();
+  });
+
   it('renders a non-media file part as a file attachment with name and size', () => {
     const turns = messagesToTurns(
       [
diff --git a/packages/agent-core-v2/src/agent/contextMemory/protocolMessage.ts b/packages/agent-core-v2/src/agent/contextMemory/protocolMessage.ts
index 6db5d65720..0922cbb8fe 100644
--- a/packages/agent-core-v2/src/agent/contextMemory/protocolMessage.ts
+++ b/packages/agent-core-v2/src/agent/contextMemory/protocolMessage.ts
@@ -36,7 +36,13 @@ export const toolResultContentSchema = z.object({
 export type ToolResultContent = z.infer<typeof toolResultContentSchema>;
 
 export const imageSourceSchema = z.discriminatedUnion('kind', [
-  z.object({ kind: z.literal('url'), url: z.string().min(1) }),
+  z.object({
+    kind: z.literal('url'),
+    url: z.string().min(1),
+    // Provider-issued file id paired with `url` (e.g. a `ms://` reference),
+    // forwarded on the wire when the provider keys media by id.
+    id: z.string().min(1).optional(),
+  }),
   z.object({
     kind: z.literal('base64'),
     media_type: z.string().min(1),
diff --git a/packages/agent-core/src/agent/index.ts b/packages/agent-core/src/agent/index.ts
index cc57dc1462..12d17f072b 100644
--- a/packages/agent-core/src/agent/index.ts
+++ b/packages/agent-core/src/agent/index.ts
@@ -6,7 +6,7 @@ import { ErrorCodes, KimiError, makeErrorPayload } from '#/errors';
 import { log } from '#/logging/logger';
 import type { Logger } from '#/logging/types';
 import type { AgentAPI, AgentEvent, KimiConfig, SDKAgentRPC, UsageStatus } from '#/rpc';
-import { generate, type ChatProvider } from '@moonshot-ai/kosong';
+import { generate, type ChatProvider, type VideoURLPart } from '@moonshot-ai/kosong';
 
 import type { EnabledPluginSessionStart, PluginCommandDef } from '#/plugin';
 import { expandCommandArguments } from '../plugin/commands';
@@ -15,6 +15,8 @@ import type { PluginCommandOrigin } from './context';
 import type { McpConnectionManager } from '../mcp';
 import { FlagResolver, type ExperimentalFlagResolver } from '../flags';
 import { ImageLimits } from '../tools/support/image-limits';
+import { MAX_MEDIA_BYTES } from '../tools/builtin/file/read-media';
+import { MEDIA_SNIFF_BYTES, detectFileType } from '../tools/support/file-type';
 import {
   prepareSystemPromptContext,
   type PreparedSystemPromptContext,
@@ -496,11 +498,53 @@ export class Agent {
     return result;
   }
 
+  /**
+   * Upload a local video file through the bound provider's video upload
+   * channel and return the provider-issued `video_url` part. This is the
+   * transport for videos attached directly to a prompt; videos the model
+   * reads itself keep flowing through ReadMediaFile.
+   */
+  async uploadVideo(path: string): Promise<VideoURLPart> {
+    const uploader = this.tools.videoUploader();
+    if (uploader === undefined) {
+      throw new KimiError(
+        ErrorCodes.REQUEST_INVALID,
+        'The current model does not support video upload.',
+      );
+    }
+    const trimmed = path.trim();
+    if (trimmed.length === 0) {
+      throw new KimiError(ErrorCodes.REQUEST_INVALID, 'Video path cannot be empty.');
+    }
+    const header = await this.kaos.readBytes(trimmed, MEDIA_SNIFF_BYTES);
+    const fileType = detectFileType(trimmed, header, 'media');
+    if (fileType.kind !== 'video') {
+      throw new KimiError(ErrorCodes.REQUEST_INVALID, `"${trimmed}" is not a video file.`);
+    }
+    const stat = await this.kaos.stat(trimmed);
+    if (stat.stSize === 0) {
+      throw new KimiError(ErrorCodes.REQUEST_INVALID, `"${trimmed}" is empty.`);
+    }
+    if (stat.stSize > MAX_MEDIA_BYTES) {
+      throw new KimiError(
+        ErrorCodes.REQUEST_INVALID,
+        `"${trimmed}" is ${String(stat.stSize)} bytes, which exceeds the 100MB maximum for video uploads.`,
+      );
+    }
+    const data = await this.kaos.readBytes(trimmed);
+    return uploader({
+      data,
+      mimeType: fileType.mimeType,
+      filename: trimmed.split(/[\\/]/).at(-1),
+    });
+  }
+
   get rpcMethods(): PromisableMethods<AgentAPI> {
     return {
       prompt: (payload) => {
         this.turn.prompt(payload.input);
       },
+      uploadVideo: (payload) => this.uploadVideo(payload.path),
       runShellCommand: (payload) => this.tools.runShellCommand(payload.command, payload.commandId),
       cancelShellCommand: (payload) => this.tools.cancelShellCommand(payload.commandId),
       steer: (payload) => {
diff --git a/packages/agent-core/src/agent/tool/index.ts b/packages/agent-core/src/agent/tool/index.ts
index 13a26eeba5..e707dedce6 100644
--- a/packages/agent-core/src/agent/tool/index.ts
+++ b/packages/agent-core/src/agent/tool/index.ts
@@ -776,6 +776,16 @@ export class ToolManager {
     this.initializeBuiltinTools();
   }
 
+  /**
+   * Uploader bound to the agent's current provider, for media that arrives
+   * outside a tool call (e.g. a video attached to a prompt). `undefined`
+   * when no model is bound or the provider has no video upload channel.
+   */
+  videoUploader(): b.VideoUploader | undefined {
+    if (!this.agent.config.hasProvider) return undefined;
+    return this.createVideoUploader(this.agent.config.provider);
+  }
+
   private createVideoUploader(provider: ChatProvider): b.VideoUploader | undefined {
     const uploadVideo = provider.uploadVideo?.bind(provider);
     if (uploadVideo === undefined) return undefined;
diff --git a/packages/agent-core/src/rpc/core-api.ts b/packages/agent-core/src/rpc/core-api.ts
index ec6d825f54..28ce4ca0d9 100644
--- a/packages/agent-core/src/rpc/core-api.ts
+++ b/packages/agent-core/src/rpc/core-api.ts
@@ -20,7 +20,7 @@ import type { ExperimentalFeatureState } from '#/flags';
 import type { ResumeSessionResult } from '#/rpc/resumed';
 import type { SessionMeta } from '#/session';
 import type { GlobalMcpServerConfig } from '#/mcp/global-config';
-import type { ContentPart } from '@moonshot-ai/kosong';
+import type { ContentPart, VideoURLPart } from '@moonshot-ai/kosong';
 import type { SessionWarning } from '@moonshot-ai/protocol';
 
 import type { PluginCommandDef, PluginInfo, PluginSummary, ReloadSummary } from '#/plugin';
@@ -440,8 +440,19 @@ export interface GetCronTasksResult {
   readonly tasks: readonly CronTaskSnapshot[];
 }
 
+export interface UploadVideoPayload {
+  /** Absolute path to a local video file readable by the core process. */
+  readonly path: string;
+}
+
 export interface AgentAPI {
   prompt: (payload: PromptPayload) => void;
+  /**
+   * Upload a local video file through the agent's bound model provider and
+   * return the provider-issued `video_url` part, ready to be embedded in a
+   * user prompt. Rejects when the provider has no video upload channel.
+   */
+  uploadVideo: (payload: UploadVideoPayload) => Promise<VideoURLPart>;
   runShellCommand: (payload: RunShellCommandPayload) => Promise<ShellCommandResult>;
   cancelShellCommand: (payload: CancelShellCommandPayload) => void;
   steer: (payload: SteerPayload) => void;
diff --git a/packages/agent-core/src/rpc/core-impl.ts b/packages/agent-core/src/rpc/core-impl.ts
index 09cf2965ca..704de982ab 100644
--- a/packages/agent-core/src/rpc/core-impl.ts
+++ b/packages/agent-core/src/rpc/core-impl.ts
@@ -142,6 +142,7 @@ import type {
   UndoHistoryPayload,
   UnregisterToolPayload,
   UpdateSessionMetadataPayload,
+  UploadVideoPayload,
 } from './core-api';
 import type { ResumedAgentState, ResumeSessionResult } from './resumed';
 import type { SDKRPC } from './sdk-api';
@@ -788,6 +789,10 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
     return this.sessionApi(sessionId).prompt(payload);
   }
 
+  uploadVideo({ sessionId, ...payload }: SessionAgentPayload<UploadVideoPayload>) {
+    return this.sessionApi(sessionId).uploadVideo(payload);
+  }
+
   runShellCommand({ sessionId, ...payload }: SessionAgentPayload<RunShellCommandPayload>) {
     return this.sessionApi(sessionId).runShellCommand(payload);
   }
diff --git a/packages/agent-core/src/session/rpc.ts b/packages/agent-core/src/session/rpc.ts
index a2e6f0c1e9..92df9b6501 100644
--- a/packages/agent-core/src/session/rpc.ts
+++ b/packages/agent-core/src/session/rpc.ts
@@ -36,6 +36,7 @@ import type {
   UndoHistoryPayload,
   UnregisterToolPayload,
   UpdateSessionMetadataPayload,
+  UploadVideoPayload,
 } from '#/rpc';
 import type { PromisableMethods } from '#/utils/types';
 
@@ -127,6 +128,10 @@ export class SessionAPIImpl implements PromisableMethods<SessionAPI> {
     return (await this.getAgent(agentId)).prompt(payload);
   }
 
+  async uploadVideo({ agentId, ...payload }: AgentScopedPayload<UploadVideoPayload>) {
+    return (await this.getAgent(agentId)).uploadVideo(payload);
+  }
+
   async steer({ agentId, ...payload }: AgentScopedPayload<SteerPayload>) {
     return (await this.getAgent(agentId)).steer(payload);
   }
diff --git a/packages/agent-core/src/tools/builtin/file/read-media.ts b/packages/agent-core/src/tools/builtin/file/read-media.ts
index 0f46154f1f..028d3f11d9 100644
--- a/packages/agent-core/src/tools/builtin/file/read-media.ts
+++ b/packages/agent-core/src/tools/builtin/file/read-media.ts
@@ -62,7 +62,7 @@ import readMediaDescriptionHead from './read-media.md?raw';
 // ── Constants ────────────────────────────────────────────────────────
 
 const MAX_MEDIA_MEGABYTES = 100;
-const MAX_MEDIA_BYTES = MAX_MEDIA_MEGABYTES * 1024 * 1024;
+export const MAX_MEDIA_BYTES = MAX_MEDIA_MEGABYTES * 1024 * 1024;
 
 function buildImageDeliveryLimitError(input: {
   readonly finalBytes: number;
diff --git a/packages/agent-core/test/agent/basic.test.ts b/packages/agent-core/test/agent/basic.test.ts
index dd0fc16376..94601b988c 100644
--- a/packages/agent-core/test/agent/basic.test.ts
+++ b/packages/agent-core/test/agent/basic.test.ts
@@ -1,5 +1,10 @@
 import type { ToolCall } from '@moonshot-ai/kosong';
-import { expect, it } from 'vitest';
+import { createServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { mkdtempSync, truncateSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
 
 import { FLAG_DEFINITIONS, FlagResolver } from '../../src/flags';
 import { createCommandKaos, testAgent } from './harness/agent';
@@ -151,3 +156,116 @@ it('runs an agent turn through builtin tool approval and execution', async () =>
   `);
   await ctx.expectResumeMatches();
 });
+
+describe('uploadVideo', () => {
+  // Minimal ISO-BMFF header: a 24-byte ftyp box with the `isom` brand, which
+  // is all the media sniffer needs to classify the file as video/mp4.
+  const FTYP_MP4 = Buffer.from([
+    0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70, 0x69, 0x73, 0x6f, 0x6d, 0x00, 0x00, 0x02,
+    0x00, 0x69, 0x73, 0x6f, 0x6d, 0x69, 0x73, 0x6f, 0x32,
+  ]);
+
+  function tempVideo(name = 'clip.mp4', bytes: Buffer = FTYP_MP4): string {
+    const dir = mkdtempSync(join(tmpdir(), 'agent-upload-video-'));
+    const path = join(dir, name);
+    writeFileSync(path, bytes);
+    return path;
+  }
+
+  interface StubFilesRequest {
+    readonly authorization?: string | undefined;
+    readonly bytes: number;
+  }
+
+  async function stubFilesServer(): Promise<{
+    url: string;
+    requests: StubFilesRequest[];
+    close: () => Promise<void>;
+  }> {
+    const requests: StubFilesRequest[] = [];
+    const server = createServer((req, res) => {
+      if (req.method === 'POST' && req.url === '/files') {
+        const chunks: Buffer[] = [];
+        req.on('data', (chunk: Buffer) => chunks.push(chunk));
+        req.on('end', () => {
+          requests.push({
+            authorization: req.headers.authorization,
+            bytes: Buffer.concat(chunks).length,
+          });
+          res.writeHead(200, { 'content-type': 'application/json' });
+          res.end(
+            JSON.stringify({
+              id: 'stub-video-file',
+              object: 'file',
+              bytes: FTYP_MP4.length,
+              created_at: 0,
+              filename: 'clip.mp4',
+              purpose: 'video',
+            }),
+          );
+        });
+        return;
+      }
+      res.writeHead(404);
+      res.end();
+    });
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const { port } = server.address() as AddressInfo;
+    return {
+      url: `http://127.0.0.1:${String(port)}`,
+      requests,
+      close: () => new Promise<void>((resolve) => server.close(() => resolve())),
+    };
+  }
+
+  it('uploads a local video through the bound provider and returns the issued reference', async () => {
+    const stub = await stubFilesServer();
+    try {
+      const ctx = testAgent();
+      ctx.configure({
+        provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model', baseUrl: stub.url },
+      });
+
+      const part = await ctx.rpc.uploadVideo({ path: tempVideo() });
+
+      expect(part).toEqual({
+        type: 'video_url',
+        videoUrl: { url: 'ms://stub-video-file', id: 'stub-video-file' },
+      });
+      expect(stub.requests).toHaveLength(1);
+      expect(stub.requests[0]?.authorization).toBe('Bearer test-key');
+      // The multipart body carries the video bytes, so it must be larger.
+      expect(stub.requests[0]?.bytes).toBeGreaterThan(FTYP_MP4.length);
+    } finally {
+      await stub.close();
+    }
+  });
+
+  it('rejects when the provider has no video upload channel', async () => {
+    const ctx = testAgent();
+    ctx.configure({ provider: { type: 'openai', apiKey: 'test-key', model: 'mock-model' } });
+
+    await expect(ctx.rpc.uploadVideo({ path: tempVideo() })).rejects.toThrow(
+      /does not support video upload/,
+    );
+  });
+
+  it('rejects a non-video file', async () => {
+    const ctx = testAgent();
+    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' } });
+
+    await expect(
+      ctx.rpc.uploadVideo({ path: tempVideo('notes.txt', Buffer.from('plain text')) }),
+    ).rejects.toThrow(/not a video file/);
+  });
+
+  it('rejects a video over the 100MB cap', async () => {
+    const ctx = testAgent();
+    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' } });
+    const path = tempVideo();
+    // Sparse extend: the ftyp header stays, the size crosses the cap.
+    truncateSync(path, 101 * 1024 * 1024);
+
+    await expect(ctx.rpc.uploadVideo({ path })).rejects.toThrow(/100MB/);
+  });
+});
diff --git a/packages/kap-server/src/lib/llmVideoRefs.ts b/packages/kap-server/src/lib/llmVideoRefs.ts
new file mode 100644
index 0000000000..c4acf825c8
--- /dev/null
+++ b/packages/kap-server/src/lib/llmVideoRefs.ts
@@ -0,0 +1,35 @@
+/**
+ * Maps provider-issued video file ids back to the local `/files` upload they
+ * were produced from. When a prompt video is inlined as a provider reference
+ * (`ms://<id>`), the transcript no longer names the local file, so UIs
+ * resolve the provider id through this map to play the video back from
+ * daemon storage (see `GET /files/llm/{llm_id}`).
+ *
+ * Each mapping is one blob-store key (`llm-video/<llmFileId>` → local file
+ * id), so concurrent prompt uploads never lose entries to a read-modify-write
+ * race, and the map survives restarts.
+ */
+
+import type { IBlobStore } from '@moonshot-ai/agent-core-v2';
+
+const SCOPE = 'llm-video';
+
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+
+/** Best-effort persistence is the caller's job; this throws on store errors. */
+export async function recordLlmVideoRef(
+  blobs: IBlobStore,
+  llmFileId: string,
+  localFileId: string,
+): Promise<void> {
+  await blobs.put(SCOPE, llmFileId, textEncoder.encode(localFileId));
+}
+
+export async function resolveLlmVideoRef(
+  blobs: IBlobStore,
+  llmFileId: string,
+): Promise<string | undefined> {
+  const data = await blobs.get(SCOPE, llmFileId);
+  return data === undefined ? undefined : textDecoder.decode(data);
+}
diff --git a/packages/kap-server/src/protocol/rest-file.ts b/packages/kap-server/src/protocol/rest-file.ts
index 21d6a119cd..85e2d63457 100644
--- a/packages/kap-server/src/protocol/rest-file.ts
+++ b/packages/kap-server/src/protocol/rest-file.ts
@@ -1,6 +1,7 @@
 /**
  *   POST   /v1/files                  (multipart upload)
  *   GET    /v1/files/{file_id}        (binary stream)
+ *   GET    /v1/files/llm/{llm_id}     (redirect to the local file a provider video id came from)
  *   DELETE /v1/files/{file_id}
  */
 
@@ -16,6 +17,11 @@ export const getFileParamSchema = z.object({
 });
 export type GetFileParam = z.infer<typeof getFileParamSchema>;
 
+export const getLlmVideoParamSchema = z.object({
+  llm_id: z.string().min(1),
+});
+export type GetLlmVideoParam = z.infer<typeof getLlmVideoParamSchema>;
+
 export const deleteFileParamSchema = z.object({
   file_id: z.string().min(1),
 });
diff --git a/packages/kap-server/src/routes/files.ts b/packages/kap-server/src/routes/files.ts
index ff74e99ffc..e70f82f6a5 100644
--- a/packages/kap-server/src/routes/files.ts
+++ b/packages/kap-server/src/routes/files.ts
@@ -3,6 +3,8 @@
  *
  *   POST   /files            upload a file (multipart/form-data) → FileMeta
  *   GET    /files/{file_id}  download a file (binary stream)
+ *   GET    /files/llm/{llm_id}  redirect a provider-issued video file id to
+ *                               the local file it was uploaded from
  *   DELETE /files/{file_id}  delete a file → { deleted: true }
  *
  * Backed by the v2 `IFileService` (Core scope), which stores bytes in
@@ -16,6 +18,7 @@ import multipart from '@fastify/multipart';
 import {
   DEFAULT_MAX_UPLOAD_BYTES,
   ErrorCodes,
+  IBlobStore,
   IFileService,
   Error2,
   type Scope,
@@ -23,6 +26,7 @@ import {
 import { z } from 'zod';
 
 import { requestLog } from '../lib/requestLog';
+import { resolveLlmVideoRef } from '../lib/llmVideoRefs';
 import { defineRoute } from '../middleware/defineRoute';
 import { ErrorCode } from '../protocol/error-codes';
 import { errEnvelope, okEnvelope } from '../protocol/envelope';
@@ -30,6 +34,7 @@ import {
   deleteFileParamSchema,
   deleteFileResponseSchema,
   getFileParamSchema,
+  getLlmVideoParamSchema,
   uploadFileResponseSchema,
 } from '../protocol/rest-file';
 
@@ -205,6 +210,38 @@ export function registerFilesRoutes(app: FilesRouteHost, core: Scope): void {
     downloadRoute.handler as unknown as Parameters<FilesRouteHost['get']>[2],
   );
 
+  const llmVideoRoute = defineRoute(
+    {
+      method: 'GET',
+      path: '/files/llm/{llm_id}',
+      params: getLlmVideoParamSchema,
+      errors: {
+        [ErrorCode.FILE_NOT_FOUND]: {},
+      },
+      description:
+        'Redirect a provider-issued video file id to the local file it was uploaded from',
+      tags: ['files'],
+    },
+    async (req, reply) => {
+      try {
+        const { llm_id } = req.params;
+        const localFileId = await resolveLlmVideoRef(core.accessor.get(IBlobStore), llm_id);
+        if (localFileId === undefined) {
+          throw new Error2(ErrorCodes.FILE_NOT_FOUND, 'file not found');
+        }
+        const r = reply as unknown as FilesReply;
+        r.code(302).header('location', `/api/v1/files/${localFileId}`).send('');
+      } catch (error) {
+        sendMappedError(reply as unknown as FilesReply, req, error);
+      }
+    },
+  );
+  app.get(
+    llmVideoRoute.path,
+    llmVideoRoute.options,
+    llmVideoRoute.handler as unknown as Parameters<FilesRouteHost['get']>[2],
+  );
+
   const deleteRoute = defineRoute(
     {
       method: 'DELETE',
diff --git a/packages/kap-server/src/routes/prompts.ts b/packages/kap-server/src/routes/prompts.ts
index 1cddd845f4..ce811a9f93 100644
--- a/packages/kap-server/src/routes/prompts.ts
+++ b/packages/kap-server/src/routes/prompts.ts
@@ -18,9 +18,12 @@ import {
   IAgentProfileService,
   IAgentPromptService,
   IAuthSummaryService,
+  IBlobStore,
   IEventService,
   IFileService,
+  IModelCatalog,
   ISessionMetadata,
+  createVideoUploader,
   promptMetadataTextFromContentParts,
   type ContentPart,
   type PromptHandle,
@@ -46,6 +49,8 @@ import {
   type ImageCompressionTelemetry,
   type ISessionScopeHandle,
   type Scope,
+  type VideoUploadInput,
+  type VideoURLPart,
 } from '@moonshot-ai/agent-core-v2';
 import { ErrorCode } from '../protocol/error-codes';
 import {
@@ -60,6 +65,7 @@ import {
 import { z } from 'zod';
 
 import { errEnvelope, okEnvelope } from '../envelope';
+import { recordLlmVideoRef } from '../lib/llmVideoRefs';
 import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
 import { ensureMainAgent, MAIN_AGENT_ID } from '../transport/mainAgent';
@@ -136,6 +142,32 @@ async function resolvePromptFromSession(session: ISessionScopeHandle, agentId?:
   };
 }
 
+/**
+ * Build the prompt-time video uploader from the session's effective model.
+ * `undefined` when the model cannot ingest video (no `video_in` capability
+ * or no provider upload channel) — prompt videos then fall back to the
+ * file-tag form and the model opens them with ReadMediaFile.
+ */
+function promptVideoUploader(
+  profile: IAgentProfileService,
+  modelCatalog: IModelCatalog,
+  telemetry: ITelemetryService,
+): ((input: VideoUploadInput) => Promise<VideoURLPart>) | undefined {
+  if (!profile.getModelCapabilities().video_in) return undefined;
+  const modelAlias = profile.getModel();
+  if (modelAlias === '') return undefined;
+  const requester = modelCatalog.getRequester(modelAlias);
+  const model = requester.model;
+  return createVideoUploader(requester, {
+    client: telemetry,
+    props: {
+      model: modelAlias,
+      provider_type: model?.providerType ?? model?.protocol,
+      protocol: model?.protocol,
+    },
+  });
+}
+
 export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
   const listRoute = defineRoute(
     {
@@ -184,12 +216,32 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
     async (req, reply) => {
       try {
         const { session_id } = req.params;
+        // Resolve the agent and apply profile overrides first: prompt media
+        // resolution (video upload) keys off the effective model.
+        const resolved = await resolvePrompt(core, session_id, req.body.agent_id);
+        await resolved.auth.ensureReady();
+        if (req.body.model !== undefined) await resolved.profile.setModel(req.body.model);
+        if (req.body.thinking !== undefined) resolved.profile.setThinking(req.body.thinking);
+        if (req.body.permission_mode !== undefined) resolved.permissionMode.setMode(req.body.permission_mode);
+        const telemetry = core.accessor.get(ITelemetryService).withContext({ sessionId: session_id });
         const resolvedBody = await resolvePromptMediaFiles(
           req.body,
           core.accessor.get(IFileService),
           core.accessor.get(IBootstrapService).cacheDir,
           {
-            telemetry: core.accessor.get(ITelemetryService).withContext({ sessionId: session_id }),
+            telemetry,
+            videoUploader: promptVideoUploader(
+              resolved.profile,
+              core.accessor.get(IModelCatalog),
+              telemetry,
+            ),
+            onVideoInlined: async (localFileId, llmFileId) => {
+              // Best effort — a lost mapping only means the web UI cannot
+              // play this prompt video back from daemon storage.
+              await recordLlmVideoRef(core.accessor.get(IBlobStore), llmFileId, localFileId).catch(
+                () => undefined,
+              );
+            },
             resolveOriginalsDir: async () => {
               const session = await core.accessor.get(ISessionLifecycleService).resume(session_id);
               if (session === undefined) return undefined;
@@ -202,11 +254,6 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
             },
           },
         );
-        const resolved = await resolvePrompt(core, session_id, resolvedBody.agent_id);
-        await resolved.auth.ensureReady();
-        if (resolvedBody.model !== undefined) await resolved.profile.setModel(resolvedBody.model);
-        if (resolvedBody.thinking !== undefined) resolved.profile.setThinking(resolvedBody.thinking);
-        if (resolvedBody.permission_mode !== undefined) resolved.permissionMode.setMode(resolvedBody.permission_mode);
         const parts = contentToCoreParts(resolvedBody.content);
         const session = await resolveSession(core, session_id);
         await applyPromptMetadataUpdate({
@@ -338,7 +385,7 @@ function corePartsToProtocol(content: readonly ContentPart[]): PromptSubmission[
     } else if (part.type === 'video_url') {
       const match = /^data:([^;]+);base64,(.*)$/.exec(part.videoUrl.url);
       parts.push(match === null
-        ? { type: 'video', source: { kind: 'url', url: part.videoUrl.url } }
+        ? { type: 'video', source: { kind: 'url', url: part.videoUrl.url, id: part.videoUrl.id } }
         : { type: 'video', source: { kind: 'base64', media_type: match[1]!, data: match[2]! } });
     }
   }
@@ -351,7 +398,7 @@ function contentToCoreParts(content: PromptSubmission['content']): ContentPart[]
     if (part.type === 'text') parts.push({ type: 'text', text: part.text });
     else if (part.type === 'image' && part.source.kind === 'url') parts.push({ type: 'image_url', imageUrl: { url: part.source.url } });
     else if (part.type === 'image' && part.source.kind === 'base64') parts.push({ type: 'image_url', imageUrl: { url: `data:${part.source.media_type};base64,${part.source.data}` } });
-    else if (part.type === 'video' && part.source.kind === 'url') parts.push({ type: 'video_url', videoUrl: { url: part.source.url } });
+    else if (part.type === 'video' && part.source.kind === 'url') parts.push({ type: 'video_url', videoUrl: { url: part.source.url, id: part.source.id } });
     else if (part.type === 'video' && part.source.kind === 'base64') parts.push({ type: 'video_url', videoUrl: { url: `data:${part.source.media_type};base64,${part.source.data}` } });
   }
   return parts;
@@ -374,6 +421,18 @@ interface ResolvePromptMediaOptions {
   readonly resolveAttachmentsDir?: () => Promise<string | undefined>;
   /** Report an `image_compress` event per compressed prompt image. */
   readonly telemetry?: ITelemetryService;
+  /**
+   * When set, uploaded video files are inlined into the prompt as the
+   * provider-issued reference. Undefined disables inlining — every video
+   * falls back to the file-tag form.
+   */
+  readonly videoUploader?: (input: VideoUploadInput) => Promise<VideoURLPart>;
+  /**
+   * Called after a video is inlined, with the local `/files` id and the
+   * provider-issued file id, so the daemon can map the reference back to
+   * local bytes for playback. Errors are swallowed by the caller.
+   */
+  readonly onVideoInlined?: (localFileId: string, llmFileId: string) => Promise<void>;
 }
 
 async function resolvePromptMediaFiles(
@@ -583,6 +642,32 @@ async function resolvePromptMediaFiles(
       continue;
     }
 
+    // Uploaded video: inline the provider-issued reference into the prompt
+    // so the model receives the video with the user message instead of having
+    // to open it with a tool call. Falls back to the file-tag form when the
+    // model has no upload channel or the upload fails.
+    if (part.type === 'video' && options.videoUploader !== undefined) {
+      try {
+        const data = await readFileOrStream(file);
+        const uploaded = await options.videoUploader({
+          data,
+          mimeType: file.meta.media_type,
+          filename: file.meta.name,
+        });
+        content.push({
+          type: 'video',
+          source: { kind: 'url', url: uploaded.videoUrl.url, id: uploaded.videoUrl.id },
+        });
+        changed = true;
+        if (uploaded.videoUrl.id !== undefined) {
+          await options.onVideoInlined?.(file.meta.id, uploaded.videoUrl.id);
+        }
+        continue;
+      } catch {
+        // Fall through to the file-tag form below.
+      }
+    }
+
     const cachePath = await materializeVideoToCache(file, cacheDir);
     content.push({ type: 'text', text: `<video path="${escapeAttribute(cachePath)}"></video>` });
     changed = true;
diff --git a/packages/kap-server/test/__snapshots__/apiSurface.snapshot.test.ts.snap b/packages/kap-server/test/__snapshots__/apiSurface.snapshot.test.ts.snap
index d6585d9036..b37ef2f2f9 100644
--- a/packages/kap-server/test/__snapshots__/apiSurface.snapshot.test.ts.snap
+++ b/packages/kap-server/test/__snapshots__/apiSurface.snapshot.test.ts.snap
@@ -64,6 +64,10 @@ exports[`API surface snapshot > matches the documented v2 route table and meta e
       "GET",
       "/api/v1/files/{file_id}",
     ],
+    [
+      "GET",
+      "/api/v1/files/llm/{llm_id}",
+    ],
     [
       "GET",
       "/api/v1/fs:browse",
diff --git a/packages/kap-server/test/files.test.ts b/packages/kap-server/test/files.test.ts
index 6a9060d1d2..ac14035c58 100644
--- a/packages/kap-server/test/files.test.ts
+++ b/packages/kap-server/test/files.test.ts
@@ -320,3 +320,15 @@ describe('POST /api/v1/files (server-v2)', () => {
     expect((res.json() as Envelope).code).toBe(40001);
   });
 });
+
+describe('GET /api/v1/files/llm/{llm_id} (server-v2)', () => {
+  it('unknown provider file id → 40407 file not found', async () => {
+    const r = await boot();
+    const res = await appOf(r).inject({
+      method: 'GET',
+      url: '/api/v1/files/llm/no-such-provider-file',
+    });
+    expect(res.statusCode).toBe(404);
+    expect((res.json() as Envelope).code).toBe(40407);
+  });
+});
diff --git a/packages/kap-server/test/prompts.test.ts b/packages/kap-server/test/prompts.test.ts
index ac471db21d..9daba52ffe 100644
--- a/packages/kap-server/test/prompts.test.ts
+++ b/packages/kap-server/test/prompts.test.ts
@@ -1,4 +1,6 @@
 import { mkdtemp, readFile, realpath, rm, writeFile } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { deflateSync } from 'node:zlib';
@@ -211,7 +213,7 @@ describe('server-v2 /api/v1 prompts', () => {
     expect(Array.isArray(list.body.data.queued)).toBe(true);
   });
 
-  it('materializes uploaded video prompts into cache path tags', async () => {
+  it('falls back to cache path tags for uploaded videos when the model has no upload channel', async () => {
     const id = await createSession(home as string);
     await createMainAgent(id);
     const videoBytes = Buffer.from('tiny fake mp4 bytes');
@@ -651,3 +653,161 @@ describe('server-v2 /api/v1 prompts', () => {
     expect(body.code).toBe(40401);
   });
 });
+
+describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
+  let server: RunningServer | undefined;
+  let home: string | undefined;
+  let base: string;
+  let stubClose: (() => Promise<void>) | undefined;
+  let stubBodies: Buffer[];
+
+  function kimiToml(stubUrl: string): string {
+    return [
+      'default_model = "stub"',
+      '',
+      '[providers.stub]',
+      'type = "kimi"',
+      `base_url = "${stubUrl}"`,
+      'api_key = "stub"',
+      '',
+      '[models.stub]',
+      'provider = "stub"',
+      'model = "stub"',
+      'max_context_size = 1000',
+      'capabilities = [ "video_in", "image_in" ]',
+      '',
+    ].join('\n');
+  }
+
+  beforeEach(async () => {
+    stubBodies = [];
+    const stub = createServer((req, res) => {
+      if (req.method === 'POST' && req.url === '/files') {
+        const chunks: Buffer[] = [];
+        req.on('data', (chunk: Buffer) => chunks.push(chunk));
+        req.on('end', () => {
+          stubBodies.push(Buffer.concat(chunks));
+          res.writeHead(200, { 'content-type': 'application/json' });
+          res.end(
+            JSON.stringify({
+              id: 'stub-llm-video',
+              object: 'file',
+              bytes: 17,
+              created_at: 0,
+              filename: 'clip.mp4',
+              purpose: 'video',
+            }),
+          );
+        });
+        return;
+      }
+      if (req.method === 'POST' && req.url === '/chat/completions') {
+        // The turn is aborted by the test; this answer is never needed.
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+      res.writeHead(404);
+      res.end();
+    });
+    await new Promise<void>((resolve) => stub.listen(0, '127.0.0.1', resolve));
+    const { port } = stub.address() as AddressInfo;
+    stubClose = () => new Promise<void>((resolve) => stub.close(() => resolve()));
+
+    home = await mkdtemp(join(tmpdir(), 'kimi-server-v2-prompts-kimi-'));
+    await writeFile(join(home, 'config.toml'), kimiToml(`http://127.0.0.1:${String(port)}`), 'utf-8');
+    server = await startServer({ host: '127.0.0.1', port: 0, homeDir: home, logLevel: 'silent' });
+    base = `http://127.0.0.1:${server.port}`;
+  });
+
+  afterEach(async () => {
+    if (server !== undefined) {
+      await server.close();
+      server = undefined;
+      await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+    if (stubClose !== undefined) {
+      await stubClose();
+      stubClose = undefined;
+    }
+    if (home !== undefined) {
+      await rm(home, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 } as never);
+      home = undefined;
+    }
+  });
+
+  it('inlines an uploaded video prompt as the provider-issued reference', async () => {
+    const sessionRes = await fetch(`${base}/api/v1/sessions`, {
+      method: 'POST',
+      headers: authHeaders(server as RunningServer, { 'content-type': 'application/json' }),
+      body: JSON.stringify({ metadata: { cwd: home } }),
+    } as never);
+    const sessionBody = (await sessionRes.json()) as Envelope<{ id: string }>;
+    const id = sessionBody.data.id;
+    const session = server!.core.accessor.get(ISessionLifecycleService).get(id);
+    await session!.accessor.get(IAgentLifecycleService).create({ agentId: 'main' });
+
+    const videoBytes = Buffer.from('tiny fake mp4 bytes');
+    const form = new FormData();
+    form.set('file', new Blob([videoBytes], { type: 'video/mp4' }), 'clip.mp4');
+    const uploadRes = await fetch(`${base}/api/v1/files`, {
+      method: 'POST',
+      headers: authHeaders(server as RunningServer),
+      body: form,
+    } as never);
+    const uploaded = (await uploadRes.json()) as Envelope<{ id: string }>;
+    expect(uploaded.code).toBe(0);
+
+    const submitRes = await fetch(`${base}/api/v1/sessions/${id}/prompts`, {
+      method: 'POST',
+      headers: authHeaders(server as RunningServer, { 'content-type': 'application/json' }),
+      body: JSON.stringify({
+        // The prompt-time model override is applied before media resolution,
+        // so the video uploader is built from this model.
+        model: 'stub',
+        content: [
+          { type: 'text', text: 'what happens in this video?' },
+          { type: 'video', source: { kind: 'file', file_id: uploaded.data.id } },
+        ],
+      }),
+    } as never);
+    const submitted = (await submitRes.json()) as Envelope<PromptItemWire>;
+    expect(submitted.code).toBe(0);
+
+    // The prompt carries the provider-issued reference, not a path tag.
+    const content = submitted.data.content as Array<Record<string, unknown>>;
+    expect(content[0]).toEqual({ type: 'text', text: 'what happens in this video?' });
+    expect(content[1]).toEqual({
+      type: 'video',
+      source: { kind: 'url', url: 'ms://stub-llm-video', id: 'stub-llm-video' },
+    });
+
+    // The upload happened synchronously, before the prompt was accepted, and
+    // carried the video bytes.
+    expect(stubBodies).toHaveLength(1);
+    expect(stubBodies[0]!.includes(videoBytes)).toBe(true);
+
+    // The provider id maps back to the local upload for playback.
+    const redirectRes = await fetch(`${base}/api/v1/files/llm/stub-llm-video`, {
+      headers: authHeaders(server as RunningServer),
+      redirect: 'manual',
+    } as never);
+    expect(redirectRes.status).toBe(302);
+    const location = redirectRes.headers.get('location');
+    expect(location).toBe(`/api/v1/files/${uploaded.data.id}`);
+
+    const downloadRes = await fetch(`${base}${location}`, {
+      headers: authHeaders(server as RunningServer),
+    } as never);
+    expect(downloadRes.status).toBe(200);
+    expect(Buffer.from(await downloadRes.arrayBuffer())).toEqual(videoBytes);
+
+    // The stub serves no generation, so the turn keeps retrying in the
+    // background; abort it deterministically to let the server close.
+    const abortRes = await fetch(
+      `${base}/api/v1/sessions/${id}/prompts/${submitted.data.prompt_id}:abort`,
+      { method: 'POST', headers: authHeaders(server as RunningServer) } as never,
+    );
+    expect(abortRes.status).toBe(200);
+  });
+});
diff --git a/packages/node-sdk/src/rpc.ts b/packages/node-sdk/src/rpc.ts
index df5a2825e2..a6e99048b3 100644
--- a/packages/node-sdk/src/rpc.ts
+++ b/packages/node-sdk/src/rpc.ts
@@ -59,6 +59,7 @@ import type {
   SkillSummary,
   PluginCommandDef,
   Unsubscribe,
+  VideoURLPart,
 } from '#/types';
 
 const MAIN_AGENT_ID = 'main';
@@ -320,6 +321,15 @@ export abstract class SDKRpcClientBase {
     });
   }
 
+  async uploadVideo(input: SessionIdRpcInput & { path: string }): Promise<VideoURLPart> {
+    const rpc = await this.getRpc();
+    return rpc.uploadVideo({
+      sessionId: input.sessionId,
+      agentId: this.interactiveAgentId,
+      path: input.path,
+    });
+  }
+
   async runShellCommand(input: {
     sessionId: string;
     command: string;
diff --git a/packages/node-sdk/src/session.ts b/packages/node-sdk/src/session.ts
index 571c2355ff..f767d0f509 100644
--- a/packages/node-sdk/src/session.ts
+++ b/packages/node-sdk/src/session.ts
@@ -36,6 +36,7 @@ import type {
   PluginCommandDef,
   ThinkingEffort,
   Unsubscribe,
+  VideoURLPart,
 } from '#/types';
 
 const MAIN_AGENT_ID = 'main';
@@ -111,6 +112,18 @@ export class Session {
     });
   }
 
+  /**
+   * Upload a local video file through the session's current model and return
+   * the provider-issued `video_url` part, ready to embed in a prompt.
+   * Rejects when the model has no video upload channel — the caller decides
+   * how to degrade (e.g. fall back to a path reference the model can open
+   * with ReadMediaFile).
+   */
+  async uploadVideo(path: string): Promise<VideoURLPart> {
+    this.ensureOpen();
+    return this.rpc.uploadVideo({ sessionId: this.id, path });
+  }
+
   /** Execute a user-initiated `!` shell command (silent — does not prompt the
    *  model). Resolves with the command's stdout/stderr for immediate display.
    *  Pass `commandId` to receive live `shell.output` events for this command. */
diff --git a/packages/node-sdk/src/types.ts b/packages/node-sdk/src/types.ts
index c72419e3f4..a005bad348 100644
--- a/packages/node-sdk/src/types.ts
+++ b/packages/node-sdk/src/types.ts
@@ -70,7 +70,7 @@ export type {
 
 export type { KimiHostIdentity, OAuthRefreshOutcome };
 export type { TelemetryClient, TelemetryContextPatch, TelemetryProperties };
-export type { ContentPart, Role, ThinkingEffort, ToolCall } from '@moonshot-ai/kosong';
+export type { ContentPart, Role, ThinkingEffort, ToolCall, VideoURLPart } from '@moonshot-ai/kosong';
 
 export type PermissionMode = 'yolo' | 'manual' | 'auto';
 
diff --git a/packages/node-sdk/test/session-prompt-input.test.ts b/packages/node-sdk/test/session-prompt-input.test.ts
index f88c710009..c073a8c45e 100644
--- a/packages/node-sdk/test/session-prompt-input.test.ts
+++ b/packages/node-sdk/test/session-prompt-input.test.ts
@@ -158,4 +158,21 @@ describe('Session.prompt input normalization', () => {
       ]),
     );
   });
+
+  it('uploads a video through the session RPC and returns the issued reference', async () => {
+    const uploadVideo = vi.fn(async () => ({
+      type: 'video_url' as const,
+      videoUrl: { url: 'ms://file-123', id: 'file-123' },
+    }));
+    const session = new Session({
+      id: 'ses_upload_video',
+      workDir: '/tmp/work',
+      rpc: { uploadVideo } as unknown as SDKRpcClientBase,
+    });
+
+    const part = await session.uploadVideo('/tmp/clip.mp4');
+
+    expect(part).toEqual({ type: 'video_url', videoUrl: { url: 'ms://file-123', id: 'file-123' } });
+    expect(uploadVideo).toHaveBeenCalledWith({ sessionId: 'ses_upload_video', path: '/tmp/clip.mp4' });
+  });
 });

From 6946c57ca81ca9cef5a00bc83d0fd9c6304615be Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 16:32:31 +0800
Subject: [PATCH 02/45] fix: fall back to inline video when the upload channel
 fails
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ReadMediaFile only used the provider's video upload channel when one
was bound, and surfaced a hard tool error when the upload itself
failed — on providers without a files endpoint (or a transient upload
failure) the model was told the video could not be read at all. Now a
missing or failing upload falls back to delivering the video inline
(base64), the same shape providers without an upload channel already
get. Both engines (agent-core and agent-core-v2) are fixed.
---
 .../fix-read-media-video-upload-fallback.md   |  5 +++
 .../src/agent/media/tools/read-media.ts       | 41 ++++++++++++++-----
 .../test/agent/media/tools/read-media.test.ts | 15 +++++++
 .../src/tools/builtin/file/read-media.ts      | 41 ++++++++++++++-----
 .../agent-core/test/tools/read-media.test.ts  | 30 ++++++++++++++
 5 files changed, 110 insertions(+), 22 deletions(-)
 create mode 100644 .changeset/fix-read-media-video-upload-fallback.md

diff --git a/.changeset/fix-read-media-video-upload-fallback.md b/.changeset/fix-read-media-video-upload-fallback.md
new file mode 100644
index 0000000000..5ce6d3b140
--- /dev/null
+++ b/.changeset/fix-read-media-video-upload-fallback.md
@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Fix ReadMediaFile failing on videos when the model's provider has no usable file upload channel — the video now falls back to being sent inline.
diff --git a/packages/agent-core-v2/src/agent/media/tools/read-media.ts b/packages/agent-core-v2/src/agent/media/tools/read-media.ts
index f8f7f93380..aa7946ed70 100644
--- a/packages/agent-core-v2/src/agent/media/tools/read-media.ts
+++ b/packages/agent-core-v2/src/agent/media/tools/read-media.ts
@@ -255,6 +255,35 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
       telemetry === undefined ? undefined : { client: telemetry, source: 'read_media' };
   }
 
+  /**
+   * Deliver a video through the provider's upload channel when available,
+   * falling back to an inline base64 part when the channel is missing or the
+   * upload itself fails (e.g. the provider has no files endpoint) — a failed
+   * upload must not turn the whole read into an error.
+   */
+  private async videoContentPart(
+    data: Buffer,
+    mimeType: string,
+    safePath: string,
+  ): Promise<ContentPart> {
+    if (this.videoUploader !== undefined) {
+      try {
+        return await this.videoUploader({
+          data,
+          mimeType,
+          filename: safePath.split(/[\\/]/).at(-1),
+        });
+      } catch {
+        // Fall through to the inline form.
+      }
+    }
+    const base64 = data.toString('base64');
+    return {
+      type: 'video_url',
+      videoUrl: { url: `data:${mimeType};base64,${base64}` },
+    };
+  }
+
   resolveExecution(args: ReadMediaFileInput): ToolExecution {
     if (!args.path) {
       return { isError: true, output: 'File path cannot be empty.' };
@@ -475,18 +504,8 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
             dimensions = { width: compressed.originalWidth, height: compressed.originalHeight };
           }
         }
-      } else if (this.videoUploader !== undefined) {
-        mediaPart = await this.videoUploader({
-          data,
-          mimeType: fileType.mimeType,
-          filename: safePath.split(/[\\/]/).at(-1),
-        });
       } else {
-        const base64 = data.toString('base64');
-        mediaPart = {
-          type: 'video_url',
-          videoUrl: { url: `data:${fileType.mimeType};base64,${base64}` },
-        };
+        mediaPart = await this.videoContentPart(data, fileType.mimeType, safePath);
       }
 
       const tag = fileType.kind === 'image' ? 'image' : 'video';
diff --git a/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts b/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts
index 505050106f..e00df92116 100644
--- a/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts
+++ b/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts
@@ -684,6 +684,21 @@ describe('ReadMediaFileTool', () => {
     expect(parts[1]).toEqual(uploadResult);
   });
 
+  it('falls back to an inline base64 video part when the upload fails', async () => {
+    const videoUploader = vi.fn<VideoUploader>().mockRejectedValue(new Error('404 route not found'));
+    const result = await execute(
+      makeTool({ '/workspace/clip.mp4': { data: mp4Buffer() } }, capabilities(), videoUploader),
+      { path: '/workspace/clip.mp4' },
+    );
+    expect(result.isError).not.toBe(true);
+    const parts = outputParts(result);
+    expect(videoUploader).toHaveBeenCalledOnce();
+    expect(parts[1]).toEqual({
+      type: 'video_url',
+      videoUrl: { url: `data:video/mp4;base64,${mp4Buffer().toString('base64')}` },
+    });
+  });
+
   it('rejects empty files', async () => {
     const result = await execute(
       makeTool({ '/workspace/sample.png': { data: pngBuffer(), size: 0 } }),
diff --git a/packages/agent-core/src/tools/builtin/file/read-media.ts b/packages/agent-core/src/tools/builtin/file/read-media.ts
index 028d3f11d9..414b73c9a5 100644
--- a/packages/agent-core/src/tools/builtin/file/read-media.ts
+++ b/packages/agent-core/src/tools/builtin/file/read-media.ts
@@ -277,6 +277,35 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
     this.imageLimits = imageLimits ?? new ImageLimits();
   }
 
+  /**
+   * Deliver a video through the provider's upload channel when available,
+   * falling back to an inline base64 part when the channel is missing or the
+   * upload itself fails (e.g. the provider has no files endpoint) — a failed
+   * upload must not turn the whole read into an error.
+   */
+  private async videoContentPart(
+    data: Buffer,
+    mimeType: string,
+    safePath: string,
+  ): Promise<ContentPart> {
+    if (this.videoUploader !== undefined) {
+      try {
+        return await this.videoUploader({
+          data,
+          mimeType,
+          filename: safePath.split(/[\\/]/).at(-1),
+        });
+      } catch {
+        // Fall through to the inline form.
+      }
+    }
+    const base64 = data.toString('base64');
+    return {
+      type: 'video_url',
+      videoUrl: { url: `data:${mimeType};base64,${base64}` },
+    };
+  }
+
   resolveExecution(args: ReadMediaFileInput): ToolExecution {
     const path = resolvePathAccessPath(args.path, {
       kaos: this.kaos,
@@ -534,18 +563,8 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
             dimensions = { width: compressed.originalWidth, height: compressed.originalHeight };
           }
         }
-      } else if (this.videoUploader !== undefined) {
-        mediaPart = await this.videoUploader({
-          data,
-          mimeType: fileType.mimeType,
-          filename: safePath.split(/[\\/]/).at(-1),
-        });
       } else {
-        const base64 = data.toString('base64');
-        mediaPart = {
-          type: 'video_url',
-          videoUrl: { url: `data:${fileType.mimeType};base64,${base64}` },
-        };
+        mediaPart = await this.videoContentPart(data, fileType.mimeType, safePath);
       }
 
       const tag = fileType.kind === 'image' ? 'image' : 'video';
diff --git a/packages/agent-core/test/tools/read-media.test.ts b/packages/agent-core/test/tools/read-media.test.ts
index 67a0aad985..ff3489b1e1 100644
--- a/packages/agent-core/test/tools/read-media.test.ts
+++ b/packages/agent-core/test/tools/read-media.test.ts
@@ -419,6 +419,36 @@ describe('ReadMediaFileTool', () => {
     });
   });
 
+  it('falls back to an inline base64 video part when the upload fails', async () => {
+    const videoUploader = vi.fn().mockRejectedValue(new Error('404 route not found'));
+    const tool = new ReadMediaFileTool(
+      createFakeKaos({
+        stat: vi.fn<Kaos['stat']>().mockResolvedValue({
+          ...DEFAULT_STAT,
+          stSize: MP4_HEADER.length,
+        }),
+        readBytes: vi.fn<Kaos['readBytes']>().mockResolvedValue(MP4_HEADER),
+      }),
+      PERMISSIVE_WORKSPACE,
+      capabilities(),
+      videoUploader,
+    );
+
+    const result = await executeTool(tool, {
+      turnId: 't1',
+      toolCallId: 'c4b',
+      args: { path: '/workspace/sample.mp4' },
+      signal,
+    });
+
+    expect(result.isError).not.toBe(true);
+    const parts = outputParts(result);
+    expect(parts[1]).toEqual({
+      type: 'video_url',
+      videoUrl: { url: `data:video/mp4;base64,${MP4_HEADER.toString('base64')}` },
+    });
+  });
+
   it('rejects text files with a Read hint', async () => {
     const text = Buffer.from('hello');
     const tool = makeReadMediaTool({

From ead47c6bc66ecc2f8730ce4d26850fe94c5fb018 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 16:33:35 +0800
Subject: [PATCH 03/45] test: cover prompt video edge cases and failure paths

Stress coverage for the prompt video pipeline:

- agent-core uploadVideo RPC: extension/magic classification
  (.txt with video bytes accepted, extension trusted when magic is
  absent), exact 100MB boundary, directory and nonexistent paths
- TUI: mixed per-video outcomes (one inlined, one tag fallback),
  submission order behind an in-flight upload, queued video messages
  carrying final uploaded parts
- kap-server: per-video provider-id mappings, Range requests through
  the llm redirect, mapping persistence across a server restart
---
 .../test/tui/input/image-placeholder.test.ts  |  34 +++++
 .../test/tui/kimi-tui-message-flow.test.ts    |  76 ++++++++++
 packages/agent-core/test/agent/basic.test.ts  | 103 +++++++++++++
 packages/kap-server/test/prompts.test.ts      | 141 ++++++++++++++----
 4 files changed, 324 insertions(+), 30 deletions(-)

diff --git a/apps/kimi-code/test/tui/input/image-placeholder.test.ts b/apps/kimi-code/test/tui/input/image-placeholder.test.ts
index 5a6de196e2..41fe208587 100644
--- a/apps/kimi-code/test/tui/input/image-placeholder.test.ts
+++ b/apps/kimi-code/test/tui/input/image-placeholder.test.ts
@@ -478,3 +478,37 @@ describe('extractMediaSegments + materializeMediaSegments', () => {
     }
   });
 });
+
+describe('materializeMediaSegments failure mixing', () => {
+  it('inlines successful uploads and falls back per-video on individual failures', async () => {
+    const { cleanup } = setupTempCache();
+    const srcDir = makeTempDir();
+    try {
+      const srcA = join(srcDir, 'a.mp4');
+      const srcB = join(srcDir, 'b.mp4');
+      writeFileSync(srcA, 'a-bytes');
+      writeFileSync(srcB, 'b-bytes');
+      const store = new ImageAttachmentStore();
+      const vidA = store.addVideo('video/mp4', srcA);
+      const vidB = store.addVideo('video/mp4', srcB);
+      const r = extractMediaSegments(`${vidA.placeholder} then ${vidB.placeholder}`, store);
+
+      const parts = await materializeMediaSegments(r.segments, async (att) => {
+        if (att.sourcePath === srcB) throw new Error('upload failed');
+        return { type: 'video_url', videoUrl: { url: `ms://${att.sourcePath}` } };
+      });
+
+      // A inlined, B degraded to a cache tag — order and both contents kept.
+      expect(parts[0]).toEqual({ type: 'video_url', videoUrl: { url: `ms://${srcA}` } });
+      expect(parts[1]).toEqual({ type: 'text', text: ' then ' });
+      expect(parts[2]?.type).toBe('text');
+      const tag = (parts[2] as TextPart).text;
+      const m = /<video path="([^"]+)"><\/video>/.exec(tag);
+      expect(m).not.toBeNull();
+      expect(readFileSync(m![1]!, 'utf8')).toBe('b-bytes');
+    } finally {
+      cleanup();
+      rmSync(srcDir, { recursive: true, force: true });
+    }
+  });
+});
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index ae0ea985b4..47b3c6b2c5 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -1607,6 +1607,82 @@ command = "vim"
     }
   });
 
+  it('keeps submit order when a video upload is in flight', async () => {
+    const { driver, session } = await makeDriver();
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
+    try {
+      const srcVideo = join(dir, 'clip.mp4');
+      await writeFile(srcVideo, 'video-bytes');
+      const attachment = imageStore.addVideo('video/mp4', srcVideo);
+
+      let releaseUpload!: () => void;
+      vi.mocked(session.uploadVideo).mockImplementationOnce(
+        () =>
+          new Promise((resolve) => {
+            releaseUpload = () =>
+              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
+          }),
+      );
+
+      driver.handleUserInput(`watch ${attachment.placeholder}`);
+      driver.handleUserInput('plain follow-up');
+
+      // Nothing may overtake the in-flight upload.
+      await new Promise((r) => setTimeout(r, 20));
+      expect(session.prompt).not.toHaveBeenCalled();
+
+      releaseUpload();
+      await vi.waitFor(() => {
+        expect(session.prompt).toHaveBeenCalledWith([
+          { type: 'text', text: 'watch ' },
+          { type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } },
+        ]);
+      });
+      // The video prompt starts a turn, so the follow-up holds in the queue —
+      // submission order is preserved either way.
+      expect(session.prompt).toHaveBeenCalledTimes(1);
+      expect(driver.state.queuedMessages.map((m) => m.text)).toEqual(['plain follow-up']);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('queues a pasted-video message with uploaded parts while streaming', async () => {
+    const session = makeSession();
+    const { driver } = await makeDriver(session);
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
+    try {
+      const srcVideo = join(dir, 'clip.mp4');
+      await writeFile(srcVideo, 'video-bytes');
+      const attachment = imageStore.addVideo('video/mp4', srcVideo);
+      driver.state.appState.streamingPhase = 'waiting';
+
+      driver.handleUserInput(`describe ${attachment.placeholder}`);
+
+      // The upload completes even while the turn is busy; the queued message
+      // carries the final parts by the time it is drained.
+      await vi.waitFor(() => {
+        expect(driver.state.queuedMessages).toHaveLength(1);
+      });
+      expect(session.prompt).not.toHaveBeenCalled();
+      const queued = driver.state.queuedMessages[0];
+      expect(queued?.parts).toEqual([
+        { type: 'text', text: 'describe ' },
+        { type: 'video_url', videoUrl: { url: 'ms://stub-video', id: 'stub-video' } },
+      ]);
+
+      driver.sendQueuedMessage(session, queued!);
+      expect(session.prompt).toHaveBeenCalledWith([
+        { type: 'text', text: 'describe ' },
+        { type: 'video_url', videoUrl: { url: 'ms://stub-video', id: 'stub-video' } },
+      ]);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
   it('sends pasted image placeholders as image content parts', async () => {
     const { driver, session } = await makeDriver();
     const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
diff --git a/packages/agent-core/test/agent/basic.test.ts b/packages/agent-core/test/agent/basic.test.ts
index 94601b988c..64dc7c30f5 100644
--- a/packages/agent-core/test/agent/basic.test.ts
+++ b/packages/agent-core/test/agent/basic.test.ts
@@ -269,3 +269,106 @@ describe('uploadVideo', () => {
     await expect(ctx.rpc.uploadVideo({ path })).rejects.toThrow(/100MB/);
   });
 });
+
+describe('uploadVideo input validation', () => {
+  const FTYP_MP4 = Buffer.from([
+    0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70, 0x69, 0x73, 0x6f, 0x6d, 0x00, 0x00, 0x02,
+    0x00, 0x69, 0x73, 0x6f, 0x6d, 0x69, 0x73, 0x6f, 0x32,
+  ]);
+
+  function tempFile(name: string, bytes: Buffer): string {
+    const dir = mkdtempSync(join(tmpdir(), 'agent-upload-video-'));
+    const path = join(dir, name);
+    writeFileSync(path, bytes);
+    return path;
+  }
+
+  async function stubFilesServer(): Promise<{ url: string; close: () => Promise<void> }> {
+    const server = createServer((req, res) => {
+      if (req.method === 'POST' && req.url === '/files') {
+        req.resume();
+        req.on('end', () => {
+          res.writeHead(200, { 'content-type': 'application/json' });
+          res.end(JSON.stringify({ id: 'stub-video-file', object: 'file', bytes: 0, created_at: 0, filename: 'x.mp4', purpose: 'video' }));
+        });
+        return;
+      }
+      res.writeHead(404);
+      res.end();
+    });
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const { port } = server.address() as AddressInfo;
+    return {
+      url: `http://127.0.0.1:${String(port)}`,
+      close: () => new Promise<void>((resolve) => server.close(() => resolve())),
+    };
+  }
+
+  it('trusts the video extension when magic bytes are absent (documented sniff fallback)', async () => {
+    // Some containers (MPEG-PS) carry no recognizable magic, so when the
+    // header cannot be sniffed the extension is the only signal — the same
+    // classification ReadMediaFile uses. A mislabeled file therefore passes
+    // validation and fails later, at the provider, not here.
+    const stub = await stubFilesServer();
+    try {
+      const ctx = testAgent();
+      ctx.configure({
+        provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model', baseUrl: stub.url },
+      });
+      const part = await ctx.rpc.uploadVideo({
+        path: tempFile('fake.mp4', Buffer.from('definitely not a video')),
+      });
+      expect(part.videoUrl.url).toBe('ms://stub-video-file');
+    } finally {
+      await stub.close();
+    }
+  });
+
+  it('accepts video bytes in a .txt file (magic bytes win over the extension)', async () => {
+    const stub = await stubFilesServer();
+    try {
+      const ctx = testAgent();
+      ctx.configure({
+        provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model', baseUrl: stub.url },
+      });
+      const part = await ctx.rpc.uploadVideo({ path: tempFile('video.txt', FTYP_MP4) });
+      expect(part.videoUrl.url).toBe('ms://stub-video-file');
+    } finally {
+      await stub.close();
+    }
+  });
+
+  it('accepts a video at exactly 100MB and rejects 100MB+1', async () => {
+    const stub = await stubFilesServer();
+    try {
+      const ctx = testAgent();
+      ctx.configure({
+        provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model', baseUrl: stub.url },
+      });
+
+      const over = tempFile('over.mp4', FTYP_MP4);
+      truncateSync(over, 100 * 1024 * 1024 + 1);
+      await expect(ctx.rpc.uploadVideo({ path: over })).rejects.toThrow(/100MB/);
+
+      const exact = tempFile('exact.mp4', FTYP_MP4);
+      truncateSync(exact, 100 * 1024 * 1024);
+      const part = await ctx.rpc.uploadVideo({ path: exact });
+      expect(part.videoUrl.url).toBe('ms://stub-video-file');
+    } finally {
+      await stub.close();
+    }
+  }, 30000);
+
+  it('rejects a directory path', async () => {
+    const ctx = testAgent();
+    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' } });
+    const dir = mkdtempSync(join(tmpdir(), 'agent-upload-video-'));
+    await expect(ctx.rpc.uploadVideo({ path: dir })).rejects.toThrow();
+  });
+
+  it('rejects a nonexistent path', async () => {
+    const ctx = testAgent();
+    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' } });
+    await expect(ctx.rpc.uploadVideo({ path: '/no/such/file.mp4' })).rejects.toThrow();
+  });
+});
diff --git a/packages/kap-server/test/prompts.test.ts b/packages/kap-server/test/prompts.test.ts
index 9daba52ffe..6f4f8bd5b1 100644
--- a/packages/kap-server/test/prompts.test.ts
+++ b/packages/kap-server/test/prompts.test.ts
@@ -681,16 +681,18 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
 
   beforeEach(async () => {
     stubBodies = [];
+    let uploadCounter = 0;
     const stub = createServer((req, res) => {
       if (req.method === 'POST' && req.url === '/files') {
         const chunks: Buffer[] = [];
         req.on('data', (chunk: Buffer) => chunks.push(chunk));
         req.on('end', () => {
+          uploadCounter += 1;
           stubBodies.push(Buffer.concat(chunks));
           res.writeHead(200, { 'content-type': 'application/json' });
           res.end(
             JSON.stringify({
-              id: 'stub-llm-video',
+              id: `stub-llm-video-${String(uploadCounter)}`,
               object: 'file',
               bytes: 17,
               created_at: 0,
@@ -736,29 +738,33 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
     }
   });
 
-  it('inlines an uploaded video prompt as the provider-issued reference', async () => {
-    const sessionRes = await fetch(`${base}/api/v1/sessions`, {
+  async function createSessionWithAgent(): Promise<string> {
+    const res = await fetch(`${base}/api/v1/sessions`, {
       method: 'POST',
       headers: authHeaders(server as RunningServer, { 'content-type': 'application/json' }),
       body: JSON.stringify({ metadata: { cwd: home } }),
     } as never);
-    const sessionBody = (await sessionRes.json()) as Envelope<{ id: string }>;
-    const id = sessionBody.data.id;
-    const session = server!.core.accessor.get(ISessionLifecycleService).get(id);
+    const body = (await res.json()) as Envelope<{ id: string }>;
+    const session = server!.core.accessor.get(ISessionLifecycleService).get(body.data.id);
     await session!.accessor.get(IAgentLifecycleService).create({ agentId: 'main' });
+    return body.data.id;
+  }
 
-    const videoBytes = Buffer.from('tiny fake mp4 bytes');
+  async function uploadVideoFile(name: string, bytes: Buffer): Promise<string> {
     const form = new FormData();
-    form.set('file', new Blob([videoBytes], { type: 'video/mp4' }), 'clip.mp4');
-    const uploadRes = await fetch(`${base}/api/v1/files`, {
+    form.set('file', new Blob([bytes], { type: 'video/mp4' }), name);
+    const res = await fetch(`${base}/api/v1/files`, {
       method: 'POST',
       headers: authHeaders(server as RunningServer),
       body: form,
     } as never);
-    const uploaded = (await uploadRes.json()) as Envelope<{ id: string }>;
-    expect(uploaded.code).toBe(0);
+    const body = (await res.json()) as Envelope<{ id: string }>;
+    expect(body.code).toBe(0);
+    return body.data.id;
+  }
 
-    const submitRes = await fetch(`${base}/api/v1/sessions/${id}/prompts`, {
+  async function submitVideoPrompt(sessionId: string, fileIds: string[]): Promise<Envelope<PromptItemWire>> {
+    const res = await fetch(`${base}/api/v1/sessions/${sessionId}/prompts`, {
       method: 'POST',
       headers: authHeaders(server as RunningServer, { 'content-type': 'application/json' }),
       body: JSON.stringify({
@@ -767,19 +773,46 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
         model: 'stub',
         content: [
           { type: 'text', text: 'what happens in this video?' },
-          { type: 'video', source: { kind: 'file', file_id: uploaded.data.id } },
+          ...fileIds.map((fileId) => ({ type: 'video', source: { kind: 'file', file_id: fileId } })),
         ],
       }),
     } as never);
-    const submitted = (await submitRes.json()) as Envelope<PromptItemWire>;
-    expect(submitted.code).toBe(0);
+    const body = (await res.json()) as Envelope<PromptItemWire>;
+    expect(body.code).toBe(0);
+    return body;
+  }
+
+  async function abortPrompt(sessionId: string, promptId: string): Promise<void> {
+    // The stub serves no generation, so the turn keeps retrying in the
+    // background; abort it deterministically to let the server close.
+    const res = await fetch(`${base}/api/v1/sessions/${sessionId}/prompts/${promptId}:abort`, {
+      method: 'POST',
+      headers: authHeaders(server as RunningServer),
+    } as never);
+    expect(res.status).toBe(200);
+  }
+
+  async function redirectOf(llmId: string): Promise<{ status: number; location: string | null }> {
+    const res = await fetch(`${base}/api/v1/files/llm/${llmId}`, {
+      headers: authHeaders(server as RunningServer),
+      redirect: 'manual',
+    } as never);
+    return { status: res.status, location: res.headers.get('location') };
+  }
+
+  it('inlines an uploaded video prompt as the provider-issued reference', async () => {
+    const id = await createSessionWithAgent();
+    const videoBytes = Buffer.from('tiny fake mp4 bytes');
+    const fileId = await uploadVideoFile('clip.mp4', videoBytes);
+
+    const submitted = await submitVideoPrompt(id, [fileId]);
 
     // The prompt carries the provider-issued reference, not a path tag.
     const content = submitted.data.content as Array<Record<string, unknown>>;
     expect(content[0]).toEqual({ type: 'text', text: 'what happens in this video?' });
     expect(content[1]).toEqual({
       type: 'video',
-      source: { kind: 'url', url: 'ms://stub-llm-video', id: 'stub-llm-video' },
+      source: { kind: 'url', url: 'ms://stub-llm-video-1', id: 'stub-llm-video-1' },
     });
 
     // The upload happened synchronously, before the prompt was accepted, and
@@ -788,13 +821,9 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
     expect(stubBodies[0]!.includes(videoBytes)).toBe(true);
 
     // The provider id maps back to the local upload for playback.
-    const redirectRes = await fetch(`${base}/api/v1/files/llm/stub-llm-video`, {
-      headers: authHeaders(server as RunningServer),
-      redirect: 'manual',
-    } as never);
-    expect(redirectRes.status).toBe(302);
-    const location = redirectRes.headers.get('location');
-    expect(location).toBe(`/api/v1/files/${uploaded.data.id}`);
+    const { status, location } = await redirectOf('stub-llm-video-1');
+    expect(status).toBe(302);
+    expect(location).toBe(`/api/v1/files/${fileId}`);
 
     const downloadRes = await fetch(`${base}${location}`, {
       headers: authHeaders(server as RunningServer),
@@ -802,12 +831,64 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
     expect(downloadRes.status).toBe(200);
     expect(Buffer.from(await downloadRes.arrayBuffer())).toEqual(videoBytes);
 
-    // The stub serves no generation, so the turn keeps retrying in the
-    // background; abort it deterministically to let the server close.
-    const abortRes = await fetch(
-      `${base}/api/v1/sessions/${id}/prompts/${submitted.data.prompt_id}:abort`,
-      { method: 'POST', headers: authHeaders(server as RunningServer) } as never,
-    );
-    expect(abortRes.status).toBe(200);
+    await abortPrompt(id, submitted.data.prompt_id);
+  });
+
+  it('maps each inlined video back to its own upload', async () => {
+    const id = await createSessionWithAgent();
+    const fileA = await uploadVideoFile('a.mp4', Buffer.from('video-A'));
+    const fileB = await uploadVideoFile('b.mp4', Buffer.from('video-B'));
+
+    const submitted = await submitVideoPrompt(id, [fileA, fileB]);
+
+    expect(stubBodies).toHaveLength(2);
+    const content = submitted.data.content as Array<Record<string, unknown>>;
+    expect(content[1]).toEqual({
+      type: 'video',
+      source: { kind: 'url', url: 'ms://stub-llm-video-1', id: 'stub-llm-video-1' },
+    });
+    expect(content[2]).toEqual({
+      type: 'video',
+      source: { kind: 'url', url: 'ms://stub-llm-video-2', id: 'stub-llm-video-2' },
+    });
+    expect((await redirectOf('stub-llm-video-1')).location).toBe(`/api/v1/files/${fileA}`);
+    expect((await redirectOf('stub-llm-video-2')).location).toBe(`/api/v1/files/${fileB}`);
+
+    await abortPrompt(id, submitted.data.prompt_id);
+  });
+
+  it('serves range requests through the llm redirect', async () => {
+    const id = await createSessionWithAgent();
+    const fileId = await uploadVideoFile('clip.mp4', Buffer.from('0123456789'));
+
+    const submitted = await submitVideoPrompt(id, [fileId]);
+
+    const { location } = await redirectOf('stub-llm-video-1');
+    const rangeRes = await fetch(`${base}${location}`, {
+      headers: { ...authHeaders(server as RunningServer), range: 'bytes=2-5' },
+    } as never);
+    expect(rangeRes.status).toBe(206);
+    expect(rangeRes.headers.get('content-range')).toBe('bytes 2-5/10');
+    expect(Buffer.from(await rangeRes.arrayBuffer()).toString()).toBe('2345');
+
+    await abortPrompt(id, submitted.data.prompt_id);
+  });
+
+  it('keeps the llm video mapping across a server restart', async () => {
+    const id = await createSessionWithAgent();
+    const fileId = await uploadVideoFile('clip.mp4', Buffer.from('persisted'));
+
+    const submitted = await submitVideoPrompt(id, [fileId]);
+    await abortPrompt(id, submitted.data.prompt_id);
+
+    await server!.close();
+    server = undefined;
+    await new Promise((resolve) => setTimeout(resolve, 25));
+    server = await startServer({ host: '127.0.0.1', port: 0, homeDir: home, logLevel: 'silent' });
+    base = `http://127.0.0.1:${server.port}`;
+
+    const { status, location } = await redirectOf('stub-llm-video-1');
+    expect(status).toBe(302);
+    expect(location).toBe(`/api/v1/files/${fileId}`);
   });
 });

From 64d95efe006f7205c761163436ae2b8fe767554e Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 17:28:19 +0800
Subject: [PATCH 04/45] fix: surface auth rejections from the video upload
 channel

The base64 fallback for a failing video upload must not mask auth
rejections: a 401/403 (surfaced as provider.auth_error) drives the
credential force-refresh and a clear auth error, while an inline
payload would just be rejected again by the next request. Only a
missing or broken upload channel (no files endpoint, network/server
errors) falls back to inline delivery.
---
 .../src/agent/media/tools/read-media.ts       | 26 ++++++++++++++---
 .../test/agent/media/tools/read-media.test.ts | 12 ++++++++
 .../src/tools/builtin/file/read-media.ts      | 26 ++++++++++++++---
 .../agent-core/test/tools/read-media.test.ts  | 29 +++++++++++++++++++
 4 files changed, 85 insertions(+), 8 deletions(-)

diff --git a/packages/agent-core-v2/src/agent/media/tools/read-media.ts b/packages/agent-core-v2/src/agent/media/tools/read-media.ts
index aa7946ed70..e0afb6a60c 100644
--- a/packages/agent-core-v2/src/agent/media/tools/read-media.ts
+++ b/packages/agent-core-v2/src/agent/media/tools/read-media.ts
@@ -36,6 +36,7 @@
 import type { ModelCapability } from '#/kosong/contract/capability';
 import type { ContentPart, VideoURLPart } from '#/kosong/contract/message';
 import type { VideoUploadInput as ProviderVideoUploadInput } from '#/kosong/contract/provider';
+import { ProtocolErrors } from '#/kosong/protocol/errors';
 import type { ITelemetryService } from '#/app/telemetry/telemetry';
 import { z } from 'zod';
 
@@ -237,6 +238,19 @@ function buildFullResolutionLimitError(path: string, finalBytes: number): string
   );
 }
 
+/**
+ * Auth rejections from the upload channel that must surface (they drive
+ * credential refresh and a clear auth error). The auth layer wraps provider
+ * 401/403s as `provider.auth_error`; a raw status-coded error is matched
+ * directly.
+ */
+function isAuthUploadError(error: unknown): boolean {
+  if (typeof error !== 'object' || error === null) return false;
+  if ((error as { code?: unknown }).code === ProtocolErrors.codes.PROVIDER_AUTH_ERROR) return true;
+  const statusCode = (error as { statusCode?: unknown }).statusCode;
+  return statusCode === 401 || statusCode === 403;
+}
+
 export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
   readonly name = 'ReadMediaFile' as const;
   readonly description: string;
@@ -257,9 +271,12 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
 
   /**
    * Deliver a video through the provider's upload channel when available,
-   * falling back to an inline base64 part when the channel is missing or the
-   * upload itself fails (e.g. the provider has no files endpoint) — a failed
-   * upload must not turn the whole read into an error.
+   * falling back to an inline base64 part when the channel is missing or
+   * broken (e.g. the provider has no files endpoint) — a failed upload must
+   * not turn the whole read into an error. Auth rejections (401/403) are
+   * the exception: they must surface, because they drive credential
+   * refresh and a clear auth error instead of masking a bad token behind
+   * an inline payload the next request will also reject.
    */
   private async videoContentPart(
     data: Buffer,
@@ -273,7 +290,8 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
           mimeType,
           filename: safePath.split(/[\\/]/).at(-1),
         });
-      } catch {
+      } catch (error) {
+        if (isAuthUploadError(error)) throw error;
         // Fall through to the inline form.
       }
     }
diff --git a/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts b/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts
index e00df92116..2f0a4eae88 100644
--- a/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts
+++ b/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts
@@ -699,6 +699,18 @@ describe('ReadMediaFileTool', () => {
     });
   });
 
+  it('surfaces auth rejections from the upload channel instead of falling back', async () => {
+    const videoUploader = vi
+      .fn<VideoUploader>()
+      .mockRejectedValue(Object.assign(new Error('401 Unauthorized'), { statusCode: 401 }));
+    const result = await execute(
+      makeTool({ '/workspace/clip.mp4': { data: mp4Buffer() } }, capabilities(), videoUploader),
+      { path: '/workspace/clip.mp4' },
+    );
+    expect(result.isError).toBe(true);
+    expect(result.output).toContain('401 Unauthorized');
+  });
+
   it('rejects empty files', async () => {
     const result = await execute(
       makeTool({ '/workspace/sample.png': { data: pngBuffer(), size: 0 } }),
diff --git a/packages/agent-core/src/tools/builtin/file/read-media.ts b/packages/agent-core/src/tools/builtin/file/read-media.ts
index 414b73c9a5..36f61e512c 100644
--- a/packages/agent-core/src/tools/builtin/file/read-media.ts
+++ b/packages/agent-core/src/tools/builtin/file/read-media.ts
@@ -33,6 +33,7 @@ import type {
 } from '@moonshot-ai/kosong';
 import { z } from 'zod';
 
+import { ErrorCodes } from '../../../errors';
 import type { BuiltinTool } from '../../../agent/tool';
 import { ToolAccesses } from '../../../loop/tool-access';
 import type { ExecutableToolResult, ToolExecution } from '../../../loop/types';
@@ -252,6 +253,19 @@ function buildMediaNote(input: {
 
 // ── Implementation ───────────────────────────────────────────────────
 
+/**
+ * Auth rejections from the upload channel that must surface (they drive
+ * credential refresh and a clear auth error). The auth layer wraps provider
+ * 401/403s as `provider.auth_error`; a raw status-coded error is matched
+ * directly.
+ */
+function isAuthUploadError(error: unknown): boolean {
+  if (typeof error !== 'object' || error === null) return false;
+  if ((error as { code?: unknown }).code === ErrorCodes.PROVIDER_AUTH_ERROR) return true;
+  const statusCode = (error as { statusCode?: unknown }).statusCode;
+  return statusCode === 401 || statusCode === 403;
+}
+
 export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
   readonly name = 'ReadMediaFile' as const;
   readonly description: string;
@@ -279,9 +293,12 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
 
   /**
    * Deliver a video through the provider's upload channel when available,
-   * falling back to an inline base64 part when the channel is missing or the
-   * upload itself fails (e.g. the provider has no files endpoint) — a failed
-   * upload must not turn the whole read into an error.
+   * falling back to an inline base64 part when the channel is missing or
+   * broken (e.g. the provider has no files endpoint) — a failed upload must
+   * not turn the whole read into an error. Auth rejections (401/403) are
+   * the exception: they must surface, because they drive credential
+   * refresh and a clear auth error instead of masking a bad token behind
+   * an inline payload the next request will also reject.
    */
   private async videoContentPart(
     data: Buffer,
@@ -295,7 +312,8 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
           mimeType,
           filename: safePath.split(/[\\/]/).at(-1),
         });
-      } catch {
+      } catch (error) {
+        if (isAuthUploadError(error)) throw error;
         // Fall through to the inline form.
       }
     }
diff --git a/packages/agent-core/test/tools/read-media.test.ts b/packages/agent-core/test/tools/read-media.test.ts
index ff3489b1e1..679aee2b37 100644
--- a/packages/agent-core/test/tools/read-media.test.ts
+++ b/packages/agent-core/test/tools/read-media.test.ts
@@ -449,6 +449,35 @@ describe('ReadMediaFileTool', () => {
     });
   });
 
+  it('surfaces auth rejections from the upload channel instead of falling back', async () => {
+    const videoUploader = vi
+      .fn()
+      .mockRejectedValue(Object.assign(new Error('401 Unauthorized'), { statusCode: 401 }));
+    const tool = new ReadMediaFileTool(
+      createFakeKaos({
+        stat: vi.fn<Kaos['stat']>().mockResolvedValue({
+          ...DEFAULT_STAT,
+          stSize: MP4_HEADER.length,
+        }),
+        readBytes: vi.fn<Kaos['readBytes']>().mockResolvedValue(MP4_HEADER),
+      }),
+      PERMISSIVE_WORKSPACE,
+      capabilities(),
+      videoUploader,
+    );
+
+    const result = await executeTool(tool, {
+      turnId: 't1',
+      toolCallId: 'c4c',
+      args: { path: '/workspace/sample.mp4' },
+      signal,
+    });
+
+    expect(result.isError).toBe(true);
+    expect(result.output).toContain('401 Unauthorized');
+    expect(result.output).not.toContain('base64');
+  });
+
   it('rejects text files with a Read hint', async () => {
     const text = Buffer.from('hello');
     const tool = makeReadMediaTool({

From 3a4e720c6055538a3ef1a7eaae718efa5f7c3d39 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 17:50:09 +0800
Subject: [PATCH 05/45] fix: keep the by-design no-hook video error from
 degrading to inline
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Main's contract for a provider with no video upload hook is an honest
"does not support video upload" tool error — an inline payload would
be dropped on that protocol's wire anyway. The base64 fallback now only
applies to an upload channel that exists but failed at runtime. The
no-hook throw gets a stable type (VideoUploadUnsupportedError) so the
two cases are told apart without matching message text.
---
 .../src/agent/media/tools/read-media.ts       | 31 ++++++++++++-------
 .../src/kosong/contract/errors.ts             | 12 +++++++
 .../src/kosong/model/modelRequesterImpl.ts    |  4 +--
 .../test/agent/media/tools/read-media.test.ts | 17 ++++++++++
 4 files changed, 50 insertions(+), 14 deletions(-)

diff --git a/packages/agent-core-v2/src/agent/media/tools/read-media.ts b/packages/agent-core-v2/src/agent/media/tools/read-media.ts
index e0afb6a60c..dfc9166538 100644
--- a/packages/agent-core-v2/src/agent/media/tools/read-media.ts
+++ b/packages/agent-core-v2/src/agent/media/tools/read-media.ts
@@ -36,6 +36,7 @@
 import type { ModelCapability } from '#/kosong/contract/capability';
 import type { ContentPart, VideoURLPart } from '#/kosong/contract/message';
 import type { VideoUploadInput as ProviderVideoUploadInput } from '#/kosong/contract/provider';
+import { VideoUploadUnsupportedError } from '#/kosong/contract/errors';
 import { ProtocolErrors } from '#/kosong/protocol/errors';
 import type { ITelemetryService } from '#/app/telemetry/telemetry';
 import { z } from 'zod';
@@ -239,12 +240,18 @@ function buildFullResolutionLimitError(path: string, finalBytes: number): string
 }
 
 /**
- * Auth rejections from the upload channel that must surface (they drive
- * credential refresh and a clear auth error). The auth layer wraps provider
- * 401/403s as `provider.auth_error`; a raw status-coded error is matched
- * directly.
+ * Upload-channel errors that must surface as a tool error rather than
+ * degrade to inline delivery:
+ *  - `VideoUploadUnsupportedError` — the provider has no upload hook by
+ *    design; an inline payload would be dropped on the wire anyway, so the
+ *    honest "does not support video upload" error wins;
+ *  - auth rejections (`provider.auth_error` / 401 / 403) — they drive
+ *    credential refresh and a clear auth error.
+ * Everything else (no files endpoint, network/server failures) falls back
+ * to inline delivery.
  */
-function isAuthUploadError(error: unknown): boolean {
+function shouldSurfaceVideoUploadError(error: unknown): boolean {
+  if (error instanceof VideoUploadUnsupportedError) return true;
   if (typeof error !== 'object' || error === null) return false;
   if ((error as { code?: unknown }).code === ProtocolErrors.codes.PROVIDER_AUTH_ERROR) return true;
   const statusCode = (error as { statusCode?: unknown }).statusCode;
@@ -271,12 +278,12 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
 
   /**
    * Deliver a video through the provider's upload channel when available,
-   * falling back to an inline base64 part when the channel is missing or
-   * broken (e.g. the provider has no files endpoint) — a failed upload must
-   * not turn the whole read into an error. Auth rejections (401/403) are
-   * the exception: they must surface, because they drive credential
-   * refresh and a clear auth error instead of masking a bad token behind
-   * an inline payload the next request will also reject.
+   * falling back to an inline base64 part when the channel exists but is
+   * broken (no files endpoint, network/server failure) — a failed upload
+   * must not turn the whole read into an error. Errors that must surface
+   * instead (see {@link shouldSurfaceVideoUploadError}): a provider with no
+   * upload hook by design, whose wire would drop the inline payload anyway,
+   * and auth rejections, which drive credential refresh.
    */
   private async videoContentPart(
     data: Buffer,
@@ -291,7 +298,7 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
           filename: safePath.split(/[\\/]/).at(-1),
         });
       } catch (error) {
-        if (isAuthUploadError(error)) throw error;
+        if (shouldSurfaceVideoUploadError(error)) throw error;
         // Fall through to the inline form.
       }
     }
diff --git a/packages/agent-core-v2/src/kosong/contract/errors.ts b/packages/agent-core-v2/src/kosong/contract/errors.ts
index 846c4f64c5..f1c9fd91d8 100644
--- a/packages/agent-core-v2/src/kosong/contract/errors.ts
+++ b/packages/agent-core-v2/src/kosong/contract/errors.ts
@@ -29,6 +29,18 @@ export class APIConnectionError extends ChatProviderError {
   }
 }
 
+/**
+ * The provider has no video upload hook at all — a by-design capability gap
+ * (distinct from an upload that failed at runtime), so callers that would
+ * otherwise degrade gracefully can tell the two apart.
+ */
+export class VideoUploadUnsupportedError extends ChatProviderError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'VideoUploadUnsupportedError';
+  }
+}
+
 export class APITimeoutError extends ChatProviderError {
   constructor(message: string) {
     super(message);
diff --git a/packages/agent-core-v2/src/kosong/model/modelRequesterImpl.ts b/packages/agent-core-v2/src/kosong/model/modelRequesterImpl.ts
index dff94ce2ab..6e7d52e260 100644
--- a/packages/agent-core-v2/src/kosong/model/modelRequesterImpl.ts
+++ b/packages/agent-core-v2/src/kosong/model/modelRequesterImpl.ts
@@ -23,7 +23,7 @@
 
 import { AsyncEventQueue } from '#/_base/asyncEventQueue';
 import type { VideoURLPart } from '#/kosong/contract/message';
-import { APIStatusError, isAbortError } from '#/kosong/contract/errors';
+import { APIStatusError, isAbortError, VideoUploadUnsupportedError } from '#/kosong/contract/errors';
 import { generate, type GenerateResult } from '#/kosong/contract/generate';
 import type {
   ChatProvider,
@@ -85,7 +85,7 @@ export class ModelRequesterImpl implements ModelRequester {
   ): Promise<VideoURLPart> {
     const provider = this.resolveChatProvider();
     if (provider.uploadVideo === undefined) {
-      throw new Error(
+      throw new VideoUploadUnsupportedError(
         `Model "${this.model.id}" (protocol=${this.model.protocol}) does not support video upload`,
       );
     }
diff --git a/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts b/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts
index 2f0a4eae88..da6e1f9d08 100644
--- a/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts
+++ b/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts
@@ -9,6 +9,7 @@
 
 import type { ModelCapability } from '#/kosong/contract/capability';
 import type { ContentPart } from '#/kosong/contract/message';
+import { VideoUploadUnsupportedError } from '#/kosong/contract/errors';
 import { Jimp } from 'jimp';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
@@ -711,6 +712,22 @@ describe('ReadMediaFileTool', () => {
     expect(result.output).toContain('401 Unauthorized');
   });
 
+  it('surfaces the by-design no-hook error instead of falling back to inline', async () => {
+    const videoUploader = vi
+      .fn<VideoUploader>()
+      .mockRejectedValue(
+        new VideoUploadUnsupportedError(
+          'Model "stub" (protocol=openai) does not support video upload',
+        ),
+      );
+    const result = await execute(
+      makeTool({ '/workspace/clip.mp4': { data: mp4Buffer() } }, capabilities(), videoUploader),
+      { path: '/workspace/clip.mp4' },
+    );
+    expect(result.isError).toBe(true);
+    expect(result.output).toContain('does not support video upload');
+  });
+
   it('rejects empty files', async () => {
     const result = await execute(
       makeTool({ '/workspace/sample.png': { data: pngBuffer(), size: 0 } }),

From 465e7a69482cf5d4538a1e27d8d8531f31b1549e Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 18:18:35 +0800
Subject: [PATCH 06/45] fix: constrain the llm video route param to a safe
 alphabet

The provider file id is used as a blob-store key, and the node-fs
backend joins scope and key into a storage path. An id containing an
encoded path separator (%2F) could address a different storage path
than the intended llm-video mapping; the route now only accepts the
provider-id alphabet.
---
 packages/kap-server/src/protocol/rest-file.ts |  4 +++-
 packages/kap-server/test/files.test.ts        | 14 ++++++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/packages/kap-server/src/protocol/rest-file.ts b/packages/kap-server/src/protocol/rest-file.ts
index 85e2d63457..1ec654040c 100644
--- a/packages/kap-server/src/protocol/rest-file.ts
+++ b/packages/kap-server/src/protocol/rest-file.ts
@@ -18,7 +18,9 @@ export const getFileParamSchema = z.object({
 export type GetFileParam = z.infer<typeof getFileParamSchema>;
 
 export const getLlmVideoParamSchema = z.object({
-  llm_id: z.string().min(1),
+  // The id is used as a blob-store key; keep it inside the provider-id
+  // alphabet so a crafted value can never address another storage path.
+  llm_id: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/),
 });
 export type GetLlmVideoParam = z.infer<typeof getLlmVideoParamSchema>;
 
diff --git a/packages/kap-server/test/files.test.ts b/packages/kap-server/test/files.test.ts
index ac14035c58..d6c71ef0ee 100644
--- a/packages/kap-server/test/files.test.ts
+++ b/packages/kap-server/test/files.test.ts
@@ -331,4 +331,18 @@ describe('GET /api/v1/files/llm/{llm_id} (server-v2)', () => {
     expect(res.statusCode).toBe(404);
     expect((res.json() as Envelope).code).toBe(40407);
   });
+
+  it('rejects ids outside the provider-id alphabet (no blob-key traversal)', async () => {
+    const r = await boot();
+    // Encoded separators land inside the {llm_id} param after URL decoding;
+    // the schema must reject them before the value reaches the blob store.
+    for (const bad of ['..%2F..%2Ffiles%2Ff_x', 'a%2Fb', '%2Fetc%2Fpasswd', 'a b']) {
+      const res = await appOf(r).inject({
+        method: 'GET',
+        url: `/api/v1/files/llm/${bad}`,
+      });
+      expect((res.json() as Envelope).code, `llm_id ${bad}`).toBe(40001);
+      expect(res.statusCode).not.toBe(302);
+    }
+  });
 });

From 172a531b09c3acdd61db2fbb51238ce01888cdbe Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 18:24:31 +0800
Subject: [PATCH 07/45] style(agent-core-v2): move added explanations into
 top-of-file comment blocks

The package's comment convention keeps comments solely in the top-of-file
block; relocate the new notes (url-source id pairing, video delivery
fallback, VideoUploadUnsupportedError) from functions and schema fields
into their module headers.
---
 .../agent/contextMemory/protocolMessage.ts    |  7 +++--
 .../src/agent/media/tools/read-media.ts       | 29 ++++++-------------
 .../src/kosong/contract/errors.ts             |  8 ++---
 3 files changed, 17 insertions(+), 27 deletions(-)

diff --git a/packages/agent-core-v2/src/agent/contextMemory/protocolMessage.ts b/packages/agent-core-v2/src/agent/contextMemory/protocolMessage.ts
index 0922cbb8fe..f7e8791f1b 100644
--- a/packages/agent-core-v2/src/agent/contextMemory/protocolMessage.ts
+++ b/packages/agent-core-v2/src/agent/contextMemory/protocolMessage.ts
@@ -4,6 +4,11 @@
  * Defined next to `messageProjection.ts`, which projects `ContextMessage`
  * into this shape; consumed by the `messageLegacy` edge adapter and the
  * transports.
+ *
+ * Media sources come in three kinds: `url`, `base64`, and `file` (a daemon
+ * upload id). The `url` kind optionally pairs an `id` — the provider-issued
+ * file id behind a reference such as `ms://…` — forwarded on the wire when
+ * the provider keys media by id.
  */
 
 import { z } from 'zod';
@@ -39,8 +44,6 @@ export const imageSourceSchema = z.discriminatedUnion('kind', [
   z.object({
     kind: z.literal('url'),
     url: z.string().min(1),
-    // Provider-issued file id paired with `url` (e.g. a `ms://` reference),
-    // forwarded on the wire when the provider keys media by id.
     id: z.string().min(1).optional(),
   }),
   z.object({
diff --git a/packages/agent-core-v2/src/agent/media/tools/read-media.ts b/packages/agent-core-v2/src/agent/media/tools/read-media.ts
index dfc9166538..d6e57fba44 100644
--- a/packages/agent-core-v2/src/agent/media/tools/read-media.ts
+++ b/packages/agent-core-v2/src/agent/media/tools/read-media.ts
@@ -29,6 +29,15 @@
  * Path safety: goes through the shared path access resolver used by
  * Read/Write/Edit.
  *
+ * Videos are delivered through the provider's upload channel when one is
+ * bound, falling back to an inline base64 part when the channel exists but
+ * fails at runtime (no files endpoint, network/server failure) — a failed
+ * upload must not turn the whole read into an error. Two cases surface as
+ * tool errors instead: a provider with no upload hook by design
+ * (`VideoUploadUnsupportedError`, whose wire would drop the inline payload
+ * anyway), and auth rejections (`provider.auth_error` / 401 / 403), which
+ * drive credential refresh rather than mask a bad token.
+ *
  * Registration is capability-gated by `registerMediaTools`: this tool is
  * only registered when the active model supports image or video input.
  */
@@ -239,17 +248,6 @@ function buildFullResolutionLimitError(path: string, finalBytes: number): string
   );
 }
 
-/**
- * Upload-channel errors that must surface as a tool error rather than
- * degrade to inline delivery:
- *  - `VideoUploadUnsupportedError` — the provider has no upload hook by
- *    design; an inline payload would be dropped on the wire anyway, so the
- *    honest "does not support video upload" error wins;
- *  - auth rejections (`provider.auth_error` / 401 / 403) — they drive
- *    credential refresh and a clear auth error.
- * Everything else (no files endpoint, network/server failures) falls back
- * to inline delivery.
- */
 function shouldSurfaceVideoUploadError(error: unknown): boolean {
   if (error instanceof VideoUploadUnsupportedError) return true;
   if (typeof error !== 'object' || error === null) return false;
@@ -276,15 +274,6 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
       telemetry === undefined ? undefined : { client: telemetry, source: 'read_media' };
   }
 
-  /**
-   * Deliver a video through the provider's upload channel when available,
-   * falling back to an inline base64 part when the channel exists but is
-   * broken (no files endpoint, network/server failure) — a failed upload
-   * must not turn the whole read into an error. Errors that must surface
-   * instead (see {@link shouldSurfaceVideoUploadError}): a provider with no
-   * upload hook by design, whose wire would drop the inline payload anyway,
-   * and auth rejections, which drive credential refresh.
-   */
   private async videoContentPart(
     data: Buffer,
     mimeType: string,
diff --git a/packages/agent-core-v2/src/kosong/contract/errors.ts b/packages/agent-core-v2/src/kosong/contract/errors.ts
index f1c9fd91d8..43b9ee5dd7 100644
--- a/packages/agent-core-v2/src/kosong/contract/errors.ts
+++ b/packages/agent-core-v2/src/kosong/contract/errors.ts
@@ -5,6 +5,9 @@
  * the `API*Error` class family, the retry verdict (`isRetryableGenerateError`),
  * the telemetry classification (`ApiErrorKind` / `classifyApiError`), and the
  * status-error normalizer every dialect's error converter funnels through.
+ * Alongside the wire-status classes, `VideoUploadUnsupportedError` marks the
+ * by-design capability gap (provider has no video upload hook) so callers
+ * can tell it apart from an upload that failed at runtime.
  *
  * Abort has exactly one standard shape here: the DOMException built by
  * `createAbortError`. Provider error converters must run the `throwIfAbortError`
@@ -29,11 +32,6 @@ export class APIConnectionError extends ChatProviderError {
   }
 }
 
-/**
- * The provider has no video upload hook at all — a by-design capability gap
- * (distinct from an upload that failed at runtime), so callers that would
- * otherwise degrade gracefully can tell the two apart.
- */
 export class VideoUploadUnsupportedError extends ChatProviderError {
   constructor(message: string) {
     super(message);

From 3e08864771f7b556596da1035efce049fa7b0379 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 18:29:04 +0800
Subject: [PATCH 08/45] fix: reject prompt video uploads when the model lacks
 video input

The uploadVideo RPC only checked the provider's upload channel, so an
SDK caller on a text-only or unknown-capability model could obtain a
valid-looking video_url part the current model is not supposed to
accept. The TUI capability guard does not cover this public path, so
the agent now gates on video_in itself.
---
 packages/agent-core/src/agent/index.ts       |  6 +++
 packages/agent-core/test/agent/basic.test.ts | 41 +++++++++++++++++---
 2 files changed, 42 insertions(+), 5 deletions(-)

diff --git a/packages/agent-core/src/agent/index.ts b/packages/agent-core/src/agent/index.ts
index 12d17f072b..c52ea83b03 100644
--- a/packages/agent-core/src/agent/index.ts
+++ b/packages/agent-core/src/agent/index.ts
@@ -505,6 +505,12 @@ export class Agent {
    * reads itself keep flowing through ReadMediaFile.
    */
   async uploadVideo(path: string): Promise<VideoURLPart> {
+    if (!this.config.modelCapabilities.video_in) {
+      throw new KimiError(
+        ErrorCodes.REQUEST_INVALID,
+        'The current model does not support video input.',
+      );
+    }
     const uploader = this.tools.videoUploader();
     if (uploader === undefined) {
       throw new KimiError(
diff --git a/packages/agent-core/test/agent/basic.test.ts b/packages/agent-core/test/agent/basic.test.ts
index 64dc7c30f5..afc22fc5ee 100644
--- a/packages/agent-core/test/agent/basic.test.ts
+++ b/packages/agent-core/test/agent/basic.test.ts
@@ -157,6 +157,15 @@ it('runs an agent turn through builtin tool approval and execution', async () =>
   await ctx.expectResumeMatches();
 });
 
+const VIDEO_CAPS = {
+  image_in: true,
+  video_in: true,
+  audio_in: false,
+  thinking: false,
+  tool_use: true,
+  max_context_tokens: 1000000,
+} as const;
+
 describe('uploadVideo', () => {
   // Minimal ISO-BMFF header: a 24-byte ftyp box with the `isom` brand, which
   // is all the media sniffer needs to classify the file as video/mp4.
@@ -224,6 +233,7 @@ describe('uploadVideo', () => {
       const ctx = testAgent();
       ctx.configure({
         provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model', baseUrl: stub.url },
+        modelCapabilities: VIDEO_CAPS,
       });
 
       const part = await ctx.rpc.uploadVideo({ path: tempVideo() });
@@ -243,16 +253,34 @@ describe('uploadVideo', () => {
 
   it('rejects when the provider has no video upload channel', async () => {
     const ctx = testAgent();
-    ctx.configure({ provider: { type: 'openai', apiKey: 'test-key', model: 'mock-model' } });
+    ctx.configure({ provider: { type: 'openai', apiKey: 'test-key', model: 'mock-model' }, modelCapabilities: VIDEO_CAPS });
 
     await expect(ctx.rpc.uploadVideo({ path: tempVideo() })).rejects.toThrow(
       /does not support video upload/,
     );
   });
 
+  it('rejects when the model lacks the video_in capability', async () => {
+    const stub = await stubFilesServer();
+    try {
+      const ctx = testAgent();
+      ctx.configure({
+        provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model', baseUrl: stub.url },
+        modelCapabilities: { ...VIDEO_CAPS, video_in: false },
+      });
+
+      await expect(ctx.rpc.uploadVideo({ path: tempVideo() })).rejects.toThrow(
+        /does not support video input/,
+      );
+      expect(stub.requests).toHaveLength(0);
+    } finally {
+      await stub.close();
+    }
+  });
+
   it('rejects a non-video file', async () => {
     const ctx = testAgent();
-    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' } });
+    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' }, modelCapabilities: VIDEO_CAPS });
 
     await expect(
       ctx.rpc.uploadVideo({ path: tempVideo('notes.txt', Buffer.from('plain text')) }),
@@ -261,7 +289,7 @@ describe('uploadVideo', () => {
 
   it('rejects a video over the 100MB cap', async () => {
     const ctx = testAgent();
-    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' } });
+    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' }, modelCapabilities: VIDEO_CAPS });
     const path = tempVideo();
     // Sparse extend: the ftyp header stays, the size crosses the cap.
     truncateSync(path, 101 * 1024 * 1024);
@@ -314,6 +342,7 @@ describe('uploadVideo input validation', () => {
       const ctx = testAgent();
       ctx.configure({
         provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model', baseUrl: stub.url },
+        modelCapabilities: VIDEO_CAPS,
       });
       const part = await ctx.rpc.uploadVideo({
         path: tempFile('fake.mp4', Buffer.from('definitely not a video')),
@@ -330,6 +359,7 @@ describe('uploadVideo input validation', () => {
       const ctx = testAgent();
       ctx.configure({
         provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model', baseUrl: stub.url },
+        modelCapabilities: VIDEO_CAPS,
       });
       const part = await ctx.rpc.uploadVideo({ path: tempFile('video.txt', FTYP_MP4) });
       expect(part.videoUrl.url).toBe('ms://stub-video-file');
@@ -344,6 +374,7 @@ describe('uploadVideo input validation', () => {
       const ctx = testAgent();
       ctx.configure({
         provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model', baseUrl: stub.url },
+        modelCapabilities: VIDEO_CAPS,
       });
 
       const over = tempFile('over.mp4', FTYP_MP4);
@@ -361,14 +392,14 @@ describe('uploadVideo input validation', () => {
 
   it('rejects a directory path', async () => {
     const ctx = testAgent();
-    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' } });
+    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' }, modelCapabilities: VIDEO_CAPS });
     const dir = mkdtempSync(join(tmpdir(), 'agent-upload-video-'));
     await expect(ctx.rpc.uploadVideo({ path: dir })).rejects.toThrow();
   });
 
   it('rejects a nonexistent path', async () => {
     const ctx = testAgent();
-    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' } });
+    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' }, modelCapabilities: VIDEO_CAPS });
     await expect(ctx.rpc.uploadVideo({ path: '/no/such/file.mp4' })).rejects.toThrow();
   });
 });

From 99cfdab61bb5f07ca9c3998ffc3da1acd673090e Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 18:36:21 +0800
Subject: [PATCH 09/45] fix: sniff uploaded video bytes before inlining them
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The inline branch trusted the upload-time content type; now the bytes
are sniffed first, and anything magic-confirmed as a non-video kind
(e.g. an image mislabeled as video/mp4) falls back to the file-tag
form instead of being uploaded. Like the image gate, bytes are
authoritative where the container format allows it — an MPEG-PS
lookalike still rides the extension, matching ReadMediaFile.
---
 packages/kap-server/src/routes/prompts.ts | 48 ++++++++++++++---------
 packages/kap-server/test/prompts.test.ts  | 20 +++++++++-
 2 files changed, 48 insertions(+), 20 deletions(-)

diff --git a/packages/kap-server/src/routes/prompts.ts b/packages/kap-server/src/routes/prompts.ts
index 8e9ad56d17..248b64e6cc 100644
--- a/packages/kap-server/src/routes/prompts.ts
+++ b/packages/kap-server/src/routes/prompts.ts
@@ -69,6 +69,7 @@ import { z } from 'zod';
 
 import { errEnvelope, okEnvelope } from '../envelope';
 import { recordLlmVideoRef } from '../lib/llmVideoRefs';
+import { detectFileType, MEDIA_SNIFF_BYTES } from '@moonshot-ai/agent-core-v2/agent/media/file-type';
 import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
 import { ensureMainAgent, MAIN_AGENT_ID } from '../transport/mainAgent';
@@ -710,27 +711,36 @@ async function resolvePromptMediaFiles(
 
     // Uploaded video: inline the provider-issued reference into the prompt
     // so the model receives the video with the user message instead of having
-    // to open it with a tool call. Falls back to the file-tag form when the
-    // model has no upload channel or the upload fails.
+    // to open it with a tool call. Like the image gate above, the bytes are
+    // authoritative: a mislabeled upload (declared video/* but not actually
+    // one) never reaches the provider and falls back to the file-tag form,
+    // as does a model with no upload channel or a failed upload.
     if (part.type === 'video' && options.videoUploader !== undefined) {
-      try {
-        const data = await readFileOrStream(file);
-        const uploaded = await options.videoUploader({
-          data,
-          mimeType: file.meta.media_type,
-          filename: file.meta.name,
-        });
-        content.push({
-          type: 'video',
-          source: { kind: 'url', url: uploaded.videoUrl.url, id: uploaded.videoUrl.id },
-        });
-        changed = true;
-        if (uploaded.videoUrl.id !== undefined) {
-          await options.onVideoInlined?.(file.meta.id, uploaded.videoUrl.id);
+      const data = await readFileOrStream(file);
+      const sniffed = detectFileType(
+        file.meta.name,
+        data.subarray(0, MEDIA_SNIFF_BYTES),
+        'media',
+      );
+      if (sniffed.kind === 'video') {
+        try {
+          const uploaded = await options.videoUploader({
+            data,
+            mimeType: sniffed.mimeType,
+            filename: file.meta.name,
+          });
+          content.push({
+            type: 'video',
+            source: { kind: 'url', url: uploaded.videoUrl.url, id: uploaded.videoUrl.id },
+          });
+          changed = true;
+          if (uploaded.videoUrl.id !== undefined) {
+            await options.onVideoInlined?.(file.meta.id, uploaded.videoUrl.id);
+          }
+          continue;
+        } catch {
+          // Fall through to the file-tag form below.
         }
-        continue;
-      } catch {
-        // Fall through to the file-tag form below.
       }
     }
 
diff --git a/packages/kap-server/test/prompts.test.ts b/packages/kap-server/test/prompts.test.ts
index a85eb3d747..efcf48bcdd 100644
--- a/packages/kap-server/test/prompts.test.ts
+++ b/packages/kap-server/test/prompts.test.ts
@@ -1074,8 +1074,26 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
     await abortPrompt(id, submitted.data.prompt_id);
   });
 
-  it('keeps the llm video mapping across a server restart', async () => {
+  it('falls back to the tag form when an uploaded "video" sniffs as another kind', async () => {
     const id = await createSessionWithAgent();
+    // Declared video/mp4 at upload time, but the bytes are a PNG (magic
+    // bytes are authoritative; a text lookalike would be indistinguishable
+    // from MPEG-PS and is the provider's call, same as ReadMediaFile).
+    const pngBytes = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00]);
+    const fileId = await uploadVideoFile('clip.mp4', pngBytes);
+
+    const submitted = await submitVideoPrompt(id, [fileId]);
+
+    // No provider upload is attempted for bytes sniffed as a non-video kind.
+    expect(stubBodies).toHaveLength(0);
+    const content = submitted.data.content as Array<Record<string, unknown>>;
+    expect(content[1]?.['type']).toBe('text');
+    expect(String(content[1]?.['text'])).toMatch(/<video path="[^"]+"><\/video>/);
+
+    await abortPrompt(id, submitted.data.prompt_id);
+  });
+
+  it('keeps the llm video mapping across a server restart', async () => {    const id = await createSessionWithAgent();
     const fileId = await uploadVideoFile('clip.mp4', Buffer.from('persisted'));
 
     const submitted = await submitVideoPrompt(id, [fileId]);

From 0f89d7e90972d905ee8ed38c0c0ace9cedbf1281 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 18:37:33 +0800
Subject: [PATCH 10/45] test: keep the generation stub pending until the abort
 lands

An immediately-answered 404 ends the turn (non-retryable) before the
test's abort call, racing the cleanup into a 409; the stub now hangs
generation until the abort cancels it.
---
 packages/kap-server/test/prompts.test.ts | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/packages/kap-server/test/prompts.test.ts b/packages/kap-server/test/prompts.test.ts
index efcf48bcdd..6a8d322f61 100644
--- a/packages/kap-server/test/prompts.test.ts
+++ b/packages/kap-server/test/prompts.test.ts
@@ -1,5 +1,5 @@
 import { mkdir, mkdtemp, readFile, realpath, rm, writeFile } from 'node:fs/promises';
-import { createServer } from 'node:http';
+import { createServer, type ServerResponse } from 'node:http';
 import type { AddressInfo } from 'node:net';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
@@ -882,6 +882,7 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
   beforeEach(async () => {
     stubBodies = [];
     let uploadCounter = 0;
+    const pendingGenerations: ServerResponse[] = [];
     const stub = createServer((req, res) => {
       if (req.method === 'POST' && req.url === '/files') {
         const chunks: Buffer[] = [];
@@ -904,9 +905,15 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
         return;
       }
       if (req.method === 'POST' && req.url === '/chat/completions') {
-        // The turn is aborted by the test; this answer is never needed.
-        res.writeHead(404);
-        res.end();
+        // Hang until the turn is aborted: an answered request (404 or a
+        // completed stream) can end the turn before the test's abort lands,
+        // making the cleanup racy.
+        pendingGenerations.push(res);
+        req.on('close', () => {
+          const index = pendingGenerations.indexOf(res);
+          if (index >= 0) pendingGenerations.splice(index, 1);
+          res.end();
+        });
         return;
       }
       res.writeHead(404);
@@ -914,7 +921,11 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
     });
     await new Promise<void>((resolve) => stub.listen(0, '127.0.0.1', resolve));
     const { port } = stub.address() as AddressInfo;
-    stubClose = () => new Promise<void>((resolve) => stub.close(() => resolve()));
+    stubClose = () =>
+      new Promise<void>((resolve) => {
+        for (const pending of pendingGenerations.splice(0)) pending.destroy();
+        stub.close(() => resolve());
+      });
 
     home = await mkdtemp(join(tmpdir(), 'kimi-server-v2-prompts-kimi-'));
     await writeFile(join(home, 'config.toml'), kimiToml(`http://127.0.0.1:${String(port)}`), 'utf-8');

From b1c6e03f49ebb57b5611b459ebac0a1808773eb7 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 18:41:45 +0800
Subject: [PATCH 11/45] fix: validate prompt file references before mutating
 session controls
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A stale file_id failed inside media resolution — after the model,
thinking and permission overrides had already been applied — so a
rejected prompt still changed the session's controls. File references
are now checked up front, keeping failed submits side-effect free.
---
 packages/kap-server/src/routes/prompts.ts | 16 ++++++++++++++++
 packages/kap-server/test/prompts.test.ts  | 18 ++++++++++++++++++
 2 files changed, 34 insertions(+)

diff --git a/packages/kap-server/src/routes/prompts.ts b/packages/kap-server/src/routes/prompts.ts
index 248b64e6cc..0d618a99fa 100644
--- a/packages/kap-server/src/routes/prompts.ts
+++ b/packages/kap-server/src/routes/prompts.ts
@@ -212,6 +212,21 @@ async function applyProfileSelection(
   return true;
 }
 
+/**
+ * Fail fast on stale file references before any session control is mutated:
+ * a bad `file_id` must reject the request with the session's
+ * model/thinking/permission left untouched.
+ */
+async function assertPromptFileRefs(body: PromptSubmission, store: IFileService): Promise<void> {
+  for (const part of body.content) {
+    if (part.type === 'file') {
+      await store.get(part.file_id);
+    } else if ((part.type === 'image' || part.type === 'video') && part.source.kind === 'file') {
+      await store.get(part.source.file_id);
+    }
+  }
+}
+
 export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
   const listRoute = defineRoute(
     {
@@ -264,6 +279,7 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
         // media resolution (video upload) keys off the effective model.
         const resolved = await resolvePrompt(core, session_id, req.body.agent_id);
         await resolved.auth.ensureReady();
+        await assertPromptFileRefs(req.body, core.accessor.get(IFileService));
         let thinkingConsumed = false;
         if (req.body.profile !== undefined) {
           thinkingConsumed =
diff --git a/packages/kap-server/test/prompts.test.ts b/packages/kap-server/test/prompts.test.ts
index 6a8d322f61..d933471066 100644
--- a/packages/kap-server/test/prompts.test.ts
+++ b/packages/kap-server/test/prompts.test.ts
@@ -215,6 +215,24 @@ describe('server-v2 /api/v1 prompts', () => {
     expect(Array.isArray(list.body.data.queued)).toBe(true);
   });
 
+  it('rejects a stale file reference without mutating the session model', async () => {
+    const id = await createSession(home as string);
+    const session = server!.core.accessor.get(ISessionLifecycleService).get(id);
+    const agent = await session!.accessor.get(IAgentLifecycleService).create({ agentId: 'main' });
+    const profile = agent.accessor.get(IAgentProfileService);
+    const modelBefore = profile.getModel();
+
+    const { body } = await call<null>('POST', `/api/v1/sessions/${id}/prompts`, {
+      model: 'stub',
+      content: [
+        { type: 'text', text: 'look' },
+        { type: 'video', source: { kind: 'file', file_id: 'f_does_not_exist' } },
+      ],
+    });
+    expect(body.code).toBe(40407);
+    expect(profile.getModel()).toBe(modelBefore);
+  });
+
   it('falls back to cache path tags for uploaded videos when the model has no upload channel', async () => {
     const id = await createSession(home as string);
     await createMainAgent(id);

From a9d0ff8242cc5d6b600708c486841cc33bbbc8f6 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 18:47:17 +0800
Subject: [PATCH 12/45] fix: serialize prompt submissions per session

A slow provider video upload let a later text-only request reach the
queue ahead of an earlier video one, silently reordering the
conversation for REST clients and multiple tabs. Submissions to the
same session now chain, matching the ordering the TUI already
guarantees locally.
---
 packages/kap-server/src/routes/prompts.ts | 26 ++++++--
 packages/kap-server/test/prompts.test.ts  | 74 +++++++++++++++++++----
 2 files changed, 83 insertions(+), 17 deletions(-)

diff --git a/packages/kap-server/src/routes/prompts.ts b/packages/kap-server/src/routes/prompts.ts
index 0d618a99fa..5077e7324e 100644
--- a/packages/kap-server/src/routes/prompts.ts
+++ b/packages/kap-server/src/routes/prompts.ts
@@ -227,6 +227,12 @@ async function assertPromptFileRefs(body: PromptSubmission, store: IFileService)
   }
 }
 
+/**
+ * Serializes prompt submissions per session: a slow media upload must not
+ * let a later request reach the queue ahead of an earlier one.
+ */
+const submitChains = new Map<string, Promise<void>>();
+
 export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
   const listRoute = defineRoute(
     {
@@ -273,8 +279,9 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
       operationId: 'submitPrompt',
     },
     async (req, reply) => {
-      try {
-        const { session_id } = req.params;
+      const { session_id } = req.params;
+      const invoke = async (): Promise<void> => {
+        try {
         // Resolve the agent and apply profile/model overrides first: prompt
         // media resolution (video upload) keys off the effective model.
         const resolved = await resolvePrompt(core, session_id, req.body.agent_id);
@@ -351,8 +358,19 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
           origin: { kind: 'user' },
         } });
         reply.send(okEnvelope(projectPromptHandle(handle), req.id));
-      } catch (error) {
-        sendMappedError(reply, req, error);
+        } catch (error) {
+          sendMappedError(reply, req, error);
+        }
+      };
+      const previous = submitChains.get(session_id) ?? Promise.resolve();
+      const run = previous.then(invoke);
+      // The chain must never reject, or later submissions would be skipped.
+      const stored = run.catch(() => undefined);
+      submitChains.set(session_id, stored);
+      try {
+        await run;
+      } finally {
+        if (submitChains.get(session_id) === stored) submitChains.delete(session_id);
       }
     },
   );
diff --git a/packages/kap-server/test/prompts.test.ts b/packages/kap-server/test/prompts.test.ts
index d933471066..0fd67ef6cf 100644
--- a/packages/kap-server/test/prompts.test.ts
+++ b/packages/kap-server/test/prompts.test.ts
@@ -878,6 +878,7 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
   let base: string;
   let stubClose: (() => Promise<void>) | undefined;
   let stubBodies: Buffer[];
+  let uploadGate: Promise<void> | null;
 
   function kimiToml(stubUrl: string): string {
     return [
@@ -899,6 +900,7 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
 
   beforeEach(async () => {
     stubBodies = [];
+    uploadGate = null;
     let uploadCounter = 0;
     const pendingGenerations: ServerResponse[] = [];
     const stub = createServer((req, res) => {
@@ -906,19 +908,26 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
         const chunks: Buffer[] = [];
         req.on('data', (chunk: Buffer) => chunks.push(chunk));
         req.on('end', () => {
-          uploadCounter += 1;
-          stubBodies.push(Buffer.concat(chunks));
-          res.writeHead(200, { 'content-type': 'application/json' });
-          res.end(
-            JSON.stringify({
-              id: `stub-llm-video-${String(uploadCounter)}`,
-              object: 'file',
-              bytes: 17,
-              created_at: 0,
-              filename: 'clip.mp4',
-              purpose: 'video',
-            }),
-          );
+          void (async () => {
+            if (uploadGate !== null) {
+              const gate = uploadGate;
+              uploadGate = null;
+              await gate;
+            }
+            uploadCounter += 1;
+            stubBodies.push(Buffer.concat(chunks));
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end(
+              JSON.stringify({
+                id: `stub-llm-video-${String(uploadCounter)}`,
+                object: 'file',
+                bytes: 17,
+                created_at: 0,
+                filename: 'clip.mp4',
+                purpose: 'video',
+              }),
+            );
+          })();
         });
         return;
       }
@@ -1122,6 +1131,45 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
     await abortPrompt(id, submitted.data.prompt_id);
   });
 
+  it('serializes concurrent submissions so a media upload cannot be overtaken', async () => {
+    const id = await createSessionWithAgent();
+    const fileId = await uploadVideoFile('clip.mp4', Buffer.from('0123456789'));
+
+    // Gate the provider upload: the video submit parks inside media
+    // resolution while a later text submit races it.
+    let releaseUpload!: () => void;
+    uploadGate = new Promise<void>((resolve) => {
+      releaseUpload = resolve;
+    });
+    const first = submitVideoPrompt(id, [fileId]);
+    const second = fetch(`${base}/api/v1/sessions/${id}/prompts`, {
+      method: 'POST',
+      headers: authHeaders(server as RunningServer, { 'content-type': 'application/json' }),
+      body: JSON.stringify({ content: [{ type: 'text', text: 'follow-up' }] }),
+    } as never);
+    await new Promise((r) => setTimeout(r, 100));
+    releaseUpload();
+
+    const [firstSubmitted, secondRes] = await Promise.all([first, second]);
+    const secondSubmitted = (await secondRes.json()) as Envelope<PromptItemWire>;
+    expect(firstSubmitted.code).toBe(0);
+    expect(secondSubmitted.code).toBe(0);
+
+    // The video prompt holds the active slot; the follow-up waits behind it
+    // in the queue instead of overtaking.
+    const listRes = await fetch(`${base}/api/v1/sessions/${id}/prompts`, {
+      headers: authHeaders(server as RunningServer),
+    } as never);
+    const list = ((await listRes.json()) as Envelope<{
+      active: { prompt_id: string } | null;
+      queued: Array<{ prompt_id: string }>;
+    }>).data;
+    expect(list.active?.prompt_id).toBe(firstSubmitted.data.prompt_id);
+    expect(list.queued.map((p) => p.prompt_id)).toEqual([secondSubmitted.data.prompt_id]);
+
+    await abortPrompt(id, firstSubmitted.data.prompt_id);
+  });
+
   it('keeps the llm video mapping across a server restart', async () => {    const id = await createSessionWithAgent();
     const fileId = await uploadVideoFile('clip.mp4', Buffer.from('persisted'));
 

From ef197c268cd0b393bc5b872743c20814218c312e Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 18:56:46 +0800
Subject: [PATCH 13/45] fix: play reloaded provider videos through the
 authenticated fetch path
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A video recovered from an ms:// reference carried only the bare redirect
URL, which 401s under daemon auth when loaded natively. The attachment
now keeps the provider file id (llmFileId) end to end, and AuthMedia
fetches the bytes with the Bearer credential through the daemon's llm
redirect — the same blob-URL path uploaded files already use.
---
 apps/kimi-web/src/api/daemon/client.ts        |  4 ++++
 apps/kimi-web/src/api/types.ts                |  2 ++
 .../src/components/chat/AuthMedia.vue         | 22 ++++++++++++++-----
 .../kimi-web/src/components/chat/ChatPane.vue | 12 ++++++++--
 .../src/composables/messagesToTurns.ts        |  7 +++---
 apps/kimi-web/src/types.ts                    |  9 +++++++-
 apps/kimi-web/test/turn-logic.test.ts         |  4 ++--
 7 files changed, 47 insertions(+), 13 deletions(-)

diff --git a/apps/kimi-web/src/api/daemon/client.ts b/apps/kimi-web/src/api/daemon/client.ts
index 9c68a83ead..d320d3d81d 100644
--- a/apps/kimi-web/src/api/daemon/client.ts
+++ b/apps/kimi-web/src/api/daemon/client.ts
@@ -1393,6 +1393,10 @@ export class DaemonKimiWebApi implements KimiWebApi {
     return buildRestUrl(this.config.serverHttpUrl, `/files/llm/${encodeURIComponent(llmFileId)}`);
   }
 
+  async getLlmFileBlob(llmFileId: string): Promise<Blob> {
+    return this.http.getBlob(`/files/llm/${encodeURIComponent(llmFileId)}`);
+  }
+
   // -------------------------------------------------------------------------
   // WebSocket events
   // -------------------------------------------------------------------------
diff --git a/apps/kimi-web/src/api/types.ts b/apps/kimi-web/src/api/types.ts
index ed7d1a1b82..6fe62420a0 100644
--- a/apps/kimi-web/src/api/types.ts
+++ b/apps/kimi-web/src/api/types.ts
@@ -784,6 +784,8 @@ export interface KimiWebApi {
   /** URL of the daemon redirect that maps a provider-issued video file id
    *  (`ms://<llmFileId>`) back to the local upload it was produced from. */
   getLlmFileUrl(llmFileId: string): string;
+  /** Fetch a provider-referenced video's bytes with auth via the llm redirect. */
+  getLlmFileBlob(llmFileId: string): Promise<Blob>;
 
   // Config — REAL endpoints
   getConfig(): Promise<AppConfig>;
diff --git a/apps/kimi-web/src/components/chat/AuthMedia.vue b/apps/kimi-web/src/components/chat/AuthMedia.vue
index 2e6939fcbc..aced943d1c 100644
--- a/apps/kimi-web/src/components/chat/AuthMedia.vue
+++ b/apps/kimi-web/src/components/chat/AuthMedia.vue
@@ -16,6 +16,9 @@ const props = withDefaults(
     /** File-store id. When present the bytes are fetched with auth and played
      *  from a blob URL; otherwise `url` is used directly (e.g. a data: URL). */
     fileId?: string;
+    /** Provider-issued file id of an inlined video (`ms://<id>`). Like fileId,
+     *  the bytes are fetched with auth — through the daemon's llm redirect. */
+    llmFileId?: string;
     mediaClass?: string;
     /** Video: show native controls. Defaults to true (chat bubble); queue
      *  thumbnails pass false. */
@@ -26,12 +29,12 @@ const props = withDefaults(
   { mediaClass: 'u-img', controls: true, muted: false },
 );
 
-const resolvedUrl = ref<string>(props.fileId ? '' : props.url);
+const resolvedUrl = ref<string>(props.fileId || props.llmFileId ? '' : props.url);
 const mediaEl = ref<HTMLElement | null>(null);
 // Flips true once the element nears the viewport, deferring the authenticated
 // download so a session with many historical large uploads doesn't fetch every
 // blob (and hold them in memory) before the user ever scrolls to or plays them.
-const visible = ref(!props.fileId);
+const visible = ref(!props.fileId && !props.llmFileId);
 let objectUrl: string | null = null;
 // Sequence guard + unmount flag: a reused component (e.g. queued thumbnails
 // keyed by index) can change fileId before a previous fetch resolves, and an
@@ -51,13 +54,18 @@ function revoke(): void {
 async function resolve(): Promise<void> {
   const seq = ++requestSeq;
   revoke();
-  if (!props.fileId) {
+  const authedFetch = props.fileId
+    ? () => getKimiWebApi().getFileBlob(props.fileId!)
+    : props.llmFileId
+      ? () => getKimiWebApi().getLlmFileBlob(props.llmFileId!)
+      : null;
+  if (authedFetch === null) {
     resolvedUrl.value = props.url;
     return;
   }
   if (!visible.value) return; // defer until near the viewport
   try {
-    const blob = await getKimiWebApi().getFileBlob(props.fileId);
+    const blob = await authedFetch();
     const url = URL.createObjectURL(blob);
     if (disposed || seq !== requestSeq) {
       URL.revokeObjectURL(url);
@@ -72,7 +80,11 @@ async function resolve(): Promise<void> {
   }
 }
 
-watch(() => [props.fileId, props.url, visible.value] as const, resolve, { immediate: true });
+watch(
+  () => [props.fileId, props.llmFileId, props.url, visible.value] as const,
+  resolve,
+  { immediate: true },
+);
 
 onMounted(() => {
   if (typeof IntersectionObserver === 'function' && mediaEl.value) {
diff --git a/apps/kimi-web/src/components/chat/ChatPane.vue b/apps/kimi-web/src/components/chat/ChatPane.vue
index 5886e0ef90..cf187b422a 100644
--- a/apps/kimi-web/src/components/chat/ChatPane.vue
+++ b/apps/kimi-web/src/components/chat/ChatPane.vue
@@ -477,8 +477,15 @@ function userAttachmentMedia(att: TurnAttachment): ToolMedia {
   // User-uploaded media carries no path/mime metadata; the preview panel falls
   // back to a generic label and sniffs the mime from the URL when needed. When
   // a fileId is present the preview fetches the bytes with auth (a bare
-  // getFileUrl src 401s under daemon auth).
-  return { kind: att.kind === 'video' ? 'video' : 'image', url: att.url, path: att.name, fileId: att.fileId };
+  // getFileUrl src 401s under daemon auth); an llmFileId fetches through the
+  // daemon's authenticated llm redirect instead.
+  return {
+    kind: att.kind === 'video' ? 'video' : 'image',
+    url: att.url,
+    path: att.name,
+    fileId: att.fileId,
+    llmFileId: att.llmFileId,
+  };
 }
 
 // Transient "can't open this type" hint after clicking a file chip of a
@@ -735,6 +742,7 @@ function isStreamingRenderBlock(turn: ChatTurn, block: { sourceIndex: number }):
                 :url="att.url"
                 :kind="att.kind"
                 :file-id="att.fileId"
+                :llm-file-id="att.llmFileId"
                 media-class="q-img"
                 :controls="false"
                 muted
diff --git a/apps/kimi-web/src/composables/messagesToTurns.ts b/apps/kimi-web/src/composables/messagesToTurns.ts
index 75903964a8..7a7a1f2b30 100644
--- a/apps/kimi-web/src/composables/messagesToTurns.ts
+++ b/apps/kimi-web/src/composables/messagesToTurns.ts
@@ -750,7 +750,7 @@ export function messagesToTurns(
 
   function resolveMediaUrl(
     c: AppMessage['content'][number],
-  ): { url: string; kind: 'image' | 'video'; fileId?: string } | undefined {
+  ): { url: string; kind: 'image' | 'video'; fileId?: string; llmFileId?: string } | undefined {
     if (c.type === 'image' || c.type === 'video') {
       const kind = c.type;
       const src = c.source;
@@ -759,7 +759,7 @@ export function messagesToTurns(
         // uploaded video; the daemon serves the local bytes at /files/llm/<id>.
         const llmFileId = llmFileIdFromMsUrl(src.url);
         if (llmFileId !== undefined && getLlmFileUrl) {
-          return { url: getLlmFileUrl(llmFileId), kind };
+          return { url: getLlmFileUrl(llmFileId), kind, llmFileId };
         }
         return { url: src.url, kind };
       }
@@ -864,7 +864,7 @@ export function messagesToTurns(
             // instead of dumping the raw reference into the bubble.
             const llmFileId = llmVideoRefTag(c.text);
             if (llmFileId !== null && getLlmFileUrl) {
-              attachments.push({ url: getLlmFileUrl(llmFileId), kind: 'video' });
+              attachments.push({ url: getLlmFileUrl(llmFileId), kind: 'video', llmFileId });
               continue;
             }
             // A generic file upload comes back as an "Attached file …" notice;
@@ -895,6 +895,7 @@ export function messagesToTurns(
             kind: media.kind,
             name: c.type === 'file' ? c.name : undefined,
             fileId: media.fileId,
+            llmFileId: media.llmFileId,
           });
           continue;
         }
diff --git a/apps/kimi-web/src/types.ts b/apps/kimi-web/src/types.ts
index 4286377eed..a0fd1d4d99 100644
--- a/apps/kimi-web/src/types.ts
+++ b/apps/kimi-web/src/types.ts
@@ -110,6 +110,9 @@ export interface ToolMedia {
   /** File-store id when the media is an uploaded file. The preview fetches its
    *  bytes with the Bearer credential (a bare getFileUrl src 401s in <img>). */
   fileId?: string;
+  /** Provider-issued file id of an inlined video (`ms://<id>`); the preview
+   *  fetches through the daemon's authenticated llm redirect, not the bare URL. */
+  llmFileId?: string;
 }
 
 export type AgentPhase = 'queued' | 'working' | 'suspended' | 'completed' | 'failed';
@@ -235,6 +238,10 @@ export interface TurnAttachment {
   kind: 'image' | 'video' | 'file';
   url: string;
   fileId?: string;
+  /** Provider-issued file id behind an inlined video (`ms://<id>`). Like
+   *  `fileId`, it selects an authenticated fetch (the daemon's llm redirect)
+   *  over a bare URL load, which would 401 under daemon auth. */
+  llmFileId?: string;
   name?: string;
   mediaType?: string;
   size?: number;
@@ -336,7 +343,7 @@ export interface QueuedPromptView {
   attachmentCount: number;
   /** Attachments waiting with this prompt, with resolved URLs for thumbnails
       (file attachments render an icon chip, no thumbnail). */
-  attachments?: { fileId: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[];
+  attachments?: { fileId: string; kind: 'image' | 'video' | 'file'; url: string; name?: string; llmFileId?: string }[];
 }
 
 /** Horizontal alignment of the conversation reading column within the pane. */
diff --git a/apps/kimi-web/test/turn-logic.test.ts b/apps/kimi-web/test/turn-logic.test.ts
index 69d104cb35..bcb39189c0 100644
--- a/apps/kimi-web/test/turn-logic.test.ts
+++ b/apps/kimi-web/test/turn-logic.test.ts
@@ -240,7 +240,7 @@ describe('messagesToTurns', () => {
     expect(turns).toHaveLength(1);
     expect(turns[0]).toMatchObject({ role: 'user', text: 'look at this' });
     expect(turns[0]?.attachments).toEqual([
-      { url: `/api/v1/files/llm/${llmFileId}`, kind: 'video' },
+      { url: `/api/v1/files/llm/${llmFileId}`, kind: 'video', llmFileId },
     ]);
   });
 
@@ -259,7 +259,7 @@ describe('messagesToTurns', () => {
     );
 
     expect(turns[0]?.attachments).toEqual([
-      { url: '/api/v1/files/llm/file-abc123', kind: 'video' },
+      { url: '/api/v1/files/llm/file-abc123', kind: 'video', llmFileId: 'file-abc123' },
     ]);
   });
 

From ece87aae49b6358b8aa8b61d02fc23b73ba0e3a3 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 19:06:34 +0800
Subject: [PATCH 14/45] fix: fence pending video submits against session and
 model switches

A slow paste-upload left the TUI idle, so /new, the session picker or
/model could fire mid-upload; the continuation then dispatched the old
session's provider reference into the newly selected session or a
model that cannot resolve it. The dispatch now re-checks that the
session and model are unchanged and asks for a resend instead.
---
 apps/kimi-code/src/tui/kimi-tui.ts            | 16 ++++-
 .../test/tui/kimi-tui-message-flow.test.ts    | 72 +++++++++++++++++++
 2 files changed, 87 insertions(+), 1 deletion(-)

diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index ba4aef0c3a..077119361a 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -1166,15 +1166,29 @@ export class KimiTUI {
     // Video attachments upload asynchronously before the prompt goes out.
     // Chain this submit (and any submitted while an upload is in flight) so
     // a slow upload cannot be overtaken by a later message.
+    const modelAtSubmit = this.state.appState.model;
     this.pendingSubmits += 1;
     this.inputSubmitChain = this.inputSubmitChain.then(async () => {
       try {
+        let parts: readonly PromptPart[] | undefined;
         if (extraction.hasMedia) {
-          const parts = hasVideo
+          parts = hasVideo
             ? await materializeMediaSegments(extraction.segments, (attachment) =>
                 session.uploadVideo(attachment.sourcePath),
               )
             : segmentsToPromptParts(extraction.segments);
+        }
+        // Re-checked at dispatch time: if the user switched the session or
+        // the model mid-upload, the provider-issued reference (or the upload
+        // itself) would now go to the wrong place. Drop the message and ask
+        // for a resend instead.
+        if (this.session !== session || this.state.appState.model !== modelAtSubmit) {
+          this.showError(
+            'The session or model changed while the video was uploading — please resend.',
+          );
+          return;
+        }
+        if (parts !== undefined) {
           this.sendMessage(session, text, {
             hasMedia: true,
             parts,
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index 05f2c594e7..a926173989 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -1658,6 +1658,78 @@ command = "vim"
     }
   });
 
+  it('drops a pending video submit when the model changes mid-upload', async () => {
+    const { driver, session } = await makeDriver();
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
+    try {
+      const srcVideo = join(dir, 'clip.mp4');
+      await writeFile(srcVideo, 'video-bytes');
+      const attachment = imageStore.addVideo('video/mp4', srcVideo);
+
+      let releaseUpload!: () => void;
+      vi.mocked(session.uploadVideo).mockImplementationOnce(
+        () =>
+          new Promise((resolve) => {
+            releaseUpload = () =>
+              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
+          }),
+      );
+
+      driver.handleUserInput(`watch ${attachment.placeholder}`);
+      await vi.waitFor(() => {
+        expect(session.uploadVideo).toHaveBeenCalled();
+      });
+      driver.state.appState.model = 'another-model';
+      releaseUpload();
+
+      await vi.waitFor(() => {
+        expect(driver.state.transcriptContainer.render(120).join('\n')).toContain(
+          'The session or model changed while the video was uploading',
+        );
+      });
+      expect(session.prompt).not.toHaveBeenCalled();
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('drops a pending video submit when the session changes mid-upload', async () => {
+    const { driver, session } = await makeDriver();
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
+    try {
+      const srcVideo = join(dir, 'clip.mp4');
+      await writeFile(srcVideo, 'video-bytes');
+      const attachment = imageStore.addVideo('video/mp4', srcVideo);
+
+      let releaseUpload!: () => void;
+      vi.mocked(session.uploadVideo).mockImplementationOnce(
+        () =>
+          new Promise((resolve) => {
+            releaseUpload = () =>
+              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
+          }),
+      );
+
+      driver.handleUserInput(`watch ${attachment.placeholder}`);
+      await vi.waitFor(() => {
+        expect(session.uploadVideo).toHaveBeenCalled();
+      });
+      (driver as { session: unknown }).session = makeSession();
+      releaseUpload();
+
+      await vi.waitFor(() => {
+        expect(driver.state.transcriptContainer.render(120).join('\n')).toContain(
+          'The session or model changed while the video was uploading',
+        );
+      });
+      expect(session.prompt).not.toHaveBeenCalled();
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
   it('queues a pasted-video message with uploaded parts while streaming', async () => {
     const session = makeSession();
     const { driver } = await makeDriver(session);

From b8077eca52545dbd56c8b544673c18df20a0a3d0 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 19:17:21 +0800
Subject: [PATCH 15/45] fix: preserve the caller's video path verbatim in
 uploadVideo

Trimming the path changed the filesystem target before validation and
upload, so a name that legitimately starts or ends with whitespace
resolved to the wrong file; the trim is now only the emptiness check.
---
 packages/agent-core/src/agent/index.ts | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/packages/agent-core/src/agent/index.ts b/packages/agent-core/src/agent/index.ts
index c52ea83b03..bb7a52bfe1 100644
--- a/packages/agent-core/src/agent/index.ts
+++ b/packages/agent-core/src/agent/index.ts
@@ -518,30 +518,32 @@ export class Agent {
         'The current model does not support video upload.',
       );
     }
-    const trimmed = path.trim();
-    if (trimmed.length === 0) {
+    // The trimmed copy is only the emptiness check — the path itself is used
+    // verbatim so a name that legitimately starts or ends with whitespace
+    // still resolves to the same file.
+    if (path.trim().length === 0) {
       throw new KimiError(ErrorCodes.REQUEST_INVALID, 'Video path cannot be empty.');
     }
-    const header = await this.kaos.readBytes(trimmed, MEDIA_SNIFF_BYTES);
-    const fileType = detectFileType(trimmed, header, 'media');
+    const header = await this.kaos.readBytes(path, MEDIA_SNIFF_BYTES);
+    const fileType = detectFileType(path, header, 'media');
     if (fileType.kind !== 'video') {
-      throw new KimiError(ErrorCodes.REQUEST_INVALID, `"${trimmed}" is not a video file.`);
+      throw new KimiError(ErrorCodes.REQUEST_INVALID, `"${path}" is not a video file.`);
     }
-    const stat = await this.kaos.stat(trimmed);
+    const stat = await this.kaos.stat(path);
     if (stat.stSize === 0) {
-      throw new KimiError(ErrorCodes.REQUEST_INVALID, `"${trimmed}" is empty.`);
+      throw new KimiError(ErrorCodes.REQUEST_INVALID, `"${path}" is empty.`);
     }
     if (stat.stSize > MAX_MEDIA_BYTES) {
       throw new KimiError(
         ErrorCodes.REQUEST_INVALID,
-        `"${trimmed}" is ${String(stat.stSize)} bytes, which exceeds the 100MB maximum for video uploads.`,
+        `"${path}" is ${String(stat.stSize)} bytes, which exceeds the 100MB maximum for video uploads.`,
       );
     }
-    const data = await this.kaos.readBytes(trimmed);
+    const data = await this.kaos.readBytes(path);
     return uploader({
       data,
       mimeType: fileType.mimeType,
-      filename: trimmed.split(/[\\/]/).at(-1),
+      filename: path.split(/[\\/]/).at(-1),
     });
   }
 

From 259e4e6cb8ab8013f5728784db4d6b296914bb8b Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 19:17:21 +0800
Subject: [PATCH 16/45] fix: forward provider-issued ids on image URL prompt
 parts too

The shared url-source schema accepts id for image and video parts, but
only the video path forwarded it, dropping provider-keyed image ids
between prompt acceptance and the model request.
---
 packages/kap-server/src/routes/prompts.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/kap-server/src/routes/prompts.ts b/packages/kap-server/src/routes/prompts.ts
index 5077e7324e..5e0f793293 100644
--- a/packages/kap-server/src/routes/prompts.ts
+++ b/packages/kap-server/src/routes/prompts.ts
@@ -481,7 +481,7 @@ function corePartsToProtocol(content: readonly ContentPart[]): PromptSubmission[
     else if (part.type === 'image_url') {
       const match = /^data:([^;]+);base64,(.*)$/.exec(part.imageUrl.url);
       parts.push(match === null
-        ? { type: 'image', source: { kind: 'url', url: part.imageUrl.url } }
+        ? { type: 'image', source: { kind: 'url', url: part.imageUrl.url, id: part.imageUrl.id } }
         : { type: 'image', source: { kind: 'base64', media_type: match[1]!, data: match[2]! } });
     } else if (part.type === 'video_url') {
       const match = /^data:([^;]+);base64,(.*)$/.exec(part.videoUrl.url);
@@ -497,7 +497,7 @@ function contentToCoreParts(content: PromptSubmission['content']): ContentPart[]
   const parts: ContentPart[] = [];
   for (const part of content) {
     if (part.type === 'text') parts.push({ type: 'text', text: part.text });
-    else if (part.type === 'image' && part.source.kind === 'url') parts.push({ type: 'image_url', imageUrl: { url: part.source.url } });
+    else if (part.type === 'image' && part.source.kind === 'url') parts.push({ type: 'image_url', imageUrl: { url: part.source.url, id: part.source.id } });
     else if (part.type === 'image' && part.source.kind === 'base64') parts.push({ type: 'image_url', imageUrl: { url: `data:${part.source.media_type};base64,${part.source.data}` } });
     else if (part.type === 'video' && part.source.kind === 'url') parts.push({ type: 'video_url', videoUrl: { url: part.source.url, id: part.source.id } });
     else if (part.type === 'video' && part.source.kind === 'base64') parts.push({ type: 'video_url', videoUrl: { url: `data:${part.source.media_type};base64,${part.source.data}` } });

From 6f0c9ec9f4a82420963c1c0ded13745da1c72968 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 19:17:21 +0800
Subject: [PATCH 17/45] fix(web): reconcile inlined video echoes into the
 optimistic user message
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The loose user-message matcher counted media parts and <video path>
tags but not the [video:ms://…] text shape, so a racing server echo of
an inlined upload slipped through as a duplicate user bubble.
---
 apps/kimi-web/src/api/daemon/eventReducer.ts |  8 +++-
 apps/kimi-web/test/event-reducer.test.ts     | 43 ++++++++++++++++++++
 2 files changed, 50 insertions(+), 1 deletion(-)

diff --git a/apps/kimi-web/src/api/daemon/eventReducer.ts b/apps/kimi-web/src/api/daemon/eventReducer.ts
index 4916bfa7b7..1a24a39161 100644
--- a/apps/kimi-web/src/api/daemon/eventReducer.ts
+++ b/apps/kimi-web/src/api/daemon/eventReducer.ts
@@ -158,6 +158,11 @@ function sameMessageContent(a: AppMessage, b: AppMessage): boolean {
 // A tag is its own text part, so anchoring keeps ordinary prose from matching.
 const MEDIA_PATH_TAG_SHAPE_RE = /^<(image|video|audio)\s+path="[^"]+"><\/\1>$/;
 
+// Matches the provider reference a prompt video was inlined as:
+// `[video:ms://<id>]`. Like the media path tag it is its own text part and
+// counts as media so the echo reconciles with the optimistic copy.
+const LLM_VIDEO_REF_SHAPE_RE = /^\[video:ms:\/\/[^\]]+\]$/;
+
 function userMessageShape(m: AppMessage): { text: string; media: number } {
   let text = '';
   let media = 0;
@@ -166,7 +171,8 @@ function userMessageShape(m: AppMessage): { text: string; media: number } {
       // A video/image upload reaches us (after the server resolves it) as a
       // `<video path=…></video>` text tag, not a media part — count it as media
       // and drop it from the text so the echo reconciles with our optimistic copy.
-      if (MEDIA_PATH_TAG_SHAPE_RE.test(c.text.trim())) media += 1;
+      const trimmed = c.text.trim();
+      if (MEDIA_PATH_TAG_SHAPE_RE.test(trimmed) || LLM_VIDEO_REF_SHAPE_RE.test(trimmed)) media += 1;
       else text += c.text;
     } else if (c.type === 'image' || c.type === 'video' || c.type === 'file') media += 1;
   }
diff --git a/apps/kimi-web/test/event-reducer.test.ts b/apps/kimi-web/test/event-reducer.test.ts
index f22c51119e..d876a92bef 100644
--- a/apps/kimi-web/test/event-reducer.test.ts
+++ b/apps/kimi-web/test/event-reducer.test.ts
@@ -302,6 +302,49 @@ describe('reduceAppEvent messageCreated', () => {
     expect(msgs[0]?.content).toEqual(echo.content);
     expect(msgs[0]?.promptId).toBe('p1');
   });
+
+  it('reconciles an inlined `[video:ms://…]` echo into the optimistic user message', () => {
+    // A video the server inlined as a provider reference echoes back as a
+    // `[video:ms://…]` text part, while the optimistic copy still carries the
+    // file-source video. They must collapse into one bubble, not duplicate.
+    const optimistic: AppMessage = {
+      id: 'msg_opt_2',
+      sessionId: 's-vid',
+      role: 'user',
+      content: [
+        { type: 'text', text: 'look at this' },
+        { type: 'video', source: { kind: 'file', fileId: 'f_abc' } },
+      ],
+      createdAt: '2026-06-01T12:00:00.000Z',
+      metadata: { 'kimiWeb.optimisticUserMessage': true },
+    };
+    const echo: AppMessage = {
+      id: 'msg_real',
+      sessionId: 's-vid',
+      role: 'user',
+      content: [
+        { type: 'text', text: 'look at this' },
+        { type: 'text', text: '[video:ms://file-abc123]' },
+      ],
+      createdAt: '2026-06-01T12:00:00.000Z',
+      promptId: 'p1',
+    };
+    const state = {
+      ...createInitialState(),
+      sessions: [makeSession('s-vid', '2026-01-01T00:00:00.000Z')],
+      messagesBySession: { 's-vid': [optimistic] },
+    };
+    const next = reduceAppEvent(
+      state,
+      { type: 'messageCreated', message: echo },
+      { sessionId: 's-vid', seq: 1 },
+    );
+    const msgs = next.messagesBySession['s-vid'] ?? [];
+    expect(msgs).toHaveLength(1);
+    expect(msgs[0]?.id).toBe('msg_opt_2');
+    expect(msgs[0]?.content).toEqual(echo.content);
+    expect(msgs[0]?.promptId).toBe('p1');
+  });
 });
 
 describe('reduceAppEvent taskProgress', () => {

From f536783957fd3d41fd2481ea593ab1fd732275e6 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 19:17:21 +0800
Subject: [PATCH 18/45] fix: queue bash submits behind a pending video upload

A bash-mode submit could start while a pasted video was still
uploading, recording shell context before the earlier prompt was
dispatched and reordering user actions; it now chains behind the
upload like normal submits.
---
 apps/kimi-code/src/tui/kimi-tui.ts            | 15 ++++++
 .../test/tui/kimi-tui-message-flow.test.ts    | 47 +++++++++++++++++++
 2 files changed, 62 insertions(+)

diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 077119361a..8574aa43e3 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -1000,6 +1000,21 @@ export class KimiTUI {
     const historyText = wasBashMode ? `!${text}` : text;
     void this.persistInputHistory(historyText);
     if (wasBashMode) {
+      // A pending video upload is busy time too: chain behind it so the
+      // command cannot record shell context before the earlier prompt is
+      // dispatched (which would reorder user actions).
+      if (this.pendingSubmits > 0) {
+        this.inputSubmitChain = this.inputSubmitChain.then(() => {
+          if (this.state.appState.streamingPhase !== 'idle') {
+            this.enqueueMessage(text, undefined, 'bash');
+          } else {
+            this.runShellCommandFromInput(text);
+          }
+          this.updateQueueDisplay();
+          this.state.ui.requestRender();
+        });
+        return;
+      }
       // Only one foreground action at a time: queue the shell command while
       // another shell command is running or an agent turn is in progress.
       if (this.state.appState.streamingPhase !== 'idle') {
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index a926173989..b860136ce0 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -1730,6 +1730,53 @@ command = "vim"
     }
   });
 
+  it('queues a bash submit behind a pending video upload', async () => {
+    const runShellCommand = vi.fn(async () => ({ stdout: '', stderr: '', isError: false }));
+    const session = makeSession({ runShellCommand });
+    const { driver } = await makeDriver(session);
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
+    try {
+      const srcVideo = join(dir, 'clip.mp4');
+      await writeFile(srcVideo, 'video-bytes');
+      const attachment = imageStore.addVideo('video/mp4', srcVideo);
+
+      let releaseUpload!: () => void;
+      vi.mocked(session.uploadVideo).mockImplementationOnce(
+        () =>
+          new Promise((resolve) => {
+            releaseUpload = () =>
+              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
+          }),
+      );
+
+      driver.handleUserInput(`watch ${attachment.placeholder}`);
+      await vi.waitFor(() => {
+        expect(session.uploadVideo).toHaveBeenCalled();
+      });
+
+      driver.state.appState.inputMode = 'bash';
+      driver.handleUserInput('ls');
+      driver.state.appState.inputMode = 'prompt';
+
+      // The command must not run (or even queue) before the earlier prompt
+      // is dispatched.
+      await new Promise((r) => setTimeout(r, 20));
+      expect(runShellCommand).not.toHaveBeenCalled();
+      expect(driver.state.queuedMessages).toHaveLength(0);
+
+      releaseUpload();
+      await vi.waitFor(() => {
+        expect(driver.state.queuedMessages).toEqual([{ text: 'ls', agentId: 'main', mode: 'bash' }]);
+      });
+      // The video prompt owns the active turn, so the command holds in the
+      // queue instead of racing it.
+      expect(runShellCommand).not.toHaveBeenCalled();
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
   it('queues a pasted-video message with uploaded parts while streaming', async () => {
     const session = makeSession();
     const { driver } = await makeDriver(session);

From a637ea5dd4f38e162f2ab2826f3b658a79aafddd Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 19:35:08 +0800
Subject: [PATCH 19/45] test: cast the driver through unknown for the
 session-switch fence test

---
 apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index b860136ce0..54a730c30e 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -1716,7 +1716,7 @@ command = "vim"
       await vi.waitFor(() => {
         expect(session.uploadVideo).toHaveBeenCalled();
       });
-      (driver as { session: unknown }).session = makeSession();
+      (driver as unknown as { session: unknown }).session = makeSession();
       releaseUpload();
 
       await vi.waitFor(() => {

From d922a4c14287adb15c67ff355f9780a8831a2099 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 20:39:42 +0800
Subject: [PATCH 20/45] fix: validate prompt file references before resolving
 the prompt agent

A stale file_id posted to a fresh or cold session materialized the main
agent (registering it in session metadata and igniting agent-scoped
services) before the request was rejected. The file check now runs
first, so failed submits create nothing and mutate nothing.
---
 packages/kap-server/src/routes/prompts.ts | 11 +++++++----
 packages/kap-server/test/prompts.test.ts  |  9 ++++-----
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/packages/kap-server/src/routes/prompts.ts b/packages/kap-server/src/routes/prompts.ts
index 5e0f793293..c656b09939 100644
--- a/packages/kap-server/src/routes/prompts.ts
+++ b/packages/kap-server/src/routes/prompts.ts
@@ -213,9 +213,9 @@ async function applyProfileSelection(
 }
 
 /**
- * Fail fast on stale file references before any session control is mutated:
- * a bad `file_id` must reject the request with the session's
- * model/thinking/permission left untouched.
+ * Fail fast on stale file references before anything session-scoped happens:
+ * a bad `file_id` must reject the request without creating the prompt agent
+ * and without touching the session's model/thinking/permission.
  */
 async function assertPromptFileRefs(body: PromptSubmission, store: IFileService): Promise<void> {
   for (const part of body.content) {
@@ -282,11 +282,14 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
       const { session_id } = req.params;
       const invoke = async (): Promise<void> => {
         try {
+        // Fail fast on stale file references before anything is resolved or
+        // mutated: a bad `file_id` must not create the agent, register `main`
+        // in session metadata, or touch the session's controls.
+        await assertPromptFileRefs(req.body, core.accessor.get(IFileService));
         // Resolve the agent and apply profile/model overrides first: prompt
         // media resolution (video upload) keys off the effective model.
         const resolved = await resolvePrompt(core, session_id, req.body.agent_id);
         await resolved.auth.ensureReady();
-        await assertPromptFileRefs(req.body, core.accessor.get(IFileService));
         let thinkingConsumed = false;
         if (req.body.profile !== undefined) {
           thinkingConsumed =
diff --git a/packages/kap-server/test/prompts.test.ts b/packages/kap-server/test/prompts.test.ts
index 0fd67ef6cf..b9a8b0e3b7 100644
--- a/packages/kap-server/test/prompts.test.ts
+++ b/packages/kap-server/test/prompts.test.ts
@@ -215,12 +215,9 @@ describe('server-v2 /api/v1 prompts', () => {
     expect(Array.isArray(list.body.data.queued)).toBe(true);
   });
 
-  it('rejects a stale file reference without mutating the session model', async () => {
+  it('rejects a stale file reference without creating the agent or mutating the model', async () => {
     const id = await createSession(home as string);
     const session = server!.core.accessor.get(ISessionLifecycleService).get(id);
-    const agent = await session!.accessor.get(IAgentLifecycleService).create({ agentId: 'main' });
-    const profile = agent.accessor.get(IAgentProfileService);
-    const modelBefore = profile.getModel();
 
     const { body } = await call<null>('POST', `/api/v1/sessions/${id}/prompts`, {
       model: 'stub',
@@ -230,7 +227,9 @@ describe('server-v2 /api/v1 prompts', () => {
       ],
     });
     expect(body.code).toBe(40407);
-    expect(profile.getModel()).toBe(modelBefore);
+
+    // The failed request must not have materialized the main agent either.
+    expect(session!.accessor.get(IAgentLifecycleService).get('main')).toBeUndefined();
   });
 
   it('falls back to cache path tags for uploaded videos when the model has no upload channel', async () => {

From defe33d2fbbace9f653e0e09e4f753d7bc2bef4b Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 20:40:16 +0800
Subject: [PATCH 21/45] fix: key the playback mapping by the id embedded in the
 reference URL

Projections and clients read the provider id from the ms:// URL, not
the id field, so an upload that returns an id-less or mismatched
reference would inline fine but 404 on playback. The mapping now
derives its key from the URL, falling back to the explicit id.
---
 packages/kap-server/src/routes/prompts.ts | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/packages/kap-server/src/routes/prompts.ts b/packages/kap-server/src/routes/prompts.ts
index c656b09939..e581aff254 100644
--- a/packages/kap-server/src/routes/prompts.ts
+++ b/packages/kap-server/src/routes/prompts.ts
@@ -771,8 +771,12 @@ async function resolvePromptMediaFiles(
             source: { kind: 'url', url: uploaded.videoUrl.url, id: uploaded.videoUrl.id },
           });
           changed = true;
-          if (uploaded.videoUrl.id !== undefined) {
-            await options.onVideoInlined?.(file.meta.id, uploaded.videoUrl.id);
+          // Key the playback mapping by the id embedded in the reference URL
+          // — that's what projections and clients read back — falling back
+          // to the explicit id only for non-`ms://` shapes.
+          const refId = msFileIdFromUrl(uploaded.videoUrl.url) ?? uploaded.videoUrl.id;
+          if (refId !== undefined) {
+            await options.onVideoInlined?.(file.meta.id, refId);
           }
           continue;
         } catch {
@@ -788,6 +792,13 @@ async function resolvePromptMediaFiles(
   return changed ? { ...body, content } : body;
 }
 
+/** The provider file id behind an `ms://<id>` reference, when present. */
+function msFileIdFromUrl(url: string): string | undefined {
+  if (!url.startsWith('ms://')) return undefined;
+  const id = url.slice('ms://'.length);
+  return id.length > 0 ? id : undefined;
+}
+
 async function materializeVideoToCache(file: GetResult, cacheDir: string): Promise<string> {
   await mkdir(cacheDir, { recursive: true });
   const ext = extname(file.meta.name) || (VIDEO_EXT_BY_MIME[file.meta.media_type.toLowerCase()] ?? '.bin');

From c5f1a713e74efde13b59db92ac3ef211e3d50d30 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 20:40:16 +0800
Subject: [PATCH 22/45] fix: sanitize provider video ids on the write side of
 the playback map

The read route got the safe-alphabet guard, but recordLlmVideoRef still
used the provider-returned id verbatim as a blob-store key; a crafted
provider response could write the mapping outside the llm-video
namespace. Out-of-alphabet ids are now dropped on both put and get.
---
 packages/kap-server/src/lib/llmVideoRefs.ts | 14 ++++++++++--
 packages/kap-server/test/files.test.ts      | 24 +++++++++++++++++++++
 2 files changed, 36 insertions(+), 2 deletions(-)

diff --git a/packages/kap-server/src/lib/llmVideoRefs.ts b/packages/kap-server/src/lib/llmVideoRefs.ts
index c4acf825c8..1a8bcb791a 100644
--- a/packages/kap-server/src/lib/llmVideoRefs.ts
+++ b/packages/kap-server/src/lib/llmVideoRefs.ts
@@ -7,22 +7,31 @@
  *
  * Each mapping is one blob-store key (`llm-video/<llmFileId>` → local file
  * id), so concurrent prompt uploads never lose entries to a read-modify-write
- * race, and the map survives restarts.
+ * race, and the map survives restarts. Ids on both sides of the map are
+ * constrained to the provider-id alphabet — the id becomes a storage path
+ * segment, and a crafted provider response must not escape the namespace.
  */
 
 import type { IBlobStore } from '@moonshot-ai/agent-core-v2';
 
 const SCOPE = 'llm-video';
 
+const PROVIDER_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
 
-/** Best-effort persistence is the caller's job; this throws on store errors. */
+/**
+ * Records one mapping; a provider id outside the safe alphabet is dropped
+ * (the prompt itself is unaffected — only playback recovery for that video
+ * is lost). Store errors still propagate to the caller.
+ */
 export async function recordLlmVideoRef(
   blobs: IBlobStore,
   llmFileId: string,
   localFileId: string,
 ): Promise<void> {
+  if (!PROVIDER_ID_RE.test(llmFileId)) return;
   await blobs.put(SCOPE, llmFileId, textEncoder.encode(localFileId));
 }
 
@@ -30,6 +39,7 @@ export async function resolveLlmVideoRef(
   blobs: IBlobStore,
   llmFileId: string,
 ): Promise<string | undefined> {
+  if (!PROVIDER_ID_RE.test(llmFileId)) return undefined;
   const data = await blobs.get(SCOPE, llmFileId);
   return data === undefined ? undefined : textDecoder.decode(data);
 }
diff --git a/packages/kap-server/test/files.test.ts b/packages/kap-server/test/files.test.ts
index d6c71ef0ee..af8984bda8 100644
--- a/packages/kap-server/test/files.test.ts
+++ b/packages/kap-server/test/files.test.ts
@@ -345,4 +345,28 @@ describe('GET /api/v1/files/llm/{llm_id} (server-v2)', () => {
       expect(res.statusCode).not.toBe(302);
     }
   });
+
+  it('never writes a mapping whose provider id leaves the safe alphabet', async () => {
+    const writes: Array<[string, string]> = [];
+    const blobs = {
+      put: async (scope: string, key: string) => {
+        writes.push([scope, key]);
+      },
+      get: async () => undefined,
+      getStream: async function* () {},
+      has: async () => false,
+      delete: async () => {},
+    };
+    const { recordLlmVideoRef, resolveLlmVideoRef } = await import('../src/lib/llmVideoRefs');
+
+    await recordLlmVideoRef(blobs, 'good-id_1.2', 'f_local');
+    expect(writes).toEqual([['llm-video', 'good-id_1.2']]);
+
+    for (const bad of ['../escape', 'a/b', '..']) {
+      writes.length = 0;
+      await recordLlmVideoRef(blobs, bad, 'f_local');
+      expect(writes, `llm id ${bad}`).toEqual([]);
+      await expect(resolveLlmVideoRef(blobs, bad)).resolves.toBeUndefined();
+    }
+  });
 });

From 61db503f8ce07e432e3287a956447c75baddbd83 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 20:40:16 +0800
Subject: [PATCH 23/45] fix(web): keep recovered provider videos resendable
 through the edit path

The composer reload path only honored fileId and fell back to a
bare fetch(url) without the Bearer token, so editing a reloaded
provider-video turn dropped the chip after a 401. llmFileId is now
threaded through and the bytes are re-uploaded via the authenticated
llm redirect.
---
 .../kimi-web/src/components/chat/Composer.vue |  2 +-
 .../src/components/chat/ConversationPane.vue  |  2 +-
 .../src/composables/useAttachmentUpload.ts    | 36 ++++++++++++++++++-
 3 files changed, 37 insertions(+), 3 deletions(-)

diff --git a/apps/kimi-web/src/components/chat/Composer.vue b/apps/kimi-web/src/components/chat/Composer.vue
index 5d2e16f6d9..b64c62d903 100644
--- a/apps/kimi-web/src/components/chat/Composer.vue
+++ b/apps/kimi-web/src/components/chat/Composer.vue
@@ -291,7 +291,7 @@ function focus(): void {
   // or if focus is triggered during an animation/transition.
   textareaRef.value?.focus({ preventScroll: true });
 }
-function loadAttachmentsForEdit(atts: { fileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]): void {
+function loadAttachmentsForEdit(atts: { fileId?: string; llmFileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]): void {
   loadAttachments(atts);
 }
 defineExpose({ loadForEdit, loadAttachmentsForEdit, focus });
diff --git a/apps/kimi-web/src/components/chat/ConversationPane.vue b/apps/kimi-web/src/components/chat/ConversationPane.vue
index 1b6b1a9e79..53b20f1ce5 100644
--- a/apps/kimi-web/src/components/chat/ConversationPane.vue
+++ b/apps/kimi-web/src/components/chat/ConversationPane.vue
@@ -428,7 +428,7 @@ const chatDockStyle = computed(() => ({
 }));
 type ComposerHandle = {
   loadForEdit: (value: string) => boolean | void;
-  loadAttachmentsForEdit: (atts: { fileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]) => void;
+  loadAttachmentsForEdit: (atts: { fileId?: string; llmFileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]) => void;
   focus: () => void;
 };
 type RefArg = Element | (ComponentPublicInstance & Partial<ComposerHandle>) | null;
diff --git a/apps/kimi-web/src/composables/useAttachmentUpload.ts b/apps/kimi-web/src/composables/useAttachmentUpload.ts
index 2c97c4d6ce..5ed518af1b 100644
--- a/apps/kimi-web/src/composables/useAttachmentUpload.ts
+++ b/apps/kimi-web/src/composables/useAttachmentUpload.ts
@@ -299,7 +299,7 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
    *  fetch an authenticated blob URL so the thumbnail doesn't 401. Replaces any
    *  unsent draft attachments (mirroring loadForEdit(text), which overwrites) so
    *  a later submit sends exactly the edited message's files, not a mix. */
-  function loadAttachments(atts: { fileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]): void {
+  function loadAttachments(atts: { fileId?: string; llmFileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]): void {
     const sid = sessionId() ?? '';
     for (const existing of attachmentsBySession.value[sid] ?? []) revokeAttachment(existing);
     setForSession(sid, []);
@@ -334,6 +334,40 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
             // Keep the fallback previewUrl (honest broken state if it 401s).
           });
         }
+      } else if (att.llmFileId) {
+        // A provider-referenced video recovered after a reload: not resendable
+        // as-is (the ms:// reference can't ride a new prompt), so re-upload the
+        // bytes — fetched WITH auth through the daemon's llm redirect, unlike
+        // the plain-URL branch below which would 401 for this URL.
+        if (!att.url) continue;
+        const upload = uploadImage();
+        if (!upload) continue;
+        const entry: Attachment = {
+          localId,
+          name,
+          kind: att.kind,
+          previewUrl: att.url,
+          uploading: true,
+        };
+        setForSession(sid, [...(attachmentsBySession.value[sid] ?? []), entry]);
+        void getKimiWebApi()
+          .getLlmFileBlob(att.llmFileId)
+          .then((blob) => {
+            const fname = name.includes('.') ? name : `${name}.${blob.type.split('/')[1] ?? 'bin'}`;
+            return upload(blob, fname);
+          })
+          .then((result) => {
+            if (result === null) {
+              const current = attachmentsBySession.value[sid] ?? [];
+              setForSession(sid, current.filter((a) => a.localId !== localId));
+              return;
+            }
+            patchAttachment(sid, localId, { uploading: false, fileId: result.fileId });
+          })
+          .catch(() => {
+            const current = attachmentsBySession.value[sid] ?? [];
+            setForSession(sid, current.filter((a) => a.localId !== localId));
+          });
       } else {
         // No fileId (e.g. a server-base64-inlined image, or a URL-backed source
         // from the wire/REST prompt path): re-upload the URL so the chip is

From 8bb4bcadda72c4b16faa562ad69a7ec9b70eb10e Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 20:40:16 +0800
Subject: [PATCH 24/45] fix: fall back to inline video for no-hook providers
 whose wire carries it

The by-design no-hook error is only the honest answer when the wire
would drop an inline payload anyway (the OpenAI family). Protocols
that convert video_url (kimi, anthropic, google-genai, vertex) now
take the base64 fallback instead of failing every video read; the
registrar computes the flag from the model's protocol.
---
 .../src/agent/media/mediaToolsRegistrar.ts    |  4 +++
 .../src/agent/media/registerMediaTools.ts     |  2 ++
 .../src/agent/media/tools/read-media.ts       | 26 +++++++++++------
 .../test/agent/media/tools/read-media.test.ts | 28 +++++++++++++++++++
 4 files changed, 52 insertions(+), 8 deletions(-)

diff --git a/packages/agent-core-v2/src/agent/media/mediaToolsRegistrar.ts b/packages/agent-core-v2/src/agent/media/mediaToolsRegistrar.ts
index 60e3833d07..72fbd17796 100644
--- a/packages/agent-core-v2/src/agent/media/mediaToolsRegistrar.ts
+++ b/packages/agent-core-v2/src/agent/media/mediaToolsRegistrar.ts
@@ -103,6 +103,10 @@ export class AgentMediaToolsRegistrar extends Disposable implements IAgentMediaT
           protocol: model?.protocol,
         },
       }),
+      // The OpenAI family drops inline video on the wire; every other
+      // protocol that converts video_url (kimi, anthropic, google-genai,
+      // vertex) takes the inline fallback when no upload hook exists.
+      inlineVideoSupported: model?.protocol !== 'openai' && model?.protocol !== 'openai_responses',
       telemetry: this.telemetry,
     });
   }
diff --git a/packages/agent-core-v2/src/agent/media/registerMediaTools.ts b/packages/agent-core-v2/src/agent/media/registerMediaTools.ts
index 9c68272ec4..80d633cad2 100644
--- a/packages/agent-core-v2/src/agent/media/registerMediaTools.ts
+++ b/packages/agent-core-v2/src/agent/media/registerMediaTools.ts
@@ -32,6 +32,7 @@ export interface RegisterMediaToolsDeps {
   readonly capabilities: ModelCapability;
   readonly videoUploader?: VideoUploader;
   readonly telemetry?: ITelemetryService;
+  readonly inlineVideoSupported?: boolean;
 }
 
 export function registerMediaTools(
@@ -49,6 +50,7 @@ export function registerMediaTools(
       deps.capabilities,
       deps.videoUploader,
       deps.telemetry,
+      deps.inlineVideoSupported,
     ),
   );
 }
diff --git a/packages/agent-core-v2/src/agent/media/tools/read-media.ts b/packages/agent-core-v2/src/agent/media/tools/read-media.ts
index d6e57fba44..68d4508fb0 100644
--- a/packages/agent-core-v2/src/agent/media/tools/read-media.ts
+++ b/packages/agent-core-v2/src/agent/media/tools/read-media.ts
@@ -32,11 +32,14 @@
  * Videos are delivered through the provider's upload channel when one is
  * bound, falling back to an inline base64 part when the channel exists but
  * fails at runtime (no files endpoint, network/server failure) — a failed
- * upload must not turn the whole read into an error. Two cases surface as
- * tool errors instead: a provider with no upload hook by design
- * (`VideoUploadUnsupportedError`, whose wire would drop the inline payload
- * anyway), and auth rejections (`provider.auth_error` / 401 / 403), which
- * drive credential refresh rather than mask a bad token.
+ * upload must not turn the whole read into an error. The same fallback
+ * covers providers with no upload hook at all, as long as their protocol
+ * converts `video_url` (`inlineVideoSupported`, computed from the model's
+ * protocol at registration); when the wire would drop the inline payload
+ * anyway (the OpenAI family), the by-design no-hook error
+ * (`VideoUploadUnsupportedError`) surfaces instead. Auth rejections
+ * (`provider.auth_error` / 401 / 403) always surface, because they drive
+ * credential refresh rather than mask a bad token.
  *
  * Registration is capability-gated by `registerMediaTools`: this tool is
  * only registered when the active model supports image or video input.
@@ -248,8 +251,12 @@ function buildFullResolutionLimitError(path: string, finalBytes: number): string
   );
 }
 
-function shouldSurfaceVideoUploadError(error: unknown): boolean {
-  if (error instanceof VideoUploadUnsupportedError) return true;
+function shouldSurfaceVideoUploadError(error: unknown, inlineVideoSupported: boolean): boolean {
+  // No upload hook by design: surfacing the honest error only pays when the
+  // wire would drop an inline payload anyway (the OpenAI family). Protocols
+  // that convert video_url (kimi, anthropic, google-genai, …) take the
+  // inline fallback instead.
+  if (error instanceof VideoUploadUnsupportedError) return !inlineVideoSupported;
   if (typeof error !== 'object' || error === null) return false;
   if ((error as { code?: unknown }).code === ProtocolErrors.codes.PROVIDER_AUTH_ERROR) return true;
   const statusCode = (error as { statusCode?: unknown }).statusCode;
@@ -261,6 +268,7 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
   readonly description: string;
   readonly parameters: Record<string, unknown> = toInputJsonSchema(ReadMediaFileInputSchema);
   private readonly compressTelemetry: ImageCompressionTelemetry | undefined;
+  private readonly inlineVideoSupported: boolean;
   constructor(
     private readonly fs: IHostFileSystem,
     private readonly env: IHostEnvironment,
@@ -268,10 +276,12 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
     private readonly capabilities: ModelCapability,
     private readonly videoUploader?: VideoUploader,
     telemetry?: ITelemetryService,
+    inlineVideoSupported?: boolean,
   ) {
     this.description = buildDescription(capabilities);
     this.compressTelemetry =
       telemetry === undefined ? undefined : { client: telemetry, source: 'read_media' };
+    this.inlineVideoSupported = inlineVideoSupported ?? false;
   }
 
   private async videoContentPart(
@@ -287,7 +297,7 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
           filename: safePath.split(/[\\/]/).at(-1),
         });
       } catch (error) {
-        if (shouldSurfaceVideoUploadError(error)) throw error;
+        if (shouldSurfaceVideoUploadError(error, this.inlineVideoSupported)) throw error;
         // Fall through to the inline form.
       }
     }
diff --git a/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts b/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts
index da6e1f9d08..adbdfe43a2 100644
--- a/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts
+++ b/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts
@@ -173,6 +173,7 @@ function makeTool(
   caps: ModelCapability = capabilities(),
   videoUploader?: VideoUploader,
   telemetry?: ITelemetryService,
+  inlineVideoSupported?: boolean,
 ): ReadMediaFileTool {
   return new ReadMediaFileTool(
     createTestFs(files),
@@ -181,6 +182,7 @@ function makeTool(
     caps,
     videoUploader,
     telemetry,
+    inlineVideoSupported,
   );
 }
 
@@ -728,6 +730,32 @@ describe('ReadMediaFileTool', () => {
     expect(result.output).toContain('does not support video upload');
   });
 
+  it('falls back to inline for a no-hook provider whose wire carries video', async () => {
+    const videoUploader = vi
+      .fn<VideoUploader>()
+      .mockRejectedValue(
+        new VideoUploadUnsupportedError(
+          'Model "gemini-stub" (protocol=google-genai) does not support video upload',
+        ),
+      );
+    const result = await execute(
+      makeTool(
+        { '/workspace/clip.mp4': { data: mp4Buffer() } },
+        capabilities(),
+        videoUploader,
+        undefined,
+        true,
+      ),
+      { path: '/workspace/clip.mp4' },
+    );
+    expect(result.isError).not.toBe(true);
+    const parts = outputParts(result);
+    expect(parts[1]).toEqual({
+      type: 'video_url',
+      videoUrl: { url: `data:video/mp4;base64,${mp4Buffer().toString('base64')}` },
+    });
+  });
+
   it('rejects empty files', async () => {
     const result = await execute(
       makeTool({ '/workspace/sample.png': { data: pngBuffer(), size: 0 } }),

From 4f7d3cd660d6bdd91b8ba3ccf6a2c43046664653 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 20:47:29 +0800
Subject: [PATCH 25/45] test: satisfy the full IBlobStore shape in the
 playback-map stub

The tsgo typecheck job rejects a structural stub missing _serviceBrand
and list even though plain tsc accepted it.
---
 packages/kap-server/test/files.test.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/packages/kap-server/test/files.test.ts b/packages/kap-server/test/files.test.ts
index af8984bda8..3155e52d36 100644
--- a/packages/kap-server/test/files.test.ts
+++ b/packages/kap-server/test/files.test.ts
@@ -12,6 +12,7 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
+import type { IBlobStore } from '@moonshot-ai/agent-core-v2';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { type RunningServer, startServer } from '../src/start';
@@ -348,7 +349,8 @@ describe('GET /api/v1/files/llm/{llm_id} (server-v2)', () => {
 
   it('never writes a mapping whose provider id leaves the safe alphabet', async () => {
     const writes: Array<[string, string]> = [];
-    const blobs = {
+    const blobs: IBlobStore = {
+      _serviceBrand: undefined,
       put: async (scope: string, key: string) => {
         writes.push([scope, key]);
       },
@@ -356,6 +358,7 @@ describe('GET /api/v1/files/llm/{llm_id} (server-v2)', () => {
       getStream: async function* () {},
       has: async () => false,
       delete: async () => {},
+      list: async () => [],
     };
     const { recordLlmVideoRef, resolveLlmVideoRef } = await import('../src/lib/llmVideoRefs');
 

From c5c370d3c1660a4f7c8c0694048b11997ff285d8 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 21:21:20 +0800
Subject: [PATCH 26/45] fix: queue prompt-producing slash commands behind
 pending uploads

Skill activations and plugin commands started their turn immediately
while a pasted video was still uploading, so the earlier video prompt
queued behind them and user actions ran out of order. Both paths now
chain behind inputSubmitChain (and re-check session/model at dispatch)
like normal and bash submits.
---
 apps/kimi-code/src/tui/kimi-tui.ts            | 56 ++++++++++---
 .../test/tui/kimi-tui-message-flow.test.ts    | 84 +++++++++++++++++++
 2 files changed, 128 insertions(+), 12 deletions(-)

diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 8574aa43e3..e04cc7027b 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -1388,11 +1388,27 @@ export class KimiTUI {
       return;
     }
     if (!this.validateMediaCapabilities(rewrite)) return;
-    this.beginSessionRequest();
-    void session.activateSkill(skillName, rewrite.text).catch((error: unknown) => {
-      const message = formatErrorMessage(error);
-      this.failSessionRequest(`Skill "${skillName}" failed: ${message}`);
-    });
+    const modelAtSubmit = this.state.appState.model;
+    const dispatch = (): void => {
+      if (this.session !== session || this.state.appState.model !== modelAtSubmit) {
+        this.showError(
+          'The session or model changed while the video was uploading — please resend.',
+        );
+        return;
+      }
+      this.beginSessionRequest();
+      void session.activateSkill(skillName, rewrite.text).catch((error: unknown) => {
+        const message = formatErrorMessage(error);
+        this.failSessionRequest(`Skill "${skillName}" failed: ${message}`);
+      });
+    };
+    // A pending video upload is busy time: chain behind it so the skill
+    // prompt cannot start a turn ahead of the earlier message.
+    if (this.pendingSubmits > 0) {
+      this.inputSubmitChain = this.inputSubmitChain.then(dispatch);
+      return;
+    }
+    dispatch();
   }
 
   activatePluginCommand(
@@ -1412,13 +1428,29 @@ export class KimiTUI {
       return;
     }
     if (!this.validateMediaCapabilities(rewrite)) return;
-    this.beginSessionRequest();
-    void session
-      .activatePluginCommand(pluginId, commandName, rewrite.text)
-      .catch((error: unknown) => {
-        const message = formatErrorMessage(error);
-        this.failSessionRequest(`Command "${pluginId}:${commandName}" failed: ${message}`);
-      });
+    const modelAtSubmit = this.state.appState.model;
+    const dispatch = (): void => {
+      if (this.session !== session || this.state.appState.model !== modelAtSubmit) {
+        this.showError(
+          'The session or model changed while the video was uploading — please resend.',
+        );
+        return;
+      }
+      this.beginSessionRequest();
+      void session
+        .activatePluginCommand(pluginId, commandName, rewrite.text)
+        .catch((error: unknown) => {
+          const message = formatErrorMessage(error);
+          this.failSessionRequest(`Command "${pluginId}:${commandName}" failed: ${message}`);
+        });
+    };
+    // A pending video upload is busy time: chain behind it so the command
+    // prompt cannot start a turn ahead of the earlier message.
+    if (this.pendingSubmits > 0) {
+      this.inputSubmitChain = this.inputSubmitChain.then(dispatch);
+      return;
+    }
+    dispatch();
   }
 
   private sendMessage(session: Session, input: string, options?: SendMessageOptions): void {
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index 54a730c30e..af89f3beac 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -1777,6 +1777,90 @@ command = "vim"
     }
   });
 
+  it('queues a skill activation behind a pending video upload', async () => {
+    const { driver, session } = await makeDriver();
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
+    try {
+      const srcVideo = join(dir, 'clip.mp4');
+      await writeFile(srcVideo, 'video-bytes');
+      const attachment = imageStore.addVideo('video/mp4', srcVideo);
+
+      let releaseUpload!: () => void;
+      vi.mocked(session.uploadVideo).mockImplementationOnce(
+        () =>
+          new Promise((resolve) => {
+            releaseUpload = () =>
+              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
+          }),
+      );
+
+      driver.handleUserInput(`watch ${attachment.placeholder}`);
+      await vi.waitFor(() => {
+        expect(session.uploadVideo).toHaveBeenCalled();
+      });
+
+      (
+        driver as unknown as {
+          sendSkillActivation(s: unknown, skillName: string, args: string): void;
+        }
+      ).sendSkillActivation(session, 'review', 'src/tui');
+      await new Promise((r) => setTimeout(r, 20));
+      expect(session.activateSkill).not.toHaveBeenCalled();
+
+      releaseUpload();
+      await vi.waitFor(() => {
+        expect(session.activateSkill).toHaveBeenCalledWith('review', 'src/tui');
+      });
+      // The video prompt owns the turn by the time the skill fires.
+      expect(session.prompt).toHaveBeenCalled();
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('queues a plugin command behind a pending video upload', async () => {
+    const activatePluginCommand = vi.fn(async () => {});
+    const session = makeSession({ activatePluginCommand });
+    const { driver } = await makeDriver(session);
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
+    try {
+      const srcVideo = join(dir, 'clip.mp4');
+      await writeFile(srcVideo, 'video-bytes');
+      const attachment = imageStore.addVideo('video/mp4', srcVideo);
+
+      let releaseUpload!: () => void;
+      vi.mocked(session.uploadVideo).mockImplementationOnce(
+        () =>
+          new Promise((resolve) => {
+            releaseUpload = () =>
+              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
+          }),
+      );
+
+      driver.handleUserInput(`watch ${attachment.placeholder}`);
+      await vi.waitFor(() => {
+        expect(session.uploadVideo).toHaveBeenCalled();
+      });
+
+      (
+        driver as unknown as {
+          activatePluginCommand(s: unknown, pluginId: string, command: string, args: string): void;
+        }
+      ).activatePluginCommand(session, 'plug', 'cmd', 'args');
+      await new Promise((r) => setTimeout(r, 20));
+      expect(activatePluginCommand).not.toHaveBeenCalled();
+
+      releaseUpload();
+      await vi.waitFor(() => {
+        expect(activatePluginCommand).toHaveBeenCalledWith('plug', 'cmd', 'args');
+      });
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
   it('queues a pasted-video message with uploaded parts while streaming', async () => {
     const session = makeSession();
     const { driver } = await makeDriver(session);

From 5cb32bc29eb1ae9dab560fce358a25fd79c473b8 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 21:21:20 +0800
Subject: [PATCH 27/45] fix: validate media kinds in the prompt file-reference
 preflight

The preflight only proved a referenced file exists; a real upload used
with the wrong kind (e.g. a PDF submitted as video) still passed it and
mutated session controls before assertMediaFile rejected the request.
The kind assertion now runs up front with the existence check.
---
 packages/kap-server/src/routes/prompts.ts | 11 ++++++----
 packages/kap-server/test/prompts.test.ts  | 26 +++++++++++++++++++++++
 2 files changed, 33 insertions(+), 4 deletions(-)

diff --git a/packages/kap-server/src/routes/prompts.ts b/packages/kap-server/src/routes/prompts.ts
index e581aff254..6cf939abf7 100644
--- a/packages/kap-server/src/routes/prompts.ts
+++ b/packages/kap-server/src/routes/prompts.ts
@@ -213,16 +213,19 @@ async function applyProfileSelection(
 }
 
 /**
- * Fail fast on stale file references before anything session-scoped happens:
- * a bad `file_id` must reject the request without creating the prompt agent
- * and without touching the session's model/thinking/permission.
+ * Fail fast on stale or mis-kinded file references before anything
+ * session-scoped happens: a bad `file_id` (unknown, or a real file used with
+ * the wrong media kind, e.g. a PDF submitted as a video) must reject the
+ * request without creating the prompt agent and without touching the
+ * session's model/thinking/permission.
  */
 async function assertPromptFileRefs(body: PromptSubmission, store: IFileService): Promise<void> {
   for (const part of body.content) {
     if (part.type === 'file') {
       await store.get(part.file_id);
     } else if ((part.type === 'image' || part.type === 'video') && part.source.kind === 'file') {
-      await store.get(part.source.file_id);
+      const file = await store.get(part.source.file_id);
+      assertMediaFile(file, part.type);
     }
   }
 }
diff --git a/packages/kap-server/test/prompts.test.ts b/packages/kap-server/test/prompts.test.ts
index b9a8b0e3b7..8e1c31f30d 100644
--- a/packages/kap-server/test/prompts.test.ts
+++ b/packages/kap-server/test/prompts.test.ts
@@ -232,6 +232,32 @@ describe('server-v2 /api/v1 prompts', () => {
     expect(session!.accessor.get(IAgentLifecycleService).get('main')).toBeUndefined();
   });
 
+  it('rejects a mis-kinded file reference without creating the agent', async () => {
+    const id = await createSession(home as string);
+    const session = server!.core.accessor.get(ISessionLifecycleService).get(id);
+
+    // A real upload, but referenced with the wrong media kind.
+    const form = new FormData();
+    form.set('file', new Blob([Buffer.from('%PDF-1.4 fake')], { type: 'application/pdf' }), 'spec.pdf');
+    const uploadRes = await fetch(`${base}/api/v1/files`, {
+      method: 'POST',
+      headers: authHeaders(server as RunningServer),
+      body: form,
+    } as never);
+    const uploaded = (await uploadRes.json()) as Envelope<{ id: string }>;
+    expect(uploaded.code).toBe(0);
+
+    const { body } = await call<null>('POST', `/api/v1/sessions/${id}/prompts`, {
+      model: 'stub',
+      content: [
+        { type: 'text', text: 'watch this' },
+        { type: 'video', source: { kind: 'file', file_id: uploaded.data.id } },
+      ],
+    });
+    expect(body.code).toBe(40001);
+    expect(session!.accessor.get(IAgentLifecycleService).get('main')).toBeUndefined();
+  });
+
   it('falls back to cache path tags for uploaded videos when the model has no upload channel', async () => {
     const id = await createSession(home as string);
     await createMainAgent(id);

From 78061b9ff75961bdc6c3e2e8d38b9789f1491ea4 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 21:21:20 +0800
Subject: [PATCH 28/45] fix(web): play sent and recovered videos in the file
 preview

The media preview returned early for every kind except image, so a
user-turn video chip's play action was a no-op even with llmFileId
threaded through. The preview now handles video: bytes come from the
authenticated file/llm fetch into a blob URL and render in a native
player.
---
 apps/kimi-web/src/components/FilePreview.vue  | 24 ++++++++++++++++++-
 .../src/composables/useFilePreview.ts         | 22 +++++++++++------
 .../src/i18n/locales/en/filePreview.ts        |  1 +
 .../src/i18n/locales/zh/filePreview.ts        |  1 +
 4 files changed, 40 insertions(+), 8 deletions(-)

diff --git a/apps/kimi-web/src/components/FilePreview.vue b/apps/kimi-web/src/components/FilePreview.vue
index 1888c2127d..8f21e75307 100644
--- a/apps/kimi-web/src/components/FilePreview.vue
+++ b/apps/kimi-web/src/components/FilePreview.vue
@@ -98,7 +98,7 @@ const rootRef = ref<HTMLElement | null>(null);
 // Content type detection
 // ---------------------------------------------------------------------------
 
-type ContentKind = 'markdown' | 'json' | 'html' | 'pdf' | 'csv' | 'image' | 'text' | 'binary';
+type ContentKind = 'markdown' | 'json' | 'html' | 'pdf' | 'csv' | 'image' | 'video' | 'text' | 'binary';
 
 const contentKind = computed<ContentKind>(() => {
   const f = props.file;
@@ -113,6 +113,7 @@ const contentKind = computed<ContentKind>(() => {
   if (mime === 'application/pdf' || lowerPath.endsWith('.pdf')) return 'pdf';
   if (mime === 'text/csv' || lang === 'csv' || lowerPath.endsWith('.csv')) return 'csv';
   if (mime.startsWith('image/')) return 'image';
+  if (mime.startsWith('video/')) return 'video';
   if (f.isBinary) return 'binary';
   // text/* and code files
   if (mime.startsWith('text/') || lang !== '') return 'text';
@@ -309,6 +310,14 @@ const imageSrc = computed<string | null>(() => {
   return null;
 });
 
+const videoSrc = computed<string | null>(() => {
+  const f = props.file;
+  if (!f || contentKind.value !== 'video') return null;
+  if (f.sourceUrl) return f.sourceUrl;
+  if (f.encoding === 'base64') return `data:${f.mime};base64,${f.content}`;
+  return null;
+});
+
 const pdfSrc = computed<string | null>(() => {
   const f = props.file;
   if (!f || contentKind.value !== 'pdf') return null;
@@ -626,6 +635,19 @@ function truncatePath(path: string, maxLen = 55): string {
         </div>
       </div>
 
+      <!-- Body: Video -->
+      <div v-else-if="contentKind === 'video'" class="fp-body fp-image-wrap">
+        <template v-if="videoSrc">
+          <video :src="videoSrc" class="fp-image" controls playsinline preload="metadata" />
+        </template>
+        <div v-else class="fp-binary-card">
+          <span class="fp-binary-icon">
+            <Icon name="image-off" size="lg" />
+          </span>
+          <span class="fp-binary-label">{{ t('filePreview.videoNoPreview', { mime: file.mime, size: formatSize(file.size) }) }}</span>
+        </div>
+      </div>
+
       <!-- Body: Text/Code (with line numbers) -->
       <div v-else-if="contentKind === 'text'" class="fp-body fp-code">
         <div class="fp-line-table">
diff --git a/apps/kimi-web/src/composables/useFilePreview.ts b/apps/kimi-web/src/composables/useFilePreview.ts
index dea317f482..beae19effe 100644
--- a/apps/kimi-web/src/composables/useFilePreview.ts
+++ b/apps/kimi-web/src/composables/useFilePreview.ts
@@ -155,27 +155,35 @@ export function useFilePreview({ client, detailTarget }: UseFilePreviewOptions)
   }
 
   function openMediaPreview(media: ToolMedia): void {
-    if (media.kind !== 'image') return;
+    if (media.kind !== 'image' && media.kind !== 'video') return;
     const seq = ++previewRequestSeq;
     revokeMediaObjectUrl();
     detailTarget.value = 'file';
     previewTarget.value = null;
     previewNormalizedPath.value = null;
     previewError.value = null;
+    const isVideo = media.kind === 'video';
     const base = {
-      path: media.path ?? 'ReadMediaFile image',
+      path: media.path ?? (isVideo ? 'Video' : 'ReadMediaFile image'),
       content: '',
       encoding: 'utf-8' as const,
-      mime: media.mimeType ?? mimeFromDataUrl(media.url) ?? 'image/*',
+      mime: media.mimeType ?? mimeFromDataUrl(media.url) ?? (isVideo ? 'video/*' : 'image/*'),
       isBinary: true,
       size: media.bytes ?? 0,
     };
-    if (media.fileId) {
-      // The raw getFileUrl 401s under daemon auth (browsers load <img> without
-      // the Bearer token), so fetch the bytes with auth and preview a blob URL.
+    // The raw URL 401s under daemon auth (browsers load media without the
+    // Bearer token), so fetch the bytes with auth and preview a blob URL —
+    // from the file store for uploads, from the llm redirect for provider
+    // references.
+    const authedFetch = media.fileId
+      ? () => getKimiWebApi().getFileBlob(media.fileId!)
+      : media.llmFileId
+        ? () => getKimiWebApi().getLlmFileBlob(media.llmFileId!)
+        : null;
+    if (authedFetch !== null) {
       previewLoading.value = true;
       previewFile.value = base;
-      void getKimiWebApi().getFileBlob(media.fileId).then((blob) => {
+      void authedFetch().then((blob) => {
         if (seq !== previewRequestSeq) return;
         // The user may have switched to another detail panel while this was in
         // flight — don't create (and leak) a blob URL for a hidden panel.
diff --git a/apps/kimi-web/src/i18n/locales/en/filePreview.ts b/apps/kimi-web/src/i18n/locales/en/filePreview.ts
index 2eb11d72ec..85ae97edb3 100644
--- a/apps/kimi-web/src/i18n/locales/en/filePreview.ts
+++ b/apps/kimi-web/src/i18n/locales/en/filePreview.ts
@@ -21,6 +21,7 @@ export default {
   actual: 'Actual',
   pdfNoPreview: 'This PDF cannot be embedded here. Download it to view.',
   imageNoPreview: 'Image file · {mime} · {size} · preview unavailable',
+  videoNoPreview: 'Video file · {mime} · {size} · preview unavailable',
   binaryNoPreview: 'Binary file · {mime} · {size} bytes · preview unavailable',
   unknownType: 'unknown type',
   copyCode: 'Copy code',
diff --git a/apps/kimi-web/src/i18n/locales/zh/filePreview.ts b/apps/kimi-web/src/i18n/locales/zh/filePreview.ts
index 0906e93d49..333dd77345 100644
--- a/apps/kimi-web/src/i18n/locales/zh/filePreview.ts
+++ b/apps/kimi-web/src/i18n/locales/zh/filePreview.ts
@@ -21,6 +21,7 @@ export default {
   actual: '原始',
   pdfNoPreview: '无法内嵌预览此 PDF，可以下载后查看',
   imageNoPreview: '图片文件 · {mime} · {size} · 暂不预览',
+  videoNoPreview: '视频文件 · {mime} · {size} · 暂不预览',
   binaryNoPreview: '二进制文件 · {mime} · {size} 字节 · 暂不预览',
   unknownType: '未知类型',
   copyCode: '复制代码',

From a780bce11615b17e02640e5bc407258f4400a642 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 21:24:32 +0800
Subject: [PATCH 29/45] fix(web): preview recovered videos with the
 authenticated blob URL

The llm re-upload branch fetched bytes with auth but kept the protected
redirect URL as the chip preview, which 401s as a native video src; the
fetched blob now becomes the preview URL, mirroring the fileId branch.
---
 apps/kimi-web/src/composables/useAttachmentUpload.ts | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/apps/kimi-web/src/composables/useAttachmentUpload.ts b/apps/kimi-web/src/composables/useAttachmentUpload.ts
index 5ed518af1b..c752ddd555 100644
--- a/apps/kimi-web/src/composables/useAttachmentUpload.ts
+++ b/apps/kimi-web/src/composables/useAttachmentUpload.ts
@@ -353,6 +353,16 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
         void getKimiWebApi()
           .getLlmFileBlob(att.llmFileId)
           .then((blob) => {
+            // The same authenticated bytes drive the preview: the protected
+            // llm URL would 401 as a native <video src>, so swap previewUrl
+            // for this blob URL (mirroring the fileId branch above).
+            const blobUrl = URL.createObjectURL(blob);
+            const current = attachmentsBySession.value[sid] ?? [];
+            if (!current.some((a) => a.localId === localId)) {
+              URL.revokeObjectURL(blobUrl);
+              return null;
+            }
+            patchAttachment(sid, localId, { previewUrl: blobUrl });
             const fname = name.includes('.') ? name : `${name}.${blob.type.split('/')[1] ?? 'bin'}`;
             return upload(blob, fname);
           })

From 399ae2ed0bfdfc4ac94da4e03d88e145fbac2deb Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 21:24:32 +0800
Subject: [PATCH 30/45] style(agent-core-v2): move the inline-fallback note
 into the module header

Same package comment convention as before: rationale lives in the
top-of-file block, not beside the registration call.
---
 .../agent-core-v2/src/agent/media/mediaToolsRegistrar.ts | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/packages/agent-core-v2/src/agent/media/mediaToolsRegistrar.ts b/packages/agent-core-v2/src/agent/media/mediaToolsRegistrar.ts
index 72fbd17796..30848ad7a4 100644
--- a/packages/agent-core-v2/src/agent/media/mediaToolsRegistrar.ts
+++ b/packages/agent-core-v2/src/agent/media/mediaToolsRegistrar.ts
@@ -11,7 +11,11 @@
  * service re-invokes {@link registerMediaTools} when the model alias or its
  * media capabilities differ from what it last registered (rebinding the
  * video uploader to the new model, and dropping the tool when the model
- * loses media input).
+ * loses media input). The `inlineVideoSupported` flag rides the same
+ * refresh: it is derived from the model's protocol because only the OpenAI
+ * family drops inline video on the wire — every other protocol that
+ * converts `video_url` takes the inline fallback when no upload hook
+ * exists.
  *
  * `AgentLifecycleService.create` force-instantiates this service right after
  * the builtin-tools registrar, before any `opts.binding` bind runs, so the
@@ -103,9 +107,6 @@ export class AgentMediaToolsRegistrar extends Disposable implements IAgentMediaT
           protocol: model?.protocol,
         },
       }),
-      // The OpenAI family drops inline video on the wire; every other
-      // protocol that converts video_url (kimi, anthropic, google-genai,
-      // vertex) takes the inline fallback when no upload hook exists.
       inlineVideoSupported: model?.protocol !== 'openai' && model?.protocol !== 'openai_responses',
       telemetry: this.telemetry,
     });

From 0df5e3b3cd55b8db6f67d68cb22c0a59450f10c5 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 21:49:42 +0800
Subject: [PATCH 31/45] fix: fence delayed bash submits to the originating
 session

The chained bash callback ran runShellCommandFromInput against whatever
session was active at dispatch time, so a command submitted in session
A could execute in session B's workspace and be recorded there after a
mid-upload switch. The originating session is now captured at submit
and re-verified at dispatch, like the prompt and skill paths.
---
 apps/kimi-code/src/tui/kimi-tui.ts            | 10 +++++
 .../test/tui/kimi-tui-message-flow.test.ts    | 44 +++++++++++++++++++
 2 files changed, 54 insertions(+)

diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index e04cc7027b..35c0101834 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -1004,7 +1004,17 @@ export class KimiTUI {
       // command cannot record shell context before the earlier prompt is
       // dispatched (which would reorder user actions).
       if (this.pendingSubmits > 0) {
+        // Shell commands are session-scoped: capture the originating session
+        // and re-verify at dispatch, or a mid-upload switch would run the
+        // command in another session's workspace and record it there.
+        const sessionAtSubmit = this.session;
         this.inputSubmitChain = this.inputSubmitChain.then(() => {
+          if (sessionAtSubmit === undefined || this.session !== sessionAtSubmit) {
+            this.showError(
+              'The session changed while the video was uploading — please resend the command.',
+            );
+            return;
+          }
           if (this.state.appState.streamingPhase !== 'idle') {
             this.enqueueMessage(text, undefined, 'bash');
           } else {
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index af89f3beac..b6227bc09c 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -1861,6 +1861,50 @@ command = "vim"
     }
   });
 
+  it('drops a queued bash submit when the session changes mid-upload', async () => {
+    const runShellCommand = vi.fn(async () => ({ stdout: '', stderr: '', isError: false }));
+    const session = makeSession({ runShellCommand });
+    const { driver } = await makeDriver(session);
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
+    try {
+      const srcVideo = join(dir, 'clip.mp4');
+      await writeFile(srcVideo, 'video-bytes');
+      const attachment = imageStore.addVideo('video/mp4', srcVideo);
+
+      let releaseUpload!: () => void;
+      vi.mocked(session.uploadVideo).mockImplementationOnce(
+        () =>
+          new Promise((resolve) => {
+            releaseUpload = () =>
+              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
+          }),
+      );
+
+      driver.handleUserInput(`watch ${attachment.placeholder}`);
+      await vi.waitFor(() => {
+        expect(session.uploadVideo).toHaveBeenCalled();
+      });
+
+      driver.state.appState.inputMode = 'bash';
+      driver.handleUserInput('ls');
+      driver.state.appState.inputMode = 'prompt';
+      (driver as unknown as { session: unknown }).session = makeSession();
+
+      releaseUpload();
+      await vi.waitFor(() => {
+        expect(driver.state.transcriptContainer.render(120).join('\n')).toContain(
+          'The session changed while the video was uploading',
+        );
+      });
+      // Never executed (nor queued) into the new session's workspace.
+      expect(runShellCommand).not.toHaveBeenCalled();
+      expect(driver.state.queuedMessages).toHaveLength(0);
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
   it('queues a pasted-video message with uploaded parts while streaming', async () => {
     const session = makeSession();
     const { driver } = await makeDriver(session);

From e76851f6a84ee7bb3944e0abaf1feca58a7177a7 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 21:49:42 +0800
Subject: [PATCH 32/45] fix: emit prompt video telemetry from the agent scope

video_upload is an agent-level event requiring ambient agent identity,
but the uploader was built with the Core-scoped session view, leaving
prompt-upload events unattributable. The route now resolves telemetry
from the target agent for the uploader while image compression keeps
the session-scoped view.
---
 packages/kap-server/src/routes/prompts.ts | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/packages/kap-server/src/routes/prompts.ts b/packages/kap-server/src/routes/prompts.ts
index 6cf939abf7..f782305029 100644
--- a/packages/kap-server/src/routes/prompts.ts
+++ b/packages/kap-server/src/routes/prompts.ts
@@ -144,6 +144,10 @@ async function resolvePromptFromSession(session: ISessionScopeHandle, agentId?:
     profile: agent.accessor.get(IAgentProfileService),
     toolPolicy: agent.accessor.get(IAgentToolPolicyService),
     permissionMode: agent.accessor.get(IAgentPermissionModeService),
+    // Agent-scoped view: agent identity is ambient for agent-level events
+    // (e.g. video_upload), unlike the Core-scoped view used for session-level
+    // events (e.g. image_compress).
+    telemetry: agent.accessor.get(ITelemetryService),
   };
 }
 
@@ -329,7 +333,9 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
             videoUploader: promptVideoUploader(
               resolved.profile,
               core.accessor.get(IModelCatalog),
-              telemetry,
+              // Agent-level events (video_upload) need the target agent's
+              // ambient identity, not the Core-scoped session view above.
+              resolved.telemetry.withContext({ sessionId: session_id }),
             ),
             onVideoInlined: async (localFileId, llmFileId) => {
               // Best effort — a lost mapping only means the web UI cannot

From 9a9f9d204f4e58bd71aa3f9a1001b00a9060d423 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 21:49:42 +0800
Subject: [PATCH 33/45] fix: preserve provider image ids through legacy
 projections and web mappers

The url-source id accepted by the prompt schema was dropped again by
the legacy message projection and the web wire mapper, so provider-
keyed image references lost their id across messages, snapshots, and
undo responses. It now flows through both directions.
---
 apps/kimi-web/src/api/daemon/mappers.ts                       | 4 ++--
 apps/kimi-web/src/api/daemon/wire.ts                          | 2 +-
 apps/kimi-web/src/api/types.ts                                | 2 +-
 .../src/agent/contextMemory/messageProjection.ts              | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/apps/kimi-web/src/api/daemon/mappers.ts b/apps/kimi-web/src/api/daemon/mappers.ts
index 5eeda29e08..a9e9c03be6 100644
--- a/apps/kimi-web/src/api/daemon/mappers.ts
+++ b/apps/kimi-web/src/api/daemon/mappers.ts
@@ -133,7 +133,7 @@ function toAppImageSource(src: WireImageSource): ImageSource {
   if (src.kind === 'file') {
     return { kind: 'file', fileId: src.file_id };
   }
-  return { kind: 'url', url: src.url };
+  return { kind: 'url', url: src.url, id: src.id };
 }
 
 export function toAppMessageContent(wire: WireMessageContent): AppMessageContent {
@@ -229,7 +229,7 @@ function toWireMessageContent(app: AppMessageContent): WireMessageContent {
       } else if (src.kind === 'file') {
         wireSrc = { kind: 'file', file_id: src.fileId };
       } else {
-        wireSrc = { kind: 'url', url: src.url };
+        wireSrc = { kind: 'url', url: src.url, id: src.id };
       }
       return { type: app.type, source: wireSrc };
     }
diff --git a/apps/kimi-web/src/api/daemon/wire.ts b/apps/kimi-web/src/api/daemon/wire.ts
index 900d98bcf0..bb87f3e3c0 100644
--- a/apps/kimi-web/src/api/daemon/wire.ts
+++ b/apps/kimi-web/src/api/daemon/wire.ts
@@ -193,7 +193,7 @@ export type WireMessageContent =
   | { type: 'thinking'; thinking: string; signature?: string };
 
 export type WireImageSource =
-  | { kind: 'url'; url: string }
+  | { kind: 'url'; url: string; id?: string }
   | { kind: 'base64'; media_type: string; data: string }
   | { kind: 'file'; file_id: string };
 
diff --git a/apps/kimi-web/src/api/types.ts b/apps/kimi-web/src/api/types.ts
index 6fe62420a0..49f5309bd2 100644
--- a/apps/kimi-web/src/api/types.ts
+++ b/apps/kimi-web/src/api/types.ts
@@ -156,7 +156,7 @@ export type AppMessageContent =
   | { type: 'unknown'; raw: unknown };
 
 export type ImageSource =
-  | { kind: 'url'; url: string }
+  | { kind: 'url'; url: string; id?: string }
   | { kind: 'base64'; mediaType: string; data: string }
   | { kind: 'file'; fileId: string };
 
diff --git a/packages/agent-core-v2/src/agent/contextMemory/messageProjection.ts b/packages/agent-core-v2/src/agent/contextMemory/messageProjection.ts
index 11df04c4a7..8c9810de96 100644
--- a/packages/agent-core-v2/src/agent/contextMemory/messageProjection.ts
+++ b/packages/agent-core-v2/src/agent/contextMemory/messageProjection.ts
@@ -41,7 +41,7 @@ function mapContentPart(part: ContextMessage['content'][number]): MessageContent
     case 'image_url':
       return {
         type: 'image',
-        source: { kind: 'url', url: part.imageUrl.url },
+        source: { kind: 'url', url: part.imageUrl.url, id: part.imageUrl.id },
       };
     case 'audio_url':
       return { type: 'text', text: `[audio:${part.audioUrl.url}]` };

From a08db8ab6035c6e4bd51fb1bfcfdc5c7a7a158fd Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 21:49:42 +0800
Subject: [PATCH 34/45] fix(web): revoke recovered video blob URLs before
 dropping attachments

A failed llm re-upload removed the attachment without revoking the
freshly created preview blob URL, pinning the whole video in the
browser blob store until page unload on every failed edit attempt.
---
 .../src/composables/useAttachmentUpload.ts        | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/apps/kimi-web/src/composables/useAttachmentUpload.ts b/apps/kimi-web/src/composables/useAttachmentUpload.ts
index c752ddd555..344c4a50ae 100644
--- a/apps/kimi-web/src/composables/useAttachmentUpload.ts
+++ b/apps/kimi-web/src/composables/useAttachmentUpload.ts
@@ -71,6 +71,15 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
     try { URL.revokeObjectURL(att.previewUrl); } catch { /* ignore */ }
   }
 
+  /** Remove an attachment and release its preview blob URL first — an object
+   *  URL pins the (possibly large) blob in the browser store until revoked. */
+  function dropAttachment(sid: string, localId: string): void {
+    const current = attachmentsBySession.value[sid] ?? [];
+    const entry = current.find((a) => a.localId === localId);
+    if (entry !== undefined) revokeAttachment(entry);
+    setForSession(sid, current.filter((a) => a.localId !== localId));
+  }
+
   function attachmentKind(mime: string): 'image' | 'video' | 'file' {
     if (mime.startsWith('image/')) return 'image';
     if (mime.startsWith('video/')) return 'video';
@@ -368,15 +377,13 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
           })
           .then((result) => {
             if (result === null) {
-              const current = attachmentsBySession.value[sid] ?? [];
-              setForSession(sid, current.filter((a) => a.localId !== localId));
+              dropAttachment(sid, localId);
               return;
             }
             patchAttachment(sid, localId, { uploading: false, fileId: result.fileId });
           })
           .catch(() => {
-            const current = attachmentsBySession.value[sid] ?? [];
-            setForSession(sid, current.filter((a) => a.localId !== localId));
+            dropAttachment(sid, localId);
           });
       } else {
         // No fileId (e.g. a server-base64-inlined image, or a URL-backed source

From 37eacff508ebbd3376a79b4a3db6a105abe0edec Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 22:28:39 +0800
Subject: [PATCH 35/45] fix: serialize foreground slash commands behind pending
 uploads
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

/compact and /init started their turn while a pasted video was still
uploading, so the earlier message landed after them — and compaction
summarized the context without it. Prompt-producing builtin commands
now share the same queueBehindPendingUploads chain (with the
session/model dispatch fence) as skill, plugin, and bash submits.
---
 apps/kimi-code/src/tui/commands/config.ts     | 10 ++-
 apps/kimi-code/src/tui/commands/dispatch.ts   |  1 +
 apps/kimi-code/src/tui/commands/session.ts    |  8 ++
 apps/kimi-code/src/tui/kimi-tui.ts            | 25 +++++++
 .../test/tui/kimi-tui-message-flow.test.ts    | 75 +++++++++++++++++++
 5 files changed, 117 insertions(+), 2 deletions(-)

diff --git a/apps/kimi-code/src/tui/commands/config.ts b/apps/kimi-code/src/tui/commands/config.ts
index 58f1c27acb..4e8903a26a 100644
--- a/apps/kimi-code/src/tui/commands/config.ts
+++ b/apps/kimi-code/src/tui/commands/config.ts
@@ -207,8 +207,14 @@ export async function handleCompactCommand(host: SlashCommandHost, args: string)
     host.showError(NO_ACTIVE_SESSION_MESSAGE);
     return;
   }
-  const customInstruction = args.trim() || undefined;
-  await session.compact({ instruction: customInstruction });
+  // Compaction must see the pending video message: chain behind in-flight
+  // uploads so the context isn't summarized without it.
+  host.queueBehindPendingUploads(() => {
+    const customInstruction = args.trim() || undefined;
+    void session.compact({ instruction: customInstruction }).catch((error: unknown) => {
+      host.showError(formatErrorMessage(error));
+    });
+  });
 }
 
 export async function handleEditorCommand(host: SlashCommandHost, args: string): Promise<void> {
diff --git a/apps/kimi-code/src/tui/commands/dispatch.ts b/apps/kimi-code/src/tui/commands/dispatch.ts
index dcfb904733..1f75d91aca 100644
--- a/apps/kimi-code/src/tui/commands/dispatch.ts
+++ b/apps/kimi-code/src/tui/commands/dispatch.ts
@@ -155,6 +155,7 @@ export interface SlashCommandHost {
     commandName: string,
     args: string,
   ): void;
+  queueBehindPendingUploads(dispatch: () => void): void;
   readonly skillCommandMap: Map<string, string>;
   readonly pluginCommandMap: Map<string, string>;
 
diff --git a/apps/kimi-code/src/tui/commands/session.ts b/apps/kimi-code/src/tui/commands/session.ts
index 2f0870db0d..d7f74aec5e 100644
--- a/apps/kimi-code/src/tui/commands/session.ts
+++ b/apps/kimi-code/src/tui/commands/session.ts
@@ -164,6 +164,14 @@ export async function handleInitCommand(host: SlashCommandHost): Promise<void> {
     return;
   }
 
+  // Chain behind in-flight uploads so the init turn cannot start ahead of the
+  // earlier message.
+  host.queueBehindPendingUploads(() => {
+    void runInit(host, session);
+  });
+}
+
+async function runInit(host: SlashCommandHost, session: Session): Promise<void> {
   host.deferUserMessages = true;
   host.beginSessionRequest();
   try {
diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 35c0101834..10dd901906 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -1158,6 +1158,31 @@ export class KimiTUI {
   private pendingSubmits = 0;
   private inputSubmitChain: Promise<void> = Promise.resolve();
 
+  /**
+   * Run `dispatch` immediately, or chain it behind in-flight media uploads so
+   * a slow upload cannot be overtaken by a later action (slash commands,
+   * compaction, init, bash). A mid-upload session/model switch drops the
+   * deferred dispatch with a resend hint — the same fence pending prompt
+   * submits use.
+   */
+  queueBehindPendingUploads(dispatch: () => void): void {
+    if (this.pendingSubmits === 0) {
+      dispatch();
+      return;
+    }
+    const session = this.session;
+    const modelAtSubmit = this.state.appState.model;
+    this.inputSubmitChain = this.inputSubmitChain.then(() => {
+      if (this.session !== session || this.state.appState.model !== modelAtSubmit) {
+        this.showError(
+          'The session or model changed while the video was uploading — please resend.',
+        );
+        return;
+      }
+      dispatch();
+    });
+  }
+
   sendNormalUserInput(text: string): void {
     if (this.btwPanelController.sendUserInput(text)) return;
     if (this.state.appState.model.trim().length === 0) {
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index b6227bc09c..cb9b8db6f3 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -158,6 +158,7 @@ function makeSession(overrides: Record<string, unknown> = {}) {
     model: 'k2',
     summary: { title: null },
     prompt: vi.fn(async () => {}),
+    compact: vi.fn(async () => {}),
     uploadVideo: vi.fn(async () => ({
       type: 'video_url',
       videoUrl: { url: 'ms://stub-video', id: 'stub-video' },
@@ -1905,6 +1906,80 @@ command = "vim"
     }
   });
 
+  it('queues /compact behind a pending video upload', async () => {
+    const { driver, session } = await makeDriver();
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
+    try {
+      const srcVideo = join(dir, 'clip.mp4');
+      await writeFile(srcVideo, 'video-bytes');
+      const attachment = imageStore.addVideo('video/mp4', srcVideo);
+
+      let releaseUpload!: () => void;
+      vi.mocked(session.uploadVideo).mockImplementationOnce(
+        () =>
+          new Promise((resolve) => {
+            releaseUpload = () =>
+              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
+          }),
+      );
+
+      driver.handleUserInput(`watch ${attachment.placeholder}`);
+      await vi.waitFor(() => {
+        expect(session.uploadVideo).toHaveBeenCalled();
+      });
+
+      driver.handleUserInput('/compact');
+      await new Promise((r) => setTimeout(r, 20));
+      expect(session.compact).not.toHaveBeenCalled();
+
+      releaseUpload();
+      await vi.waitFor(() => {
+        expect(session.compact).toHaveBeenCalled();
+      });
+      // The video prompt landed before compaction starts.
+      expect(session.prompt).toHaveBeenCalled();
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('queues /init behind a pending video upload', async () => {
+    const { driver, session } = await makeDriver();
+    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
+    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
+    try {
+      const srcVideo = join(dir, 'clip.mp4');
+      await writeFile(srcVideo, 'video-bytes');
+      const attachment = imageStore.addVideo('video/mp4', srcVideo);
+
+      let releaseUpload!: () => void;
+      vi.mocked(session.uploadVideo).mockImplementationOnce(
+        () =>
+          new Promise((resolve) => {
+            releaseUpload = () =>
+              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
+          }),
+      );
+
+      driver.handleUserInput(`watch ${attachment.placeholder}`);
+      await vi.waitFor(() => {
+        expect(session.uploadVideo).toHaveBeenCalled();
+      });
+
+      driver.handleUserInput('/init');
+      await new Promise((r) => setTimeout(r, 20));
+      expect(session.init).not.toHaveBeenCalled();
+
+      releaseUpload();
+      await vi.waitFor(() => {
+        expect(session.init).toHaveBeenCalled();
+      });
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
   it('queues a pasted-video message with uploaded parts while streaming', async () => {
     const session = makeSession();
     const { driver } = await makeDriver(session);

From 45c3f81d388e34f87bef7b814c91405114c4a4ca Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 22:28:39 +0800
Subject: [PATCH 36/45] fix: defer session controls until media preparation
 succeeds
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Media resolution now runs before any profile/model/thinking/permission/
denylist mutation, with the uploader resolved transiently from the
requested (or currently bound) model — a failed submission leaves the
session's controls untouched. A concurrent model switch during
preparation is rejected with session.busy instead of enqueueing a
reference uploaded for the previous model.
---
 packages/kap-server/src/routes/prompts.ts | 101 +++++++++++++---------
 packages/kap-server/test/prompts.test.ts  |  36 ++++++++
 2 files changed, 97 insertions(+), 40 deletions(-)

diff --git a/packages/kap-server/src/routes/prompts.ts b/packages/kap-server/src/routes/prompts.ts
index f782305029..00f935f8c4 100644
--- a/packages/kap-server/src/routes/prompts.ts
+++ b/packages/kap-server/src/routes/prompts.ts
@@ -152,27 +152,32 @@ async function resolvePromptFromSession(session: ISessionScopeHandle, agentId?:
 }
 
 /**
- * Build the prompt-time video uploader from the session's effective model.
- * `undefined` when the model cannot ingest video (no `video_in` capability
- * or no provider upload channel) — prompt videos then fall back to the
- * file-tag form and the model opens them with ReadMediaFile.
+ * Build the prompt-time video uploader from the model the submission will
+ * use, resolved TRANSIENTLY (no bind/setModel): `modelOverride` when the
+ * body names one, else the agent's currently bound alias. `undefined` when
+ * no model is determinable (unbound agent without an override — that
+ * submission is invalid anyway), when the model cannot ingest video (no
+ * `video_in` capability), or when the provider has no upload channel —
+ * prompt videos then fall back to the file-tag form and the model opens
+ * them with ReadMediaFile.
  */
 function promptVideoUploader(
+  modelOverride: string | undefined,
   profile: IAgentProfileService,
   modelCatalog: IModelCatalog,
   telemetry: ITelemetryService,
 ): ((input: VideoUploadInput) => Promise<VideoURLPart>) | undefined {
-  if (!profile.getModelCapabilities().video_in) return undefined;
-  const modelAlias = profile.getModel();
-  if (modelAlias === '') return undefined;
-  const requester = modelCatalog.getRequester(modelAlias);
-  const model = requester.model;
+  const alias = modelOverride ?? profile.getModel();
+  if (alias === '') return undefined;
+  const model = modelCatalog.get(alias);
+  if (!model.capabilities.video_in) return undefined;
+  const requester = modelCatalog.getRequester(alias);
   return createVideoUploader(requester, {
     client: telemetry,
     props: {
-      model: modelAlias,
-      provider_type: model?.providerType ?? model?.protocol,
-      protocol: model?.protocol,
+      model: alias,
+      provider_type: model.providerType ?? model.protocol,
+      protocol: model.protocol,
     },
   });
 }
@@ -293,37 +298,14 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
         // mutated: a bad `file_id` must not create the agent, register `main`
         // in session metadata, or touch the session's controls.
         await assertPromptFileRefs(req.body, core.accessor.get(IFileService));
-        // Resolve the agent and apply profile/model overrides first: prompt
-        // media resolution (video upload) keys off the effective model.
         const resolved = await resolvePrompt(core, session_id, req.body.agent_id);
         await resolved.auth.ensureReady();
-        let thinkingConsumed = false;
-        if (req.body.profile !== undefined) {
-          thinkingConsumed =
-            (await applyProfileSelection(
-              resolved.profile,
-              req.body.profile,
-              req.body.model,
-              req.body.thinking,
-            )) && req.body.thinking !== undefined;
-        }
-        if (req.body.model !== undefined) await resolved.profile.setModel(req.body.model);
-        if (req.body.thinking !== undefined && !thinkingConsumed)
-          resolved.profile.setThinking(req.body.thinking);
-        if (req.body.permission_mode !== undefined) resolved.permissionMode.setMode(req.body.permission_mode);
-        if (req.body.disabled_tools !== undefined) {
-          // A session denylist before bind throws `profile.not_bound` — map it
-          // onto 40001 like the profile-selection errors above.
-          try {
-            await resolved.toolPolicy.setSessionDisabledTools(req.body.disabled_tools);
-          } catch (error) {
-            if (error instanceof ProfileError) {
-              throw new Error2(ErrorCodes.REQUEST_INVALID, error.message);
-            }
-            throw error;
-          }
-        }
+
+        // Media resolution runs BEFORE any control mutation: the uploader is
+        // resolved transiently from the requested (or currently bound) model,
+        // so a failed submission leaves the session's controls untouched.
         const telemetry = core.accessor.get(ITelemetryService).withContext({ sessionId: session_id });
+        const boundBeforeMedia = resolved.profile.getModel();
         const resolvedBody = await resolvePromptMediaFiles(
           req.body,
           core.accessor.get(IFileService),
@@ -331,6 +313,7 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
           {
             telemetry,
             videoUploader: promptVideoUploader(
+              req.body.model,
               resolved.profile,
               core.accessor.get(IModelCatalog),
               // Agent-level events (video_upload) need the target agent's
@@ -356,6 +339,44 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
             },
           },
         );
+
+        // A concurrent model switch during preparation must not receive a
+        // reference uploaded for the previous model — reject instead of
+        // enqueueing an account-scoped id against the wrong provider.
+        if (resolved.profile.getModel() !== boundBeforeMedia) {
+          throw new Error2(
+            'session.busy',
+            'the model changed while the prompt was being prepared; resubmit',
+          );
+        }
+
+        // Media prepared successfully — only now do the overrides bind.
+        let thinkingConsumed = false;
+        if (req.body.profile !== undefined) {
+          thinkingConsumed =
+            (await applyProfileSelection(
+              resolved.profile,
+              req.body.profile,
+              req.body.model,
+              req.body.thinking,
+            )) && req.body.thinking !== undefined;
+        }
+        if (req.body.model !== undefined) await resolved.profile.setModel(req.body.model);
+        if (req.body.thinking !== undefined && !thinkingConsumed)
+          resolved.profile.setThinking(req.body.thinking);
+        if (req.body.permission_mode !== undefined) resolved.permissionMode.setMode(req.body.permission_mode);
+        if (req.body.disabled_tools !== undefined) {
+          // A session denylist before bind throws `profile.not_bound` — map it
+          // onto 40001 like the profile-selection errors above.
+          try {
+            await resolved.toolPolicy.setSessionDisabledTools(req.body.disabled_tools);
+          } catch (error) {
+            if (error instanceof ProfileError) {
+              throw new Error2(ErrorCodes.REQUEST_INVALID, error.message);
+            }
+            throw error;
+          }
+        }
         const parts = contentToCoreParts(resolvedBody.content);
         const session = await resolveSession(core, session_id);
         await applyPromptMetadataUpdate({
diff --git a/packages/kap-server/test/prompts.test.ts b/packages/kap-server/test/prompts.test.ts
index 8e1c31f30d..f0ce413976 100644
--- a/packages/kap-server/test/prompts.test.ts
+++ b/packages/kap-server/test/prompts.test.ts
@@ -920,6 +920,12 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
       'max_context_size = 1000',
       'capabilities = [ "video_in", "image_in" ]',
       '',
+      '[models.stub2]',
+      'provider = "stub"',
+      'model = "stub2"',
+      'max_context_size = 1000',
+      'capabilities = [ "video_in", "image_in" ]',
+      '',
     ].join('\n');
   }
 
@@ -1156,6 +1162,36 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
     await abortPrompt(id, submitted.data.prompt_id);
   });
 
+  it('rejects the submission when the model switches mid-upload', async () => {
+    const id = await createSessionWithAgent();
+    const fileId = await uploadVideoFile('clip.mp4', Buffer.from('0123456789'));
+
+    let releaseUpload!: () => void;
+    uploadGate = new Promise<void>((resolve) => {
+      releaseUpload = resolve;
+    });
+    const submit = fetch(`${base}/api/v1/sessions/${id}/prompts`, {
+      method: 'POST',
+      headers: authHeaders(server as RunningServer, { 'content-type': 'application/json' }),
+      body: JSON.stringify({
+        model: 'stub',
+        content: [
+          { type: 'text', text: 'watch this' },
+          { type: 'video', source: { kind: 'file', file_id: fileId } },
+        ],
+      }),
+    } as never);
+
+    // A concurrent model switch lands while the upload is parked.
+    const session = server!.core.accessor.get(ISessionLifecycleService).get(id);
+    const agent = session!.accessor.get(IAgentLifecycleService).get('main')!;
+    await agent.accessor.get(IAgentProfileService).setModel('stub2');
+    releaseUpload();
+
+    const body = (await (await submit).json()) as Envelope<null>;
+    expect(body.code).toBe(40901);
+  });
+
   it('serializes concurrent submissions so a media upload cannot be overtaken', async () => {
     const id = await createSessionWithAgent();
     const fileId = await uploadVideoFile('clip.mp4', Buffer.from('0123456789'));

From d6f64ef96dce85acaf4dfa9a0a9084bb89ba148b Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 22:29:25 +0800
Subject: [PATCH 37/45] chore: bump the new SDK video upload API as a minor
 release

Session.uploadVideo is new public API surface, not a patch-level tweak.
---
 .changeset/sdk-session-upload-video.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.changeset/sdk-session-upload-video.md b/.changeset/sdk-session-upload-video.md
index aafd048f2e..05eb532b14 100644
--- a/.changeset/sdk-session-upload-video.md
+++ b/.changeset/sdk-session-upload-video.md
@@ -1,5 +1,5 @@
 ---
-"@moonshot-ai/kimi-code-sdk": patch
+"@moonshot-ai/kimi-code-sdk": minor
 ---
 
 Add Session.uploadVideo to upload a local video through the session's current model and embed the returned reference as a prompt part.

From 099897870039a0a4a0794aa41a62af6ce04bcf9e Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 23:09:49 +0800
Subject: [PATCH 38/45] fix: re-check busy state before draining upload-queued
 commands

A slash command deferred behind a video upload ran the moment the video
prompt dispatched, landing on an already-running turn: beginSessionRequest
wiped the active turn's live pane, and /init or /compact started on top
of it. The deferred callbacks for skills, plugin commands, /compact and
/init now re-run the resolver's busy check at dispatch and show the same
blocked message the user would get when typing while streaming.
---
 apps/kimi-code/src/tui/commands/config.ts     | 11 ++++++++
 apps/kimi-code/src/tui/commands/session.ts    | 11 ++++++++
 apps/kimi-code/src/tui/kimi-tui.ts            | 21 +++++++++++++++
 .../test/tui/kimi-tui-message-flow.test.ts    | 26 ++++++++++++++-----
 4 files changed, 63 insertions(+), 6 deletions(-)

diff --git a/apps/kimi-code/src/tui/commands/config.ts b/apps/kimi-code/src/tui/commands/config.ts
index 4e8903a26a..b816cda101 100644
--- a/apps/kimi-code/src/tui/commands/config.ts
+++ b/apps/kimi-code/src/tui/commands/config.ts
@@ -24,6 +24,7 @@ import type { ThemeName } from '#/tui/theme';
 import { currentTheme, isBuiltInTheme, lightColors, loadCustomThemeMerged } from '#/tui/theme';
 import { NO_ACTIVE_SESSION_MESSAGE } from '../constant/kimi-tui';
 import { formatErrorMessage } from '../utils/event-payload';
+import { slashBusyMessage, slashCommandBusyReason } from './resolve';
 import { thinkingEffortToConfig } from '../utils/thinking-config';
 import { showUsage } from './info';
 import { setExperimentalFeatures } from './experimental-flags';
@@ -210,6 +211,16 @@ export async function handleCompactCommand(host: SlashCommandHost, args: string)
   // Compaction must see the pending video message: chain behind in-flight
   // uploads so the context isn't summarized without it.
   host.queueBehindPendingUploads(() => {
+    // The resolver blocks /compact while busy; keep that behavior when the
+    // deferred callback lands on an already-running turn.
+    const busy = slashCommandBusyReason({
+      isStreaming: host.state.appState.streamingPhase !== 'idle',
+      isCompacting: host.state.appState.isCompacting,
+    });
+    if (busy !== undefined) {
+      host.showError(slashBusyMessage('compact', busy));
+      return;
+    }
     const customInstruction = args.trim() || undefined;
     void session.compact({ instruction: customInstruction }).catch((error: unknown) => {
       host.showError(formatErrorMessage(error));
diff --git a/apps/kimi-code/src/tui/commands/session.ts b/apps/kimi-code/src/tui/commands/session.ts
index d7f74aec5e..4c35f96fbb 100644
--- a/apps/kimi-code/src/tui/commands/session.ts
+++ b/apps/kimi-code/src/tui/commands/session.ts
@@ -10,6 +10,7 @@ import { toTerminalHyperlink } from '#/utils/terminal-hyperlink';
 import { LLM_NOT_SET_MESSAGE, NO_ACTIVE_SESSION_MESSAGE } from '../constant/kimi-tui';
 import { isAbortError } from '../utils/errors';
 import { formatErrorMessage } from '../utils/event-payload';
+import { slashBusyMessage, slashCommandBusyReason } from './resolve';
 import { buildExportMarkdown } from '../utils/export-markdown';
 import type { SlashCommandHost } from './dispatch';
 
@@ -172,6 +173,16 @@ export async function handleInitCommand(host: SlashCommandHost): Promise<void> {
 }
 
 async function runInit(host: SlashCommandHost, session: Session): Promise<void> {
+  // The resolver blocks /init while busy; keep that behavior when the
+  // deferred callback lands on an already-running turn.
+  const busy = slashCommandBusyReason({
+    isStreaming: host.state.appState.streamingPhase !== 'idle',
+    isCompacting: host.state.appState.isCompacting,
+  });
+  if (busy !== undefined) {
+    host.showError(slashBusyMessage('init', busy));
+    return;
+  }
   host.deferUserMessages = true;
   host.beginSessionRequest();
   try {
diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 10dd901906..75295dae95 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -138,6 +138,7 @@ import { pickForegroundTasks } from './utils/foreground-task';
 import { ImageAttachmentStore, type ImageAttachment } from './utils/image-attachment-store';
 import { extractMediaSegments, materializeMediaSegments, rewriteMediaPlaceholders, segmentsToPromptParts } from './utils/image-placeholder';
 import { REPLAY_TURN_LIMIT } from './utils/message-replay';
+import { slashBusyMessage, slashCommandBusyReason } from './commands/resolve';
 import { hasPatchChanges } from './utils/object-patch';
 import { sessionRowsForPicker } from './utils/session-picker-rows';
 import { formatBashOutputForDisplay } from './utils/shell-output';
@@ -1431,6 +1432,16 @@ export class KimiTUI {
         );
         return;
       }
+      // The resolver blocks skill commands while busy; keep that behavior
+      // when the deferred callback lands on an already-running turn.
+      const busy = slashCommandBusyReason({
+        isStreaming: this.state.appState.streamingPhase !== 'idle',
+        isCompacting: this.state.appState.isCompacting,
+      });
+      if (busy !== undefined) {
+        this.showError(slashBusyMessage(skillName, busy));
+        return;
+      }
       this.beginSessionRequest();
       void session.activateSkill(skillName, rewrite.text).catch((error: unknown) => {
         const message = formatErrorMessage(error);
@@ -1471,6 +1482,16 @@ export class KimiTUI {
         );
         return;
       }
+      // The resolver blocks plugin commands while busy; keep that behavior
+      // when the deferred callback lands on an already-running turn.
+      const busy = slashCommandBusyReason({
+        isStreaming: this.state.appState.streamingPhase !== 'idle',
+        isCompacting: this.state.appState.isCompacting,
+      });
+      if (busy !== undefined) {
+        this.showError(slashBusyMessage(`${pluginId}:${commandName}`, busy));
+        return;
+      }
       this.beginSessionRequest();
       void session
         .activatePluginCommand(pluginId, commandName, rewrite.text)
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index cb9b8db6f3..f3b4951f94 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -1811,9 +1811,13 @@ command = "vim"
 
       releaseUpload();
       await vi.waitFor(() => {
-        expect(session.activateSkill).toHaveBeenCalledWith('review', 'src/tui');
+        expect(driver.state.transcriptContainer.render(120).join('\n')).toContain(
+          'Cannot /review while streaming',
+        );
       });
-      // The video prompt owns the turn by the time the skill fires.
+      // The video turn is active by then, so the deferred skill is blocked
+      // with the same message the resolver shows while streaming.
+      expect(session.activateSkill).not.toHaveBeenCalled();
       expect(session.prompt).toHaveBeenCalled();
     } finally {
       await rm(dir, { recursive: true, force: true });
@@ -1855,8 +1859,11 @@ command = "vim"
 
       releaseUpload();
       await vi.waitFor(() => {
-        expect(activatePluginCommand).toHaveBeenCalledWith('plug', 'cmd', 'args');
+        expect(driver.state.transcriptContainer.render(120).join('\n')).toContain(
+          'Cannot /plug:cmd while streaming',
+        );
       });
+      expect(activatePluginCommand).not.toHaveBeenCalled();
     } finally {
       await rm(dir, { recursive: true, force: true });
     }
@@ -1935,9 +1942,13 @@ command = "vim"
 
       releaseUpload();
       await vi.waitFor(() => {
-        expect(session.compact).toHaveBeenCalled();
+        expect(driver.state.transcriptContainer.render(120).join('\n')).toContain(
+          'Cannot /compact while streaming',
+        );
       });
-      // The video prompt landed before compaction starts.
+      // The video turn is active, so the deferred /compact is blocked like
+      // the resolver would block it while streaming.
+      expect(session.compact).not.toHaveBeenCalled();
       expect(session.prompt).toHaveBeenCalled();
     } finally {
       await rm(dir, { recursive: true, force: true });
@@ -1973,8 +1984,11 @@ command = "vim"
 
       releaseUpload();
       await vi.waitFor(() => {
-        expect(session.init).toHaveBeenCalled();
+        expect(driver.state.transcriptContainer.render(120).join('\n')).toContain(
+          'Cannot /init while streaming',
+        );
       });
+      expect(session.init).not.toHaveBeenCalled();
     } finally {
       await rm(dir, { recursive: true, force: true });
     }

From 78f5ca98164476d0600d6216e8846f5161ba2239 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Tue, 21 Jul 2026 23:32:28 +0800
Subject: [PATCH 39/45] fix: resolve profile-bound models before choosing the
 uploader

A first prompt carrying "profile" without "model" resolved the upload
model from the still-unbound alias, so no uploader was installed and
every attached video fell back to a tool-read tag even when the
configured default model supports provider upload. The transient
resolution now mirrors AgentProfileService.bind: an explicit body model
wins, a profile bind falls back to the configured default model, and
only otherwise does the currently bound alias apply.
---
 packages/kap-server/src/routes/prompts.ts | 25 ++++++++++++------
 packages/kap-server/test/prompts.test.ts  | 31 +++++++++++++++++++++++
 2 files changed, 48 insertions(+), 8 deletions(-)

diff --git a/packages/kap-server/src/routes/prompts.ts b/packages/kap-server/src/routes/prompts.ts
index 00f935f8c4..d85a52f701 100644
--- a/packages/kap-server/src/routes/prompts.ts
+++ b/packages/kap-server/src/routes/prompts.ts
@@ -20,6 +20,7 @@ import {
   IAgentPromptService,
   IAuthSummaryService,
   IBlobStore,
+  IConfigService,
   IEventService,
   IFileService,
   IModelCatalog,
@@ -153,22 +154,29 @@ async function resolvePromptFromSession(session: ISessionScopeHandle, agentId?:
 
 /**
  * Build the prompt-time video uploader from the model the submission will
- * use, resolved TRANSIENTLY (no bind/setModel): `modelOverride` when the
- * body names one, else the agent's currently bound alias. `undefined` when
- * no model is determinable (unbound agent without an override — that
- * submission is invalid anyway), when the model cannot ingest video (no
+ * use, resolved TRANSIENTLY (no bind/setModel) with the same rules as
+ * `AgentProfileService.bind`: an explicit body model wins; a profile bind
+ * without one falls back to the configured global default model; otherwise
+ * the agent's currently bound alias. `undefined` when no model is
+ * determinable (unbound, no override, no configured default — that
+ * submission fails on bind anyway), when the model cannot ingest video (no
  * `video_in` capability), or when the provider has no upload channel —
  * prompt videos then fall back to the file-tag form and the model opens
  * them with ReadMediaFile.
  */
 function promptVideoUploader(
-  modelOverride: string | undefined,
+  body: { readonly model?: string | undefined; readonly profile?: string | undefined },
   profile: IAgentProfileService,
   modelCatalog: IModelCatalog,
+  config: IConfigService,
   telemetry: ITelemetryService,
 ): ((input: VideoUploadInput) => Promise<VideoURLPart>) | undefined {
-  const alias = modelOverride ?? profile.getModel();
-  if (alias === '') return undefined;
+  const alias =
+    body.model ??
+    (body.profile !== undefined
+      ? config.get<string>('defaultModel')
+      : profile.getModel());
+  if (alias === undefined || alias === '') return undefined;
   const model = modelCatalog.get(alias);
   if (!model.capabilities.video_in) return undefined;
   const requester = modelCatalog.getRequester(alias);
@@ -313,9 +321,10 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
           {
             telemetry,
             videoUploader: promptVideoUploader(
-              req.body.model,
+              req.body,
               resolved.profile,
               core.accessor.get(IModelCatalog),
+              core.accessor.get(IConfigService),
               // Agent-level events (video_upload) need the target agent's
               // ambient identity, not the Core-scoped session view above.
               resolved.telemetry.withContext({ sessionId: session_id }),
diff --git a/packages/kap-server/test/prompts.test.ts b/packages/kap-server/test/prompts.test.ts
index f0ce413976..1a564f8ea1 100644
--- a/packages/kap-server/test/prompts.test.ts
+++ b/packages/kap-server/test/prompts.test.ts
@@ -1192,6 +1192,37 @@ describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
     expect(body.code).toBe(40901);
   });
 
+  it('inlines videos on a first prompt that binds a profile without an explicit model', async () => {
+    const id = await createSessionWithAgent();
+    const videoBytes = Buffer.from('tiny fake mp4 bytes');
+    const fileId = await uploadVideoFile('clip.mp4', videoBytes);
+
+    // `profile` without `model`: the uploader must resolve the configured
+    // default model (video-capable) instead of falling back to a path tag.
+    const submitRes = await fetch(`${base}/api/v1/sessions/${id}/prompts`, {
+      method: 'POST',
+      headers: authHeaders(server as RunningServer, { 'content-type': 'application/json' }),
+      body: JSON.stringify({
+        profile: 'agent',
+        content: [
+          { type: 'text', text: 'what happens in this video?' },
+          { type: 'video', source: { kind: 'file', file_id: fileId } },
+        ],
+      }),
+    } as never);
+    const submitted = (await submitRes.json()) as Envelope<PromptItemWire>;
+    expect(submitted.code).toBe(0);
+
+    const content = submitted.data.content as Array<Record<string, unknown>>;
+    expect(content[1]).toEqual({
+      type: 'video',
+      source: { kind: 'url', url: 'ms://stub-llm-video-1', id: 'stub-llm-video-1' },
+    });
+    expect(stubBodies).toHaveLength(1);
+
+    await abortPrompt(id, submitted.data.prompt_id);
+  });
+
   it('serializes concurrent submissions so a media upload cannot be overtaken', async () => {
     const id = await createSessionWithAgent();
     const fileId = await uploadVideoFile('clip.mp4', Buffer.from('0123456789'));

From 6a1bd2677c1ad4012bb5cabc6669d1d5fcdd5073 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Wed, 22 Jul 2026 01:13:10 +0800
Subject: [PATCH 40/45] refactor: resolve prompt videos at request time inside
 the engine

Move prompt-video delivery out of the submission edge: the TUI submits
synchronously with a local file:// part the v1 turn resolves before the
message enters history, and kap-server carries an internal kimi-file://
reference the v2 requester resolves against the effective model with an
app-scoped upload cache. History keeps the durable local file id, the
/messages projection emits structured video parts, and the web plays
videos back through the authenticated /files channel - deleting the
submit fences, per-session serialization, provider-id reverse mapping,
redirect endpoint, and the unreleased SDK upload API.
---
 .changeset/prompt-video-inline.md             |   2 +-
 .changeset/sdk-session-upload-video.md        |   5 -
 apps/kimi-code/src/tui/commands/config.ts     |  21 +-
 apps/kimi-code/src/tui/commands/dispatch.ts   |   1 -
 apps/kimi-code/src/tui/commands/session.ts    |  19 -
 apps/kimi-code/src/tui/kimi-tui.ts            | 214 ++------
 .../src/tui/utils/image-placeholder.ts        | 175 ++-----
 .../test/tui/input/image-placeholder.test.ts  | 177 +------
 .../test/tui/kimi-tui-message-flow.test.ts    | 463 +-----------------
 apps/kimi-web/src/api/daemon/client.ts        |   8 -
 apps/kimi-web/src/api/daemon/eventReducer.ts  |   8 +-
 apps/kimi-web/src/api/types.ts                |   5 -
 .../src/components/chat/AuthMedia.vue         |  22 +-
 .../kimi-web/src/components/chat/ChatPane.vue |  12 +-
 .../kimi-web/src/components/chat/Composer.vue |   2 +-
 .../src/components/chat/ConversationPane.vue  |   2 +-
 .../src/composables/client/useSideChat.ts     |   2 -
 .../src/composables/messagesToTurns.ts        |  46 +-
 .../src/composables/useAttachmentUpload.ts    |  53 +-
 .../src/composables/useFilePreview.ts         |  25 +-
 .../src/composables/useKimiWebClient.ts       |   1 -
 apps/kimi-web/src/types.ts                    |   9 +-
 apps/kimi-web/test/event-reducer.test.ts      |  10 +-
 apps/kimi-web/test/turn-logic.test.ts         |  74 ++-
 .../agent/contextMemory/messageProjection.ts  |  16 +-
 .../agent/llmRequester/llmRequesterService.ts |  18 +-
 .../src/agent/media/kimiFileUrl.ts            |  50 ++
 .../src/agent/media/registerMediaTools.ts     |   6 +-
 .../src/agent/media/tools/read-media.ts       |  18 +-
 .../src/agent/media/videoResolver.ts          |  27 +
 .../src/agent/media/videoResolverService.ts   | Bin 0 -> 7674 bytes
 .../src/agent/media/videoUpload.ts            |  35 ++
 packages/agent-core-v2/src/index.ts           |   4 +
 .../llmRequester/llmRequesterService.test.ts  |   2 +
 .../test/agent/media/tools/read-media.test.ts |   2 +-
 .../test/agent/media/videoResolver.test.ts    | 257 ++++++++++
 .../app/messageLegacy/messageLegacy.test.ts   |  48 ++
 packages/agent-core/src/agent/index.ts        |  54 +-
 packages/agent-core/src/agent/tool/index.ts   |   9 +-
 packages/agent-core/src/agent/turn/index.ts   |  23 +-
 .../src/agent/turn/media-resolve.ts           | 136 +++++
 packages/agent-core/src/rpc/core-api.ts       |  13 +-
 packages/agent-core/src/rpc/core-impl.ts      |   5 -
 packages/agent-core/src/session/rpc.ts        |   5 -
 .../src/tools/builtin/file/read-media.ts      |  41 +-
 .../src/tools/support/video-delivery.ts       |  68 +++
 packages/agent-core/test/agent/basic.test.ts  | 303 ++++++------
 packages/kap-server/src/lib/llmVideoRefs.ts   |  45 --
 packages/kap-server/src/protocol/rest-file.ts |   8 -
 packages/kap-server/src/routes/files.ts       |  37 --
 packages/kap-server/src/routes/prompts.ts     | 197 ++------
 .../apiSurface.snapshot.test.ts.snap          |   4 -
 packages/kap-server/test/files.test.ts        |  53 --
 packages/kap-server/test/prompts.test.ts      | 411 +---------------
 packages/node-sdk/src/rpc.ts                  |  10 -
 packages/node-sdk/src/session.ts              |  13 -
 packages/node-sdk/src/types.ts                |   2 +-
 .../test/session-prompt-input.test.ts         |  17 -
 58 files changed, 1076 insertions(+), 2217 deletions(-)
 delete mode 100644 .changeset/sdk-session-upload-video.md
 create mode 100644 packages/agent-core-v2/src/agent/media/kimiFileUrl.ts
 create mode 100644 packages/agent-core-v2/src/agent/media/videoResolver.ts
 create mode 100644 packages/agent-core-v2/src/agent/media/videoResolverService.ts
 create mode 100644 packages/agent-core-v2/src/agent/media/videoUpload.ts
 create mode 100644 packages/agent-core-v2/test/agent/media/videoResolver.test.ts
 create mode 100644 packages/agent-core/src/agent/turn/media-resolve.ts
 create mode 100644 packages/agent-core/src/tools/support/video-delivery.ts
 delete mode 100644 packages/kap-server/src/lib/llmVideoRefs.ts

diff --git a/.changeset/prompt-video-inline.md b/.changeset/prompt-video-inline.md
index a24770dd6d..e6e4d9b381 100644
--- a/.changeset/prompt-video-inline.md
+++ b/.changeset/prompt-video-inline.md
@@ -2,4 +2,4 @@
 "@moonshot-ai/kimi-code": minor
 ---
 
-Send pasted videos to the model directly with the prompt instead of routing them through a ReadMediaFile tool call, so video input is faster and no longer depends on an extra tool round trip.
+Send videos attached to a prompt (pasted in the TUI or uploaded in the web UI) to the model together with the prompt, instead of routing them through a ReadMediaFile tool call — video input no longer costs an extra tool round trip.
diff --git a/.changeset/sdk-session-upload-video.md b/.changeset/sdk-session-upload-video.md
deleted file mode 100644
index 05eb532b14..0000000000
--- a/.changeset/sdk-session-upload-video.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"@moonshot-ai/kimi-code-sdk": minor
----
-
-Add Session.uploadVideo to upload a local video through the session's current model and embed the returned reference as a prompt part.
diff --git a/apps/kimi-code/src/tui/commands/config.ts b/apps/kimi-code/src/tui/commands/config.ts
index b816cda101..58f1c27acb 100644
--- a/apps/kimi-code/src/tui/commands/config.ts
+++ b/apps/kimi-code/src/tui/commands/config.ts
@@ -24,7 +24,6 @@ import type { ThemeName } from '#/tui/theme';
 import { currentTheme, isBuiltInTheme, lightColors, loadCustomThemeMerged } from '#/tui/theme';
 import { NO_ACTIVE_SESSION_MESSAGE } from '../constant/kimi-tui';
 import { formatErrorMessage } from '../utils/event-payload';
-import { slashBusyMessage, slashCommandBusyReason } from './resolve';
 import { thinkingEffortToConfig } from '../utils/thinking-config';
 import { showUsage } from './info';
 import { setExperimentalFeatures } from './experimental-flags';
@@ -208,24 +207,8 @@ export async function handleCompactCommand(host: SlashCommandHost, args: string)
     host.showError(NO_ACTIVE_SESSION_MESSAGE);
     return;
   }
-  // Compaction must see the pending video message: chain behind in-flight
-  // uploads so the context isn't summarized without it.
-  host.queueBehindPendingUploads(() => {
-    // The resolver blocks /compact while busy; keep that behavior when the
-    // deferred callback lands on an already-running turn.
-    const busy = slashCommandBusyReason({
-      isStreaming: host.state.appState.streamingPhase !== 'idle',
-      isCompacting: host.state.appState.isCompacting,
-    });
-    if (busy !== undefined) {
-      host.showError(slashBusyMessage('compact', busy));
-      return;
-    }
-    const customInstruction = args.trim() || undefined;
-    void session.compact({ instruction: customInstruction }).catch((error: unknown) => {
-      host.showError(formatErrorMessage(error));
-    });
-  });
+  const customInstruction = args.trim() || undefined;
+  await session.compact({ instruction: customInstruction });
 }
 
 export async function handleEditorCommand(host: SlashCommandHost, args: string): Promise<void> {
diff --git a/apps/kimi-code/src/tui/commands/dispatch.ts b/apps/kimi-code/src/tui/commands/dispatch.ts
index 1f75d91aca..dcfb904733 100644
--- a/apps/kimi-code/src/tui/commands/dispatch.ts
+++ b/apps/kimi-code/src/tui/commands/dispatch.ts
@@ -155,7 +155,6 @@ export interface SlashCommandHost {
     commandName: string,
     args: string,
   ): void;
-  queueBehindPendingUploads(dispatch: () => void): void;
   readonly skillCommandMap: Map<string, string>;
   readonly pluginCommandMap: Map<string, string>;
 
diff --git a/apps/kimi-code/src/tui/commands/session.ts b/apps/kimi-code/src/tui/commands/session.ts
index 4c35f96fbb..2f0870db0d 100644
--- a/apps/kimi-code/src/tui/commands/session.ts
+++ b/apps/kimi-code/src/tui/commands/session.ts
@@ -10,7 +10,6 @@ import { toTerminalHyperlink } from '#/utils/terminal-hyperlink';
 import { LLM_NOT_SET_MESSAGE, NO_ACTIVE_SESSION_MESSAGE } from '../constant/kimi-tui';
 import { isAbortError } from '../utils/errors';
 import { formatErrorMessage } from '../utils/event-payload';
-import { slashBusyMessage, slashCommandBusyReason } from './resolve';
 import { buildExportMarkdown } from '../utils/export-markdown';
 import type { SlashCommandHost } from './dispatch';
 
@@ -165,24 +164,6 @@ export async function handleInitCommand(host: SlashCommandHost): Promise<void> {
     return;
   }
 
-  // Chain behind in-flight uploads so the init turn cannot start ahead of the
-  // earlier message.
-  host.queueBehindPendingUploads(() => {
-    void runInit(host, session);
-  });
-}
-
-async function runInit(host: SlashCommandHost, session: Session): Promise<void> {
-  // The resolver blocks /init while busy; keep that behavior when the
-  // deferred callback lands on an already-running turn.
-  const busy = slashCommandBusyReason({
-    isStreaming: host.state.appState.streamingPhase !== 'idle',
-    isCompacting: host.state.appState.isCompacting,
-  });
-  if (busy !== undefined) {
-    host.showError(slashBusyMessage('init', busy));
-    return;
-  }
   host.deferUserMessages = true;
   host.beginSessionRequest();
   try {
diff --git a/apps/kimi-code/src/tui/kimi-tui.ts b/apps/kimi-code/src/tui/kimi-tui.ts
index 75295dae95..14951c6ed8 100644
--- a/apps/kimi-code/src/tui/kimi-tui.ts
+++ b/apps/kimi-code/src/tui/kimi-tui.ts
@@ -136,9 +136,8 @@ import { isDeadTerminalError } from './utils/dead-terminal';
 import { formatErrorMessage } from './utils/event-payload';
 import { pickForegroundTasks } from './utils/foreground-task';
 import { ImageAttachmentStore, type ImageAttachment } from './utils/image-attachment-store';
-import { extractMediaSegments, materializeMediaSegments, rewriteMediaPlaceholders, segmentsToPromptParts } from './utils/image-placeholder';
+import { extractMediaAttachments, rewriteMediaPlaceholders } from './utils/image-placeholder';
 import { REPLAY_TURN_LIMIT } from './utils/message-replay';
-import { slashBusyMessage, slashCommandBusyReason } from './commands/resolve';
 import { hasPatchChanges } from './utils/object-patch';
 import { sessionRowsForPicker } from './utils/session-picker-rows';
 import { formatBashOutputForDisplay } from './utils/shell-output';
@@ -1001,31 +1000,6 @@ export class KimiTUI {
     const historyText = wasBashMode ? `!${text}` : text;
     void this.persistInputHistory(historyText);
     if (wasBashMode) {
-      // A pending video upload is busy time too: chain behind it so the
-      // command cannot record shell context before the earlier prompt is
-      // dispatched (which would reorder user actions).
-      if (this.pendingSubmits > 0) {
-        // Shell commands are session-scoped: capture the originating session
-        // and re-verify at dispatch, or a mid-upload switch would run the
-        // command in another session's workspace and record it there.
-        const sessionAtSubmit = this.session;
-        this.inputSubmitChain = this.inputSubmitChain.then(() => {
-          if (sessionAtSubmit === undefined || this.session !== sessionAtSubmit) {
-            this.showError(
-              'The session changed while the video was uploading — please resend the command.',
-            );
-            return;
-          }
-          if (this.state.appState.streamingPhase !== 'idle') {
-            this.enqueueMessage(text, undefined, 'bash');
-          } else {
-            this.runShellCommandFromInput(text);
-          }
-          this.updateQueueDisplay();
-          this.state.ui.requestRender();
-        });
-        return;
-      }
       // Only one foreground action at a time: queue the shell command while
       // another shell command is running or an agent turn is in progress.
       if (this.state.appState.streamingPhase !== 'idle') {
@@ -1155,109 +1129,41 @@ export class KimiTUI {
     this.updateQueueDisplay();
   }
 
-  // Submits chained behind an in-flight video upload (see sendNormalUserInput).
-  private pendingSubmits = 0;
-  private inputSubmitChain: Promise<void> = Promise.resolve();
-
-  /**
-   * Run `dispatch` immediately, or chain it behind in-flight media uploads so
-   * a slow upload cannot be overtaken by a later action (slash commands,
-   * compaction, init, bash). A mid-upload session/model switch drops the
-   * deferred dispatch with a resend hint — the same fence pending prompt
-   * submits use.
-   */
-  queueBehindPendingUploads(dispatch: () => void): void {
-    if (this.pendingSubmits === 0) {
-      dispatch();
-      return;
-    }
-    const session = this.session;
-    const modelAtSubmit = this.state.appState.model;
-    this.inputSubmitChain = this.inputSubmitChain.then(() => {
-      if (this.session !== session || this.state.appState.model !== modelAtSubmit) {
-        this.showError(
-          'The session or model changed while the video was uploading — please resend.',
-        );
-        return;
-      }
-      dispatch();
-    });
-  }
-
   sendNormalUserInput(text: string): void {
     if (this.btwPanelController.sendUserInput(text)) return;
     if (this.state.appState.model.trim().length === 0) {
       this.showError(LLM_NOT_SET_MESSAGE);
       return;
     }
-    const extraction = extractMediaSegments(text, this.imageStore);
+    let extraction: ReturnType<typeof extractMediaAttachments>;
+    try {
+      // Pasted videos are copied into the cache and expand to a `file://`
+      // `video_url` part; the engine resolves (uploads or degrades) them
+      // inside the turn, so submission stays fully synchronous.
+      extraction = extractMediaAttachments(text, this.imageStore);
+    } catch (error) {
+      // A video cache copy failed (unwritable cache dir, vanished source…);
+      // nothing was dispatched.
+      this.showError(`Failed to prepare media attachment: ${formatErrorMessage(error)}`);
+      return;
+    }
     if (!this.validateMediaCapabilities(extraction)) return;
     const session = this.session;
     if (session === undefined) {
       this.showError(LLM_NOT_SET_MESSAGE);
       return;
     }
-    const hasVideo = extraction.videoAttachmentIds.length > 0;
-    if (!hasVideo && this.pendingSubmits === 0) {
-      // Fully synchronous path: nothing to upload, nothing queued behind an
-      // upload, so ordering is trivially safe.
-      if (extraction.hasMedia) {
-        this.sendMessage(session, text, {
-          hasMedia: true,
-          parts: segmentsToPromptParts(extraction.segments),
-          imageAttachmentIds: extraction.imageAttachmentIds,
-        });
-      } else {
-        this.sendMessage(session, text);
-      }
-      this.updateQueueDisplay();
-      this.state.ui.requestRender();
-      return;
+    if (extraction.hasMedia) {
+      this.sendMessage(session, text, {
+        hasMedia: true,
+        parts: extraction.parts,
+        imageAttachmentIds: extraction.imageAttachmentIds,
+      });
+    } else {
+      this.sendMessage(session, text);
     }
-    // Video attachments upload asynchronously before the prompt goes out.
-    // Chain this submit (and any submitted while an upload is in flight) so
-    // a slow upload cannot be overtaken by a later message.
-    const modelAtSubmit = this.state.appState.model;
-    this.pendingSubmits += 1;
-    this.inputSubmitChain = this.inputSubmitChain.then(async () => {
-      try {
-        let parts: readonly PromptPart[] | undefined;
-        if (extraction.hasMedia) {
-          parts = hasVideo
-            ? await materializeMediaSegments(extraction.segments, (attachment) =>
-                session.uploadVideo(attachment.sourcePath),
-              )
-            : segmentsToPromptParts(extraction.segments);
-        }
-        // Re-checked at dispatch time: if the user switched the session or
-        // the model mid-upload, the provider-issued reference (or the upload
-        // itself) would now go to the wrong place. Drop the message and ask
-        // for a resend instead.
-        if (this.session !== session || this.state.appState.model !== modelAtSubmit) {
-          this.showError(
-            'The session or model changed while the video was uploading — please resend.',
-          );
-          return;
-        }
-        if (parts !== undefined) {
-          this.sendMessage(session, text, {
-            hasMedia: true,
-            parts,
-            imageAttachmentIds: extraction.imageAttachmentIds,
-          });
-        } else {
-          this.sendMessage(session, text);
-        }
-      } catch (error) {
-        // The tag fallback itself could not be prepared (unwritable cache
-        // dir, vanished video source…); nothing was dispatched.
-        this.showError(`Failed to prepare media attachment: ${formatErrorMessage(error)}`);
-      } finally {
-        this.pendingSubmits -= 1;
-      }
-      this.updateQueueDisplay();
-      this.state.ui.requestRender();
-    });
+    this.updateQueueDisplay();
+    this.state.ui.requestRender();
   }
 
   validateMediaCapabilities(extraction: {
@@ -1424,37 +1330,11 @@ export class KimiTUI {
       return;
     }
     if (!this.validateMediaCapabilities(rewrite)) return;
-    const modelAtSubmit = this.state.appState.model;
-    const dispatch = (): void => {
-      if (this.session !== session || this.state.appState.model !== modelAtSubmit) {
-        this.showError(
-          'The session or model changed while the video was uploading — please resend.',
-        );
-        return;
-      }
-      // The resolver blocks skill commands while busy; keep that behavior
-      // when the deferred callback lands on an already-running turn.
-      const busy = slashCommandBusyReason({
-        isStreaming: this.state.appState.streamingPhase !== 'idle',
-        isCompacting: this.state.appState.isCompacting,
-      });
-      if (busy !== undefined) {
-        this.showError(slashBusyMessage(skillName, busy));
-        return;
-      }
-      this.beginSessionRequest();
-      void session.activateSkill(skillName, rewrite.text).catch((error: unknown) => {
-        const message = formatErrorMessage(error);
-        this.failSessionRequest(`Skill "${skillName}" failed: ${message}`);
-      });
-    };
-    // A pending video upload is busy time: chain behind it so the skill
-    // prompt cannot start a turn ahead of the earlier message.
-    if (this.pendingSubmits > 0) {
-      this.inputSubmitChain = this.inputSubmitChain.then(dispatch);
-      return;
-    }
-    dispatch();
+    this.beginSessionRequest();
+    void session.activateSkill(skillName, rewrite.text).catch((error: unknown) => {
+      const message = formatErrorMessage(error);
+      this.failSessionRequest(`Skill "${skillName}" failed: ${message}`);
+    });
   }
 
   activatePluginCommand(
@@ -1474,39 +1354,13 @@ export class KimiTUI {
       return;
     }
     if (!this.validateMediaCapabilities(rewrite)) return;
-    const modelAtSubmit = this.state.appState.model;
-    const dispatch = (): void => {
-      if (this.session !== session || this.state.appState.model !== modelAtSubmit) {
-        this.showError(
-          'The session or model changed while the video was uploading — please resend.',
-        );
-        return;
-      }
-      // The resolver blocks plugin commands while busy; keep that behavior
-      // when the deferred callback lands on an already-running turn.
-      const busy = slashCommandBusyReason({
-        isStreaming: this.state.appState.streamingPhase !== 'idle',
-        isCompacting: this.state.appState.isCompacting,
+    this.beginSessionRequest();
+    void session
+      .activatePluginCommand(pluginId, commandName, rewrite.text)
+      .catch((error: unknown) => {
+        const message = formatErrorMessage(error);
+        this.failSessionRequest(`Command "${pluginId}:${commandName}" failed: ${message}`);
       });
-      if (busy !== undefined) {
-        this.showError(slashBusyMessage(`${pluginId}:${commandName}`, busy));
-        return;
-      }
-      this.beginSessionRequest();
-      void session
-        .activatePluginCommand(pluginId, commandName, rewrite.text)
-        .catch((error: unknown) => {
-          const message = formatErrorMessage(error);
-          this.failSessionRequest(`Command "${pluginId}:${commandName}" failed: ${message}`);
-        });
-    };
-    // A pending video upload is busy time: chain behind it so the command
-    // prompt cannot start a turn ahead of the earlier message.
-    if (this.pendingSubmits > 0) {
-      this.inputSubmitChain = this.inputSubmitChain.then(dispatch);
-      return;
-    }
-    dispatch();
   }
 
   private sendMessage(session: Session, input: string, options?: SendMessageOptions): void {
diff --git a/apps/kimi-code/src/tui/utils/image-placeholder.ts b/apps/kimi-code/src/tui/utils/image-placeholder.ts
index 7c15201f57..87d53eabc2 100644
--- a/apps/kimi-code/src/tui/utils/image-placeholder.ts
+++ b/apps/kimi-code/src/tui/utils/image-placeholder.ts
@@ -2,29 +2,27 @@
  * Scan submitted text for media placeholders and produce the prompt content
  * we'll send to the SDK prompt endpoint.
  *
- * Two extraction paths share the same placeholder scan:
+ * `extractMediaAttachments` (sync) is the single expansion path for prompts:
+ *   - image placeholders expand to inline image content parts (preceded by a
+ *     compression caption when paste-time compression shrank the bytes — see
+ *     `ImageAttachment.original`);
+ *   - video placeholders are copied into the shared cache (`getCacheDir()`)
+ *     and expand to a `video_url` part pointing at the cache copy with a
+ *     `file://` url. The v1 engine resolves that local reference inside the
+ *     turn — uploading it (the `ms://` inline form) or degrading to a
+ *     `<video path>` tag the model reads with `ReadMediaFile` — before the
+ *     prompt lands in history.
  *
- *   - `extractMediaAttachments` (sync): image placeholders expand to image
- *     content parts; video placeholders are copied into the shared cache
- *     (`getCacheDir()`) and expand to `<video path="…">` file tags, so the
- *     model opens them with `ReadMediaFile`. Used by channels that cannot
- *     upload first (steer splice, `/skill` args via rewriteMediaPlaceholders,
- *     plugin commands) and as the fallback when a prompt-time video upload
- *     fails.
- *   - `extractMediaSegments` + `materializeMediaSegments` (async): video
- *     placeholders stay unresolved references until `materializeMediaSegments`
- *     uploads each one through the session's video upload channel and embeds
- *     the provider-issued `video_url` part directly in the prompt — the model
- *     receives the video with the user message, no tool call needed. An
- *     upload that fails falls back to the file-tag form above.
+ * `rewriteMediaPlaceholders` is the separate text channel for slash-command
+ * args (`/skill`, plugin commands): those are plain text, so media is rendered
+ * as a `<video|image path="…">` tag / plain-text reference into cache-dir
+ * copies the model opens with `ReadMediaFile`.
  *
  * Rules for both:
  *   - Only placeholders that resolve against `store` get extracted.
  *     A literal `[image #999 ...]` the user typed themselves stays in
  *     the text (we can't hallucinate files for it).
- *   - Order is preserved for text/image/video segments. Image placeholders
- *     expand to image content parts so the prompt reaches the provider
- *     without relying on a model tool call.
+ *   - Order is preserved for text/image/video segments.
  *   - Adjacent text segments are flattened — empty / whitespace-only
  *     segments drop out so we never emit `{type:'text', text:' '}`
  *     noise between two media parts.
@@ -33,6 +31,7 @@
 import { randomUUID } from 'node:crypto';
 import { copyFileSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
 
 import type { PromptPart } from '@moonshot-ai/kimi-code-sdk';
 import { buildImageCompressionCaption } from '@moonshot-ai/kimi-code-sdk';
@@ -84,8 +83,10 @@ export function extractMediaAttachments(
     const before = text.slice(cursor, match.index);
     pushText(parts, before);
     if (attachment.kind === 'video') {
+      // Copy the paste into the shared cache and reference it by a `file://`
+      // url; the engine resolves (uploads or degrades) it inside the turn.
       const cachePath = materializeVideoToCache(attachment);
-      pushText(parts, formatMediaTag('video', cachePath));
+      parts.push(videoPartForCachePath(cachePath));
       videoAttachmentIds.push(id);
     } else {
       // Paste-time compression is announced next to the image so the model
@@ -114,118 +115,6 @@ export function extractMediaAttachments(
   };
 }
 
-export interface MediaSegmentPart {
-  readonly kind: 'part';
-  readonly part: PromptPart;
-}
-
-export interface MediaSegmentVideo {
-  readonly kind: 'video';
-  readonly attachment: VideoAttachment;
-}
-
-export type MediaSegment = MediaSegmentPart | MediaSegmentVideo;
-
-export interface SegmentExtractionResult {
-  /** Ordered segments: text/image parts inline, videos as unresolved refs. */
-  readonly segments: MediaSegment[];
-  readonly hasMedia: boolean;
-  readonly imageAttachmentIds: number[];
-  readonly videoAttachmentIds: number[];
-}
-
-/**
- * Variant of `extractMediaAttachments` that leaves video placeholders
- * unresolved: the returned segments keep the `VideoAttachment` so the caller
- * can upload it (async) before deciding the final part shape. No cache copy
- * happens here, so unlike `extractMediaAttachments` this never throws for a
- * vanished video source — that surfaces only if the tag fallback runs.
- */
-export function extractMediaSegments(
-  text: string,
-  store: ImageAttachmentStore,
-): SegmentExtractionResult {
-  const segments: MediaSegment[] = [];
-  const imageAttachmentIds: number[] = [];
-  const videoAttachmentIds: number[] = [];
-  let cursor = 0;
-  let hasMedia = false;
-
-  PLACEHOLDER_REGEX.lastIndex = 0;
-  let match: RegExpExecArray | null;
-  while ((match = PLACEHOLDER_REGEX.exec(text)) !== null) {
-    const [literal, kind, idStr] = match;
-    if (kind !== 'image' && kind !== 'video') continue;
-    if (idStr === undefined) continue;
-    const id = Number.parseInt(idStr, 10);
-    const attachment = store.get(id);
-    if (attachment === undefined) continue; // stale / user-typed — leave as text
-    if (attachment.kind !== kind) continue;
-    const before = text.slice(cursor, match.index);
-    pushTextPart(segments, before);
-    if (attachment.kind === 'video') {
-      segments.push({ kind: 'video', attachment });
-      videoAttachmentIds.push(id);
-    } else {
-      if (attachment.original !== undefined) {
-        pushTextPart(segments, captionForCompressedImage(attachment));
-      }
-      segments.push({ kind: 'part', part: imagePartForAttachment(attachment) });
-      imageAttachmentIds.push(id);
-    }
-    hasMedia = true;
-    cursor = match.index + literal.length;
-  }
-  pushTextPart(segments, text.slice(cursor));
-
-  return {
-    segments: hasMedia ? segments : [],
-    hasMedia,
-    imageAttachmentIds,
-    videoAttachmentIds,
-  };
-}
-
-/**
- * Resolve extracted segments into final prompt parts. Text and image
- * segments pass through; each video attachment is uploaded through `upload`
- * (the session's video upload channel) so the prompt embeds the
- * provider-issued `video_url` part directly. When an upload fails the video
- * degrades to a `<video path="…">` tag pointing at a cache copy, which the
- * model can open with `ReadMediaFile` — uploads run concurrently, order is
- * preserved. Throws only when a fallback cache copy itself fails.
- */
-export async function materializeMediaSegments(
-  segments: readonly MediaSegment[],
-  upload: (attachment: VideoAttachment) => Promise<PromptPart>,
-): Promise<PromptPart[]> {
-  const resolved = await Promise.all(
-    segments.map(async (segment): Promise<PromptPart[]> => {
-      if (segment.kind === 'part') return [segment.part];
-      try {
-        return [await upload(segment.attachment)];
-      } catch {
-        // Fall back to the file-tag form: the model reads the video itself.
-        const cachePath = materializeVideoToCache(segment.attachment);
-        return [{ type: 'text', text: formatMediaTag('video', cachePath) }];
-      }
-    }),
-  );
-  return resolved.flat();
-}
-
-/**
- * Resolve already-extracted segments that contain no video placeholders into
- * prompt parts synchronously (all segments are inline parts by then).
- */
-export function segmentsToPromptParts(segments: readonly MediaSegment[]): PromptPart[] {
-  const parts: PromptPart[] = [];
-  for (const segment of segments) {
-    if (segment.kind === 'part') parts.push(segment.part);
-  }
-  return parts;
-}
-
 export interface MediaTagRewriteResult {
   /** Input text with resolved placeholders replaced by media references. */
   text: string;
@@ -312,20 +201,6 @@ function pushText(parts: PromptPart[], segment: string): void {
   parts.push({ type: 'text', text: segment });
 }
 
-function pushTextPart(segments: MediaSegment[], segment: string): void {
-  if (segment.length === 0) return;
-  if (segment.trim().length === 0) return;
-  const last = segments.at(-1);
-  if (last?.kind === 'part' && last.part.type === 'text') {
-    segments[segments.length - 1] = {
-      kind: 'part',
-      part: { type: 'text', text: last.part.text + segment },
-    };
-    return;
-  }
-  segments.push({ kind: 'part', part: { type: 'text', text: segment } });
-}
-
 function imagePartForAttachment(att: ImageAttachment): PromptPart {
   const base64 = Buffer.from(att.bytes).toString('base64');
   return {
@@ -334,6 +209,18 @@ function imagePartForAttachment(att: ImageAttachment): PromptPart {
   };
 }
 
+/**
+ * A `video_url` prompt part pointing at a cache copy by `file://` url. The v1
+ * engine resolves the local reference in-turn (upload → `ms://`, or degrade to
+ * a `<video path>` tag) before it reaches the model or the persisted history.
+ */
+function videoPartForCachePath(cachePath: string): PromptPart {
+  return {
+    type: 'video_url',
+    videoUrl: { url: pathToFileURL(cachePath).href },
+  };
+}
+
 function materializeVideoToCache(att: VideoAttachment, escapeProofName = false): string {
   const cacheDir = getCacheDir();
   mkdirSync(cacheDir, { recursive: true });
diff --git a/apps/kimi-code/test/tui/input/image-placeholder.test.ts b/apps/kimi-code/test/tui/input/image-placeholder.test.ts
index 41fe208587..85755641c6 100644
--- a/apps/kimi-code/test/tui/input/image-placeholder.test.ts
+++ b/apps/kimi-code/test/tui/input/image-placeholder.test.ts
@@ -1,6 +1,7 @@
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 import { describe, it, expect } from 'vitest';
 
@@ -8,8 +9,6 @@ import { KIMI_CODE_HOME_ENV } from '#/constant/app';
 import { ImageAttachmentStore } from '#/tui/utils/image-attachment-store';
 import {
   extractMediaAttachments,
-  extractMediaSegments,
-  materializeMediaSegments,
   rewriteMediaPlaceholders,
 } from '#/tui/utils/image-placeholder';
 import { getCacheDir } from '#/utils/paths';
@@ -42,16 +41,17 @@ function makeTempDir(): string {
   return mkdtempSync(join(tmpdir(), 'kimi-src-'));
 }
 
-type TextPart = { type: 'text'; text: string };
+type VideoUrlPart = { type: 'video_url'; videoUrl: { url: string } };
 
+// Prompt-attached videos are emitted as a `video_url` part whose url is a
+// local `file://` reference to the cache copy; decode it back to a filesystem
+// path for assertions.
 function videoPathFromParts(parts: unknown[]): string {
-  const text = parts
-    .filter((p): p is TextPart => (p as TextPart).type === 'text')
-    .map((p) => p.text)
-    .join('');
-  const m = /<video path="([^"]+)"><\/video>/.exec(text);
-  if (!m) throw new Error(`no video tag found in: ${text}`);
-  return m[1]!;
+  const part = parts.find(
+    (p): p is VideoUrlPart => (p as VideoUrlPart).type === 'video_url',
+  );
+  if (!part) throw new Error(`no video_url part found in: ${JSON.stringify(parts)}`);
+  return fileURLToPath(part.videoUrl.url);
 }
 
 describe('extractMediaAttachments', () => {
@@ -137,26 +137,27 @@ describe('extractMediaAttachments', () => {
     });
   });
 
-  it('escapes media paths in generated tags', () => {
+  it('keeps the video label (including special chars) in the cache path', () => {
     const { cleanup } = setupTempCache();
     const srcDir = makeTempDir();
     try {
       const srcVideo = join(srcDir, 'source.mp4');
       writeFileSync(srcVideo, 'x');
       const store = new ImageAttachmentStore();
-      // The filename drives the cache label; `&` must be escaped in the attribute.
+      // The filename drives the cache label; `&` is a valid path char the cache
+      // copy keeps verbatim (the engine escapes it if it later renders a tag).
       const att = store.addVideo('video/mp4', srcVideo, 'a&b.mp4');
       const r = extractMediaAttachments(att.placeholder, store);
       expect(r.parts).toHaveLength(1);
-      const text = (r.parts[0] as TextPart).text;
-      expect(text).toMatch(/<video path="[^"]+a&amp;b\.mp4"><\/video>/);
+      expect((r.parts[0] as VideoUrlPart).type).toBe('video_url');
+      expect(videoPathFromParts(r.parts).endsWith('a&b.mp4')).toBe(true);
     } finally {
       cleanup();
       rmSync(srcDir, { recursive: true, force: true });
     }
   });
 
-  it('copies video placeholders into the cache and emits cache-path tags', () => {
+  it('copies video placeholders into the cache and emits a file:// video_url part', () => {
     const { cleanup } = setupTempCache();
     const srcDir = makeTempDir();
     try {
@@ -167,8 +168,11 @@ describe('extractMediaAttachments', () => {
       const r = extractMediaAttachments(att.placeholder, store);
       expect(r.hasMedia).toBe(true);
       expect(r.videoAttachmentIds).toEqual([1]);
+      const part = r.parts[0] as VideoUrlPart;
+      expect(part.type).toBe('video_url');
+      expect(part.videoUrl.url.startsWith('file:')).toBe(true);
       const cachePath = videoPathFromParts(r.parts);
-      // The tag points at the cache, not the original source path.
+      // The part points at the cache copy, not the original source path.
       expect(cachePath.startsWith(getCacheDir())).toBe(true);
       expect(cachePath).not.toBe(srcVideo);
       expect(readFileSync(cachePath, 'utf8')).toBe('video-data');
@@ -371,144 +375,3 @@ describe('rewriteMediaPlaceholders', () => {
     }
   });
 });
-
-describe('extractMediaSegments + materializeMediaSegments', () => {
-  it('returns no segments and hasMedia=false for plain text', () => {
-    const store = new ImageAttachmentStore();
-    const r = extractMediaSegments('hello world', store);
-    expect(r.hasMedia).toBe(false);
-    expect(r.segments).toEqual([]);
-    expect(r.imageAttachmentIds).toEqual([]);
-    expect(r.videoAttachmentIds).toEqual([]);
-  });
-
-  it('keeps a video as an unresolved reference and inlines it via the upload result', async () => {
-    const srcDir = makeTempDir();
-    try {
-      const srcVideo = join(srcDir, 'clip.mp4');
-      writeFileSync(srcVideo, 'video-bytes');
-      const store = new ImageAttachmentStore();
-      const vid = store.addVideo('video/mp4', srcVideo);
-      const r = extractMediaSegments(`look ${vid.placeholder} now`, store);
-      expect(r.hasMedia).toBe(true);
-      expect(r.videoAttachmentIds).toEqual([1]);
-      expect(r.segments.map((s) => s.kind)).toEqual(['part', 'video', 'part']);
-
-      const parts = await materializeMediaSegments(r.segments, async () => ({
-        type: 'video_url',
-        videoUrl: { url: 'ms://file-1', id: 'file-1' },
-      }));
-      expect(parts).toEqual([
-        { type: 'text', text: 'look ' },
-        { type: 'video_url', videoUrl: { url: 'ms://file-1', id: 'file-1' } },
-        { type: 'text', text: ' now' },
-      ]);
-    } finally {
-      rmSync(srcDir, { recursive: true, force: true });
-    }
-  });
-
-  it('inlines images directly while videos wait for the upload result', async () => {
-    const srcDir = makeTempDir();
-    try {
-      const srcVideo = join(srcDir, 'clip.mp4');
-      writeFileSync(srcVideo, 'video-bytes');
-      const store = new ImageAttachmentStore();
-      const img = store.addImage(new Uint8Array([1]), 'image/png', 10, 10);
-      const vid = store.addVideo('video/mp4', srcVideo);
-      const r = extractMediaSegments(`${img.placeholder} then ${vid.placeholder}`, store);
-      expect(r.imageAttachmentIds).toEqual([1]);
-      expect(r.videoAttachmentIds).toEqual([2]);
-
-      const parts = await materializeMediaSegments(r.segments, async () => ({
-        type: 'video_url',
-        videoUrl: { url: 'ms://file-2', id: 'file-2' },
-      }));
-      expect(parts.map((p) => p.type)).toEqual(['image_url', 'text', 'video_url']);
-    } finally {
-      rmSync(srcDir, { recursive: true, force: true });
-    }
-  });
-
-  it('preserves video order across concurrent uploads', async () => {
-    const srcDir = makeTempDir();
-    try {
-      const srcA = join(srcDir, 'a.mp4');
-      const srcB = join(srcDir, 'b.mp4');
-      writeFileSync(srcA, 'a');
-      writeFileSync(srcB, 'b');
-      const store = new ImageAttachmentStore();
-      const vidA = store.addVideo('video/mp4', srcA);
-      const vidB = store.addVideo('video/mp4', srcB);
-      const r = extractMediaSegments(`${vidA.placeholder} and ${vidB.placeholder}`, store);
-
-      const parts = await materializeMediaSegments(r.segments, async (att) => ({
-        type: 'video_url',
-        videoUrl: { url: `ms://${att.sourcePath}` },
-      }));
-
-      expect(parts.map((p) => p.type)).toEqual(['video_url', 'text', 'video_url']);
-      expect(parts[0]).toEqual({ type: 'video_url', videoUrl: { url: `ms://${srcA}` } });
-      expect(parts[2]).toEqual({ type: 'video_url', videoUrl: { url: `ms://${srcB}` } });
-    } finally {
-      rmSync(srcDir, { recursive: true, force: true });
-    }
-  });
-
-  it('falls back to a cache-path tag when the upload fails', async () => {
-    const { cleanup } = setupTempCache();
-    const srcDir = makeTempDir();
-    try {
-      const srcVideo = join(srcDir, 'clip.mp4');
-      writeFileSync(srcVideo, 'video-bytes');
-      const store = new ImageAttachmentStore();
-      const vid = store.addVideo('video/mp4', srcVideo);
-      const r = extractMediaSegments(vid.placeholder, store);
-
-      const parts = await materializeMediaSegments(r.segments, async () => {
-        throw new Error('upload failed');
-      });
-
-      const cachePath = videoPathFromParts(parts);
-      expect(cachePath.startsWith(getCacheDir())).toBe(true);
-      expect(readFileSync(cachePath, 'utf8')).toBe('video-bytes');
-    } finally {
-      cleanup();
-      rmSync(srcDir, { recursive: true, force: true });
-    }
-  });
-});
-
-describe('materializeMediaSegments failure mixing', () => {
-  it('inlines successful uploads and falls back per-video on individual failures', async () => {
-    const { cleanup } = setupTempCache();
-    const srcDir = makeTempDir();
-    try {
-      const srcA = join(srcDir, 'a.mp4');
-      const srcB = join(srcDir, 'b.mp4');
-      writeFileSync(srcA, 'a-bytes');
-      writeFileSync(srcB, 'b-bytes');
-      const store = new ImageAttachmentStore();
-      const vidA = store.addVideo('video/mp4', srcA);
-      const vidB = store.addVideo('video/mp4', srcB);
-      const r = extractMediaSegments(`${vidA.placeholder} then ${vidB.placeholder}`, store);
-
-      const parts = await materializeMediaSegments(r.segments, async (att) => {
-        if (att.sourcePath === srcB) throw new Error('upload failed');
-        return { type: 'video_url', videoUrl: { url: `ms://${att.sourcePath}` } };
-      });
-
-      // A inlined, B degraded to a cache tag — order and both contents kept.
-      expect(parts[0]).toEqual({ type: 'video_url', videoUrl: { url: `ms://${srcA}` } });
-      expect(parts[1]).toEqual({ type: 'text', text: ' then ' });
-      expect(parts[2]?.type).toBe('text');
-      const tag = (parts[2] as TextPart).text;
-      const m = /<video path="([^"]+)"><\/video>/.exec(tag);
-      expect(m).not.toBeNull();
-      expect(readFileSync(m![1]!, 'utf8')).toBe('b-bytes');
-    } finally {
-      cleanup();
-      rmSync(srcDir, { recursive: true, force: true });
-    }
-  });
-});
diff --git a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
index f3b4951f94..4ef39560c8 100644
--- a/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
+++ b/apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts
@@ -13,7 +13,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { ApprovalPanelComponent } from '#/tui/components/dialogs/approval-panel';
 import { EffortSelectorComponent } from '#/tui/components/dialogs/effort-selector';
-import { KIMI_CODE_HOME_ENV, KIMI_CODE_PLUGIN_MARKETPLACE_URL } from '#/constant/app';
+import { KIMI_CODE_PLUGIN_MARKETPLACE_URL } from '#/constant/app';
 import { MOON_SPINNER_FRAMES } from '#/tui/constant/rendering';
 import {
   AgentSwarmProgressComponent,
@@ -157,12 +157,8 @@ function makeSession(overrides: Record<string, unknown> = {}) {
     id: 'ses-1',
     model: 'k2',
     summary: { title: null },
-    prompt: vi.fn(async () => {}),
+    prompt: vi.fn(async (_input: unknown) => {}),
     compact: vi.fn(async () => {}),
-    uploadVideo: vi.fn(async () => ({
-      type: 'video_url',
-      videoUrl: { url: 'ms://stub-video', id: 'stub-video' },
-    })),
     steer: vi.fn(async () => {}),
     init: vi.fn(async () => {}),
     startBtw: vi.fn(async () => 'agent-btw'),
@@ -1559,226 +1555,7 @@ command = "vim"
     expect(transcript).not.toContain('review');
   });
 
-  it('uploads pasted videos and sends the issued video_url part', async () => {
-    const { driver, session } = await makeDriver();
-    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
-    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
-    try {
-      const srcVideo = join(dir, 'clip.mp4');
-      await writeFile(srcVideo, 'video-bytes');
-      const attachment = imageStore.addVideo('video/mp4', srcVideo);
-
-      driver.handleUserInput(`watch ${attachment.placeholder}`);
-
-      await vi.waitFor(() => {
-        expect(session.prompt).toHaveBeenCalledWith([
-          { type: 'text', text: 'watch ' },
-          { type: 'video_url', videoUrl: { url: 'ms://stub-video', id: 'stub-video' } },
-        ]);
-      });
-      expect(session.uploadVideo).toHaveBeenCalledWith(srcVideo);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('falls back to a cache-path video tag when the upload fails', async () => {
-    const { driver, session } = await makeDriver();
-    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
-    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
-    const home = await mkdtemp(join(tmpdir(), 'tui-video-home-'));
-    const prevHome = process.env[KIMI_CODE_HOME_ENV];
-    process.env[KIMI_CODE_HOME_ENV] = home;
-    try {
-      const srcVideo = join(dir, 'clip.mp4');
-      await writeFile(srcVideo, 'video-bytes');
-      const attachment = imageStore.addVideo('video/mp4', srcVideo);
-      vi.mocked(session.uploadVideo).mockRejectedValueOnce(new Error('upload failed'));
-
-      driver.handleUserInput(`watch ${attachment.placeholder}`);
-
-      await vi.waitFor(() => {
-        expect(session.prompt).toHaveBeenCalled();
-      });
-      const promptCalls = vi.mocked(session.prompt).mock.calls as unknown as ReadonlyArray<
-        [Array<{ type: string; text?: string }>]
-      >;
-      const parts = promptCalls[0]?.[0] ?? [];
-      const text = parts
-        .filter((p) => p.type === 'text')
-        .map((p) => p.text)
-        .join('');
-      expect(text).toContain('watch ');
-      expect(text).toMatch(/<video path="[^"]+clip\.mp4"><\/video>/);
-    } finally {
-      if (prevHome === undefined) delete process.env[KIMI_CODE_HOME_ENV];
-      else process.env[KIMI_CODE_HOME_ENV] = prevHome;
-      await rm(dir, { recursive: true, force: true });
-      await rm(home, { recursive: true, force: true });
-    }
-  });
-
-  it('keeps submit order when a video upload is in flight', async () => {
-    const { driver, session } = await makeDriver();
-    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
-    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
-    try {
-      const srcVideo = join(dir, 'clip.mp4');
-      await writeFile(srcVideo, 'video-bytes');
-      const attachment = imageStore.addVideo('video/mp4', srcVideo);
-
-      let releaseUpload!: () => void;
-      vi.mocked(session.uploadVideo).mockImplementationOnce(
-        () =>
-          new Promise((resolve) => {
-            releaseUpload = () =>
-              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
-          }),
-      );
-
-      driver.handleUserInput(`watch ${attachment.placeholder}`);
-      driver.handleUserInput('plain follow-up');
-
-      // Nothing may overtake the in-flight upload.
-      await new Promise((r) => setTimeout(r, 20));
-      expect(session.prompt).not.toHaveBeenCalled();
-
-      releaseUpload();
-      await vi.waitFor(() => {
-        expect(session.prompt).toHaveBeenCalledWith([
-          { type: 'text', text: 'watch ' },
-          { type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } },
-        ]);
-      });
-      // The video prompt starts a turn, so the follow-up holds in the queue —
-      // submission order is preserved either way.
-      expect(session.prompt).toHaveBeenCalledTimes(1);
-      expect(driver.state.queuedMessages.map((m) => m.text)).toEqual(['plain follow-up']);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('drops a pending video submit when the model changes mid-upload', async () => {
-    const { driver, session } = await makeDriver();
-    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
-    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
-    try {
-      const srcVideo = join(dir, 'clip.mp4');
-      await writeFile(srcVideo, 'video-bytes');
-      const attachment = imageStore.addVideo('video/mp4', srcVideo);
-
-      let releaseUpload!: () => void;
-      vi.mocked(session.uploadVideo).mockImplementationOnce(
-        () =>
-          new Promise((resolve) => {
-            releaseUpload = () =>
-              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
-          }),
-      );
-
-      driver.handleUserInput(`watch ${attachment.placeholder}`);
-      await vi.waitFor(() => {
-        expect(session.uploadVideo).toHaveBeenCalled();
-      });
-      driver.state.appState.model = 'another-model';
-      releaseUpload();
-
-      await vi.waitFor(() => {
-        expect(driver.state.transcriptContainer.render(120).join('\n')).toContain(
-          'The session or model changed while the video was uploading',
-        );
-      });
-      expect(session.prompt).not.toHaveBeenCalled();
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('drops a pending video submit when the session changes mid-upload', async () => {
-    const { driver, session } = await makeDriver();
-    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
-    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
-    try {
-      const srcVideo = join(dir, 'clip.mp4');
-      await writeFile(srcVideo, 'video-bytes');
-      const attachment = imageStore.addVideo('video/mp4', srcVideo);
-
-      let releaseUpload!: () => void;
-      vi.mocked(session.uploadVideo).mockImplementationOnce(
-        () =>
-          new Promise((resolve) => {
-            releaseUpload = () =>
-              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
-          }),
-      );
-
-      driver.handleUserInput(`watch ${attachment.placeholder}`);
-      await vi.waitFor(() => {
-        expect(session.uploadVideo).toHaveBeenCalled();
-      });
-      (driver as unknown as { session: unknown }).session = makeSession();
-      releaseUpload();
-
-      await vi.waitFor(() => {
-        expect(driver.state.transcriptContainer.render(120).join('\n')).toContain(
-          'The session or model changed while the video was uploading',
-        );
-      });
-      expect(session.prompt).not.toHaveBeenCalled();
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('queues a bash submit behind a pending video upload', async () => {
-    const runShellCommand = vi.fn(async () => ({ stdout: '', stderr: '', isError: false }));
-    const session = makeSession({ runShellCommand });
-    const { driver } = await makeDriver(session);
-    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
-    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
-    try {
-      const srcVideo = join(dir, 'clip.mp4');
-      await writeFile(srcVideo, 'video-bytes');
-      const attachment = imageStore.addVideo('video/mp4', srcVideo);
-
-      let releaseUpload!: () => void;
-      vi.mocked(session.uploadVideo).mockImplementationOnce(
-        () =>
-          new Promise((resolve) => {
-            releaseUpload = () =>
-              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
-          }),
-      );
-
-      driver.handleUserInput(`watch ${attachment.placeholder}`);
-      await vi.waitFor(() => {
-        expect(session.uploadVideo).toHaveBeenCalled();
-      });
-
-      driver.state.appState.inputMode = 'bash';
-      driver.handleUserInput('ls');
-      driver.state.appState.inputMode = 'prompt';
-
-      // The command must not run (or even queue) before the earlier prompt
-      // is dispatched.
-      await new Promise((r) => setTimeout(r, 20));
-      expect(runShellCommand).not.toHaveBeenCalled();
-      expect(driver.state.queuedMessages).toHaveLength(0);
-
-      releaseUpload();
-      await vi.waitFor(() => {
-        expect(driver.state.queuedMessages).toEqual([{ text: 'ls', agentId: 'main', mode: 'bash' }]);
-      });
-      // The video prompt owns the active turn, so the command holds in the
-      // queue instead of racing it.
-      expect(runShellCommand).not.toHaveBeenCalled();
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('queues a skill activation behind a pending video upload', async () => {
+  it('sends a pasted video as a file:// video_url part', async () => {
     const { driver, session } = await makeDriver();
     const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
     const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
@@ -1787,214 +1564,26 @@ command = "vim"
       await writeFile(srcVideo, 'video-bytes');
       const attachment = imageStore.addVideo('video/mp4', srcVideo);
 
-      let releaseUpload!: () => void;
-      vi.mocked(session.uploadVideo).mockImplementationOnce(
-        () =>
-          new Promise((resolve) => {
-            releaseUpload = () =>
-              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
-          }),
-      );
-
-      driver.handleUserInput(`watch ${attachment.placeholder}`);
-      await vi.waitFor(() => {
-        expect(session.uploadVideo).toHaveBeenCalled();
-      });
-
-      (
-        driver as unknown as {
-          sendSkillActivation(s: unknown, skillName: string, args: string): void;
-        }
-      ).sendSkillActivation(session, 'review', 'src/tui');
-      await new Promise((r) => setTimeout(r, 20));
-      expect(session.activateSkill).not.toHaveBeenCalled();
-
-      releaseUpload();
-      await vi.waitFor(() => {
-        expect(driver.state.transcriptContainer.render(120).join('\n')).toContain(
-          'Cannot /review while streaming',
-        );
-      });
-      // The video turn is active by then, so the deferred skill is blocked
-      // with the same message the resolver shows while streaming.
-      expect(session.activateSkill).not.toHaveBeenCalled();
-      expect(session.prompt).toHaveBeenCalled();
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('queues a plugin command behind a pending video upload', async () => {
-    const activatePluginCommand = vi.fn(async () => {});
-    const session = makeSession({ activatePluginCommand });
-    const { driver } = await makeDriver(session);
-    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
-    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
-    try {
-      const srcVideo = join(dir, 'clip.mp4');
-      await writeFile(srcVideo, 'video-bytes');
-      const attachment = imageStore.addVideo('video/mp4', srcVideo);
-
-      let releaseUpload!: () => void;
-      vi.mocked(session.uploadVideo).mockImplementationOnce(
-        () =>
-          new Promise((resolve) => {
-            releaseUpload = () =>
-              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
-          }),
-      );
-
+      // Submission is fully synchronous: the paste is copied to the cache and
+      // referenced by a `file://` video_url the engine resolves in-turn.
       driver.handleUserInput(`watch ${attachment.placeholder}`);
-      await vi.waitFor(() => {
-        expect(session.uploadVideo).toHaveBeenCalled();
-      });
-
-      (
-        driver as unknown as {
-          activatePluginCommand(s: unknown, pluginId: string, command: string, args: string): void;
-        }
-      ).activatePluginCommand(session, 'plug', 'cmd', 'args');
-      await new Promise((r) => setTimeout(r, 20));
-      expect(activatePluginCommand).not.toHaveBeenCalled();
 
-      releaseUpload();
-      await vi.waitFor(() => {
-        expect(driver.state.transcriptContainer.render(120).join('\n')).toContain(
-          'Cannot /plug:cmd while streaming',
-        );
-      });
-      expect(activatePluginCommand).not.toHaveBeenCalled();
+      const parts = vi.mocked(session.prompt).mock.calls[0]?.[0] as
+        | Array<{
+            type: string;
+            text?: string;
+            videoUrl?: { url: string };
+          }>
+        | undefined;
+      expect(parts?.[0]).toEqual({ type: 'text', text: 'watch ' });
+      expect(parts?.[1]?.type).toBe('video_url');
+      expect(parts?.[1]?.videoUrl?.url).toMatch(/^file:\/\/.*clip\.mp4$/);
     } finally {
       await rm(dir, { recursive: true, force: true });
     }
   });
 
-  it('drops a queued bash submit when the session changes mid-upload', async () => {
-    const runShellCommand = vi.fn(async () => ({ stdout: '', stderr: '', isError: false }));
-    const session = makeSession({ runShellCommand });
-    const { driver } = await makeDriver(session);
-    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
-    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
-    try {
-      const srcVideo = join(dir, 'clip.mp4');
-      await writeFile(srcVideo, 'video-bytes');
-      const attachment = imageStore.addVideo('video/mp4', srcVideo);
-
-      let releaseUpload!: () => void;
-      vi.mocked(session.uploadVideo).mockImplementationOnce(
-        () =>
-          new Promise((resolve) => {
-            releaseUpload = () =>
-              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
-          }),
-      );
-
-      driver.handleUserInput(`watch ${attachment.placeholder}`);
-      await vi.waitFor(() => {
-        expect(session.uploadVideo).toHaveBeenCalled();
-      });
-
-      driver.state.appState.inputMode = 'bash';
-      driver.handleUserInput('ls');
-      driver.state.appState.inputMode = 'prompt';
-      (driver as unknown as { session: unknown }).session = makeSession();
-
-      releaseUpload();
-      await vi.waitFor(() => {
-        expect(driver.state.transcriptContainer.render(120).join('\n')).toContain(
-          'The session changed while the video was uploading',
-        );
-      });
-      // Never executed (nor queued) into the new session's workspace.
-      expect(runShellCommand).not.toHaveBeenCalled();
-      expect(driver.state.queuedMessages).toHaveLength(0);
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('queues /compact behind a pending video upload', async () => {
-    const { driver, session } = await makeDriver();
-    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
-    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
-    try {
-      const srcVideo = join(dir, 'clip.mp4');
-      await writeFile(srcVideo, 'video-bytes');
-      const attachment = imageStore.addVideo('video/mp4', srcVideo);
-
-      let releaseUpload!: () => void;
-      vi.mocked(session.uploadVideo).mockImplementationOnce(
-        () =>
-          new Promise((resolve) => {
-            releaseUpload = () =>
-              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
-          }),
-      );
-
-      driver.handleUserInput(`watch ${attachment.placeholder}`);
-      await vi.waitFor(() => {
-        expect(session.uploadVideo).toHaveBeenCalled();
-      });
-
-      driver.handleUserInput('/compact');
-      await new Promise((r) => setTimeout(r, 20));
-      expect(session.compact).not.toHaveBeenCalled();
-
-      releaseUpload();
-      await vi.waitFor(() => {
-        expect(driver.state.transcriptContainer.render(120).join('\n')).toContain(
-          'Cannot /compact while streaming',
-        );
-      });
-      // The video turn is active, so the deferred /compact is blocked like
-      // the resolver would block it while streaming.
-      expect(session.compact).not.toHaveBeenCalled();
-      expect(session.prompt).toHaveBeenCalled();
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('queues /init behind a pending video upload', async () => {
-    const { driver, session } = await makeDriver();
-    const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
-    const dir = await mkdtemp(join(tmpdir(), 'tui-video-'));
-    try {
-      const srcVideo = join(dir, 'clip.mp4');
-      await writeFile(srcVideo, 'video-bytes');
-      const attachment = imageStore.addVideo('video/mp4', srcVideo);
-
-      let releaseUpload!: () => void;
-      vi.mocked(session.uploadVideo).mockImplementationOnce(
-        () =>
-          new Promise((resolve) => {
-            releaseUpload = () =>
-              resolve({ type: 'video_url', videoUrl: { url: 'ms://slow', id: 'slow' } });
-          }),
-      );
-
-      driver.handleUserInput(`watch ${attachment.placeholder}`);
-      await vi.waitFor(() => {
-        expect(session.uploadVideo).toHaveBeenCalled();
-      });
-
-      driver.handleUserInput('/init');
-      await new Promise((r) => setTimeout(r, 20));
-      expect(session.init).not.toHaveBeenCalled();
-
-      releaseUpload();
-      await vi.waitFor(() => {
-        expect(driver.state.transcriptContainer.render(120).join('\n')).toContain(
-          'Cannot /init while streaming',
-        );
-      });
-      expect(session.init).not.toHaveBeenCalled();
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('queues a pasted-video message with uploaded parts while streaming', async () => {
+  it('queues a pasted video (file:// part) while a turn is streaming', async () => {
     const session = makeSession();
     const { driver } = await makeDriver(session);
     const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
@@ -2007,28 +1596,22 @@ command = "vim"
 
       driver.handleUserInput(`describe ${attachment.placeholder}`);
 
-      // The upload completes even while the turn is busy; the queued message
-      // carries the final parts by the time it is drained.
-      await vi.waitFor(() => {
-        expect(driver.state.queuedMessages).toHaveLength(1);
-      });
       expect(session.prompt).not.toHaveBeenCalled();
+      expect(driver.state.queuedMessages).toHaveLength(1);
       const queued = driver.state.queuedMessages[0];
-      expect(queued?.parts).toEqual([
-        { type: 'text', text: 'describe ' },
-        { type: 'video_url', videoUrl: { url: 'ms://stub-video', id: 'stub-video' } },
-      ]);
+      const parts = queued?.parts as Array<{ type: string; text?: string; videoUrl?: { url: string } }>;
+      expect(parts?.[0]).toEqual({ type: 'text', text: 'describe ' });
+      expect(parts?.[1]?.type).toBe('video_url');
+      expect(parts?.[1]?.videoUrl?.url).toMatch(/^file:\/\/.*clip\.mp4$/);
 
       driver.sendQueuedMessage(session, queued!);
-      expect(session.prompt).toHaveBeenCalledWith([
-        { type: 'text', text: 'describe ' },
-        { type: 'video_url', videoUrl: { url: 'ms://stub-video', id: 'stub-video' } },
-      ]);
+      expect(session.prompt).toHaveBeenCalledWith(parts);
     } finally {
       await rm(dir, { recursive: true, force: true });
     }
   });
 
+
   it('sends pasted image placeholders as image content parts', async () => {
     const { driver, session } = await makeDriver();
     const imageStore = (driver as unknown as { imageStore: ImageAttachmentStore }).imageStore;
diff --git a/apps/kimi-web/src/api/daemon/client.ts b/apps/kimi-web/src/api/daemon/client.ts
index d320d3d81d..d8b1833edf 100644
--- a/apps/kimi-web/src/api/daemon/client.ts
+++ b/apps/kimi-web/src/api/daemon/client.ts
@@ -1389,14 +1389,6 @@ export class DaemonKimiWebApi implements KimiWebApi {
     return this.http.getBlob(`/files/${encodeURIComponent(fileId)}`);
   }
 
-  getLlmFileUrl(llmFileId: string): string {
-    return buildRestUrl(this.config.serverHttpUrl, `/files/llm/${encodeURIComponent(llmFileId)}`);
-  }
-
-  async getLlmFileBlob(llmFileId: string): Promise<Blob> {
-    return this.http.getBlob(`/files/llm/${encodeURIComponent(llmFileId)}`);
-  }
-
   // -------------------------------------------------------------------------
   // WebSocket events
   // -------------------------------------------------------------------------
diff --git a/apps/kimi-web/src/api/daemon/eventReducer.ts b/apps/kimi-web/src/api/daemon/eventReducer.ts
index 1a24a39161..4916bfa7b7 100644
--- a/apps/kimi-web/src/api/daemon/eventReducer.ts
+++ b/apps/kimi-web/src/api/daemon/eventReducer.ts
@@ -158,11 +158,6 @@ function sameMessageContent(a: AppMessage, b: AppMessage): boolean {
 // A tag is its own text part, so anchoring keeps ordinary prose from matching.
 const MEDIA_PATH_TAG_SHAPE_RE = /^<(image|video|audio)\s+path="[^"]+"><\/\1>$/;
 
-// Matches the provider reference a prompt video was inlined as:
-// `[video:ms://<id>]`. Like the media path tag it is its own text part and
-// counts as media so the echo reconciles with the optimistic copy.
-const LLM_VIDEO_REF_SHAPE_RE = /^\[video:ms:\/\/[^\]]+\]$/;
-
 function userMessageShape(m: AppMessage): { text: string; media: number } {
   let text = '';
   let media = 0;
@@ -171,8 +166,7 @@ function userMessageShape(m: AppMessage): { text: string; media: number } {
       // A video/image upload reaches us (after the server resolves it) as a
       // `<video path=…></video>` text tag, not a media part — count it as media
       // and drop it from the text so the echo reconciles with our optimistic copy.
-      const trimmed = c.text.trim();
-      if (MEDIA_PATH_TAG_SHAPE_RE.test(trimmed) || LLM_VIDEO_REF_SHAPE_RE.test(trimmed)) media += 1;
+      if (MEDIA_PATH_TAG_SHAPE_RE.test(c.text.trim())) media += 1;
       else text += c.text;
     } else if (c.type === 'image' || c.type === 'video' || c.type === 'file') media += 1;
   }
diff --git a/apps/kimi-web/src/api/types.ts b/apps/kimi-web/src/api/types.ts
index 49f5309bd2..6c4679f165 100644
--- a/apps/kimi-web/src/api/types.ts
+++ b/apps/kimi-web/src/api/types.ts
@@ -781,11 +781,6 @@ export interface KimiWebApi {
   getFileUrl(fileId: string): string;
   /** Fetch a file's bytes with auth — feed the resulting Blob to a blob URL for <video>/<img> src. */
   getFileBlob(fileId: string): Promise<Blob>;
-  /** URL of the daemon redirect that maps a provider-issued video file id
-   *  (`ms://<llmFileId>`) back to the local upload it was produced from. */
-  getLlmFileUrl(llmFileId: string): string;
-  /** Fetch a provider-referenced video's bytes with auth via the llm redirect. */
-  getLlmFileBlob(llmFileId: string): Promise<Blob>;
 
   // Config — REAL endpoints
   getConfig(): Promise<AppConfig>;
diff --git a/apps/kimi-web/src/components/chat/AuthMedia.vue b/apps/kimi-web/src/components/chat/AuthMedia.vue
index aced943d1c..2e6939fcbc 100644
--- a/apps/kimi-web/src/components/chat/AuthMedia.vue
+++ b/apps/kimi-web/src/components/chat/AuthMedia.vue
@@ -16,9 +16,6 @@ const props = withDefaults(
     /** File-store id. When present the bytes are fetched with auth and played
      *  from a blob URL; otherwise `url` is used directly (e.g. a data: URL). */
     fileId?: string;
-    /** Provider-issued file id of an inlined video (`ms://<id>`). Like fileId,
-     *  the bytes are fetched with auth — through the daemon's llm redirect. */
-    llmFileId?: string;
     mediaClass?: string;
     /** Video: show native controls. Defaults to true (chat bubble); queue
      *  thumbnails pass false. */
@@ -29,12 +26,12 @@ const props = withDefaults(
   { mediaClass: 'u-img', controls: true, muted: false },
 );
 
-const resolvedUrl = ref<string>(props.fileId || props.llmFileId ? '' : props.url);
+const resolvedUrl = ref<string>(props.fileId ? '' : props.url);
 const mediaEl = ref<HTMLElement | null>(null);
 // Flips true once the element nears the viewport, deferring the authenticated
 // download so a session with many historical large uploads doesn't fetch every
 // blob (and hold them in memory) before the user ever scrolls to or plays them.
-const visible = ref(!props.fileId && !props.llmFileId);
+const visible = ref(!props.fileId);
 let objectUrl: string | null = null;
 // Sequence guard + unmount flag: a reused component (e.g. queued thumbnails
 // keyed by index) can change fileId before a previous fetch resolves, and an
@@ -54,18 +51,13 @@ function revoke(): void {
 async function resolve(): Promise<void> {
   const seq = ++requestSeq;
   revoke();
-  const authedFetch = props.fileId
-    ? () => getKimiWebApi().getFileBlob(props.fileId!)
-    : props.llmFileId
-      ? () => getKimiWebApi().getLlmFileBlob(props.llmFileId!)
-      : null;
-  if (authedFetch === null) {
+  if (!props.fileId) {
     resolvedUrl.value = props.url;
     return;
   }
   if (!visible.value) return; // defer until near the viewport
   try {
-    const blob = await authedFetch();
+    const blob = await getKimiWebApi().getFileBlob(props.fileId);
     const url = URL.createObjectURL(blob);
     if (disposed || seq !== requestSeq) {
       URL.revokeObjectURL(url);
@@ -80,11 +72,7 @@ async function resolve(): Promise<void> {
   }
 }
 
-watch(
-  () => [props.fileId, props.llmFileId, props.url, visible.value] as const,
-  resolve,
-  { immediate: true },
-);
+watch(() => [props.fileId, props.url, visible.value] as const, resolve, { immediate: true });
 
 onMounted(() => {
   if (typeof IntersectionObserver === 'function' && mediaEl.value) {
diff --git a/apps/kimi-web/src/components/chat/ChatPane.vue b/apps/kimi-web/src/components/chat/ChatPane.vue
index cf187b422a..5886e0ef90 100644
--- a/apps/kimi-web/src/components/chat/ChatPane.vue
+++ b/apps/kimi-web/src/components/chat/ChatPane.vue
@@ -477,15 +477,8 @@ function userAttachmentMedia(att: TurnAttachment): ToolMedia {
   // User-uploaded media carries no path/mime metadata; the preview panel falls
   // back to a generic label and sniffs the mime from the URL when needed. When
   // a fileId is present the preview fetches the bytes with auth (a bare
-  // getFileUrl src 401s under daemon auth); an llmFileId fetches through the
-  // daemon's authenticated llm redirect instead.
-  return {
-    kind: att.kind === 'video' ? 'video' : 'image',
-    url: att.url,
-    path: att.name,
-    fileId: att.fileId,
-    llmFileId: att.llmFileId,
-  };
+  // getFileUrl src 401s under daemon auth).
+  return { kind: att.kind === 'video' ? 'video' : 'image', url: att.url, path: att.name, fileId: att.fileId };
 }
 
 // Transient "can't open this type" hint after clicking a file chip of a
@@ -742,7 +735,6 @@ function isStreamingRenderBlock(turn: ChatTurn, block: { sourceIndex: number }):
                 :url="att.url"
                 :kind="att.kind"
                 :file-id="att.fileId"
-                :llm-file-id="att.llmFileId"
                 media-class="q-img"
                 :controls="false"
                 muted
diff --git a/apps/kimi-web/src/components/chat/Composer.vue b/apps/kimi-web/src/components/chat/Composer.vue
index b64c62d903..5d2e16f6d9 100644
--- a/apps/kimi-web/src/components/chat/Composer.vue
+++ b/apps/kimi-web/src/components/chat/Composer.vue
@@ -291,7 +291,7 @@ function focus(): void {
   // or if focus is triggered during an animation/transition.
   textareaRef.value?.focus({ preventScroll: true });
 }
-function loadAttachmentsForEdit(atts: { fileId?: string; llmFileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]): void {
+function loadAttachmentsForEdit(atts: { fileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]): void {
   loadAttachments(atts);
 }
 defineExpose({ loadForEdit, loadAttachmentsForEdit, focus });
diff --git a/apps/kimi-web/src/components/chat/ConversationPane.vue b/apps/kimi-web/src/components/chat/ConversationPane.vue
index 53b20f1ce5..1b6b1a9e79 100644
--- a/apps/kimi-web/src/components/chat/ConversationPane.vue
+++ b/apps/kimi-web/src/components/chat/ConversationPane.vue
@@ -428,7 +428,7 @@ const chatDockStyle = computed(() => ({
 }));
 type ComposerHandle = {
   loadForEdit: (value: string) => boolean | void;
-  loadAttachmentsForEdit: (atts: { fileId?: string; llmFileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]) => void;
+  loadAttachmentsForEdit: (atts: { fileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]) => void;
   focus: () => void;
 };
 type RefArg = Element | (ComponentPublicInstance & Partial<ComposerHandle>) | null;
diff --git a/apps/kimi-web/src/composables/client/useSideChat.ts b/apps/kimi-web/src/composables/client/useSideChat.ts
index c5d686d841..10322ae46a 100644
--- a/apps/kimi-web/src/composables/client/useSideChat.ts
+++ b/apps/kimi-web/src/composables/client/useSideChat.ts
@@ -78,8 +78,6 @@ export function useSideChat(rawState: ExtendedState, deps: UseSideChatDeps) {
       [],
       (fileId) => getKimiWebApi().getFileUrl(fileId),
       sideChatRunning.value,
-      undefined,
-      (llmFileId) => getKimiWebApi().getLlmFileUrl(llmFileId),
     );
   });
 
diff --git a/apps/kimi-web/src/composables/messagesToTurns.ts b/apps/kimi-web/src/composables/messagesToTurns.ts
index 7a7a1f2b30..82b170a2c8 100644
--- a/apps/kimi-web/src/composables/messagesToTurns.ts
+++ b/apps/kimi-web/src/composables/messagesToTurns.ts
@@ -22,26 +22,6 @@ const MEDIA_PATH_TAG_RE = /^<(image|video|audio)\s+path="([^"]+)">$/;
 // matching; the closing tag is optional because ReadMediaFile emits the bare
 // opening tag as a standalone part.
 const USER_MEDIA_PATH_TAG_RE = /^<(image|video|audio)\s+path="([^"]+)">(?:<\/\1>)?$/;
-// A user-uploaded video the server inlined as a provider file reference is
-// persisted as a `video_url` part, which the daemon's message projection
-// flattens into a self-contained `[video:ms://<llmFileId>]` text part. Like
-// the media path tag above, it is its own content part, so anchoring keeps
-// ordinary prose from matching.
-const LLM_VIDEO_REF_TAG_RE = /^\[video:ms:\/\/([^\]]+)\]$/;
-const MS_URL_PREFIX = 'ms://';
-
-/** The provider-issued file id behind a `ms://` url, undefined for any other scheme. */
-function llmFileIdFromMsUrl(url: string): string | undefined {
-  if (!url.startsWith(MS_URL_PREFIX)) return undefined;
-  const id = url.slice(MS_URL_PREFIX.length);
-  return id.length > 0 ? id : undefined;
-}
-
-/** Parse a `[video:ms://<llmFileId>]` text part (see LLM_VIDEO_REF_TAG_RE). */
-function llmVideoRefTag(text: string): string | null {
-  return LLM_VIDEO_REF_TAG_RE.exec(text.trim())?.[1] ?? null;
-}
-
 const SYSTEM_MIME_RE = /Mime type:\s*([^.\s]+)/i;
 const SYSTEM_SIZE_RE = /Size:\s*(\d+)\s*bytes/i;
 const SYSTEM_DIMENSIONS_RE = /Original dimensions:\s*(\d+)x(\d+)\s*pixels/i;
@@ -608,10 +588,6 @@ export function messagesToTurns(
   /** Preserved `plan_review` displays keyed by toolCallId — used to link the
    *  ExitPlanMode tool card back to the plan file after the approval resolves. */
   planReviewByToolCallId: Record<string, { plan: string; path?: string }> = {},
-  /** Maps a provider-issued video file id (`ms://<llmFileId>`) to the daemon
-   *  redirect that serves the local bytes (`/files/llm/<id>`). Without it an
-   *  ms:// reference can't produce a playable URL and stays as raw text. */
-  getLlmFileUrl?: (llmFileId: string) => string,
 ): ChatTurn[] {
   const turns: ChatTurn[] = [];
   let no = 1;
@@ -750,19 +726,11 @@ export function messagesToTurns(
 
   function resolveMediaUrl(
     c: AppMessage['content'][number],
-  ): { url: string; kind: 'image' | 'video'; fileId?: string; llmFileId?: string } | undefined {
+  ): { url: string; kind: 'image' | 'video'; fileId?: string } | undefined {
     if (c.type === 'image' || c.type === 'video') {
       const kind = c.type;
       const src = c.source;
-      if (src.kind === 'url') {
-        // A `ms://<llmFileId>` source is the provider-issued reference of an
-        // uploaded video; the daemon serves the local bytes at /files/llm/<id>.
-        const llmFileId = llmFileIdFromMsUrl(src.url);
-        if (llmFileId !== undefined && getLlmFileUrl) {
-          return { url: getLlmFileUrl(llmFileId), kind, llmFileId };
-        }
-        return { url: src.url, kind };
-      }
+      if (src.kind === 'url') return { url: src.url, kind };
       if (src.kind === 'base64') return { url: `data:${src.mediaType};base64,${src.data}`, kind };
       if (src.kind === 'file' && getFileUrl) return { url: getFileUrl(src.fileId), kind, fileId: src.fileId };
     }
@@ -858,15 +826,6 @@ export function messagesToTurns(
                 continue;
               }
             }
-            // A video the server inlined as a provider file reference comes
-            // back (after a reload) as a `[video:ms://…]` text part — recover
-            // the same video attachment via the daemon's llm-file redirect
-            // instead of dumping the raw reference into the bubble.
-            const llmFileId = llmVideoRefTag(c.text);
-            if (llmFileId !== null && getLlmFileUrl) {
-              attachments.push({ url: getLlmFileUrl(llmFileId), kind: 'video', llmFileId });
-              continue;
-            }
             // A generic file upload comes back as an "Attached file …" notice;
             // recover the chip the same way (see attachedFileNotice).
             const attached = attachedFileNotice(c.text);
@@ -895,7 +854,6 @@ export function messagesToTurns(
             kind: media.kind,
             name: c.type === 'file' ? c.name : undefined,
             fileId: media.fileId,
-            llmFileId: media.llmFileId,
           });
           continue;
         }
diff --git a/apps/kimi-web/src/composables/useAttachmentUpload.ts b/apps/kimi-web/src/composables/useAttachmentUpload.ts
index 344c4a50ae..2c97c4d6ce 100644
--- a/apps/kimi-web/src/composables/useAttachmentUpload.ts
+++ b/apps/kimi-web/src/composables/useAttachmentUpload.ts
@@ -71,15 +71,6 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
     try { URL.revokeObjectURL(att.previewUrl); } catch { /* ignore */ }
   }
 
-  /** Remove an attachment and release its preview blob URL first — an object
-   *  URL pins the (possibly large) blob in the browser store until revoked. */
-  function dropAttachment(sid: string, localId: string): void {
-    const current = attachmentsBySession.value[sid] ?? [];
-    const entry = current.find((a) => a.localId === localId);
-    if (entry !== undefined) revokeAttachment(entry);
-    setForSession(sid, current.filter((a) => a.localId !== localId));
-  }
-
   function attachmentKind(mime: string): 'image' | 'video' | 'file' {
     if (mime.startsWith('image/')) return 'image';
     if (mime.startsWith('video/')) return 'video';
@@ -308,7 +299,7 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
    *  fetch an authenticated blob URL so the thumbnail doesn't 401. Replaces any
    *  unsent draft attachments (mirroring loadForEdit(text), which overwrites) so
    *  a later submit sends exactly the edited message's files, not a mix. */
-  function loadAttachments(atts: { fileId?: string; llmFileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]): void {
+  function loadAttachments(atts: { fileId?: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[]): void {
     const sid = sessionId() ?? '';
     for (const existing of attachmentsBySession.value[sid] ?? []) revokeAttachment(existing);
     setForSession(sid, []);
@@ -343,48 +334,6 @@ export function useAttachmentUpload(deps: AttachmentUploadDeps) {
             // Keep the fallback previewUrl (honest broken state if it 401s).
           });
         }
-      } else if (att.llmFileId) {
-        // A provider-referenced video recovered after a reload: not resendable
-        // as-is (the ms:// reference can't ride a new prompt), so re-upload the
-        // bytes — fetched WITH auth through the daemon's llm redirect, unlike
-        // the plain-URL branch below which would 401 for this URL.
-        if (!att.url) continue;
-        const upload = uploadImage();
-        if (!upload) continue;
-        const entry: Attachment = {
-          localId,
-          name,
-          kind: att.kind,
-          previewUrl: att.url,
-          uploading: true,
-        };
-        setForSession(sid, [...(attachmentsBySession.value[sid] ?? []), entry]);
-        void getKimiWebApi()
-          .getLlmFileBlob(att.llmFileId)
-          .then((blob) => {
-            // The same authenticated bytes drive the preview: the protected
-            // llm URL would 401 as a native <video src>, so swap previewUrl
-            // for this blob URL (mirroring the fileId branch above).
-            const blobUrl = URL.createObjectURL(blob);
-            const current = attachmentsBySession.value[sid] ?? [];
-            if (!current.some((a) => a.localId === localId)) {
-              URL.revokeObjectURL(blobUrl);
-              return null;
-            }
-            patchAttachment(sid, localId, { previewUrl: blobUrl });
-            const fname = name.includes('.') ? name : `${name}.${blob.type.split('/')[1] ?? 'bin'}`;
-            return upload(blob, fname);
-          })
-          .then((result) => {
-            if (result === null) {
-              dropAttachment(sid, localId);
-              return;
-            }
-            patchAttachment(sid, localId, { uploading: false, fileId: result.fileId });
-          })
-          .catch(() => {
-            dropAttachment(sid, localId);
-          });
       } else {
         // No fileId (e.g. a server-base64-inlined image, or a URL-backed source
         // from the wire/REST prompt path): re-upload the URL so the chip is
diff --git a/apps/kimi-web/src/composables/useFilePreview.ts b/apps/kimi-web/src/composables/useFilePreview.ts
index beae19effe..f61d98d0b2 100644
--- a/apps/kimi-web/src/composables/useFilePreview.ts
+++ b/apps/kimi-web/src/composables/useFilePreview.ts
@@ -13,6 +13,13 @@ type KimiWebClient = ReturnType<typeof useKimiWebClient>;
 /** Which occupant currently owns the shared right-side detail layer. */
 export type DetailTarget = 'file' | 'diff' | 'thinking' | 'compaction' | 'agent' | 'toolDiff' | 'btw';
 
+/** Whether a url can feed a native <video>/<img> src. A provider reference like
+ *  `ms://…` has no local bytes and only yields a broken player, so it's treated
+ *  as non-loadable and falls through to the no-preview card. */
+export function isPlayableMediaUrl(url: string): boolean {
+  return /^(?:https?:|blob:|data:)/i.test(url);
+}
+
 export interface UseFilePreviewOptions {
   client: KimiWebClient;
   detailTarget: Ref<DetailTarget | null>;
@@ -172,18 +179,11 @@ export function useFilePreview({ client, detailTarget }: UseFilePreviewOptions)
       size: media.bytes ?? 0,
     };
     // The raw URL 401s under daemon auth (browsers load media without the
-    // Bearer token), so fetch the bytes with auth and preview a blob URL —
-    // from the file store for uploads, from the llm redirect for provider
-    // references.
-    const authedFetch = media.fileId
-      ? () => getKimiWebApi().getFileBlob(media.fileId!)
-      : media.llmFileId
-        ? () => getKimiWebApi().getLlmFileBlob(media.llmFileId!)
-        : null;
-    if (authedFetch !== null) {
+    // Bearer token), so fetch the bytes with auth and preview a blob URL.
+    if (media.fileId) {
       previewLoading.value = true;
       previewFile.value = base;
-      void authedFetch().then((blob) => {
+      void getKimiWebApi().getFileBlob(media.fileId).then((blob) => {
         if (seq !== previewRequestSeq) return;
         // The user may have switched to another detail panel while this was in
         // flight — don't create (and leak) a blob URL for a hidden panel.
@@ -202,7 +202,10 @@ export function useFilePreview({ client, detailTarget }: UseFilePreviewOptions)
       });
     } else {
       previewLoading.value = false;
-      previewFile.value = { ...base, sourceUrl: media.url };
+      // A non-loadable url (e.g. a provider `ms://` reference with no local
+      // bytes) can't feed a <video>/<img> src — leave sourceUrl unset so the
+      // preview shows the no-preview card instead of a broken player.
+      previewFile.value = isPlayableMediaUrl(media.url) ? { ...base, sourceUrl: media.url } : base;
     }
   }
 
diff --git a/apps/kimi-web/src/composables/useKimiWebClient.ts b/apps/kimi-web/src/composables/useKimiWebClient.ts
index 6d742de2c9..f6e3f6a694 100644
--- a/apps/kimi-web/src/composables/useKimiWebClient.ts
+++ b/apps/kimi-web/src/composables/useKimiWebClient.ts
@@ -1973,7 +1973,6 @@ const turns = computed<ChatTurn[]>(() => {
     (fileId) => getKimiWebApi().getFileUrl(fileId),
     turnActive.value,
     rawState.planReviewByToolCallId,
-    (llmFileId) => getKimiWebApi().getLlmFileUrl(llmFileId),
   );
 });
 
diff --git a/apps/kimi-web/src/types.ts b/apps/kimi-web/src/types.ts
index a0fd1d4d99..4286377eed 100644
--- a/apps/kimi-web/src/types.ts
+++ b/apps/kimi-web/src/types.ts
@@ -110,9 +110,6 @@ export interface ToolMedia {
   /** File-store id when the media is an uploaded file. The preview fetches its
    *  bytes with the Bearer credential (a bare getFileUrl src 401s in <img>). */
   fileId?: string;
-  /** Provider-issued file id of an inlined video (`ms://<id>`); the preview
-   *  fetches through the daemon's authenticated llm redirect, not the bare URL. */
-  llmFileId?: string;
 }
 
 export type AgentPhase = 'queued' | 'working' | 'suspended' | 'completed' | 'failed';
@@ -238,10 +235,6 @@ export interface TurnAttachment {
   kind: 'image' | 'video' | 'file';
   url: string;
   fileId?: string;
-  /** Provider-issued file id behind an inlined video (`ms://<id>`). Like
-   *  `fileId`, it selects an authenticated fetch (the daemon's llm redirect)
-   *  over a bare URL load, which would 401 under daemon auth. */
-  llmFileId?: string;
   name?: string;
   mediaType?: string;
   size?: number;
@@ -343,7 +336,7 @@ export interface QueuedPromptView {
   attachmentCount: number;
   /** Attachments waiting with this prompt, with resolved URLs for thumbnails
       (file attachments render an icon chip, no thumbnail). */
-  attachments?: { fileId: string; kind: 'image' | 'video' | 'file'; url: string; name?: string; llmFileId?: string }[];
+  attachments?: { fileId: string; kind: 'image' | 'video' | 'file'; url: string; name?: string }[];
 }
 
 /** Horizontal alignment of the conversation reading column within the pane. */
diff --git a/apps/kimi-web/test/event-reducer.test.ts b/apps/kimi-web/test/event-reducer.test.ts
index d876a92bef..9df96de2ed 100644
--- a/apps/kimi-web/test/event-reducer.test.ts
+++ b/apps/kimi-web/test/event-reducer.test.ts
@@ -303,10 +303,10 @@ describe('reduceAppEvent messageCreated', () => {
     expect(msgs[0]?.promptId).toBe('p1');
   });
 
-  it('reconciles an inlined `[video:ms://…]` echo into the optimistic user message', () => {
-    // A video the server inlined as a provider reference echoes back as a
-    // `[video:ms://…]` text part, while the optimistic copy still carries the
-    // file-source video. They must collapse into one bubble, not duplicate.
+  it('reconciles a structured file-source video echo into the optimistic user message', () => {
+    // The server now echoes an uploaded video back as a structured
+    // `{video, source:{kind:'file'}}` part (mirroring images), not a text tag.
+    // It must collapse into the optimistic file-source copy, not duplicate.
     const optimistic: AppMessage = {
       id: 'msg_opt_2',
       sessionId: 's-vid',
@@ -324,7 +324,7 @@ describe('reduceAppEvent messageCreated', () => {
       role: 'user',
       content: [
         { type: 'text', text: 'look at this' },
-        { type: 'text', text: '[video:ms://file-abc123]' },
+        { type: 'video', source: { kind: 'file', fileId: 'f_abc' } },
       ],
       createdAt: '2026-06-01T12:00:00.000Z',
       promptId: 'p1',
diff --git a/apps/kimi-web/test/turn-logic.test.ts b/apps/kimi-web/test/turn-logic.test.ts
index bcb39189c0..7c4557b4cf 100644
--- a/apps/kimi-web/test/turn-logic.test.ts
+++ b/apps/kimi-web/test/turn-logic.test.ts
@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest';
 import type { AppMessage, AppMessageContent } from '../src/api/types';
 import { latestTodos } from '../src/composables/latestTodos';
 import { messagesToTurns } from '../src/composables/messagesToTurns';
+import { isPlayableMediaUrl } from '../src/composables/useFilePreview';
 
 function message(
   id: string,
@@ -217,53 +218,31 @@ describe('messagesToTurns', () => {
     ]);
   });
 
-  it('renders a `[video:ms://…]` text part as a video attachment via the llm-file redirect', () => {
-    // A video the server inlined as a provider file reference is persisted as a
-    // video_url part and comes back from the message projection as this
-    // self-contained text part. It must render like the upload did — not as raw
-    // text — with the bytes served by the daemon's /files/llm redirect.
-    const llmFileId = 'file-abc123';
+  it('renders a structured file-source video part as a video attachment', () => {
+    // An uploaded video comes back from the message projection as a structured
+    // `{video, source:{kind:'file'}}` part (mirroring images). It resolves to
+    // the authenticated file URL, keyed by the same fileId the preview fetches.
+    const fileId = 'f_01KWK39A0ZC8R2ATZEQMD8716C';
     const turns = messagesToTurns(
       [
         message('u1', 'user', [
           { type: 'text', text: 'look at this' },
-          { type: 'text', text: `[video:ms://${llmFileId}]` },
+          { type: 'video', source: { kind: 'file', fileId } },
         ]),
       ],
       [],
       (id) => `/api/v1/files/${id}`,
       false,
-      undefined,
-      (id) => `/api/v1/files/llm/${id}`,
     );
 
     expect(turns).toHaveLength(1);
     expect(turns[0]).toMatchObject({ role: 'user', text: 'look at this' });
     expect(turns[0]?.attachments).toEqual([
-      { url: `/api/v1/files/llm/${llmFileId}`, kind: 'video', llmFileId },
-    ]);
-  });
-
-  it('maps an ms:// url-source video part to the llm-file redirect', () => {
-    const turns = messagesToTurns(
-      [
-        message('u1', 'user', [
-          { type: 'video', source: { kind: 'url', url: 'ms://file-abc123' } },
-        ]),
-      ],
-      [],
-      (id) => `/api/v1/files/${id}`,
-      false,
-      undefined,
-      (id) => `/api/v1/files/llm/${id}`,
-    );
-
-    expect(turns[0]?.attachments).toEqual([
-      { url: '/api/v1/files/llm/file-abc123', kind: 'video', llmFileId: 'file-abc123' },
+      { url: `/api/v1/files/${fileId}`, kind: 'video', fileId },
     ]);
   });
 
-  it('leaves non-ms video urls untouched', () => {
+  it('leaves url-source video parts untouched', () => {
     const dataUrl = 'data:video/mp4;base64,AAAA';
     const turns = messagesToTurns(
       [
@@ -275,8 +254,6 @@ describe('messagesToTurns', () => {
       [],
       (id) => `/api/v1/files/${id}`,
       false,
-      undefined,
-      (id) => `/api/v1/files/llm/${id}`,
     );
 
     expect(turns[0]?.attachments).toEqual([
@@ -285,19 +262,6 @@ describe('messagesToTurns', () => {
     ]);
   });
 
-  it('keeps the `[video:ms://…]` text when no llm-file resolver is provided', () => {
-    const text = '[video:ms://file-abc123]';
-    const turns = messagesToTurns(
-      [message('u1', 'user', [{ type: 'text', text }])],
-      [],
-      (id) => `/api/v1/files/${id}`,
-      false,
-    );
-
-    expect(turns[0]).toMatchObject({ role: 'user', text });
-    expect(turns[0]?.attachments).toBeUndefined();
-  });
-
   it('renders a non-media file part as a file attachment with name and size', () => {
     const turns = messagesToTurns(
       [
@@ -896,3 +860,23 @@ describe('messagesToTurns cron', () => {
     expect(turns.map((t) => t.role)).toEqual(['user', 'assistant', 'cron', 'assistant']);
   });
 });
+
+describe('isPlayableMediaUrl', () => {
+  // Gates the file-preview media source: a playable url feeds a native
+  // <video>/<img> src; a non-playable one falls through to the no-preview card.
+  it('accepts browser-loadable schemes', () => {
+    expect(isPlayableMediaUrl('https://example.com/clip.mp4')).toBe(true);
+    expect(isPlayableMediaUrl('http://example.com/clip.mp4')).toBe(true);
+    expect(isPlayableMediaUrl('data:video/mp4;base64,AAAA')).toBe(true);
+    expect(isPlayableMediaUrl('blob:https://app/uuid')).toBe(true);
+  });
+
+  it('rejects a provider ms:// reference (no local bytes → no preview)', () => {
+    expect(isPlayableMediaUrl('ms://file-abc123')).toBe(false);
+  });
+
+  it('rejects other non-loadable inputs', () => {
+    expect(isPlayableMediaUrl('/api/v1/files/f_abc')).toBe(false);
+    expect(isPlayableMediaUrl('')).toBe(false);
+  });
+});
diff --git a/packages/agent-core-v2/src/agent/contextMemory/messageProjection.ts b/packages/agent-core-v2/src/agent/contextMemory/messageProjection.ts
index 8c9810de96..7e48c65995 100644
--- a/packages/agent-core-v2/src/agent/contextMemory/messageProjection.ts
+++ b/packages/agent-core-v2/src/agent/contextMemory/messageProjection.ts
@@ -13,10 +13,18 @@
  * (image/video/audio — e.g. ReadMediaFile) passes the raw kosong content-part
  * array through, the same shape the live `tool.result` event stream carries,
  * so REST consumers can still render the media after reload/resume.
+ *
+ * A user `video_url` part projects to a structured `video` content part so
+ * REST consumers can render it: an internal `kimi-file://<id>?path=…`
+ * reference becomes `{ kind: 'file', file_id }` (the materialization path is
+ * stripped, never leaked to clients); any other url becomes `{ kind: 'url' }`
+ * carrying the provider id. An `audio_url` part still flattens to a text
+ * marker.
  */
 
 import type { Message, MessageContent, MessageRole, ToolUseContent } from './protocolMessage';
 
+import { parseKimiFileUrl } from '#/agent/media/kimiFileUrl';
 import type { ContextMessage } from './types';
 
 function deriveMessageId(sessionId: string, index: number): string {
@@ -45,8 +53,12 @@ function mapContentPart(part: ContextMessage['content'][number]): MessageContent
       };
     case 'audio_url':
       return { type: 'text', text: `[audio:${part.audioUrl.url}]` };
-    case 'video_url':
-      return { type: 'text', text: `[video:${part.videoUrl.url}]` };
+    case 'video_url': {
+      const ref = parseKimiFileUrl(part.videoUrl.url);
+      return ref !== undefined
+        ? { type: 'video', source: { kind: 'file', file_id: ref.fileId } }
+        : { type: 'video', source: { kind: 'url', url: part.videoUrl.url, id: part.videoUrl.id } };
+    }
   }
 }
 
diff --git a/packages/agent-core-v2/src/agent/llmRequester/llmRequesterService.ts b/packages/agent-core-v2/src/agent/llmRequester/llmRequesterService.ts
index 006bd39eaf..fa4d9daa94 100644
--- a/packages/agent-core-v2/src/agent/llmRequester/llmRequesterService.ts
+++ b/packages/agent-core-v2/src/agent/llmRequester/llmRequesterService.ts
@@ -9,7 +9,11 @@
  * resolved from `IModelCatalog`: one primary `requester.request(input, signal,
  * params)` attempt plus projection rebuilds for request structure or media
  * compatibility; general retry policy remains in the loop's `stepRetry`
- * plugin. When a model is configured, `prepareTurnConfig` snapshots the
+ * plugin. Before each request the projected messages pass through `media`'s
+ * video resolver, which rewrites every `kimi-file://` prompt-video reference
+ * to a provider-acceptable part (uploaded `ms://`, inline base64, or a
+ * `<video path>` tag) so the internal reference never reaches the wire. When a
+ * model is configured, `prepareTurnConfig` snapshots the
  * model, effective thinking effort, and system prompt at the turn boundary
  * so loop telemetry and every request in that turn share one configuration.
  * Forwards streamed `part` events to the caller's `onPart`
@@ -38,6 +42,7 @@ import {
 import { IAgentProfileService, type ProfileModelContext } from '#/agent/profile/profile';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { IAgentToolSelectService } from '#/agent/toolSelect/toolSelect';
+import { IAgentVideoResolverService } from '#/agent/media/videoResolver';
 import { IAgentUsageService } from '#/agent/usage/usage';
 import { IConfigService } from '#/app/config/config';
 import { IEventBus } from '#/app/event/eventBus';
@@ -149,6 +154,7 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
     @IAgentContextSizeService private readonly contextSize: IAgentContextSizeService,
     @IAgentToolRegistryService private readonly tools: IAgentToolRegistryService,
     @IAgentToolSelectService private readonly toolSelect: IAgentToolSelectService,
+    @IAgentVideoResolverService private readonly videoResolver: IAgentVideoResolverService,
     @IAgentProfileService private readonly profile: IAgentProfileService,
     @IAgentUsageService private readonly usage: IAgentUsageService,
     @IConfigService private readonly config: IConfigService,
@@ -299,7 +305,15 @@ export class AgentLLMRequesterService implements IAgentLLMRequesterService {
 
     const run = async (projection: RequestProjection): Promise<AgentLLMRequestFinish> => {
       onRequestTrace(undefined);
-      const input = requestInput(projection);
+      const projected = requestInput(projection);
+      const input = {
+        ...projected,
+        messages: await this.videoResolver.resolve(
+          projected.messages,
+          request.requester,
+          signal,
+        ),
+      };
       const fields =
         projection === 'normal'
           ? request.logFields
diff --git a/packages/agent-core-v2/src/agent/media/kimiFileUrl.ts b/packages/agent-core-v2/src/agent/media/kimiFileUrl.ts
new file mode 100644
index 0000000000..567eeb086d
--- /dev/null
+++ b/packages/agent-core-v2/src/agent/media/kimiFileUrl.ts
@@ -0,0 +1,50 @@
+/**
+ * `media` domain (L4) — the `kimi-file://` internal video reference.
+ *
+ * A prompt video uploaded to `/files` enters context memory as a `video_url`
+ * part carrying `kimi-file://<fileId>?path=<encoded absolute path>`: `fileId`
+ * addresses the daemon upload the request-time resolver reads bytes from, and
+ * the optional `?path=` names the edge-materialized copy the model opens with
+ * `ReadMediaFile` when the video cannot be uploaded or inlined. The reference
+ * never reaches the provider wire — the resolver rewrites it first. Pure
+ * helpers; no scoped service.
+ */
+
+const KIMI_FILE_SCHEME = 'kimi-file://';
+const PATH_QUERY = '?path=';
+
+export interface KimiFileRef {
+  readonly fileId: string;
+  readonly path?: string;
+}
+
+export function isKimiFileUrl(url: string): boolean {
+  return url.startsWith(KIMI_FILE_SCHEME);
+}
+
+export function buildKimiFileUrl(fileId: string, path?: string): string {
+  const base = `${KIMI_FILE_SCHEME}${fileId}`;
+  return path === undefined || path.length === 0
+    ? base
+    : `${base}${PATH_QUERY}${encodeURIComponent(path)}`;
+}
+
+export function parseKimiFileUrl(url: string): KimiFileRef | undefined {
+  if (!url.startsWith(KIMI_FILE_SCHEME)) return undefined;
+  const rest = url.slice(KIMI_FILE_SCHEME.length);
+  const queryAt = rest.indexOf(PATH_QUERY);
+  if (queryAt === -1) {
+    return rest.length > 0 ? { fileId: rest } : undefined;
+  }
+  const fileId = rest.slice(0, queryAt);
+  if (fileId.length === 0) return undefined;
+  const encoded = rest.slice(queryAt + PATH_QUERY.length);
+  if (encoded.length === 0) return { fileId };
+  let path: string;
+  try {
+    path = decodeURIComponent(encoded);
+  } catch {
+    return { fileId };
+  }
+  return { fileId, path };
+}
diff --git a/packages/agent-core-v2/src/agent/media/registerMediaTools.ts b/packages/agent-core-v2/src/agent/media/registerMediaTools.ts
index 80d633cad2..10f57281f8 100644
--- a/packages/agent-core-v2/src/agent/media/registerMediaTools.ts
+++ b/packages/agent-core-v2/src/agent/media/registerMediaTools.ts
@@ -62,9 +62,9 @@ export function createVideoUploader(
   const uploadVideo = requester?.uploadVideo;
   if (uploadVideo === undefined) return undefined;
   const bound = uploadVideo.bind(requester);
-  if (telemetry === undefined) return (input) => bound(input);
+  if (telemetry === undefined) return (input, options) => bound(input, options);
 
-  return async (input) => {
+  return async (input, options) => {
     const startedAt = Date.now();
     const base = {
       ...telemetry.props,
@@ -78,7 +78,7 @@ export function createVideoUploader(
       }
     };
     try {
-      const part = await bound(input);
+      const part = await bound(input, options);
       track({ ...base, outcome: 'success', duration_ms: Date.now() - startedAt });
       return part;
     } catch (error) {
diff --git a/packages/agent-core-v2/src/agent/media/tools/read-media.ts b/packages/agent-core-v2/src/agent/media/tools/read-media.ts
index 68d4508fb0..5d4d79f0a5 100644
--- a/packages/agent-core-v2/src/agent/media/tools/read-media.ts
+++ b/packages/agent-core-v2/src/agent/media/tools/read-media.ts
@@ -49,7 +49,7 @@ import type { ModelCapability } from '#/kosong/contract/capability';
 import type { ContentPart, VideoURLPart } from '#/kosong/contract/message';
 import type { VideoUploadInput as ProviderVideoUploadInput } from '#/kosong/contract/provider';
 import { VideoUploadUnsupportedError } from '#/kosong/contract/errors';
-import { ProtocolErrors } from '#/kosong/protocol/errors';
+import { inlineVideoPart, isVideoUploadAuthError } from '#/agent/media/videoUpload';
 import type { ITelemetryService } from '#/app/telemetry/telemetry';
 import { z } from 'zod';
 
@@ -93,7 +93,10 @@ const MAX_MEDIA_BYTES = MAX_MEDIA_MEGABYTES * 1024 * 1024;
 
 export type VideoUploadInput = ProviderVideoUploadInput;
 
-export type VideoUploader = (input: VideoUploadInput) => Promise<VideoURLPart>;
+export type VideoUploader = (
+  input: VideoUploadInput,
+  options?: { readonly signal?: AbortSignal },
+) => Promise<VideoURLPart>;
 
 
 export const ReadMediaFileInputSchema = z.object({
@@ -257,10 +260,7 @@ function shouldSurfaceVideoUploadError(error: unknown, inlineVideoSupported: boo
   // that convert video_url (kimi, anthropic, google-genai, …) take the
   // inline fallback instead.
   if (error instanceof VideoUploadUnsupportedError) return !inlineVideoSupported;
-  if (typeof error !== 'object' || error === null) return false;
-  if ((error as { code?: unknown }).code === ProtocolErrors.codes.PROVIDER_AUTH_ERROR) return true;
-  const statusCode = (error as { statusCode?: unknown }).statusCode;
-  return statusCode === 401 || statusCode === 403;
+  return isVideoUploadAuthError(error);
 }
 
 export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
@@ -301,11 +301,7 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
         // Fall through to the inline form.
       }
     }
-    const base64 = data.toString('base64');
-    return {
-      type: 'video_url',
-      videoUrl: { url: `data:${mimeType};base64,${base64}` },
-    };
+    return inlineVideoPart(data, mimeType);
   }
 
   resolveExecution(args: ReadMediaFileInput): ToolExecution {
diff --git a/packages/agent-core-v2/src/agent/media/videoResolver.ts b/packages/agent-core-v2/src/agent/media/videoResolver.ts
new file mode 100644
index 0000000000..9a279f35ef
--- /dev/null
+++ b/packages/agent-core-v2/src/agent/media/videoResolver.ts
@@ -0,0 +1,27 @@
+/**
+ * `media` domain (L4) — request-time video reference resolver contract.
+ *
+ * Rewrites the `kimi-file://` video references a prompt carries in the
+ * projected wire messages into a provider-acceptable form (an uploaded
+ * `ms://` reference, an inline base64 `data:` part, or a `<video path>` text
+ * tag) right before the messages reach the provider — so a `kimi-file://` url
+ * never touches the wire. Bound at Agent scope.
+ */
+
+import { createDecorator } from '#/_base/di/instantiation';
+import type { Message } from '#/kosong/contract/message';
+import type { ModelRequester } from '#/kosong/model/modelRequester';
+
+export interface IAgentVideoResolverService {
+  readonly _serviceBrand: undefined;
+
+  resolve(
+    messages: readonly Message[],
+    requester: ModelRequester,
+    signal?: AbortSignal,
+  ): Promise<readonly Message[]>;
+}
+
+export const IAgentVideoResolverService = createDecorator<IAgentVideoResolverService>(
+  'agentVideoResolverService',
+);
diff --git a/packages/agent-core-v2/src/agent/media/videoResolverService.ts b/packages/agent-core-v2/src/agent/media/videoResolverService.ts
new file mode 100644
index 0000000000000000000000000000000000000000..68cf41ea2db7c0561fd4f553a2ef331b19c78fbf
GIT binary patch
literal 7674
zcmb_h+j1Mn5zRBdqV1@Jg$i7#QjRNuL@E?TmKjU7ilmf_N&$wu17NMiF1$0K48yF-
zQ$8S-FU*(ZbkEFQ0FVz!_`m{YrhEE&rn@nG^5lS?&}5<0Oid^)7b+_#di_<O{{8oV
z(d6P}rVIN%OLcjvO_|^7>PlC)S)wPDEta`nU|ZR&EMo9sR{oeFt&%xSK4pvSaGK?M
zG#pOomKjl{r@GQbq6v4|xu#`R{-6`9Q~I1$nikp^HPeRK*^(6RGi7zCl0+}9y2(MK
zDoa&1n_Ifk(-LINsnS2Lw6T<Hb*l|wU6z?G3kc~{YGi4(%uAKx%A2*tNjtB~)od<X
z6PC9z#^mB0--Fuy0Xb49-dry_v^V9dNNG`~I`0{pyx|X*PAFZ)j#A7yq3Cm^mP<$g
zDOt9OSZD0cOvq}suC3NJ|4CA5WwnsMbK+MM$fI!MQdcH3R&*0)5i2pMO$UGe<DZo0
z3)bZ#ozMbzXT_{$&eogU<mJtkg)t}0gRO1M;Zj+vtAY$~kSWDRPD+}y28E%Ly{VF_
zGzR{%tEzzZ#_FXRFsBN7WZF1UCDslros@{CHTJyw5kw}YbCu_YZdCF~d|x0&@~qHU
zG5YJT+IFgP*bua~OiGa0xw4d~3M@0*CwN}b<hj@s!D8pfY|@`BSv8{w+A=Hg6YEn@
zDSEIKbUM?A3mCe}RG$3|2PNfljnK4+XAYn@oGfg|N&gwCm7O!Ismk(Ig-9~1YN}uj
zXQ(x$Rd%Zhu1k?B;K<>Rb8{#L1F4kCDV$+Gu`?9ZOqrW4Kj|W-ml93TOVW@G1d%u%
z9vmS1N@T!>IYZWO6gb||v?>?WD-d;~q*^a+*?ZPHdVw1i3&9C{y<X~?;@8758+e#z
zL)Zu&WoLl4zU6f`)yX<R9<U4pC^1900S)+T>XTz1JCV7~shv$N0tC{KLstHIejT#w
zkPo|;F>ReL&8LRkvaTCCEeq&o-vT-Y^v0n~ON39QDT~=K!Kq3mcIa_vhfO!BcNs`j
z4ds8G`VEr}UAzow)}r+Z%&<7jAf^P-uue$OH_k}41zd6jvJ;`o*{h3_@zr-1=jY>>
zf4M%ps`<uZ&O_F}ErHnMTR=1OxYW}DWhQ)mSLJ{WRT<q{X)$C(XEK~?v)qGCEus)E
zk~-HV^0h^KKt9O@*~B~DrK{DFgI%ZRW%br4Ja7d<x3KU8iFj63Wwo>Ot}uatKM)cn
z9tu7<Fl|Xh_rH5BrGz#-i=aM0<lyZ&Jvsg6Y<zY4{o6A-qMn>Oba;7~;8A2xxRY-$
zzkh%6>g;lS@oId@hlhXraB}!pb@=ns!{2{wKE~t2k53*A0~ynNKYsV!$@`Ow*C#Ju
zpN+52{(MbGut@KNTu0?118AqC7FP2^1Gm9wRFsq>(lsFR7O=(d>BmNXM#-}x0ftl%
zsnDP4x><?(K?*+h3LxG+=2!UGf&NJ#D#;aIg?kH$rj9TVnSBH8QVm{sgMfHxS>$UP
z8&{0Htndbo2v4t`;;~3^IpOKcZh?%=X`n7wFsaw-jaoi8c$bRVpp6X2B0B-};mm54
z;MI%3jpz>@<l5oR#x)~qAL2-4x+dRus5rrysy-5EcHnM@v_?FTZ=Yr^ecIfy9h6xY
z39KN>J5@r3HEN9G;qb#pCx9=cbTy(b+_`O&%?g#j7}3cM67x#F$(<uYf-W+npVv;R
zIUf@{5otT6=!+miY|4d>=Bmb@_go_~2=x1qj!TKUAQZO}iaR{?bA<qAS58%K^fO`X
zvZ`EJ2<_1Q!$+L>@X>8^H5j=w{&snL-AMy;2@@~hK8Yev2Fb!%B3u_QS7u&sy31Hm
z+-0+3<)tIK^A|W7co(nHs2zMAc}eP5FEJ3=w#1D+bz2h07UhLN0Smx?Oc)E`9~}ia
z8m|D}^kN6*BRMP(0(g&cs!yG?ax9%@kliURH-dMaevY#Rsrsxklw9-7#6AGovk@q`
zgpgWYR|9h4)CXv|3xc6)+iob1V{iR|*cG?aT}{x015(!8+cEJW6b`&#e?c(M%kYho
zB_X{!*&@P<Optg);X%BF_<q%^@KBa?l7xO~%(Rs-r%iPdGR1jRDhb4KZLnBYoUz=I
zrSFiw)oUD-?KrG)jX*D6G^<iDx2fe-a-@?-8>kvHm|diIzk0L@T(EsN@d@a~(u-0u
zu<hP7o@pBehTcD%@C$ePi*}r}5}a9exN{^zmE8b(R|xlXCy2tObvQW{yV9AKbW-M6
zFQbnWzV_jmsPF&p<042pLW?BtkFat{@IOb3v(D?#>22FkrKenjq^{=K=c#Q5TQ1v(
zuoSR)LyRpWU*`z03|yZN1R0^|28fI>U@#Z}JlbsWzMG)(#KXO{j2i3CIZsm4A-?qK
zBYL@-VtU|q`61v)Ez|-MI9s|MZkvOkE?TAb>BN&f*b=Ty#Mgl0rUKzSzhzez{}&Nc
z#kh(;H-HtSfVJfS8g~`5SY8ciXfX~6BKcrLE6P#qFZH@M;!5Hkq3UT@`yv2y9=ORx
zY*sgDdeu65x~CDqbf72wcCVF+EFtrb(Q~H6?sY|Kug=G=U_RZmg;04Fg~7tFbu#xs
zxN>hlPetNHE!9nyXBLxzSl*m*Ry-(z8wJ$e03>lMQZm%bttKI=kx(!XHjv<T3b~S8
zirhWT3mj8FPr+?Tp2>qPkW!al?kV7Uvs|K-3x~-8E}k0ER$S&&N6xaw)z~FZEv77r
z-**5zTqDGyPGF6T<$E}B=RSnjkxky{+Qr`>tPjX-1HWh+SRO;kivb14b9vAW79YjC
z3Ft-OlFfm7kSW?ws;nBhcy4$P>fENg0f5BeWBbvUcB`IgfpNIQg%g)BSt?JTIhP0R
z9JMJ{gE`XX98jvxeKuIbbqoGl57Or<vwAO@4w^|@&DEPYi1<um;m!j?q`7l#ia8cx
ze|PIo_EA(-<!2H)$IBJ29jfilw<ZpLuVMWE;Q6M$y$9azskH8SkpiIio0h^Me7l6|
z7D^mOb$CgVN_!<3-|EVNoankx&@``KA7})Cj-oyt9XAzP3p5??ZuSJ1Hf<-DuMS<B
z06LPnqi>93^svB#h}n7Wo=bNa5MwB9n<(s~q;5EFmE?Qs*ZV^=n6(w6VX0;5+cHao
zZ3VI)mM);S3&d86IQuVGHhS3p1F?~xI>Z=)v5jhl`@uaPKexQ(;7+W0cK~BdS4F}T
zPE4nFyUNg})h!~lzQI6Bt3sgLd&Bn!q0Mq#s$4HUl7tD@iu*gO$B(-MwLN_m3k{Lm
z;(8$M^cj%uwCM{(LiPt&EIiaE?&+Go>z7|pmbsl6WzozZcp8AkD_7TSJj3ZZ+mGm;
zv656`+)F)3+@7=_efemk4W4&>Vo~4TtgNmD?%#cR{M=35FpvlDwgDE~FwLc-OM2L0
zH~VXId;$1IQ3ijQKVeKC^`zYFH4}u|L>!?mLGd!cbWE4y=d3{D%_hO*70%LN%VT<q
zJOp7U0oxjE151#)5ucIQGj1mLQP0fPZ+`oAuaBRI01di9rZ~;;Q<#l<bNv$+ak$O3
zsCAULic?pYj_5n2&mXViOO&lV+`E!;6*9c_vl&-Jy99UENam~J6RH=t(;7qY(8MLQ
zA4JGWo<z9ILTEV#ZXn>8#QbAK<c=%;HHcdsfcHC$w|{rSC9A8STe0N{Arj!&k(#X}
z*$%8*m9OgJf3KP41guVk8N@QjZ!;%(9`zn0@OzKdV)?As-`)LEc7I%zcJKCc+0OTG
z9?Ry8H^pCJ_}%%fga>imA5~%*kuomaKYixidnc(vilJraC!Y9~&ed9{yy;tk!2#s@
E4~r4}Y5)KL

literal 0
HcmV?d00001

diff --git a/packages/agent-core-v2/src/agent/media/videoUpload.ts b/packages/agent-core-v2/src/agent/media/videoUpload.ts
new file mode 100644
index 0000000000..e10e3a1fe7
--- /dev/null
+++ b/packages/agent-core-v2/src/agent/media/videoUpload.ts
@@ -0,0 +1,35 @@
+/**
+ * `media` domain (L4) — shared video-upload fallback helpers.
+ *
+ * The provider video-upload attempt and its graceful fallbacks run in two
+ * places — the `ReadMediaFile` tool (a model tool call) and the request-time
+ * video resolver (a prompt's `kimi-file://` part) — and must agree on which
+ * failures are auth failures (surfaced, never masked into a fallback) and
+ * which protocols carry inline `video_url` on the wire. Pure helpers; no
+ * scoped service.
+ */
+
+import { VideoUploadUnsupportedError } from '#/kosong/contract/errors';
+import type { VideoURLPart } from '#/kosong/contract/message';
+import type { Protocol } from '#/kosong/protocol/protocol';
+import { ProtocolErrors } from '#/kosong/protocol/errors';
+
+export function isVideoUploadAuthError(error: unknown): boolean {
+  if (typeof error !== 'object' || error === null) return false;
+  if ((error as { code?: unknown }).code === ProtocolErrors.codes.PROVIDER_AUTH_ERROR) return true;
+  const statusCode = (error as { statusCode?: unknown }).statusCode;
+  return statusCode === 401 || statusCode === 403;
+}
+
+export function isVideoUploadUnsupportedError(error: unknown): error is VideoUploadUnsupportedError {
+  return error instanceof VideoUploadUnsupportedError;
+}
+
+export function inlineVideoSupportedForProtocol(protocol: Protocol): boolean {
+  return protocol !== 'openai' && protocol !== 'openai_responses';
+}
+
+export function inlineVideoPart(data: Uint8Array, mimeType: string): VideoURLPart {
+  const base64 = Buffer.from(data).toString('base64');
+  return { type: 'video_url', videoUrl: { url: `data:${mimeType};base64,${base64}` } };
+}
diff --git a/packages/agent-core-v2/src/index.ts b/packages/agent-core-v2/src/index.ts
index 219c55a51c..6f833e0b32 100644
--- a/packages/agent-core-v2/src/index.ts
+++ b/packages/agent-core-v2/src/index.ts
@@ -428,6 +428,10 @@ export * from '#/agent/mcp/config-schema';
 export * from '#/agent/media/mediaTools';
 export * from '#/agent/media/mediaToolsRegistrar';
 export * from '#/agent/media/registerMediaTools';
+export * from '#/agent/media/kimiFileUrl';
+export * from '#/agent/media/videoUpload';
+export * from '#/agent/media/videoResolver';
+export * from '#/agent/media/videoResolverService';
 import '#/agent/media/configSection';
 export * from '#/agent/media/imageConfigBridge';
 import '#/agent/permissionMode/configSection';
diff --git a/packages/agent-core-v2/test/agent/llmRequester/llmRequesterService.test.ts b/packages/agent-core-v2/test/agent/llmRequester/llmRequesterService.test.ts
index 53307d2623..a91ddfb3df 100644
--- a/packages/agent-core-v2/test/agent/llmRequester/llmRequesterService.test.ts
+++ b/packages/agent-core-v2/test/agent/llmRequester/llmRequesterService.test.ts
@@ -32,6 +32,7 @@ import { IAgentContextSizeService } from '#/agent/contextSize/contextSize';
 import { IAgentProfileService } from '#/agent/profile/profile';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { IAgentToolSelectService } from '#/agent/toolSelect/toolSelect';
+import { IAgentVideoResolverService } from '#/agent/media/videoResolver';
 import { IAgentUsageService } from '#/agent/usage/usage';
 import { IConfigService } from '#/app/config/config';
 import { type DomainEvent, IEventBus } from '#/app/event/eventBus';
@@ -194,6 +195,7 @@ function createService(
 
   ix.stub(IAgentContextMemoryService, context);
   ix.stub(IAgentToolSelectService, toolSelect);
+  ix.stub(IAgentVideoResolverService, { resolve: async (messages) => messages });
   if (projector === undefined) {
     ix.set(
       IAgentContextProjectorService,
diff --git a/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts b/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts
index adbdfe43a2..0e5a0b7c2a 100644
--- a/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts
+++ b/packages/agent-core-v2/test/agent/media/tools/read-media.test.ts
@@ -936,7 +936,7 @@ describe('createVideoUploader', () => {
     const uploadVideo = vi.fn().mockResolvedValue(uploadResult);
     const uploader = createVideoUploader(modelWith(uploadVideo));
     await expect(uploader!(input)).resolves.toEqual(uploadResult);
-    expect(uploadVideo).toHaveBeenCalledWith(input);
+    expect(uploadVideo).toHaveBeenCalledWith(input, undefined);
   });
 
   it('reports video_upload telemetry on success', async () => {
diff --git a/packages/agent-core-v2/test/agent/media/videoResolver.test.ts b/packages/agent-core-v2/test/agent/media/videoResolver.test.ts
new file mode 100644
index 0000000000..c89d6e2083
--- /dev/null
+++ b/packages/agent-core-v2/test/agent/media/videoResolver.test.ts
@@ -0,0 +1,257 @@
+import { Readable } from 'node:stream';
+
+import { describe, expect, it, vi } from 'vitest';
+
+import { buildKimiFileUrl, parseKimiFileUrl } from '#/agent/media/kimiFileUrl';
+import { AgentVideoResolverService } from '#/agent/media/videoResolverService';
+import type { GetResult, IFileService } from '#/app/file/fileService';
+import type { ITelemetryService } from '#/app/telemetry/telemetry';
+import type { ModelCapability } from '#/kosong/contract/capability';
+import type { Message, VideoURLPart } from '#/kosong/contract/message';
+import type { ModelRequester } from '#/kosong/model/modelRequester';
+import type { Protocol } from '#/kosong/protocol/protocol';
+import type { IBlobStore } from '#/persistence/interface/blobStore';
+
+const FILE_ID = 'file_abc';
+const FALLBACK_PATH = '/cache/file_abc.mp4';
+const VIDEO_BYTES = Buffer.from('tiny fake mp4 bytes');
+const PNG_BYTES = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00]);
+
+function videoMessage(url: string): Message {
+  return { role: 'user', content: [{ type: 'video_url', videoUrl: { url } }], toolCalls: [] };
+}
+
+function firstPart(messages: readonly Message[]) {
+  return messages[0]!.content[0]!;
+}
+
+function fileService(files: Map<string, { name: string; bytes: Buffer }>): IFileService {
+  return {
+    _serviceBrand: undefined,
+    save: async () => {
+      throw new Error('unused');
+    },
+    delete: async () => {},
+    get: async (fileId): Promise<GetResult> => {
+      const file = files.get(fileId);
+      if (file === undefined) throw new Error(`file not found: ${fileId}`);
+      return {
+        meta: {
+          id: fileId,
+          name: file.name,
+          media_type: 'video/mp4',
+          size: file.bytes.length,
+          created_at: new Date(0).toISOString(),
+        },
+        stream: () => Readable.from([file.bytes]),
+      };
+    },
+  };
+}
+
+function blobStore(): IBlobStore {
+  const data = new Map<string, Uint8Array>();
+  return {
+    _serviceBrand: undefined,
+    put: async (scope, key, bytes) => {
+      data.set(`${scope}/${key}`, bytes);
+    },
+    get: async (scope, key) => data.get(`${scope}/${key}`),
+    getStream: async function* () {},
+    has: async (scope, key) => data.has(`${scope}/${key}`),
+    delete: async (scope, key) => {
+      data.delete(`${scope}/${key}`);
+    },
+    list: async () => [],
+  };
+}
+
+const telemetry = { track2: () => {} } as unknown as ITelemetryService;
+
+function requester(opts: {
+  videoIn?: boolean;
+  protocol?: Protocol;
+  providerType?: string;
+  uploadVideo?: ModelRequester['uploadVideo'];
+}): ModelRequester {
+  return {
+    model: {
+      id: 'm',
+      name: 'stub',
+      aliases: [],
+      protocol: opts.protocol ?? 'openai',
+      headers: {},
+      capabilities: { video_in: opts.videoIn ?? true } as unknown as ModelCapability,
+      maxContextSize: 1000,
+      alwaysThinking: false,
+      providerName: 'p',
+      providerType: opts.providerType ?? 'kimi',
+      authProvider: {} as never,
+    },
+    request: () => {
+      throw new Error('unused');
+    },
+    uploadVideo: opts.uploadVideo,
+  };
+}
+
+function msPart(id: string): VideoURLPart {
+  return { type: 'video_url', videoUrl: { url: `ms://${id}`, id } };
+}
+
+describe('kimiFileUrl', () => {
+  it('round-trips a file id and an escaped materialization path', () => {
+    const url = buildKimiFileUrl('file_1', '/a b/clip.mp4');
+    expect(url).toBe(`kimi-file://file_1?path=${encodeURIComponent('/a b/clip.mp4')}`);
+    expect(parseKimiFileUrl(url)).toEqual({ fileId: 'file_1', path: '/a b/clip.mp4' });
+  });
+
+  it('omits the query when no path is given', () => {
+    expect(buildKimiFileUrl('file_1')).toBe('kimi-file://file_1');
+    expect(parseKimiFileUrl('kimi-file://file_1')).toEqual({ fileId: 'file_1' });
+  });
+
+  it('returns undefined for any non-kimi-file url', () => {
+    expect(parseKimiFileUrl('ms://prov-1')).toBeUndefined();
+    expect(parseKimiFileUrl('data:video/mp4;base64,AAAA')).toBeUndefined();
+    expect(parseKimiFileUrl('https://example.com/clip.mp4')).toBeUndefined();
+  });
+});
+
+describe('AgentVideoResolverService', () => {
+  it('uploads a kimi-file video once and reuses the cached reference on later steps', async () => {
+    const upload = vi.fn(async (): Promise<VideoURLPart> => msPart('prov-1'));
+    const resolver = new AgentVideoResolverService(
+      fileService(new Map([[FILE_ID, { name: 'clip.mp4', bytes: VIDEO_BYTES }]])),
+      blobStore(),
+      telemetry,
+    );
+    const req = requester({ uploadVideo: upload });
+    const message = videoMessage(buildKimiFileUrl(FILE_ID, FALLBACK_PATH));
+
+    const first = await resolver.resolve([message], req);
+    const second = await resolver.resolve([message], req);
+
+    expect(firstPart(first)).toEqual(msPart('prov-1'));
+    expect(firstPart(second)).toEqual(msPart('prov-1'));
+    expect(upload).toHaveBeenCalledTimes(1);
+  });
+
+  it('reuses a persisted upload across resolver instances without re-uploading', async () => {
+    const files = new Map([[FILE_ID, { name: 'clip.mp4', bytes: VIDEO_BYTES }]]);
+    const blobs = blobStore();
+    const message = videoMessage(buildKimiFileUrl(FILE_ID, FALLBACK_PATH));
+
+    const upload1 = vi.fn(async (): Promise<VideoURLPart> => msPart('prov-1'));
+    await new AgentVideoResolverService(fileService(files), blobs, telemetry).resolve(
+      [message],
+      requester({ uploadVideo: upload1 }),
+    );
+
+    const upload2 = vi.fn(async (): Promise<VideoURLPart> => msPart('prov-2'));
+    const out = await new AgentVideoResolverService(fileService(files), blobs, telemetry).resolve(
+      [message],
+      requester({ uploadVideo: upload2 }),
+    );
+
+    expect(firstPart(out)).toEqual(msPart('prov-1'));
+    expect(upload1).toHaveBeenCalledTimes(1);
+    expect(upload2).not.toHaveBeenCalled();
+  });
+
+  it('falls back to a path tag when the model cannot ingest video', async () => {
+    const upload = vi.fn();
+    const out = await new AgentVideoResolverService(
+      fileService(new Map([[FILE_ID, { name: 'clip.mp4', bytes: VIDEO_BYTES }]])),
+      blobStore(),
+      telemetry,
+    ).resolve([videoMessage(buildKimiFileUrl(FILE_ID, FALLBACK_PATH))], requester({ videoIn: false, uploadVideo: upload }));
+
+    expect(firstPart(out)).toEqual({ type: 'text', text: `<video path="${FALLBACK_PATH}"></video>` });
+    expect(upload).not.toHaveBeenCalled();
+  });
+
+  it('inlines base64 for a no-upload provider whose wire carries video', async () => {
+    const out = await new AgentVideoResolverService(
+      fileService(new Map([[FILE_ID, { name: 'clip.mp4', bytes: VIDEO_BYTES }]])),
+      blobStore(),
+      telemetry,
+    ).resolve([videoMessage(buildKimiFileUrl(FILE_ID, FALLBACK_PATH))], requester({ protocol: 'anthropic', uploadVideo: undefined }));
+
+    expect(firstPart(out)).toEqual({
+      type: 'video_url',
+      videoUrl: { url: `data:video/mp4;base64,${VIDEO_BYTES.toString('base64')}` },
+    });
+  });
+
+  it('tags for a no-upload provider whose wire drops inline video (openai family)', async () => {
+    const out = await new AgentVideoResolverService(
+      fileService(new Map([[FILE_ID, { name: 'clip.mp4', bytes: VIDEO_BYTES }]])),
+      blobStore(),
+      telemetry,
+    ).resolve([videoMessage(buildKimiFileUrl(FILE_ID, FALLBACK_PATH))], requester({ protocol: 'openai', uploadVideo: undefined }));
+
+    expect(firstPart(out)).toEqual({ type: 'text', text: `<video path="${FALLBACK_PATH}"></video>` });
+  });
+
+  it('rethrows an auth failure so it can drive credential refresh', async () => {
+    const upload = vi.fn(async () => {
+      throw Object.assign(new Error('unauthorized'), { statusCode: 401 });
+    });
+    const resolver = new AgentVideoResolverService(
+      fileService(new Map([[FILE_ID, { name: 'clip.mp4', bytes: VIDEO_BYTES }]])),
+      blobStore(),
+      telemetry,
+    );
+
+    await expect(
+      resolver.resolve([videoMessage(buildKimiFileUrl(FILE_ID, FALLBACK_PATH))], requester({ uploadVideo: upload })),
+    ).rejects.toThrow('unauthorized');
+  });
+
+  it('tags when the bytes do not sniff as a video', async () => {
+    const upload = vi.fn();
+    const out = await new AgentVideoResolverService(
+      fileService(new Map([[FILE_ID, { name: 'clip.mp4', bytes: PNG_BYTES }]])),
+      blobStore(),
+      telemetry,
+    ).resolve([videoMessage(buildKimiFileUrl(FILE_ID, FALLBACK_PATH))], requester({ uploadVideo: upload }));
+
+    expect(firstPart(out)).toEqual({ type: 'text', text: `<video path="${FALLBACK_PATH}"></video>` });
+    expect(upload).not.toHaveBeenCalled();
+  });
+
+  it('tags a stale reference by its materialization path', async () => {
+    const out = await new AgentVideoResolverService(fileService(new Map()), blobStore(), telemetry).resolve(
+      [videoMessage(buildKimiFileUrl('missing', FALLBACK_PATH))],
+      requester({ uploadVideo: vi.fn() }),
+    );
+
+    expect(firstPart(out)).toEqual({ type: 'text', text: `<video path="${FALLBACK_PATH}"></video>` });
+  });
+
+  it('emits an unavailable placeholder when a stale reference has no fallback path', async () => {
+    const out = await new AgentVideoResolverService(fileService(new Map()), blobStore(), telemetry).resolve(
+      [videoMessage(buildKimiFileUrl('missing'))],
+      requester({ uploadVideo: vi.fn() }),
+    );
+
+    expect(firstPart(out)).toEqual({
+      type: 'text',
+      text: '[video omitted: the uploaded file is no longer available]',
+    });
+  });
+
+  it('leaves messages without a kimi-file video untouched', async () => {
+    const resolver = new AgentVideoResolverService(
+      fileService(new Map([[FILE_ID, { name: 'clip.mp4', bytes: VIDEO_BYTES }]])),
+      blobStore(),
+      telemetry,
+    );
+    const messages = [videoMessage('ms://already-uploaded')];
+
+    const out = await resolver.resolve(messages, requester({ uploadVideo: vi.fn() }));
+
+    expect(out).toBe(messages);
+  });
+});
diff --git a/packages/agent-core-v2/test/app/messageLegacy/messageLegacy.test.ts b/packages/agent-core-v2/test/app/messageLegacy/messageLegacy.test.ts
index 1e6655169a..eb102235dd 100644
--- a/packages/agent-core-v2/test/app/messageLegacy/messageLegacy.test.ts
+++ b/packages/agent-core-v2/test/app/messageLegacy/messageLegacy.test.ts
@@ -178,6 +178,54 @@ describe('MessageLegacyService', () => {
     });
   });
 
+  it('projects a kimi-file video reference to a structured file source without leaking the path', async () => {
+    const videoPart = {
+      type: 'video_url',
+      videoUrl: { url: 'kimi-file://file_9?path=%2Fcache%2Fclip.mp4' },
+    } as unknown as ContentPart;
+    const svc = buildService({
+      summary,
+      records: [
+        {
+          type: 'context.append_message',
+          message: { role: 'user', content: [videoPart], toolCalls: [] },
+        },
+      ],
+      contextMessages: [],
+    });
+
+    const page = await svc.list('s1', {});
+
+    expect(page.items[0]?.content[0]).toEqual({
+      type: 'video',
+      source: { kind: 'file', file_id: 'file_9' },
+    });
+  });
+
+  it('projects a provider video url to a structured url source carrying its id', async () => {
+    const videoPart = {
+      type: 'video_url',
+      videoUrl: { url: 'ms://prov-7', id: 'prov-7' },
+    } as unknown as ContentPart;
+    const svc = buildService({
+      summary,
+      records: [
+        {
+          type: 'context.append_message',
+          message: { role: 'user', content: [videoPart], toolCalls: [] },
+        },
+      ],
+      contextMessages: [],
+    });
+
+    const page = await svc.list('s1', {});
+
+    expect(page.items[0]?.content[0]).toEqual({
+      type: 'video',
+      source: { kind: 'url', url: 'ms://prov-7', id: 'prov-7' },
+    });
+  });
+
   it('passes media tool results through as raw content parts instead of flattening', async () => {
     const mediaPart = {
       type: 'image_url',
diff --git a/packages/agent-core/src/agent/index.ts b/packages/agent-core/src/agent/index.ts
index bb7a52bfe1..cc57dc1462 100644
--- a/packages/agent-core/src/agent/index.ts
+++ b/packages/agent-core/src/agent/index.ts
@@ -6,7 +6,7 @@ import { ErrorCodes, KimiError, makeErrorPayload } from '#/errors';
 import { log } from '#/logging/logger';
 import type { Logger } from '#/logging/types';
 import type { AgentAPI, AgentEvent, KimiConfig, SDKAgentRPC, UsageStatus } from '#/rpc';
-import { generate, type ChatProvider, type VideoURLPart } from '@moonshot-ai/kosong';
+import { generate, type ChatProvider } from '@moonshot-ai/kosong';
 
 import type { EnabledPluginSessionStart, PluginCommandDef } from '#/plugin';
 import { expandCommandArguments } from '../plugin/commands';
@@ -15,8 +15,6 @@ import type { PluginCommandOrigin } from './context';
 import type { McpConnectionManager } from '../mcp';
 import { FlagResolver, type ExperimentalFlagResolver } from '../flags';
 import { ImageLimits } from '../tools/support/image-limits';
-import { MAX_MEDIA_BYTES } from '../tools/builtin/file/read-media';
-import { MEDIA_SNIFF_BYTES, detectFileType } from '../tools/support/file-type';
 import {
   prepareSystemPromptContext,
   type PreparedSystemPromptContext,
@@ -498,61 +496,11 @@ export class Agent {
     return result;
   }
 
-  /**
-   * Upload a local video file through the bound provider's video upload
-   * channel and return the provider-issued `video_url` part. This is the
-   * transport for videos attached directly to a prompt; videos the model
-   * reads itself keep flowing through ReadMediaFile.
-   */
-  async uploadVideo(path: string): Promise<VideoURLPart> {
-    if (!this.config.modelCapabilities.video_in) {
-      throw new KimiError(
-        ErrorCodes.REQUEST_INVALID,
-        'The current model does not support video input.',
-      );
-    }
-    const uploader = this.tools.videoUploader();
-    if (uploader === undefined) {
-      throw new KimiError(
-        ErrorCodes.REQUEST_INVALID,
-        'The current model does not support video upload.',
-      );
-    }
-    // The trimmed copy is only the emptiness check — the path itself is used
-    // verbatim so a name that legitimately starts or ends with whitespace
-    // still resolves to the same file.
-    if (path.trim().length === 0) {
-      throw new KimiError(ErrorCodes.REQUEST_INVALID, 'Video path cannot be empty.');
-    }
-    const header = await this.kaos.readBytes(path, MEDIA_SNIFF_BYTES);
-    const fileType = detectFileType(path, header, 'media');
-    if (fileType.kind !== 'video') {
-      throw new KimiError(ErrorCodes.REQUEST_INVALID, `"${path}" is not a video file.`);
-    }
-    const stat = await this.kaos.stat(path);
-    if (stat.stSize === 0) {
-      throw new KimiError(ErrorCodes.REQUEST_INVALID, `"${path}" is empty.`);
-    }
-    if (stat.stSize > MAX_MEDIA_BYTES) {
-      throw new KimiError(
-        ErrorCodes.REQUEST_INVALID,
-        `"${path}" is ${String(stat.stSize)} bytes, which exceeds the 100MB maximum for video uploads.`,
-      );
-    }
-    const data = await this.kaos.readBytes(path);
-    return uploader({
-      data,
-      mimeType: fileType.mimeType,
-      filename: path.split(/[\\/]/).at(-1),
-    });
-  }
-
   get rpcMethods(): PromisableMethods<AgentAPI> {
     return {
       prompt: (payload) => {
         this.turn.prompt(payload.input);
       },
-      uploadVideo: (payload) => this.uploadVideo(payload.path),
       runShellCommand: (payload) => this.tools.runShellCommand(payload.command, payload.commandId),
       cancelShellCommand: (payload) => this.tools.cancelShellCommand(payload.commandId),
       steer: (payload) => {
diff --git a/packages/agent-core/src/agent/tool/index.ts b/packages/agent-core/src/agent/tool/index.ts
index e707dedce6..9833707dbc 100644
--- a/packages/agent-core/src/agent/tool/index.ts
+++ b/packages/agent-core/src/agent/tool/index.ts
@@ -797,10 +797,11 @@ export class ToolManager {
     const baseProps = this.videoUploadTelemetryProps(modelAlias);
     const upload =
       withAuth === undefined
-        ? (input: b.VideoUploadInput) => uploadVideo(input)
-        : (input: b.VideoUploadInput) => withAuth((auth) => uploadVideo(input, { auth }));
+        ? (input: b.VideoUploadInput, signal?: AbortSignal) => uploadVideo(input, { signal })
+        : (input: b.VideoUploadInput, signal?: AbortSignal) =>
+            withAuth((auth) => uploadVideo(input, { auth, signal }));
 
-    return async (input) => {
+    return async (input, options) => {
       const startedAt = Date.now();
       const base = {
         ...baseProps,
@@ -815,7 +816,7 @@ export class ToolManager {
         }
       };
       try {
-        const part = await upload(input);
+        const part = await upload(input, options?.signal);
         track({ ...base, outcome: 'success', duration_ms: Date.now() - startedAt });
         return part;
       } catch (error) {
diff --git a/packages/agent-core/src/agent/turn/index.ts b/packages/agent-core/src/agent/turn/index.ts
index 506f60ae0d..e78da7c6f4 100644
--- a/packages/agent-core/src/agent/turn/index.ts
+++ b/packages/agent-core/src/agent/turn/index.ts
@@ -46,6 +46,7 @@ import {
 } from '../context/projector';
 import { renderUserPromptHookBlockResult, renderUserPromptHookResult } from '../../session/hooks';
 import { canonicalTelemetryArgs, isPlainRecord } from './canonical-args';
+import { degradeUnresolvedVideoToTag, resolvePromptMedia } from './media-resolve';
 import { ToolCallDeduplicator } from './tool-dedup';
 import { budgetToolResultForModel } from './tool-result-budget';
 
@@ -337,7 +338,13 @@ export class TurnFlow {
     const steers = this.steerBuffer;
     if (steers.length === 0) return false;
     for (const steer of steers) {
-      this.agent.context.appendUserMessage(steer.input, steer.origin);
+      // Steer flushes happen at sites that cannot await an upload, so any
+      // prompt-attached local video is degraded to an always-safe `<video
+      // path>` tag here; the model uploads it in-turn via ReadMediaFile.
+      this.agent.context.appendUserMessage(
+        degradeUnresolvedVideoToTag(steer.input),
+        steer.origin,
+      );
     }
     steers.length = 0;
     return true;
@@ -501,7 +508,9 @@ export class TurnFlow {
     this.agent.usage.beginTurn();
     const startedAt = Date.now();
     this.agent.emitEvent({ type: 'turn.started', turnId, origin });
-    this.agent.context.appendUserMessage(input, origin);
+    // The budget-exhausted goal turn does not run the model, so it cannot
+    // await an upload — degrade any local video to the always-safe tag form.
+    this.agent.context.appendUserMessage(degradeUnresolvedVideoToTag(input), origin);
     const ended: TurnEndedEvent = {
       type: 'turn.ended',
       turnId,
@@ -536,7 +545,6 @@ export class TurnFlow {
     this.agent.fullCompaction.resetForTurn();
     this.agent.usage.beginTurn();
     this.agent.emitEvent({ type: 'turn.started', turnId, origin });
-    this.agent.context.appendUserMessage(input, origin);
 
     const startedAt = Date.now();
     let ended: TurnEndedEvent;
@@ -546,7 +554,14 @@ export class TurnFlow {
     // sits just past the turn.ended boundary that consumers watch for.
     let errorEvent: AgentEvent | undefined;
     try {
-      const promptHookEnded = await this.applyUserPromptHook(turnId, input, origin, signal, startedAt);
+      // Resolve any prompt-attached local video (a `file://` video_url) into
+      // its final delivered form — an uploaded `ms://` reference or an
+      // inline/tag fallback — BEFORE it lands in history, so no unresolved
+      // `file://` reference reaches the model or is persisted for resume. Auth
+      // rejections surface as a failed turn via the catch below.
+      const resolvedInput = await resolvePromptMedia(this.agent, input, signal);
+      this.agent.context.appendUserMessage(resolvedInput, origin);
+      const promptHookEnded = await this.applyUserPromptHook(turnId, resolvedInput, origin, signal, startedAt);
       if (promptHookEnded !== undefined) {
         ended = promptHookEnded.event;
         blockedByUserPromptHook = promptHookEnded.blocked;
diff --git a/packages/agent-core/src/agent/turn/media-resolve.ts b/packages/agent-core/src/agent/turn/media-resolve.ts
new file mode 100644
index 0000000000..0d6fe0b589
--- /dev/null
+++ b/packages/agent-core/src/agent/turn/media-resolve.ts
@@ -0,0 +1,136 @@
+/**
+ * Turn-level prompt media resolution.
+ *
+ * A video attached directly to a prompt rides in as a `video_url` part whose
+ * url is a local `file://` reference (the TUI materializes the paste into a
+ * cache copy and points the part at it). That reference must never reach the
+ * model or the persisted history: the provider would send the `file://` string
+ * verbatim on the wire, and a resumed session would replay it. So the turn
+ * resolves every local `file://` video into its final delivered form — an
+ * uploaded `ms://` reference, or an inline/tag fallback — BEFORE the prompt is
+ * appended to context.
+ *
+ * Two entry points:
+ *   - `resolvePromptMedia` (async): the primary prompt path. Validates and
+ *     uploads through the provider's channel (see `deliverVideoContent`),
+ *     degrading to a `<video path>` tag on validation failure and re-throwing
+ *     auth rejections so the turn fails visibly.
+ *   - `degradeUnresolvedVideoToTag` (sync): the always-safe floor for the few
+ *     append sites that cannot await an upload (steer-buffer flushes, the
+ *     budget-exhausted goal turn). The local video becomes a `<video path>`
+ *     tag the model opens with ReadMediaFile, which uploads it in-turn — the
+ *     same path a pasted video took before inline prompt delivery existed.
+ */
+
+import { fileURLToPath } from 'node:url';
+
+import type { ContentPart } from '@moonshot-ai/kosong';
+
+import type { Agent } from '..';
+import { MEDIA_SNIFF_BYTES, detectFileType } from '../../tools/support/file-type';
+import { deliverVideoContent, isAuthUploadError } from '../../tools/support/video-delivery';
+import { MAX_MEDIA_BYTES } from '../../tools/builtin/file/read-media';
+
+/** The local filesystem path behind a prompt-attached `file://` video part. */
+function localVideoUrl(part: ContentPart): string | undefined {
+  return part.type === 'video_url' && part.videoUrl.url.startsWith('file:')
+    ? part.videoUrl.url
+    : undefined;
+}
+
+function escapeAttribute(value: string): string {
+  return value
+    .replaceAll('&', '&amp;')
+    .replaceAll('"', '&quot;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;');
+}
+
+/** A `<video path="…">` tag part the model can open with ReadMediaFile. */
+function videoTag(path: string): ContentPart {
+  return { type: 'text', text: `<video path="${escapeAttribute(path)}"></video>` };
+}
+
+/**
+ * Resolve prompt-attached local videos to their final delivered form. Upload
+ * through the provider channel when the model supports video and the file
+ * validates; otherwise degrade to a `<video path>` tag. Auth rejections from
+ * the upload channel propagate so the turn fails visibly. Returns the input
+ * unchanged when it carries no local video part.
+ */
+export async function resolvePromptMedia(
+  agent: Agent,
+  input: readonly ContentPart[],
+  signal?: AbortSignal,
+): Promise<readonly ContentPart[]> {
+  if (!input.some((part) => localVideoUrl(part) !== undefined)) return input;
+  const resolved: ContentPart[] = [];
+  for (const part of input) {
+    const url = localVideoUrl(part);
+    if (url === undefined) {
+      resolved.push(part);
+      continue;
+    }
+    resolved.push(await resolveOneVideo(agent, url, signal));
+  }
+  return resolved;
+}
+
+async function resolveOneVideo(
+  agent: Agent,
+  fileUrl: string,
+  signal?: AbortSignal,
+): Promise<ContentPart> {
+  let path: string;
+  try {
+    path = fileURLToPath(fileUrl);
+  } catch {
+    // A malformed file URL cannot name a readable file — degrade to a tag
+    // rather than let the raw reference reach the provider.
+    return videoTag(fileUrl);
+  }
+  try {
+    // Validation ladder — any failure degrades to a tag (always safe): the
+    // model reads the file with ReadMediaFile, which re-validates and uploads.
+    if (path.trim().length === 0) return videoTag(path);
+    if (!agent.config.modelCapabilities.video_in) return videoTag(path);
+    const header = await agent.kaos.readBytes(path, MEDIA_SNIFF_BYTES);
+    const fileType = detectFileType(path, header, 'media');
+    if (fileType.kind !== 'video') return videoTag(path);
+    const stat = await agent.kaos.stat(path);
+    if (stat.stSize === 0) return videoTag(path);
+    if (stat.stSize > MAX_MEDIA_BYTES) return videoTag(path);
+
+    const data = await agent.kaos.readBytes(path);
+    return await deliverVideoContent(
+      { data, mimeType: fileType.mimeType, filename: path.split(/[\\/]/).at(-1) },
+      agent.tools.videoUploader(),
+      signal,
+    );
+  } catch (error) {
+    // Auth rejections must surface (credential refresh + clear error); any
+    // other read/upload failure degrades to the always-safe tag form.
+    if (isAuthUploadError(error)) throw error;
+    return videoTag(path);
+  }
+}
+
+/**
+ * Synchronously replace every prompt-attached local `file://` video part with
+ * a `<video path>` tag. The always-safe floor for append sites that cannot
+ * await an upload. Returns the input unchanged when it carries no local video.
+ */
+export function degradeUnresolvedVideoToTag(
+  input: readonly ContentPart[],
+): readonly ContentPart[] {
+  if (!input.some((part) => localVideoUrl(part) !== undefined)) return input;
+  return input.map((part) => {
+    const url = localVideoUrl(part);
+    if (url === undefined) return part;
+    try {
+      return videoTag(fileURLToPath(url));
+    } catch {
+      return videoTag(url);
+    }
+  });
+}
diff --git a/packages/agent-core/src/rpc/core-api.ts b/packages/agent-core/src/rpc/core-api.ts
index 51930634c0..faa44f538f 100644
--- a/packages/agent-core/src/rpc/core-api.ts
+++ b/packages/agent-core/src/rpc/core-api.ts
@@ -20,7 +20,7 @@ import type { ExperimentalFeatureState } from '#/flags';
 import type { ResumeSessionResult } from '#/rpc/resumed';
 import type { SessionMeta } from '#/session';
 import type { GlobalMcpServerConfig } from '#/mcp/global-config';
-import type { ContentPart, VideoURLPart } from '@moonshot-ai/kosong';
+import type { ContentPart } from '@moonshot-ai/kosong';
 import type { SessionWarning } from '@moonshot-ai/protocol';
 
 import type { PluginCommandDef, PluginInfo, PluginSummary, ReloadSummary } from '#/plugin';
@@ -454,19 +454,8 @@ export interface GetCronTasksResult {
   readonly tasks: readonly CronTaskSnapshot[];
 }
 
-export interface UploadVideoPayload {
-  /** Absolute path to a local video file readable by the core process. */
-  readonly path: string;
-}
-
 export interface AgentAPI {
   prompt: (payload: PromptPayload) => void;
-  /**
-   * Upload a local video file through the agent's bound model provider and
-   * return the provider-issued `video_url` part, ready to be embedded in a
-   * user prompt. Rejects when the provider has no video upload channel.
-   */
-  uploadVideo: (payload: UploadVideoPayload) => Promise<VideoURLPart>;
   runShellCommand: (payload: RunShellCommandPayload) => Promise<ShellCommandResult>;
   cancelShellCommand: (payload: CancelShellCommandPayload) => void;
   steer: (payload: SteerPayload) => void;
diff --git a/packages/agent-core/src/rpc/core-impl.ts b/packages/agent-core/src/rpc/core-impl.ts
index db26f18841..4b34590d38 100644
--- a/packages/agent-core/src/rpc/core-impl.ts
+++ b/packages/agent-core/src/rpc/core-impl.ts
@@ -143,7 +143,6 @@ import type {
   UndoHistoryPayload,
   UnregisterToolPayload,
   UpdateSessionMetadataPayload,
-  UploadVideoPayload,
 } from './core-api';
 import type { ResumedAgentState, ResumeSessionResult } from './resumed';
 import type { SDKRPC } from './sdk-api';
@@ -802,10 +801,6 @@ export class KimiCore implements PromisableMethods<CoreAPI> {
     return this.sessionApi(sessionId).prompt(payload);
   }
 
-  uploadVideo({ sessionId, ...payload }: SessionAgentPayload<UploadVideoPayload>) {
-    return this.sessionApi(sessionId).uploadVideo(payload);
-  }
-
   runShellCommand({ sessionId, ...payload }: SessionAgentPayload<RunShellCommandPayload>) {
     return this.sessionApi(sessionId).runShellCommand(payload);
   }
diff --git a/packages/agent-core/src/session/rpc.ts b/packages/agent-core/src/session/rpc.ts
index 92df9b6501..a2e6f0c1e9 100644
--- a/packages/agent-core/src/session/rpc.ts
+++ b/packages/agent-core/src/session/rpc.ts
@@ -36,7 +36,6 @@ import type {
   UndoHistoryPayload,
   UnregisterToolPayload,
   UpdateSessionMetadataPayload,
-  UploadVideoPayload,
 } from '#/rpc';
 import type { PromisableMethods } from '#/utils/types';
 
@@ -128,10 +127,6 @@ export class SessionAPIImpl implements PromisableMethods<SessionAPI> {
     return (await this.getAgent(agentId)).prompt(payload);
   }
 
-  async uploadVideo({ agentId, ...payload }: AgentScopedPayload<UploadVideoPayload>) {
-    return (await this.getAgent(agentId)).uploadVideo(payload);
-  }
-
   async steer({ agentId, ...payload }: AgentScopedPayload<SteerPayload>) {
     return (await this.getAgent(agentId)).steer(payload);
   }
diff --git a/packages/agent-core/src/tools/builtin/file/read-media.ts b/packages/agent-core/src/tools/builtin/file/read-media.ts
index 36f61e512c..fb2724b469 100644
--- a/packages/agent-core/src/tools/builtin/file/read-media.ts
+++ b/packages/agent-core/src/tools/builtin/file/read-media.ts
@@ -28,12 +28,10 @@ import type { Kaos } from '@moonshot-ai/kaos';
 import type {
   ContentPart,
   ModelCapability,
-  VideoURLPart,
   VideoUploadInput as ProviderVideoUploadInput,
 } from '@moonshot-ai/kosong';
 import { z } from 'zod';
 
-import { ErrorCodes } from '../../../errors';
 import type { BuiltinTool } from '../../../agent/tool';
 import { ToolAccesses } from '../../../loop/tool-access';
 import type { ExecutableToolResult, ToolExecution } from '../../../loop/types';
@@ -41,6 +39,7 @@ import type { TelemetryClient } from '../../../telemetry';
 import { renderPrompt } from '../../../utils/render-prompt';
 import { resolvePathAccessPath } from '../../policies/path-access';
 import { MEDIA_SNIFF_BYTES, detectFileType, sniffImageDimensions } from '../../support/file-type';
+import { deliverVideoContent, type VideoUploader } from '../../support/video-delivery';
 import {
   IMAGE_BYTE_BUDGET,
   MAX_IMAGE_DECODE_BYTES,
@@ -100,7 +99,7 @@ function buildFullResolutionLimitError(path: string, finalBytes: number): string
 
 export type VideoUploadInput = ProviderVideoUploadInput;
 
-export type VideoUploader = (input: VideoUploadInput) => Promise<VideoURLPart>;
+export type { VideoUploader };
 
 // ── Input schema ─────────────────────────────────────────────────────
 
@@ -253,19 +252,6 @@ function buildMediaNote(input: {
 
 // ── Implementation ───────────────────────────────────────────────────
 
-/**
- * Auth rejections from the upload channel that must surface (they drive
- * credential refresh and a clear auth error). The auth layer wraps provider
- * 401/403s as `provider.auth_error`; a raw status-coded error is matched
- * directly.
- */
-function isAuthUploadError(error: unknown): boolean {
-  if (typeof error !== 'object' || error === null) return false;
-  if ((error as { code?: unknown }).code === ErrorCodes.PROVIDER_AUTH_ERROR) return true;
-  const statusCode = (error as { statusCode?: unknown }).statusCode;
-  return statusCode === 401 || statusCode === 403;
-}
-
 export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
   readonly name = 'ReadMediaFile' as const;
   readonly description: string;
@@ -300,28 +286,15 @@ export class ReadMediaFileTool implements BuiltinTool<ReadMediaFileInput> {
    * refresh and a clear auth error instead of masking a bad token behind
    * an inline payload the next request will also reject.
    */
-  private async videoContentPart(
+  private videoContentPart(
     data: Buffer,
     mimeType: string,
     safePath: string,
   ): Promise<ContentPart> {
-    if (this.videoUploader !== undefined) {
-      try {
-        return await this.videoUploader({
-          data,
-          mimeType,
-          filename: safePath.split(/[\\/]/).at(-1),
-        });
-      } catch (error) {
-        if (isAuthUploadError(error)) throw error;
-        // Fall through to the inline form.
-      }
-    }
-    const base64 = data.toString('base64');
-    return {
-      type: 'video_url',
-      videoUrl: { url: `data:${mimeType};base64,${base64}` },
-    };
+    return deliverVideoContent(
+      { data, mimeType, filename: safePath.split(/[\\/]/).at(-1) },
+      this.videoUploader,
+    );
   }
 
   resolveExecution(args: ReadMediaFileInput): ToolExecution {
diff --git a/packages/agent-core/src/tools/support/video-delivery.ts b/packages/agent-core/src/tools/support/video-delivery.ts
new file mode 100644
index 0000000000..9ce4c45fc7
--- /dev/null
+++ b/packages/agent-core/src/tools/support/video-delivery.ts
@@ -0,0 +1,68 @@
+/**
+ * Shared video delivery ladder.
+ *
+ * A local video becomes a model-visible content part through one channel:
+ * upload it via the provider's video upload channel (the tiny `ms://<id>`
+ * reference), and only fall back to an inline base64 `data:` part when the
+ * channel is missing or the upload fails for a non-auth reason. Auth
+ * rejections (401/403) are the exception: they must surface so credential
+ * refresh runs and the user sees a clear auth error, instead of being masked
+ * behind an inline payload the next request would also reject.
+ *
+ * Both ReadMediaFile (videos the model reads itself) and the turn-level
+ * prompt-media resolver (videos attached directly to a prompt) share this
+ * ladder so their delivery and fallback semantics stay identical.
+ */
+
+import type { ContentPart, VideoUploadInput, VideoURLPart } from '@moonshot-ai/kosong';
+
+import { ErrorCodes } from '../../errors';
+
+/** Uploads a local video and returns the provider-issued `video_url` part. */
+export type VideoUploader = (
+  input: VideoUploadInput,
+  options?: { signal?: AbortSignal },
+) => Promise<VideoURLPart>;
+
+/**
+ * Auth rejections from the upload channel that must surface (they drive
+ * credential refresh and a clear auth error). The auth layer wraps provider
+ * 401/403s as `provider.auth_error`; a raw status-coded error is matched
+ * directly.
+ */
+export function isAuthUploadError(error: unknown): boolean {
+  if (typeof error !== 'object' || error === null) return false;
+  if ((error as { code?: unknown }).code === ErrorCodes.PROVIDER_AUTH_ERROR) return true;
+  const statusCode = (error as { statusCode?: unknown }).statusCode;
+  return statusCode === 401 || statusCode === 403;
+}
+
+/**
+ * Deliver a video through the provider's upload channel when available,
+ * falling back to an inline base64 part when the channel is missing or the
+ * upload fails for a non-auth reason — a failed upload must not turn the whole
+ * delivery into an error. Auth rejections (401/403) are re-thrown so the
+ * caller can surface them.
+ */
+export async function deliverVideoContent(
+  input: VideoUploadInput,
+  uploader: VideoUploader | undefined,
+  signal?: AbortSignal,
+): Promise<ContentPart> {
+  if (uploader !== undefined) {
+    try {
+      // Call with a single argument when there is no signal to thread, so
+      // callers that never cancel (ReadMediaFile) invoke the channel exactly
+      // as before signal support existed.
+      return await (signal === undefined ? uploader(input) : uploader(input, { signal }));
+    } catch (error) {
+      if (isAuthUploadError(error)) throw error;
+      // Fall through to the inline form.
+    }
+  }
+  const base64 = Buffer.from(input.data).toString('base64');
+  return {
+    type: 'video_url',
+    videoUrl: { url: `data:${input.mimeType};base64,${base64}` },
+  };
+}
diff --git a/packages/agent-core/test/agent/basic.test.ts b/packages/agent-core/test/agent/basic.test.ts
index afc22fc5ee..df650a5760 100644
--- a/packages/agent-core/test/agent/basic.test.ts
+++ b/packages/agent-core/test/agent/basic.test.ts
@@ -1,9 +1,10 @@
-import type { ToolCall } from '@moonshot-ai/kosong';
+import type { ContentPart, ToolCall } from '@moonshot-ai/kosong';
 import { createServer } from 'node:http';
 import type { AddressInfo } from 'node:net';
 import { mkdtempSync, truncateSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { describe, expect, it } from 'vitest';
 
 import { FLAG_DEFINITIONS, FlagResolver } from '../../src/flags';
@@ -166,7 +167,7 @@ const VIDEO_CAPS = {
   max_context_tokens: 1000000,
 } as const;
 
-describe('uploadVideo', () => {
+describe('prompt-attached video resolution', () => {
   // Minimal ISO-BMFF header: a 24-byte ftyp box with the `isom` brand, which
   // is all the media sniffer needs to classify the file as video/mp4.
   const FTYP_MP4 = Buffer.from([
@@ -175,43 +176,52 @@ describe('uploadVideo', () => {
   ]);
 
   function tempVideo(name = 'clip.mp4', bytes: Buffer = FTYP_MP4): string {
-    const dir = mkdtempSync(join(tmpdir(), 'agent-upload-video-'));
+    const dir = mkdtempSync(join(tmpdir(), 'agent-prompt-video-'));
     const path = join(dir, name);
     writeFileSync(path, bytes);
     return path;
   }
 
-  interface StubFilesRequest {
-    readonly authorization?: string | undefined;
-    readonly bytes: number;
+  function fileUrl(path: string): string {
+    return pathToFileURL(path).href;
   }
 
-  async function stubFilesServer(): Promise<{
+  function firstUserContent(ctx: ReturnType<typeof testAgent>): ContentPart[] {
+    return ctx.agent.context.messages.find((m) => m.role === 'user')?.content ?? [];
+  }
+
+  interface StubFilesServer {
     url: string;
-    requests: StubFilesRequest[];
+    requests: number;
     close: () => Promise<void>;
-  }> {
-    const requests: StubFilesRequest[] = [];
+  }
+
+  // Stubs the Moonshot files endpoint. `status` drives the ladder: 200 issues a
+  // reference, 401 exercises the auth-rejection path, any other status is a
+  // non-auth upload failure.
+  async function stubFilesServer(status = 200): Promise<StubFilesServer> {
+    const state = { requests: 0 };
     const server = createServer((req, res) => {
       if (req.method === 'POST' && req.url === '/files') {
-        const chunks: Buffer[] = [];
-        req.on('data', (chunk: Buffer) => chunks.push(chunk));
+        req.resume();
         req.on('end', () => {
-          requests.push({
-            authorization: req.headers.authorization,
-            bytes: Buffer.concat(chunks).length,
-          });
-          res.writeHead(200, { 'content-type': 'application/json' });
-          res.end(
-            JSON.stringify({
-              id: 'stub-video-file',
-              object: 'file',
-              bytes: FTYP_MP4.length,
-              created_at: 0,
-              filename: 'clip.mp4',
-              purpose: 'video',
-            }),
-          );
+          state.requests += 1;
+          if (status === 200) {
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end(
+              JSON.stringify({
+                id: 'stub-video-file',
+                object: 'file',
+                bytes: FTYP_MP4.length,
+                created_at: 0,
+                filename: 'clip.mp4',
+                purpose: 'video',
+              }),
+            );
+            return;
+          }
+          res.writeHead(status, { 'content-type': 'application/json' });
+          res.end(JSON.stringify({ error: { message: 'stub upload failure' } }));
         });
         return;
       }
@@ -222,184 +232,183 @@ describe('uploadVideo', () => {
     const { port } = server.address() as AddressInfo;
     return {
       url: `http://127.0.0.1:${String(port)}`,
-      requests,
+      get requests() {
+        return state.requests;
+      },
       close: () => new Promise<void>((resolve) => server.close(() => resolve())),
     };
   }
 
-  it('uploads a local video through the bound provider and returns the issued reference', async () => {
+  function kimiProvider(baseUrl: string) {
+    return { type: 'kimi', apiKey: 'test-key', model: 'mock-model', baseUrl } as const;
+  }
+
+  it('uploads a local file:// video and sends the issued ms:// reference to the model', async () => {
     const stub = await stubFilesServer();
     try {
       const ctx = testAgent();
-      ctx.configure({
-        provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model', baseUrl: stub.url },
-        modelCapabilities: VIDEO_CAPS,
-      });
+      ctx.configure({ provider: kimiProvider(stub.url), modelCapabilities: VIDEO_CAPS });
+      ctx.mockNextResponse({ type: 'text', text: 'ok' });
 
-      const part = await ctx.rpc.uploadVideo({ path: tempVideo() });
+      await ctx.rpc.prompt({ input: [{ type: 'video_url', videoUrl: { url: fileUrl(tempVideo()) } }] });
+      await ctx.untilTurnEnd();
 
-      expect(part).toEqual({
+      expect(firstUserContent(ctx)).toContainEqual({
         type: 'video_url',
         videoUrl: { url: 'ms://stub-video-file', id: 'stub-video-file' },
       });
-      expect(stub.requests).toHaveLength(1);
-      expect(stub.requests[0]?.authorization).toBe('Bearer test-key');
-      // The multipart body carries the video bytes, so it must be larger.
-      expect(stub.requests[0]?.bytes).toBeGreaterThan(FTYP_MP4.length);
+      expect(stub.requests).toBe(1);
     } finally {
       await stub.close();
     }
   });
 
-  it('rejects when the provider has no video upload channel', async () => {
-    const ctx = testAgent();
-    ctx.configure({ provider: { type: 'openai', apiKey: 'test-key', model: 'mock-model' }, modelCapabilities: VIDEO_CAPS });
-
-    await expect(ctx.rpc.uploadVideo({ path: tempVideo() })).rejects.toThrow(
-      /does not support video upload/,
-    );
-  });
-
-  it('rejects when the model lacks the video_in capability', async () => {
+  it('degrades to a <video path> tag when the model lacks video_in (no upload)', async () => {
     const stub = await stubFilesServer();
     try {
       const ctx = testAgent();
       ctx.configure({
-        provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model', baseUrl: stub.url },
+        provider: kimiProvider(stub.url),
         modelCapabilities: { ...VIDEO_CAPS, video_in: false },
       });
-
-      await expect(ctx.rpc.uploadVideo({ path: tempVideo() })).rejects.toThrow(
-        /does not support video input/,
-      );
-      expect(stub.requests).toHaveLength(0);
+      ctx.mockNextResponse({ type: 'text', text: 'ok' });
+
+      const path = tempVideo();
+      await ctx.rpc.prompt({ input: [{ type: 'video_url', videoUrl: { url: fileUrl(path) } }] });
+      await ctx.untilTurnEnd();
+
+      const text = firstUserContent(ctx)
+        .map((p) => (p.type === 'text' ? p.text : ''))
+        .join('');
+      expect(text).toContain(`<video path="${path}">`);
+      expect(firstUserContent(ctx).some((p) => p.type === 'video_url')).toBe(false);
+      expect(stub.requests).toBe(0);
     } finally {
       await stub.close();
     }
   });
 
-  it('rejects a non-video file', async () => {
+  it('falls back to an inline base64 part when the provider has no upload channel', async () => {
     const ctx = testAgent();
-    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' }, modelCapabilities: VIDEO_CAPS });
+    ctx.configure({
+      provider: { type: 'openai', apiKey: 'test-key', model: 'mock-model' },
+      modelCapabilities: VIDEO_CAPS,
+    });
+    ctx.mockNextResponse({ type: 'text', text: 'ok' });
 
-    await expect(
-      ctx.rpc.uploadVideo({ path: tempVideo('notes.txt', Buffer.from('plain text')) }),
-    ).rejects.toThrow(/not a video file/);
-  });
+    await ctx.rpc.prompt({ input: [{ type: 'video_url', videoUrl: { url: fileUrl(tempVideo()) } }] });
+    await ctx.untilTurnEnd();
 
-  it('rejects a video over the 100MB cap', async () => {
-    const ctx = testAgent();
-    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' }, modelCapabilities: VIDEO_CAPS });
-    const path = tempVideo();
-    // Sparse extend: the ftyp header stays, the size crosses the cap.
-    truncateSync(path, 101 * 1024 * 1024);
-
-    await expect(ctx.rpc.uploadVideo({ path })).rejects.toThrow(/100MB/);
+    const part = firstUserContent(ctx).find((p) => p.type === 'video_url');
+    expect(part?.type === 'video_url' && part.videoUrl.url).toMatch(/^data:video\/mp4;base64,/);
   });
-});
 
-describe('uploadVideo input validation', () => {
-  const FTYP_MP4 = Buffer.from([
-    0x00, 0x00, 0x00, 0x18, 0x66, 0x74, 0x79, 0x70, 0x69, 0x73, 0x6f, 0x6d, 0x00, 0x00, 0x02,
-    0x00, 0x69, 0x73, 0x6f, 0x6d, 0x69, 0x73, 0x6f, 0x32,
-  ]);
+  it('falls back to an inline base64 part on a non-auth upload failure', async () => {
+    const stub = await stubFilesServer(400);
+    try {
+      const ctx = testAgent();
+      ctx.configure({ provider: kimiProvider(stub.url), modelCapabilities: VIDEO_CAPS });
+      ctx.mockNextResponse({ type: 'text', text: 'ok' });
 
-  function tempFile(name: string, bytes: Buffer): string {
-    const dir = mkdtempSync(join(tmpdir(), 'agent-upload-video-'));
-    const path = join(dir, name);
-    writeFileSync(path, bytes);
-    return path;
-  }
+      await ctx.rpc.prompt({ input: [{ type: 'video_url', videoUrl: { url: fileUrl(tempVideo()) } }] });
+      await ctx.untilTurnEnd();
 
-  async function stubFilesServer(): Promise<{ url: string; close: () => Promise<void> }> {
-    const server = createServer((req, res) => {
-      if (req.method === 'POST' && req.url === '/files') {
-        req.resume();
-        req.on('end', () => {
-          res.writeHead(200, { 'content-type': 'application/json' });
-          res.end(JSON.stringify({ id: 'stub-video-file', object: 'file', bytes: 0, created_at: 0, filename: 'x.mp4', purpose: 'video' }));
-        });
-        return;
-      }
-      res.writeHead(404);
-      res.end();
-    });
-    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
-    const { port } = server.address() as AddressInfo;
-    return {
-      url: `http://127.0.0.1:${String(port)}`,
-      close: () => new Promise<void>((resolve) => server.close(() => resolve())),
-    };
-  }
+      const part = firstUserContent(ctx).find((p) => p.type === 'video_url');
+      expect(part?.type === 'video_url' && part.videoUrl.url).toMatch(/^data:video\/mp4;base64,/);
+    } finally {
+      await stub.close();
+    }
+  });
 
-  it('trusts the video extension when magic bytes are absent (documented sniff fallback)', async () => {
-    // Some containers (MPEG-PS) carry no recognizable magic, so when the
-    // header cannot be sniffed the extension is the only signal — the same
-    // classification ReadMediaFile uses. A mislabeled file therefore passes
-    // validation and fails later, at the provider, not here.
-    const stub = await stubFilesServer();
+  it('fails the turn on an auth (401) upload rejection without poisoning history', async () => {
+    const stub = await stubFilesServer(401);
     try {
       const ctx = testAgent();
-      ctx.configure({
-        provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model', baseUrl: stub.url },
-        modelCapabilities: VIDEO_CAPS,
-      });
-      const part = await ctx.rpc.uploadVideo({
-        path: tempFile('fake.mp4', Buffer.from('definitely not a video')),
-      });
-      expect(part.videoUrl.url).toBe('ms://stub-video-file');
+      ctx.configure({ provider: kimiProvider(stub.url), modelCapabilities: VIDEO_CAPS });
+
+      await ctx.rpc.prompt({ input: [{ type: 'video_url', videoUrl: { url: fileUrl(tempVideo()) } }] });
+      const events = await ctx.untilTurnEnd();
+
+      expect(events).toContainEqual(
+        expect.objectContaining({
+          event: 'turn.ended',
+          args: expect.objectContaining({ reason: 'failed' }),
+        }),
+      );
+      // The unresolved video is never appended to history.
+      expect(ctx.agent.context.messages.some((m) => m.role === 'user')).toBe(false);
     } finally {
       await stub.close();
     }
   });
 
-  it('accepts video bytes in a .txt file (magic bytes win over the extension)', async () => {
+  it('degrades a non-video file to a tag (magic bytes win, no upload)', async () => {
     const stub = await stubFilesServer();
     try {
       const ctx = testAgent();
-      ctx.configure({
-        provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model', baseUrl: stub.url },
-        modelCapabilities: VIDEO_CAPS,
-      });
-      const part = await ctx.rpc.uploadVideo({ path: tempFile('video.txt', FTYP_MP4) });
-      expect(part.videoUrl.url).toBe('ms://stub-video-file');
+      ctx.configure({ provider: kimiProvider(stub.url), modelCapabilities: VIDEO_CAPS });
+      ctx.mockNextResponse({ type: 'text', text: 'ok' });
+
+      const path = tempVideo('notes.txt', Buffer.from('definitely not a video'));
+      await ctx.rpc.prompt({ input: [{ type: 'video_url', videoUrl: { url: fileUrl(path) } }] });
+      await ctx.untilTurnEnd();
+
+      expect(firstUserContent(ctx).some((p) => p.type === 'video_url')).toBe(false);
+      expect(stub.requests).toBe(0);
     } finally {
       await stub.close();
     }
   });
 
-  it('accepts a video at exactly 100MB and rejects 100MB+1', async () => {
+  it('degrades an oversize video (>100MB) to a tag (no upload)', async () => {
     const stub = await stubFilesServer();
     try {
       const ctx = testAgent();
-      ctx.configure({
-        provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model', baseUrl: stub.url },
-        modelCapabilities: VIDEO_CAPS,
-      });
-
-      const over = tempFile('over.mp4', FTYP_MP4);
-      truncateSync(over, 100 * 1024 * 1024 + 1);
-      await expect(ctx.rpc.uploadVideo({ path: over })).rejects.toThrow(/100MB/);
-
-      const exact = tempFile('exact.mp4', FTYP_MP4);
-      truncateSync(exact, 100 * 1024 * 1024);
-      const part = await ctx.rpc.uploadVideo({ path: exact });
-      expect(part.videoUrl.url).toBe('ms://stub-video-file');
+      ctx.configure({ provider: kimiProvider(stub.url), modelCapabilities: VIDEO_CAPS });
+      ctx.mockNextResponse({ type: 'text', text: 'ok' });
+
+      const path = tempVideo();
+      // Sparse extend: the ftyp header stays so it sniffs as video, the size
+      // crosses the cap.
+      truncateSync(path, 100 * 1024 * 1024 + 1);
+      await ctx.rpc.prompt({ input: [{ type: 'video_url', videoUrl: { url: fileUrl(path) } }] });
+      await ctx.untilTurnEnd();
+
+      expect(firstUserContent(ctx).some((p) => p.type === 'video_url')).toBe(false);
+      expect(stub.requests).toBe(0);
     } finally {
       await stub.close();
     }
   }, 30000);
 
-  it('rejects a directory path', async () => {
-    const ctx = testAgent();
-    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' }, modelCapabilities: VIDEO_CAPS });
-    const dir = mkdtempSync(join(tmpdir(), 'agent-upload-video-'));
-    await expect(ctx.rpc.uploadVideo({ path: dir })).rejects.toThrow();
-  });
-
-  it('rejects a nonexistent path', async () => {
-    const ctx = testAgent();
-    ctx.configure({ provider: { type: 'kimi', apiKey: 'test-key', model: 'mock-model' }, modelCapabilities: VIDEO_CAPS });
-    await expect(ctx.rpc.uploadVideo({ path: '/no/such/file.mp4' })).rejects.toThrow();
+  it('resolves a video attached to a steer message', async () => {
+    const stub = await stubFilesServer();
+    try {
+      const ctx = testAgent();
+      ctx.configure({ provider: kimiProvider(stub.url), modelCapabilities: VIDEO_CAPS });
+      // Two model steps: the first lets the steer buffer while the turn runs,
+      // the second reacts to the flushed steer.
+      ctx.mockNextResponse({ type: 'text', text: 'first' });
+      ctx.mockNextResponse({ type: 'text', text: 'second' });
+
+      await ctx.rpc.prompt({ input: [{ type: 'text', text: 'start' }] });
+      const path = tempVideo();
+      ctx.agent.turn.steer([{ type: 'video_url', videoUrl: { url: fileUrl(path) } }]);
+      await ctx.untilTurnEnd();
+
+      // The steer flush cannot await an upload, so the local video degrades to
+      // an always-safe tag — no unresolved file:// reference reaches history.
+      const steered = ctx.agent.context.messages.filter((m) => m.role === 'user');
+      const hasFileUrl = steered.some((m) =>
+        m.content.some((p) => p.type === 'video_url' && p.videoUrl.url.startsWith('file:')),
+      );
+      expect(hasFileUrl).toBe(false);
+      const anyTag = steered.some((m) =>
+        m.content.some((p) => p.type === 'text' && p.text.includes(`<video path="${path}">`)),
+      );
+      expect(anyTag).toBe(true);
+    } finally {
+      await stub.close();
+    }
   });
 });
diff --git a/packages/kap-server/src/lib/llmVideoRefs.ts b/packages/kap-server/src/lib/llmVideoRefs.ts
deleted file mode 100644
index 1a8bcb791a..0000000000
--- a/packages/kap-server/src/lib/llmVideoRefs.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- * Maps provider-issued video file ids back to the local `/files` upload they
- * were produced from. When a prompt video is inlined as a provider reference
- * (`ms://<id>`), the transcript no longer names the local file, so UIs
- * resolve the provider id through this map to play the video back from
- * daemon storage (see `GET /files/llm/{llm_id}`).
- *
- * Each mapping is one blob-store key (`llm-video/<llmFileId>` → local file
- * id), so concurrent prompt uploads never lose entries to a read-modify-write
- * race, and the map survives restarts. Ids on both sides of the map are
- * constrained to the provider-id alphabet — the id becomes a storage path
- * segment, and a crafted provider response must not escape the namespace.
- */
-
-import type { IBlobStore } from '@moonshot-ai/agent-core-v2';
-
-const SCOPE = 'llm-video';
-
-const PROVIDER_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-
-const textEncoder = new TextEncoder();
-const textDecoder = new TextDecoder();
-
-/**
- * Records one mapping; a provider id outside the safe alphabet is dropped
- * (the prompt itself is unaffected — only playback recovery for that video
- * is lost). Store errors still propagate to the caller.
- */
-export async function recordLlmVideoRef(
-  blobs: IBlobStore,
-  llmFileId: string,
-  localFileId: string,
-): Promise<void> {
-  if (!PROVIDER_ID_RE.test(llmFileId)) return;
-  await blobs.put(SCOPE, llmFileId, textEncoder.encode(localFileId));
-}
-
-export async function resolveLlmVideoRef(
-  blobs: IBlobStore,
-  llmFileId: string,
-): Promise<string | undefined> {
-  if (!PROVIDER_ID_RE.test(llmFileId)) return undefined;
-  const data = await blobs.get(SCOPE, llmFileId);
-  return data === undefined ? undefined : textDecoder.decode(data);
-}
diff --git a/packages/kap-server/src/protocol/rest-file.ts b/packages/kap-server/src/protocol/rest-file.ts
index 1ec654040c..21d6a119cd 100644
--- a/packages/kap-server/src/protocol/rest-file.ts
+++ b/packages/kap-server/src/protocol/rest-file.ts
@@ -1,7 +1,6 @@
 /**
  *   POST   /v1/files                  (multipart upload)
  *   GET    /v1/files/{file_id}        (binary stream)
- *   GET    /v1/files/llm/{llm_id}     (redirect to the local file a provider video id came from)
  *   DELETE /v1/files/{file_id}
  */
 
@@ -17,13 +16,6 @@ export const getFileParamSchema = z.object({
 });
 export type GetFileParam = z.infer<typeof getFileParamSchema>;
 
-export const getLlmVideoParamSchema = z.object({
-  // The id is used as a blob-store key; keep it inside the provider-id
-  // alphabet so a crafted value can never address another storage path.
-  llm_id: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/),
-});
-export type GetLlmVideoParam = z.infer<typeof getLlmVideoParamSchema>;
-
 export const deleteFileParamSchema = z.object({
   file_id: z.string().min(1),
 });
diff --git a/packages/kap-server/src/routes/files.ts b/packages/kap-server/src/routes/files.ts
index e70f82f6a5..ff74e99ffc 100644
--- a/packages/kap-server/src/routes/files.ts
+++ b/packages/kap-server/src/routes/files.ts
@@ -3,8 +3,6 @@
  *
  *   POST   /files            upload a file (multipart/form-data) → FileMeta
  *   GET    /files/{file_id}  download a file (binary stream)
- *   GET    /files/llm/{llm_id}  redirect a provider-issued video file id to
- *                               the local file it was uploaded from
  *   DELETE /files/{file_id}  delete a file → { deleted: true }
  *
  * Backed by the v2 `IFileService` (Core scope), which stores bytes in
@@ -18,7 +16,6 @@ import multipart from '@fastify/multipart';
 import {
   DEFAULT_MAX_UPLOAD_BYTES,
   ErrorCodes,
-  IBlobStore,
   IFileService,
   Error2,
   type Scope,
@@ -26,7 +23,6 @@ import {
 import { z } from 'zod';
 
 import { requestLog } from '../lib/requestLog';
-import { resolveLlmVideoRef } from '../lib/llmVideoRefs';
 import { defineRoute } from '../middleware/defineRoute';
 import { ErrorCode } from '../protocol/error-codes';
 import { errEnvelope, okEnvelope } from '../protocol/envelope';
@@ -34,7 +30,6 @@ import {
   deleteFileParamSchema,
   deleteFileResponseSchema,
   getFileParamSchema,
-  getLlmVideoParamSchema,
   uploadFileResponseSchema,
 } from '../protocol/rest-file';
 
@@ -210,38 +205,6 @@ export function registerFilesRoutes(app: FilesRouteHost, core: Scope): void {
     downloadRoute.handler as unknown as Parameters<FilesRouteHost['get']>[2],
   );
 
-  const llmVideoRoute = defineRoute(
-    {
-      method: 'GET',
-      path: '/files/llm/{llm_id}',
-      params: getLlmVideoParamSchema,
-      errors: {
-        [ErrorCode.FILE_NOT_FOUND]: {},
-      },
-      description:
-        'Redirect a provider-issued video file id to the local file it was uploaded from',
-      tags: ['files'],
-    },
-    async (req, reply) => {
-      try {
-        const { llm_id } = req.params;
-        const localFileId = await resolveLlmVideoRef(core.accessor.get(IBlobStore), llm_id);
-        if (localFileId === undefined) {
-          throw new Error2(ErrorCodes.FILE_NOT_FOUND, 'file not found');
-        }
-        const r = reply as unknown as FilesReply;
-        r.code(302).header('location', `/api/v1/files/${localFileId}`).send('');
-      } catch (error) {
-        sendMappedError(reply as unknown as FilesReply, req, error);
-      }
-    },
-  );
-  app.get(
-    llmVideoRoute.path,
-    llmVideoRoute.options,
-    llmVideoRoute.handler as unknown as Parameters<FilesRouteHost['get']>[2],
-  );
-
   const deleteRoute = defineRoute(
     {
       method: 'DELETE',
diff --git a/packages/kap-server/src/routes/prompts.ts b/packages/kap-server/src/routes/prompts.ts
index d85a52f701..2520ad63ac 100644
--- a/packages/kap-server/src/routes/prompts.ts
+++ b/packages/kap-server/src/routes/prompts.ts
@@ -19,13 +19,11 @@ import {
   IAgentToolPolicyService,
   IAgentPromptService,
   IAuthSummaryService,
-  IBlobStore,
-  IConfigService,
   IEventService,
   IFileService,
-  IModelCatalog,
   ISessionMetadata,
-  createVideoUploader,
+  buildKimiFileUrl,
+  parseKimiFileUrl,
   promptMetadataTextFromContentParts,
   ProfileError,
   type ContentPart,
@@ -53,8 +51,6 @@ import {
   type ImageCompressionTelemetry,
   type ISessionScopeHandle,
   type Scope,
-  type VideoUploadInput,
-  type VideoURLPart,
 } from '@moonshot-ai/agent-core-v2';
 import { ErrorCode } from '../protocol/error-codes';
 import {
@@ -69,8 +65,6 @@ import {
 import { z } from 'zod';
 
 import { errEnvelope, okEnvelope } from '../envelope';
-import { recordLlmVideoRef } from '../lib/llmVideoRefs';
-import { detectFileType, MEDIA_SNIFF_BYTES } from '@moonshot-ai/agent-core-v2/agent/media/file-type';
 import { requestLog } from '../lib/requestLog';
 import { defineRoute } from '../middleware/defineRoute';
 import { ensureMainAgent, MAIN_AGENT_ID } from '../transport/mainAgent';
@@ -145,51 +139,9 @@ async function resolvePromptFromSession(session: ISessionScopeHandle, agentId?:
     profile: agent.accessor.get(IAgentProfileService),
     toolPolicy: agent.accessor.get(IAgentToolPolicyService),
     permissionMode: agent.accessor.get(IAgentPermissionModeService),
-    // Agent-scoped view: agent identity is ambient for agent-level events
-    // (e.g. video_upload), unlike the Core-scoped view used for session-level
-    // events (e.g. image_compress).
-    telemetry: agent.accessor.get(ITelemetryService),
   };
 }
 
-/**
- * Build the prompt-time video uploader from the model the submission will
- * use, resolved TRANSIENTLY (no bind/setModel) with the same rules as
- * `AgentProfileService.bind`: an explicit body model wins; a profile bind
- * without one falls back to the configured global default model; otherwise
- * the agent's currently bound alias. `undefined` when no model is
- * determinable (unbound, no override, no configured default — that
- * submission fails on bind anyway), when the model cannot ingest video (no
- * `video_in` capability), or when the provider has no upload channel —
- * prompt videos then fall back to the file-tag form and the model opens
- * them with ReadMediaFile.
- */
-function promptVideoUploader(
-  body: { readonly model?: string | undefined; readonly profile?: string | undefined },
-  profile: IAgentProfileService,
-  modelCatalog: IModelCatalog,
-  config: IConfigService,
-  telemetry: ITelemetryService,
-): ((input: VideoUploadInput) => Promise<VideoURLPart>) | undefined {
-  const alias =
-    body.model ??
-    (body.profile !== undefined
-      ? config.get<string>('defaultModel')
-      : profile.getModel());
-  if (alias === undefined || alias === '') return undefined;
-  const model = modelCatalog.get(alias);
-  if (!model.capabilities.video_in) return undefined;
-  const requester = modelCatalog.getRequester(alias);
-  return createVideoUploader(requester, {
-    client: telemetry,
-    props: {
-      model: alias,
-      provider_type: model.providerType ?? model.protocol,
-      protocol: model.protocol,
-    },
-  });
-}
-
 /**
  * Bind the resolved agent to the profile named by a prompt submission's
  * `profile` field. First-bind semantics live in the engine: a same-name
@@ -247,12 +199,6 @@ async function assertPromptFileRefs(body: PromptSubmission, store: IFileService)
   }
 }
 
-/**
- * Serializes prompt submissions per session: a slow media upload must not
- * let a later request reach the queue ahead of an earlier one.
- */
-const submitChains = new Map<string, Promise<void>>();
-
 export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
   const listRoute = defineRoute(
     {
@@ -291,7 +237,6 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
         [ErrorCode.AUTH_TOKEN_UNAUTHORIZED]: { detailsSchema: authProviderDetailsSchema },
         [ErrorCode.AUTH_MODEL_NOT_RESOLVED]: { detailsSchema: authModelDetailsSchema },
         [ErrorCode.SESSION_NOT_FOUND]: {},
-        [ErrorCode.SESSION_BUSY]: {},
         [ErrorCode.PROMPT_ALREADY_COMPLETED]: { dataSchema: z.object({ aborted: z.literal(false) }) },
       },
       description: 'Submit a prompt to a session',
@@ -300,8 +245,7 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
     },
     async (req, reply) => {
       const { session_id } = req.params;
-      const invoke = async (): Promise<void> => {
-        try {
+      try {
         // Fail fast on stale file references before anything is resolved or
         // mutated: a bad `file_id` must not create the agent, register `main`
         // in session metadata, or touch the session's controls.
@@ -309,33 +253,19 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
         const resolved = await resolvePrompt(core, session_id, req.body.agent_id);
         await resolved.auth.ensureReady();
 
-        // Media resolution runs BEFORE any control mutation: the uploader is
-        // resolved transiently from the requested (or currently bound) model,
-        // so a failed submission leaves the session's controls untouched.
+        // Media resolution runs BEFORE any control mutation, so a failed
+        // submission leaves the session's controls untouched. Prompt videos
+        // are materialized to a local copy and carried into context as an
+        // internal `kimi-file://` reference; the engine resolves them to a
+        // provider form (upload / inline / `<video path>` tag) at request
+        // time, so the edge no longer uploads.
         const telemetry = core.accessor.get(ITelemetryService).withContext({ sessionId: session_id });
-        const boundBeforeMedia = resolved.profile.getModel();
         const resolvedBody = await resolvePromptMediaFiles(
           req.body,
           core.accessor.get(IFileService),
           core.accessor.get(IBootstrapService).cacheDir,
           {
             telemetry,
-            videoUploader: promptVideoUploader(
-              req.body,
-              resolved.profile,
-              core.accessor.get(IModelCatalog),
-              core.accessor.get(IConfigService),
-              // Agent-level events (video_upload) need the target agent's
-              // ambient identity, not the Core-scoped session view above.
-              resolved.telemetry.withContext({ sessionId: session_id }),
-            ),
-            onVideoInlined: async (localFileId, llmFileId) => {
-              // Best effort — a lost mapping only means the web UI cannot
-              // play this prompt video back from daemon storage.
-              await recordLlmVideoRef(core.accessor.get(IBlobStore), llmFileId, localFileId).catch(
-                () => undefined,
-              );
-            },
             resolveOriginalsDir: async () => {
               const session = await core.accessor.get(ISessionLifecycleService).resume(session_id);
               if (session === undefined) return undefined;
@@ -349,16 +279,6 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
           },
         );
 
-        // A concurrent model switch during preparation must not receive a
-        // reference uploaded for the previous model — reject instead of
-        // enqueueing an account-scoped id against the wrong provider.
-        if (resolved.profile.getModel() !== boundBeforeMedia) {
-          throw new Error2(
-            'session.busy',
-            'the model changed while the prompt was being prepared; resubmit',
-          );
-        }
-
         // Media prepared successfully — only now do the overrides bind.
         let thinkingConsumed = false;
         if (req.body.profile !== undefined) {
@@ -400,19 +320,8 @@ export function registerPromptsRoutes(app: PromptRouteHost, core: Scope): void {
           origin: { kind: 'user' },
         } });
         reply.send(okEnvelope(projectPromptHandle(handle), req.id));
-        } catch (error) {
-          sendMappedError(reply, req, error);
-        }
-      };
-      const previous = submitChains.get(session_id) ?? Promise.resolve();
-      const run = previous.then(invoke);
-      // The chain must never reject, or later submissions would be skipped.
-      const stored = run.catch(() => undefined);
-      submitChains.set(session_id, stored);
-      try {
-        await run;
-      } finally {
-        if (submitChains.get(session_id) === stored) submitChains.delete(session_id);
+      } catch (error) {
+        sendMappedError(reply, req, error);
       }
     },
   );
@@ -526,6 +435,14 @@ function corePartsToProtocol(content: readonly ContentPart[]): PromptSubmission[
         ? { type: 'image', source: { kind: 'url', url: part.imageUrl.url, id: part.imageUrl.id } }
         : { type: 'image', source: { kind: 'base64', media_type: match[1]!, data: match[2]! } });
     } else if (part.type === 'video_url') {
+      // An internal `kimi-file://<id>?path=…` reference projects back to the
+      // daemon upload it came from — the materialization path never leaks to
+      // the client.
+      const kimiFile = parseKimiFileUrl(part.videoUrl.url);
+      if (kimiFile !== undefined) {
+        parts.push({ type: 'video', source: { kind: 'file', file_id: kimiFile.fileId } });
+        continue;
+      }
       const match = /^data:([^;]+);base64,(.*)$/.exec(part.videoUrl.url);
       parts.push(match === null
         ? { type: 'video', source: { kind: 'url', url: part.videoUrl.url, id: part.videoUrl.id } }
@@ -564,18 +481,6 @@ interface ResolvePromptMediaOptions {
   readonly resolveAttachmentsDir?: () => Promise<string | undefined>;
   /** Report an `image_compress` event per compressed prompt image. */
   readonly telemetry?: ITelemetryService;
-  /**
-   * When set, uploaded video files are inlined into the prompt as the
-   * provider-issued reference. Undefined disables inlining — every video
-   * falls back to the file-tag form.
-   */
-  readonly videoUploader?: (input: VideoUploadInput) => Promise<VideoURLPart>;
-  /**
-   * Called after a video is inlined, with the local `/files` id and the
-   * provider-issued file id, so the daemon can map the reference back to
-   * local bytes for playback. Errors are swallowed by the caller.
-   */
-  readonly onVideoInlined?: (localFileId: string, llmFileId: string) => Promise<void>;
 }
 
 async function resolvePromptMediaFiles(
@@ -785,59 +690,21 @@ async function resolvePromptMediaFiles(
       continue;
     }
 
-    // Uploaded video: inline the provider-issued reference into the prompt
-    // so the model receives the video with the user message instead of having
-    // to open it with a tool call. Like the image gate above, the bytes are
-    // authoritative: a mislabeled upload (declared video/* but not actually
-    // one) never reaches the provider and falls back to the file-tag form,
-    // as does a model with no upload channel or a failed upload.
-    if (part.type === 'video' && options.videoUploader !== undefined) {
-      const data = await readFileOrStream(file);
-      const sniffed = detectFileType(
-        file.meta.name,
-        data.subarray(0, MEDIA_SNIFF_BYTES),
-        'media',
-      );
-      if (sniffed.kind === 'video') {
-        try {
-          const uploaded = await options.videoUploader({
-            data,
-            mimeType: sniffed.mimeType,
-            filename: file.meta.name,
-          });
-          content.push({
-            type: 'video',
-            source: { kind: 'url', url: uploaded.videoUrl.url, id: uploaded.videoUrl.id },
-          });
-          changed = true;
-          // Key the playback mapping by the id embedded in the reference URL
-          // — that's what projections and clients read back — falling back
-          // to the explicit id only for non-`ms://` shapes.
-          const refId = msFileIdFromUrl(uploaded.videoUrl.url) ?? uploaded.videoUrl.id;
-          if (refId !== undefined) {
-            await options.onVideoInlined?.(file.meta.id, refId);
-          }
-          continue;
-        } catch {
-          // Fall through to the file-tag form below.
-        }
-      }
-    }
-
+    // Uploaded video: materialize a local copy the model can open as a
+    // fallback, and carry the upload into context as an internal
+    // `kimi-file://<id>?path=<materialized path>` reference. The engine
+    // resolves it to a provider form (upload / inline / `<video path>` tag) at
+    // request time, so the edge never uploads and never blocks on the provider.
     const cachePath = await materializeVideoToCache(file, cacheDir);
-    content.push({ type: 'text', text: `<video path="${escapeAttribute(cachePath)}"></video>` });
+    content.push({
+      type: 'video',
+      source: { kind: 'url', url: buildKimiFileUrl(file.meta.id, cachePath) },
+    });
     changed = true;
   }
   return changed ? { ...body, content } : body;
 }
 
-/** The provider file id behind an `ms://<id>` reference, when present. */
-function msFileIdFromUrl(url: string): string | undefined {
-  if (!url.startsWith('ms://')) return undefined;
-  const id = url.slice('ms://'.length);
-  return id.length > 0 ? id : undefined;
-}
-
 async function materializeVideoToCache(file: GetResult, cacheDir: string): Promise<string> {
   await mkdir(cacheDir, { recursive: true });
   const ext = extname(file.meta.name) || (VIDEO_EXT_BY_MIME[file.meta.media_type.toLowerCase()] ?? '.bin');
@@ -930,14 +797,6 @@ function assertMediaFile(file: GetResult, expected: 'image' | 'video'): void {
   );
 }
 
-function escapeAttribute(value: string): string {
-  return value
-    .replaceAll('&', '&amp;')
-    .replaceAll('"', '&quot;')
-    .replaceAll('<', '&lt;')
-    .replaceAll('>', '&gt;');
-}
-
 function sendMappedError(
   reply: { send(payload: unknown): unknown },
   req: { id: string },
diff --git a/packages/kap-server/test/__snapshots__/apiSurface.snapshot.test.ts.snap b/packages/kap-server/test/__snapshots__/apiSurface.snapshot.test.ts.snap
index b37ef2f2f9..d6585d9036 100644
--- a/packages/kap-server/test/__snapshots__/apiSurface.snapshot.test.ts.snap
+++ b/packages/kap-server/test/__snapshots__/apiSurface.snapshot.test.ts.snap
@@ -64,10 +64,6 @@ exports[`API surface snapshot > matches the documented v2 route table and meta e
       "GET",
       "/api/v1/files/{file_id}",
     ],
-    [
-      "GET",
-      "/api/v1/files/llm/{llm_id}",
-    ],
     [
       "GET",
       "/api/v1/fs:browse",
diff --git a/packages/kap-server/test/files.test.ts b/packages/kap-server/test/files.test.ts
index 3155e52d36..6a9060d1d2 100644
--- a/packages/kap-server/test/files.test.ts
+++ b/packages/kap-server/test/files.test.ts
@@ -12,7 +12,6 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
-import type { IBlobStore } from '@moonshot-ai/agent-core-v2';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 import { type RunningServer, startServer } from '../src/start';
@@ -321,55 +320,3 @@ describe('POST /api/v1/files (server-v2)', () => {
     expect((res.json() as Envelope).code).toBe(40001);
   });
 });
-
-describe('GET /api/v1/files/llm/{llm_id} (server-v2)', () => {
-  it('unknown provider file id → 40407 file not found', async () => {
-    const r = await boot();
-    const res = await appOf(r).inject({
-      method: 'GET',
-      url: '/api/v1/files/llm/no-such-provider-file',
-    });
-    expect(res.statusCode).toBe(404);
-    expect((res.json() as Envelope).code).toBe(40407);
-  });
-
-  it('rejects ids outside the provider-id alphabet (no blob-key traversal)', async () => {
-    const r = await boot();
-    // Encoded separators land inside the {llm_id} param after URL decoding;
-    // the schema must reject them before the value reaches the blob store.
-    for (const bad of ['..%2F..%2Ffiles%2Ff_x', 'a%2Fb', '%2Fetc%2Fpasswd', 'a b']) {
-      const res = await appOf(r).inject({
-        method: 'GET',
-        url: `/api/v1/files/llm/${bad}`,
-      });
-      expect((res.json() as Envelope).code, `llm_id ${bad}`).toBe(40001);
-      expect(res.statusCode).not.toBe(302);
-    }
-  });
-
-  it('never writes a mapping whose provider id leaves the safe alphabet', async () => {
-    const writes: Array<[string, string]> = [];
-    const blobs: IBlobStore = {
-      _serviceBrand: undefined,
-      put: async (scope: string, key: string) => {
-        writes.push([scope, key]);
-      },
-      get: async () => undefined,
-      getStream: async function* () {},
-      has: async () => false,
-      delete: async () => {},
-      list: async () => [],
-    };
-    const { recordLlmVideoRef, resolveLlmVideoRef } = await import('../src/lib/llmVideoRefs');
-
-    await recordLlmVideoRef(blobs, 'good-id_1.2', 'f_local');
-    expect(writes).toEqual([['llm-video', 'good-id_1.2']]);
-
-    for (const bad of ['../escape', 'a/b', '..']) {
-      writes.length = 0;
-      await recordLlmVideoRef(blobs, bad, 'f_local');
-      expect(writes, `llm id ${bad}`).toEqual([]);
-      await expect(resolveLlmVideoRef(blobs, bad)).resolves.toBeUndefined();
-    }
-  });
-});
diff --git a/packages/kap-server/test/prompts.test.ts b/packages/kap-server/test/prompts.test.ts
index 1a564f8ea1..0db4a13480 100644
--- a/packages/kap-server/test/prompts.test.ts
+++ b/packages/kap-server/test/prompts.test.ts
@@ -1,6 +1,4 @@
 import { mkdir, mkdtemp, readFile, realpath, rm, writeFile } from 'node:fs/promises';
-import { createServer, type ServerResponse } from 'node:http';
-import type { AddressInfo } from 'node:net';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { deflateSync } from 'node:zlib';
@@ -258,7 +256,7 @@ describe('server-v2 /api/v1 prompts', () => {
     expect(session!.accessor.get(IAgentLifecycleService).get('main')).toBeUndefined();
   });
 
-  it('falls back to cache path tags for uploaded videos when the model has no upload channel', async () => {
+  it('carries an uploaded video into the prompt as an internal kimi-file reference', async () => {
     const id = await createSession(home as string);
     await createMainAgent(id);
     const videoBytes = Buffer.from('tiny fake mp4 bytes');
@@ -280,16 +278,24 @@ describe('server-v2 /api/v1 prompts', () => {
     });
     expect(submitted.body.code).toBe(0);
 
-    const content = submitted.body.data.content as Array<{ type: string; text?: string }>;
+    // The edge no longer uploads to the provider. The queued prompt reprojects
+    // the video as the file reference it came from — a `{ kind: 'file' }` source
+    // is only ever produced from an internal `kimi-file://` url, so this proves
+    // the enqueued message carries the reference (its materialization path is
+    // never leaked back to the client).
+    const content = submitted.body.data.content as Array<Record<string, unknown>>;
     expect(content).toHaveLength(2);
     expect(content[0]).toEqual({ type: 'text', text: 'what happens in this video?' });
-    expect(content[1]?.type).toBe('text');
-    const match = /<video path="([^"]+)"><\/video>/.exec(content[1]?.text ?? '');
-    expect(match).not.toBeNull();
-    const cachePath = match![1]!;
-    expect(cachePath.startsWith(join(home as string, 'cache'))).toBe(true);
-    expect(cachePath.endsWith('.mp4')).toBe(true);
-    expect(await readFile(cachePath)).toEqual(videoBytes);
+    expect(content[1]).toEqual({
+      type: 'video',
+      source: { kind: 'file', file_id: uploaded.data.id },
+    });
+
+    // The `?path=` of that reference points at a materialized copy of the bytes
+    // (written during the submit), which the engine resolver falls back to when
+    // it cannot upload or inline the video.
+    const materialized = join(home as string, 'cache', `${uploaded.data.id}.mp4`);
+    expect(await readFile(materialized)).toEqual(videoBytes);
   });
 
   it('compresses uploaded image prompts into base64 image parts with a readback caption', async () => {
@@ -896,386 +902,3 @@ describe('server-v2 /api/v1 prompts', () => {
     expect(toolPolicy?.isToolActive('Read')).toBe(true);
   });
 });
-
-describe('server-v2 /api/v1 prompts with a video-upload-capable model', () => {
-  let server: RunningServer | undefined;
-  let home: string | undefined;
-  let base: string;
-  let stubClose: (() => Promise<void>) | undefined;
-  let stubBodies: Buffer[];
-  let uploadGate: Promise<void> | null;
-
-  function kimiToml(stubUrl: string): string {
-    return [
-      'default_model = "stub"',
-      '',
-      '[providers.stub]',
-      'type = "kimi"',
-      `base_url = "${stubUrl}"`,
-      'api_key = "stub"',
-      '',
-      '[models.stub]',
-      'provider = "stub"',
-      'model = "stub"',
-      'max_context_size = 1000',
-      'capabilities = [ "video_in", "image_in" ]',
-      '',
-      '[models.stub2]',
-      'provider = "stub"',
-      'model = "stub2"',
-      'max_context_size = 1000',
-      'capabilities = [ "video_in", "image_in" ]',
-      '',
-    ].join('\n');
-  }
-
-  beforeEach(async () => {
-    stubBodies = [];
-    uploadGate = null;
-    let uploadCounter = 0;
-    const pendingGenerations: ServerResponse[] = [];
-    const stub = createServer((req, res) => {
-      if (req.method === 'POST' && req.url === '/files') {
-        const chunks: Buffer[] = [];
-        req.on('data', (chunk: Buffer) => chunks.push(chunk));
-        req.on('end', () => {
-          void (async () => {
-            if (uploadGate !== null) {
-              const gate = uploadGate;
-              uploadGate = null;
-              await gate;
-            }
-            uploadCounter += 1;
-            stubBodies.push(Buffer.concat(chunks));
-            res.writeHead(200, { 'content-type': 'application/json' });
-            res.end(
-              JSON.stringify({
-                id: `stub-llm-video-${String(uploadCounter)}`,
-                object: 'file',
-                bytes: 17,
-                created_at: 0,
-                filename: 'clip.mp4',
-                purpose: 'video',
-              }),
-            );
-          })();
-        });
-        return;
-      }
-      if (req.method === 'POST' && req.url === '/chat/completions') {
-        // Hang until the turn is aborted: an answered request (404 or a
-        // completed stream) can end the turn before the test's abort lands,
-        // making the cleanup racy.
-        pendingGenerations.push(res);
-        req.on('close', () => {
-          const index = pendingGenerations.indexOf(res);
-          if (index >= 0) pendingGenerations.splice(index, 1);
-          res.end();
-        });
-        return;
-      }
-      res.writeHead(404);
-      res.end();
-    });
-    await new Promise<void>((resolve) => stub.listen(0, '127.0.0.1', resolve));
-    const { port } = stub.address() as AddressInfo;
-    stubClose = () =>
-      new Promise<void>((resolve) => {
-        for (const pending of pendingGenerations.splice(0)) pending.destroy();
-        stub.close(() => resolve());
-      });
-
-    home = await mkdtemp(join(tmpdir(), 'kimi-server-v2-prompts-kimi-'));
-    await writeFile(join(home, 'config.toml'), kimiToml(`http://127.0.0.1:${String(port)}`), 'utf-8');
-    server = await startServer({ host: '127.0.0.1', port: 0, homeDir: home, logLevel: 'silent' });
-    base = `http://127.0.0.1:${server.port}`;
-  });
-
-  afterEach(async () => {
-    if (server !== undefined) {
-      await server.close();
-      server = undefined;
-      await new Promise((resolve) => setTimeout(resolve, 25));
-    }
-    if (stubClose !== undefined) {
-      await stubClose();
-      stubClose = undefined;
-    }
-    if (home !== undefined) {
-      await rm(home, { recursive: true, force: true, maxRetries: 3, retryDelay: 25 } as never);
-      home = undefined;
-    }
-  });
-
-  async function createSessionWithAgent(): Promise<string> {
-    const res = await fetch(`${base}/api/v1/sessions`, {
-      method: 'POST',
-      headers: authHeaders(server as RunningServer, { 'content-type': 'application/json' }),
-      body: JSON.stringify({ metadata: { cwd: home } }),
-    } as never);
-    const body = (await res.json()) as Envelope<{ id: string }>;
-    const session = server!.core.accessor.get(ISessionLifecycleService).get(body.data.id);
-    await session!.accessor.get(IAgentLifecycleService).create({ agentId: 'main' });
-    return body.data.id;
-  }
-
-  async function uploadVideoFile(name: string, bytes: Buffer): Promise<string> {
-    const form = new FormData();
-    form.set('file', new Blob([bytes], { type: 'video/mp4' }), name);
-    const res = await fetch(`${base}/api/v1/files`, {
-      method: 'POST',
-      headers: authHeaders(server as RunningServer),
-      body: form,
-    } as never);
-    const body = (await res.json()) as Envelope<{ id: string }>;
-    expect(body.code).toBe(0);
-    return body.data.id;
-  }
-
-  async function submitVideoPrompt(sessionId: string, fileIds: string[]): Promise<Envelope<PromptItemWire>> {
-    const res = await fetch(`${base}/api/v1/sessions/${sessionId}/prompts`, {
-      method: 'POST',
-      headers: authHeaders(server as RunningServer, { 'content-type': 'application/json' }),
-      body: JSON.stringify({
-        // The prompt-time model override is applied before media resolution,
-        // so the video uploader is built from this model.
-        model: 'stub',
-        content: [
-          { type: 'text', text: 'what happens in this video?' },
-          ...fileIds.map((fileId) => ({ type: 'video', source: { kind: 'file', file_id: fileId } })),
-        ],
-      }),
-    } as never);
-    const body = (await res.json()) as Envelope<PromptItemWire>;
-    expect(body.code).toBe(0);
-    return body;
-  }
-
-  async function abortPrompt(sessionId: string, promptId: string): Promise<void> {
-    // The stub serves no generation, so the turn keeps retrying in the
-    // background; abort it deterministically to let the server close.
-    const res = await fetch(`${base}/api/v1/sessions/${sessionId}/prompts/${promptId}:abort`, {
-      method: 'POST',
-      headers: authHeaders(server as RunningServer),
-    } as never);
-    expect(res.status).toBe(200);
-  }
-
-  async function redirectOf(llmId: string): Promise<{ status: number; location: string | null }> {
-    const res = await fetch(`${base}/api/v1/files/llm/${llmId}`, {
-      headers: authHeaders(server as RunningServer),
-      redirect: 'manual',
-    } as never);
-    return { status: res.status, location: res.headers.get('location') };
-  }
-
-  it('inlines an uploaded video prompt as the provider-issued reference', async () => {
-    const id = await createSessionWithAgent();
-    const videoBytes = Buffer.from('tiny fake mp4 bytes');
-    const fileId = await uploadVideoFile('clip.mp4', videoBytes);
-
-    const submitted = await submitVideoPrompt(id, [fileId]);
-
-    // The prompt carries the provider-issued reference, not a path tag.
-    const content = submitted.data.content as Array<Record<string, unknown>>;
-    expect(content[0]).toEqual({ type: 'text', text: 'what happens in this video?' });
-    expect(content[1]).toEqual({
-      type: 'video',
-      source: { kind: 'url', url: 'ms://stub-llm-video-1', id: 'stub-llm-video-1' },
-    });
-
-    // The upload happened synchronously, before the prompt was accepted, and
-    // carried the video bytes.
-    expect(stubBodies).toHaveLength(1);
-    expect(stubBodies[0]!.includes(videoBytes)).toBe(true);
-
-    // The provider id maps back to the local upload for playback.
-    const { status, location } = await redirectOf('stub-llm-video-1');
-    expect(status).toBe(302);
-    expect(location).toBe(`/api/v1/files/${fileId}`);
-
-    const downloadRes = await fetch(`${base}${location}`, {
-      headers: authHeaders(server as RunningServer),
-    } as never);
-    expect(downloadRes.status).toBe(200);
-    expect(Buffer.from(await downloadRes.arrayBuffer())).toEqual(videoBytes);
-
-    await abortPrompt(id, submitted.data.prompt_id);
-  });
-
-  it('maps each inlined video back to its own upload', async () => {
-    const id = await createSessionWithAgent();
-    const fileA = await uploadVideoFile('a.mp4', Buffer.from('video-A'));
-    const fileB = await uploadVideoFile('b.mp4', Buffer.from('video-B'));
-
-    const submitted = await submitVideoPrompt(id, [fileA, fileB]);
-
-    expect(stubBodies).toHaveLength(2);
-    const content = submitted.data.content as Array<Record<string, unknown>>;
-    expect(content[1]).toEqual({
-      type: 'video',
-      source: { kind: 'url', url: 'ms://stub-llm-video-1', id: 'stub-llm-video-1' },
-    });
-    expect(content[2]).toEqual({
-      type: 'video',
-      source: { kind: 'url', url: 'ms://stub-llm-video-2', id: 'stub-llm-video-2' },
-    });
-    expect((await redirectOf('stub-llm-video-1')).location).toBe(`/api/v1/files/${fileA}`);
-    expect((await redirectOf('stub-llm-video-2')).location).toBe(`/api/v1/files/${fileB}`);
-
-    await abortPrompt(id, submitted.data.prompt_id);
-  });
-
-  it('serves range requests through the llm redirect', async () => {
-    const id = await createSessionWithAgent();
-    const fileId = await uploadVideoFile('clip.mp4', Buffer.from('0123456789'));
-
-    const submitted = await submitVideoPrompt(id, [fileId]);
-
-    const { location } = await redirectOf('stub-llm-video-1');
-    const rangeRes = await fetch(`${base}${location}`, {
-      headers: { ...authHeaders(server as RunningServer), range: 'bytes=2-5' },
-    } as never);
-    expect(rangeRes.status).toBe(206);
-    expect(rangeRes.headers.get('content-range')).toBe('bytes 2-5/10');
-    expect(Buffer.from(await rangeRes.arrayBuffer()).toString()).toBe('2345');
-
-    await abortPrompt(id, submitted.data.prompt_id);
-  });
-
-  it('falls back to the tag form when an uploaded "video" sniffs as another kind', async () => {
-    const id = await createSessionWithAgent();
-    // Declared video/mp4 at upload time, but the bytes are a PNG (magic
-    // bytes are authoritative; a text lookalike would be indistinguishable
-    // from MPEG-PS and is the provider's call, same as ReadMediaFile).
-    const pngBytes = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00]);
-    const fileId = await uploadVideoFile('clip.mp4', pngBytes);
-
-    const submitted = await submitVideoPrompt(id, [fileId]);
-
-    // No provider upload is attempted for bytes sniffed as a non-video kind.
-    expect(stubBodies).toHaveLength(0);
-    const content = submitted.data.content as Array<Record<string, unknown>>;
-    expect(content[1]?.['type']).toBe('text');
-    expect(String(content[1]?.['text'])).toMatch(/<video path="[^"]+"><\/video>/);
-
-    await abortPrompt(id, submitted.data.prompt_id);
-  });
-
-  it('rejects the submission when the model switches mid-upload', async () => {
-    const id = await createSessionWithAgent();
-    const fileId = await uploadVideoFile('clip.mp4', Buffer.from('0123456789'));
-
-    let releaseUpload!: () => void;
-    uploadGate = new Promise<void>((resolve) => {
-      releaseUpload = resolve;
-    });
-    const submit = fetch(`${base}/api/v1/sessions/${id}/prompts`, {
-      method: 'POST',
-      headers: authHeaders(server as RunningServer, { 'content-type': 'application/json' }),
-      body: JSON.stringify({
-        model: 'stub',
-        content: [
-          { type: 'text', text: 'watch this' },
-          { type: 'video', source: { kind: 'file', file_id: fileId } },
-        ],
-      }),
-    } as never);
-
-    // A concurrent model switch lands while the upload is parked.
-    const session = server!.core.accessor.get(ISessionLifecycleService).get(id);
-    const agent = session!.accessor.get(IAgentLifecycleService).get('main')!;
-    await agent.accessor.get(IAgentProfileService).setModel('stub2');
-    releaseUpload();
-
-    const body = (await (await submit).json()) as Envelope<null>;
-    expect(body.code).toBe(40901);
-  });
-
-  it('inlines videos on a first prompt that binds a profile without an explicit model', async () => {
-    const id = await createSessionWithAgent();
-    const videoBytes = Buffer.from('tiny fake mp4 bytes');
-    const fileId = await uploadVideoFile('clip.mp4', videoBytes);
-
-    // `profile` without `model`: the uploader must resolve the configured
-    // default model (video-capable) instead of falling back to a path tag.
-    const submitRes = await fetch(`${base}/api/v1/sessions/${id}/prompts`, {
-      method: 'POST',
-      headers: authHeaders(server as RunningServer, { 'content-type': 'application/json' }),
-      body: JSON.stringify({
-        profile: 'agent',
-        content: [
-          { type: 'text', text: 'what happens in this video?' },
-          { type: 'video', source: { kind: 'file', file_id: fileId } },
-        ],
-      }),
-    } as never);
-    const submitted = (await submitRes.json()) as Envelope<PromptItemWire>;
-    expect(submitted.code).toBe(0);
-
-    const content = submitted.data.content as Array<Record<string, unknown>>;
-    expect(content[1]).toEqual({
-      type: 'video',
-      source: { kind: 'url', url: 'ms://stub-llm-video-1', id: 'stub-llm-video-1' },
-    });
-    expect(stubBodies).toHaveLength(1);
-
-    await abortPrompt(id, submitted.data.prompt_id);
-  });
-
-  it('serializes concurrent submissions so a media upload cannot be overtaken', async () => {
-    const id = await createSessionWithAgent();
-    const fileId = await uploadVideoFile('clip.mp4', Buffer.from('0123456789'));
-
-    // Gate the provider upload: the video submit parks inside media
-    // resolution while a later text submit races it.
-    let releaseUpload!: () => void;
-    uploadGate = new Promise<void>((resolve) => {
-      releaseUpload = resolve;
-    });
-    const first = submitVideoPrompt(id, [fileId]);
-    const second = fetch(`${base}/api/v1/sessions/${id}/prompts`, {
-      method: 'POST',
-      headers: authHeaders(server as RunningServer, { 'content-type': 'application/json' }),
-      body: JSON.stringify({ content: [{ type: 'text', text: 'follow-up' }] }),
-    } as never);
-    await new Promise((r) => setTimeout(r, 100));
-    releaseUpload();
-
-    const [firstSubmitted, secondRes] = await Promise.all([first, second]);
-    const secondSubmitted = (await secondRes.json()) as Envelope<PromptItemWire>;
-    expect(firstSubmitted.code).toBe(0);
-    expect(secondSubmitted.code).toBe(0);
-
-    // The video prompt holds the active slot; the follow-up waits behind it
-    // in the queue instead of overtaking.
-    const listRes = await fetch(`${base}/api/v1/sessions/${id}/prompts`, {
-      headers: authHeaders(server as RunningServer),
-    } as never);
-    const list = ((await listRes.json()) as Envelope<{
-      active: { prompt_id: string } | null;
-      queued: Array<{ prompt_id: string }>;
-    }>).data;
-    expect(list.active?.prompt_id).toBe(firstSubmitted.data.prompt_id);
-    expect(list.queued.map((p) => p.prompt_id)).toEqual([secondSubmitted.data.prompt_id]);
-
-    await abortPrompt(id, firstSubmitted.data.prompt_id);
-  });
-
-  it('keeps the llm video mapping across a server restart', async () => {    const id = await createSessionWithAgent();
-    const fileId = await uploadVideoFile('clip.mp4', Buffer.from('persisted'));
-
-    const submitted = await submitVideoPrompt(id, [fileId]);
-    await abortPrompt(id, submitted.data.prompt_id);
-
-    await server!.close();
-    server = undefined;
-    await new Promise((resolve) => setTimeout(resolve, 25));
-    server = await startServer({ host: '127.0.0.1', port: 0, homeDir: home, logLevel: 'silent' });
-    base = `http://127.0.0.1:${server.port}`;
-
-    const { status, location } = await redirectOf('stub-llm-video-1');
-    expect(status).toBe(302);
-    expect(location).toBe(`/api/v1/files/${fileId}`);
-  });
-});
diff --git a/packages/node-sdk/src/rpc.ts b/packages/node-sdk/src/rpc.ts
index fd12e1e0a8..41abb8e277 100644
--- a/packages/node-sdk/src/rpc.ts
+++ b/packages/node-sdk/src/rpc.ts
@@ -59,7 +59,6 @@ import type {
   SkillSummary,
   PluginCommandDef,
   Unsubscribe,
-  VideoURLPart,
 } from '#/types';
 
 const MAIN_AGENT_ID = 'main';
@@ -328,15 +327,6 @@ export abstract class SDKRpcClientBase {
     });
   }
 
-  async uploadVideo(input: SessionIdRpcInput & { path: string }): Promise<VideoURLPart> {
-    const rpc = await this.getRpc();
-    return rpc.uploadVideo({
-      sessionId: input.sessionId,
-      agentId: this.interactiveAgentId,
-      path: input.path,
-    });
-  }
-
   async runShellCommand(input: {
     sessionId: string;
     command: string;
diff --git a/packages/node-sdk/src/session.ts b/packages/node-sdk/src/session.ts
index f767d0f509..571c2355ff 100644
--- a/packages/node-sdk/src/session.ts
+++ b/packages/node-sdk/src/session.ts
@@ -36,7 +36,6 @@ import type {
   PluginCommandDef,
   ThinkingEffort,
   Unsubscribe,
-  VideoURLPart,
 } from '#/types';
 
 const MAIN_AGENT_ID = 'main';
@@ -112,18 +111,6 @@ export class Session {
     });
   }
 
-  /**
-   * Upload a local video file through the session's current model and return
-   * the provider-issued `video_url` part, ready to embed in a prompt.
-   * Rejects when the model has no video upload channel — the caller decides
-   * how to degrade (e.g. fall back to a path reference the model can open
-   * with ReadMediaFile).
-   */
-  async uploadVideo(path: string): Promise<VideoURLPart> {
-    this.ensureOpen();
-    return this.rpc.uploadVideo({ sessionId: this.id, path });
-  }
-
   /** Execute a user-initiated `!` shell command (silent — does not prompt the
    *  model). Resolves with the command's stdout/stderr for immediate display.
    *  Pass `commandId` to receive live `shell.output` events for this command. */
diff --git a/packages/node-sdk/src/types.ts b/packages/node-sdk/src/types.ts
index 02ee3b642f..0968d96a18 100644
--- a/packages/node-sdk/src/types.ts
+++ b/packages/node-sdk/src/types.ts
@@ -70,7 +70,7 @@ export type {
 
 export type { KimiHostIdentity, OAuthRefreshOutcome };
 export type { TelemetryClient, TelemetryContextPatch, TelemetryProperties };
-export type { ContentPart, Role, ThinkingEffort, ToolCall, VideoURLPart } from '@moonshot-ai/kosong';
+export type { ContentPart, Role, ThinkingEffort, ToolCall } from '@moonshot-ai/kosong';
 
 export type PermissionMode = 'yolo' | 'manual' | 'auto';
 
diff --git a/packages/node-sdk/test/session-prompt-input.test.ts b/packages/node-sdk/test/session-prompt-input.test.ts
index c073a8c45e..f88c710009 100644
--- a/packages/node-sdk/test/session-prompt-input.test.ts
+++ b/packages/node-sdk/test/session-prompt-input.test.ts
@@ -158,21 +158,4 @@ describe('Session.prompt input normalization', () => {
       ]),
     );
   });
-
-  it('uploads a video through the session RPC and returns the issued reference', async () => {
-    const uploadVideo = vi.fn(async () => ({
-      type: 'video_url' as const,
-      videoUrl: { url: 'ms://file-123', id: 'file-123' },
-    }));
-    const session = new Session({
-      id: 'ses_upload_video',
-      workDir: '/tmp/work',
-      rpc: { uploadVideo } as unknown as SDKRpcClientBase,
-    });
-
-    const part = await session.uploadVideo('/tmp/clip.mp4');
-
-    expect(part).toEqual({ type: 'video_url', videoUrl: { url: 'ms://file-123', id: 'file-123' } });
-    expect(uploadVideo).toHaveBeenCalledWith({ sessionId: 'ses_upload_video', path: '/tmp/clip.mp4' });
-  });
 });

From 1c50a404fb2a0c2224360c97037ac80a82f5664e Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Wed, 22 Jul 2026 01:49:32 +0800
Subject: [PATCH 41/45] fix: propagate abort through video upload delivery
 instead of degrading

A turn cancelled mid-upload used to be treated as an ordinary upload
failure: v1 fell back to an inline base64 part and appended the degraded
message to history, and the v2 resolver memoized the tag fallback for the
rest of the agent's lifetime. Both catch sites now check the delivery
signal itself - abort rejections vary in shape by provider - and re-throw
so cancellation ends the turn (v1, classified as cancelled via the abort
reason) or the request (v2, not memoized, so the next turn uploads).
---
 .../src/agent/media/videoResolverService.ts   | Bin 7674 -> 7964 bytes
 .../test/agent/media/videoResolver.test.ts    |  25 +++++++++++
 .../src/agent/turn/media-resolve.ts           |  13 ++++--
 .../src/tools/support/video-delivery.ts       |  17 ++++---
 packages/agent-core/src/utils/abort.ts        |   2 +-
 packages/agent-core/test/agent/basic.test.ts  |  42 ++++++++++++++++++
 6 files changed, 90 insertions(+), 9 deletions(-)

diff --git a/packages/agent-core-v2/src/agent/media/videoResolverService.ts b/packages/agent-core-v2/src/agent/media/videoResolverService.ts
index 68cf41ea2db7c0561fd4f553a2ef331b19c78fbf..c3e4f68b29b9452d906779b85d84bb900e87d82e 100644
GIT binary patch
delta 297
zcmXYsF-`+95Jihfh|nO4^izR^l3V}@q*PpE)*gEeUe7Z228AZvA(T*X14Js$z%4ii
zG>nrJZbtuqzxR9fdj0V>T2BF!)dxc#87+iVNMz^>S!h;JT7q1tzsP_MOTFgc6Gjl4
zl~(vM!_V`}30y*Mv8NgO#JL1B)m$>PZ)y0BObMJaEKyc<xffmryC$i9$P5NGA0yUS
z-J@jl?th_&fpSqaB~e6n&{4<XDI^aFmb{=<Fo!WVXzszW9E#dvSI4RcdP+q_VsKPK
gM{`*4_I>nscDh%(nI9B4Uz79A_tAL!Ik`Rl2W&iTQ~&?~

delta 17
ZcmbPZ_se?2T;|QwS^f)d-X|8v0RT(m2de-8

diff --git a/packages/agent-core-v2/test/agent/media/videoResolver.test.ts b/packages/agent-core-v2/test/agent/media/videoResolver.test.ts
index c89d6e2083..1630bcc243 100644
--- a/packages/agent-core-v2/test/agent/media/videoResolver.test.ts
+++ b/packages/agent-core-v2/test/agent/media/videoResolver.test.ts
@@ -209,6 +209,31 @@ describe('AgentVideoResolverService', () => {
     ).rejects.toThrow('unauthorized');
   });
 
+  it('rethrows a cancelled upload without memoizing the fallback', async () => {
+    const controller = new AbortController();
+    // The rejection is deliberately NOT abort-shaped: the aborted signal alone
+    // must decide cancellation, since abort error shapes vary by provider.
+    const interrupted = vi.fn(async () => {
+      controller.abort();
+      throw new Error('socket closed');
+    });
+    const resolver = new AgentVideoResolverService(
+      fileService(new Map([[FILE_ID, { name: 'clip.mp4', bytes: VIDEO_BYTES }]])),
+      blobStore(),
+      telemetry,
+    );
+    const message = videoMessage(buildKimiFileUrl(FILE_ID, FALLBACK_PATH));
+
+    await expect(
+      resolver.resolve([message], requester({ uploadVideo: interrupted }), controller.signal),
+    ).rejects.toThrow('socket closed');
+
+    const retry = vi.fn(async (): Promise<VideoURLPart> => msPart('prov-1'));
+    const out = await resolver.resolve([message], requester({ uploadVideo: retry }));
+    expect(firstPart(out)).toEqual(msPart('prov-1'));
+    expect(retry).toHaveBeenCalledTimes(1);
+  });
+
   it('tags when the bytes do not sniff as a video', async () => {
     const upload = vi.fn();
     const out = await new AgentVideoResolverService(
diff --git a/packages/agent-core/src/agent/turn/media-resolve.ts b/packages/agent-core/src/agent/turn/media-resolve.ts
index 0d6fe0b589..14581d01de 100644
--- a/packages/agent-core/src/agent/turn/media-resolve.ts
+++ b/packages/agent-core/src/agent/turn/media-resolve.ts
@@ -13,8 +13,10 @@
  * Two entry points:
  *   - `resolvePromptMedia` (async): the primary prompt path. Validates and
  *     uploads through the provider's channel (see `deliverVideoContent`),
- *     degrading to a `<video path>` tag on validation failure and re-throwing
- *     auth rejections so the turn fails visibly.
+ *     degrading to a `<video path>` tag on validation failure, re-throwing
+ *     auth rejections so the turn fails visibly, and re-throwing the abort
+ *     reason when the turn is cancelled mid-upload so the cancellation ends
+ *     the turn instead of appending a degraded message.
  *   - `degradeUnresolvedVideoToTag` (sync): the always-safe floor for the few
  *     append sites that cannot await an upload (steer-buffer flushes, the
  *     budget-exhausted goal turn). The local video becomes a `<video path>`
@@ -30,6 +32,7 @@ import type { Agent } from '..';
 import { MEDIA_SNIFF_BYTES, detectFileType } from '../../tools/support/file-type';
 import { deliverVideoContent, isAuthUploadError } from '../../tools/support/video-delivery';
 import { MAX_MEDIA_BYTES } from '../../tools/builtin/file/read-media';
+import { abortReason } from '../../utils/abort';
 
 /** The local filesystem path behind a prompt-attached `file://` video part. */
 function localVideoUrl(part: ContentPart): string | undefined {
@@ -108,8 +111,12 @@ async function resolveOneVideo(
       signal,
     );
   } catch (error) {
-    // Auth rejections must surface (credential refresh + clear error); any
+    // A cancelled turn surfaces as its abort reason — whatever error the
+    // interrupted read/upload happened to produce, the user's cancellation is
+    // the real outcome, not a delivery failure to degrade around. Auth
+    // rejections must also surface (credential refresh + clear error); any
     // other read/upload failure degrades to the always-safe tag form.
+    if (signal?.aborted) throw abortReason(signal);
     if (isAuthUploadError(error)) throw error;
     return videoTag(path);
   }
diff --git a/packages/agent-core/src/tools/support/video-delivery.ts b/packages/agent-core/src/tools/support/video-delivery.ts
index 9ce4c45fc7..c6d23b1392 100644
--- a/packages/agent-core/src/tools/support/video-delivery.ts
+++ b/packages/agent-core/src/tools/support/video-delivery.ts
@@ -4,10 +4,12 @@
  * A local video becomes a model-visible content part through one channel:
  * upload it via the provider's video upload channel (the tiny `ms://<id>`
  * reference), and only fall back to an inline base64 `data:` part when the
- * channel is missing or the upload fails for a non-auth reason. Auth
- * rejections (401/403) are the exception: they must surface so credential
- * refresh runs and the user sees a clear auth error, instead of being masked
- * behind an inline payload the next request would also reject.
+ * channel is missing or the upload fails for a non-auth reason. Two failures
+ * are the exception and must surface instead of being masked behind an inline
+ * payload: auth rejections (401/403), which drive credential refresh and a
+ * clear auth error, and a cancelled delivery signal — the caller is tearing
+ * the turn down, so the interruption propagates as the signal's abort reason
+ * rather than silently delivering a degraded part.
  *
  * Both ReadMediaFile (videos the model reads itself) and the turn-level
  * prompt-media resolver (videos attached directly to a prompt) share this
@@ -17,6 +19,7 @@
 import type { ContentPart, VideoUploadInput, VideoURLPart } from '@moonshot-ai/kosong';
 
 import { ErrorCodes } from '../../errors';
+import { abortReason } from '../../utils/abort';
 
 /** Uploads a local video and returns the provider-issued `video_url` part. */
 export type VideoUploader = (
@@ -42,7 +45,8 @@ export function isAuthUploadError(error: unknown): boolean {
  * falling back to an inline base64 part when the channel is missing or the
  * upload fails for a non-auth reason — a failed upload must not turn the whole
  * delivery into an error. Auth rejections (401/403) are re-thrown so the
- * caller can surface them.
+ * caller can surface them, and a cancelled `signal` re-throws its abort
+ * reason so cancellation ends the delivery instead of degrading it.
  */
 export async function deliverVideoContent(
   input: VideoUploadInput,
@@ -56,6 +60,9 @@ export async function deliverVideoContent(
       // as before signal support existed.
       return await (signal === undefined ? uploader(input) : uploader(input, { signal }));
     } catch (error) {
+      // The signal check (not the error's shape) decides cancellation: abort
+      // rejections vary by provider, but our own aborted signal is definitive.
+      if (signal?.aborted) throw abortReason(signal);
       if (isAuthUploadError(error)) throw error;
       // Fall through to the inline form.
     }
diff --git a/packages/agent-core/src/utils/abort.ts b/packages/agent-core/src/utils/abort.ts
index d452f0079e..2a7bdcf413 100644
--- a/packages/agent-core/src/utils/abort.ts
+++ b/packages/agent-core/src/utils/abort.ts
@@ -59,7 +59,7 @@ export function linkAbortSignal(source: AbortSignal, target: AbortController): (
   };
 }
 
-function abortReason(signal: AbortSignal): Error {
+export function abortReason(signal: AbortSignal): Error {
   if (signal.reason instanceof Error && !isDefaultAbortReason(signal.reason)) {
     return signal.reason;
   }
diff --git a/packages/agent-core/test/agent/basic.test.ts b/packages/agent-core/test/agent/basic.test.ts
index df650a5760..34a94c15cc 100644
--- a/packages/agent-core/test/agent/basic.test.ts
+++ b/packages/agent-core/test/agent/basic.test.ts
@@ -263,6 +263,48 @@ describe('prompt-attached video resolution', () => {
     }
   });
 
+  it('ends the turn as cancelled when the user aborts mid-upload, appending nothing', async () => {
+    // A /files stub that never responds: the upload only settles when the
+    // turn's abort signal tears the in-flight request down, so the rejection
+    // reaching the resolver is whatever shape the HTTP client aborts with —
+    // the aborted signal alone must classify it as a cancellation.
+    let requestArrived!: () => void;
+    const arrived = new Promise<void>((resolve) => {
+      requestArrived = resolve;
+    });
+    const server = createServer((req) => {
+      req.resume();
+      requestArrived();
+    });
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const { port } = server.address() as AddressInfo;
+    try {
+      const ctx = testAgent();
+      ctx.configure({
+        provider: kimiProvider(`http://127.0.0.1:${String(port)}`),
+        modelCapabilities: VIDEO_CAPS,
+      });
+
+      await ctx.rpc.prompt({ input: [{ type: 'video_url', videoUrl: { url: fileUrl(tempVideo()) } }] });
+      await arrived;
+      await ctx.rpc.cancel({ turnId: 0 });
+      const events = await ctx.untilTurnEnd();
+
+      expect(events).toContainEqual(
+        expect.objectContaining({
+          event: 'turn.ended',
+          args: expect.objectContaining({ reason: 'cancelled' }),
+        }),
+      );
+      // The cancelled prompt is not delivered at all: no user message enters
+      // history, and in particular no inline-base64 degraded copy of it.
+      expect(ctx.agent.context.data().history).toEqual([]);
+    } finally {
+      server.closeAllConnections();
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    }
+  });
+
   it('degrades to a <video path> tag when the model lacks video_in (no upload)', async () => {
     const stub = await stubFilesServer();
     try {

From a32e0b6c7df8d568e0c7c466bc0ee2ba2a002785 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Wed, 22 Jul 2026 01:50:03 +0800
Subject: [PATCH 42/45] fix: keep the tag form for no-upload providers whose
 wire drops inline video

An OpenAI-family model configured with video_in but no provider upload
channel used to receive prompt videos as an inline base64 part - which
chat completions rejects and the Responses adapter degrades to an
omitted-video placeholder, persisting ~4/3x the file size in history for
bytes the model never sees. The prompt path now mirrors the v2 resolver's
protocol gate and degrades to the <video path> tag instead; ReadMediaFile's
own delivery is unchanged. Also merges the prompt-video changesets into a
single user-facing entry.
---
 .../fix-read-media-video-upload-fallback.md   |  2 +-
 .changeset/prompt-video-inline.md             |  2 +-
 .changeset/web-video-playback-after-reload.md |  5 ----
 .../src/agent/turn/media-resolve.ts           | 20 +++++++++++++--
 .../src/tools/support/video-delivery.ts       | 10 ++++++++
 packages/agent-core/test/agent/basic.test.ts  | 25 ++++++++++++++++++-
 6 files changed, 54 insertions(+), 10 deletions(-)
 delete mode 100644 .changeset/web-video-playback-after-reload.md

diff --git a/.changeset/fix-read-media-video-upload-fallback.md b/.changeset/fix-read-media-video-upload-fallback.md
index 5ce6d3b140..c3655aac65 100644
--- a/.changeset/fix-read-media-video-upload-fallback.md
+++ b/.changeset/fix-read-media-video-upload-fallback.md
@@ -2,4 +2,4 @@
 "@moonshot-ai/kimi-code": patch
 ---
 
-Fix ReadMediaFile failing on videos when the model's provider has no usable file upload channel — the video now falls back to being sent inline.
+Fix ReadMediaFile failing on videos when the provider has no file upload channel — such videos now fall back to inline delivery.
diff --git a/.changeset/prompt-video-inline.md b/.changeset/prompt-video-inline.md
index e6e4d9b381..bd3cacc543 100644
--- a/.changeset/prompt-video-inline.md
+++ b/.changeset/prompt-video-inline.md
@@ -2,4 +2,4 @@
 "@moonshot-ai/kimi-code": minor
 ---
 
-Send videos attached to a prompt (pasted in the TUI or uploaded in the web UI) to the model together with the prompt, instead of routing them through a ReadMediaFile tool call — video input no longer costs an extra tool round trip.
+Videos attached to a prompt — pasted in the TUI or uploaded in the web UI — now reach the model together with the prompt, with no extra tool round trip, and stay playable in the chat after a reload.
diff --git a/.changeset/web-video-playback-after-reload.md b/.changeset/web-video-playback-after-reload.md
deleted file mode 100644
index 23bd3115d8..0000000000
--- a/.changeset/web-video-playback-after-reload.md
+++ /dev/null
@@ -1,5 +0,0 @@
----
-"@moonshot-ai/kimi-code": patch
----
-
-web: Keep uploaded videos playable in the chat after reloading or resuming a session.
diff --git a/packages/agent-core/src/agent/turn/media-resolve.ts b/packages/agent-core/src/agent/turn/media-resolve.ts
index 14581d01de..08d7f4fc1a 100644
--- a/packages/agent-core/src/agent/turn/media-resolve.ts
+++ b/packages/agent-core/src/agent/turn/media-resolve.ts
@@ -30,7 +30,11 @@ import type { ContentPart } from '@moonshot-ai/kosong';
 
 import type { Agent } from '..';
 import { MEDIA_SNIFF_BYTES, detectFileType } from '../../tools/support/file-type';
-import { deliverVideoContent, isAuthUploadError } from '../../tools/support/video-delivery';
+import {
+  deliverVideoContent,
+  inlineVideoSupported,
+  isAuthUploadError,
+} from '../../tools/support/video-delivery';
 import { MAX_MEDIA_BYTES } from '../../tools/builtin/file/read-media';
 import { abortReason } from '../../utils/abort';
 
@@ -105,9 +109,21 @@ async function resolveOneVideo(
     if (stat.stSize > MAX_MEDIA_BYTES) return videoTag(path);
 
     const data = await agent.kaos.readBytes(path);
+    const uploader = agent.tools.videoUploader();
+    // No upload channel and a wire that drops inline video (OpenAI family):
+    // the tag is the only form that actually reaches the model — an inline
+    // part would persist ~4/3× the file size in history just to be degraded
+    // to a placeholder on every request.
+    if (
+      uploader === undefined &&
+      agent.config.hasProvider &&
+      !inlineVideoSupported(agent.config.provider.name)
+    ) {
+      return videoTag(path);
+    }
     return await deliverVideoContent(
       { data, mimeType: fileType.mimeType, filename: path.split(/[\\/]/).at(-1) },
-      agent.tools.videoUploader(),
+      uploader,
       signal,
     );
   } catch (error) {
diff --git a/packages/agent-core/src/tools/support/video-delivery.ts b/packages/agent-core/src/tools/support/video-delivery.ts
index c6d23b1392..291078f6d0 100644
--- a/packages/agent-core/src/tools/support/video-delivery.ts
+++ b/packages/agent-core/src/tools/support/video-delivery.ts
@@ -40,6 +40,16 @@ export function isAuthUploadError(error: unknown): boolean {
   return statusCode === 401 || statusCode === 403;
 }
 
+/**
+ * Whether the provider's wire format can carry an inline `data:` video part.
+ * The OpenAI family cannot: chat completions rejects the part outright and
+ * the Responses adapter degrades it to an omitted-video placeholder, so an
+ * inline fallback there only bloats history with bytes the model never sees.
+ */
+export function inlineVideoSupported(providerName: string): boolean {
+  return providerName !== 'openai' && providerName !== 'openai-responses';
+}
+
 /**
  * Deliver a video through the provider's upload channel when available,
  * falling back to an inline base64 part when the channel is missing or the
diff --git a/packages/agent-core/test/agent/basic.test.ts b/packages/agent-core/test/agent/basic.test.ts
index 34a94c15cc..bf7eaefd83 100644
--- a/packages/agent-core/test/agent/basic.test.ts
+++ b/packages/agent-core/test/agent/basic.test.ts
@@ -333,7 +333,8 @@ describe('prompt-attached video resolution', () => {
   it('falls back to an inline base64 part when the provider has no upload channel', async () => {
     const ctx = testAgent();
     ctx.configure({
-      provider: { type: 'openai', apiKey: 'test-key', model: 'mock-model' },
+      // Anthropic: no upload channel, but the wire carries inline data: video.
+      provider: { type: 'anthropic', apiKey: 'test-key', model: 'mock-model' },
       modelCapabilities: VIDEO_CAPS,
     });
     ctx.mockNextResponse({ type: 'text', text: 'ok' });
@@ -345,6 +346,28 @@ describe('prompt-attached video resolution', () => {
     expect(part?.type === 'video_url' && part.videoUrl.url).toMatch(/^data:video\/mp4;base64,/);
   });
 
+  it.each(['openai', 'openai_responses'] as const)(
+    'degrades to a <video path> tag for a no-upload %s provider whose wire drops inline video',
+    async (type) => {
+      const ctx = testAgent();
+      ctx.configure({
+        provider: { type, apiKey: 'test-key', model: 'mock-model' },
+        modelCapabilities: VIDEO_CAPS,
+      });
+      ctx.mockNextResponse({ type: 'text', text: 'ok' });
+
+      const path = tempVideo();
+      await ctx.rpc.prompt({ input: [{ type: 'video_url', videoUrl: { url: fileUrl(path) } }] });
+      await ctx.untilTurnEnd();
+
+      const text = firstUserContent(ctx)
+        .map((p) => (p.type === 'text' ? p.text : ''))
+        .join('');
+      expect(text).toContain(`<video path="${path}">`);
+      expect(firstUserContent(ctx).some((p) => p.type === 'video_url')).toBe(false);
+    },
+  );
+
   it('falls back to an inline base64 part on a non-auth upload failure', async () => {
     const stub = await stubFilesServer(400);
     try {

From 353210af30adf35ba3513c258613fd28e5252941 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Wed, 22 Jul 2026 02:07:23 +0800
Subject: [PATCH 43/45] fix: escape the NUL separator in the video upload cache
 key

The cache-key template literal contained a literal NUL byte instead of
the \0 escape, which made Git classify the whole source file as binary
- no inline diffs, unreliable text tooling. The escape produces the
byte-identical runtime string, so hashed cache keys are unchanged.
---
 .../src/agent/media/videoResolverService.ts   | Bin 7964 -> 7965 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/packages/agent-core-v2/src/agent/media/videoResolverService.ts b/packages/agent-core-v2/src/agent/media/videoResolverService.ts
index c3e4f68b29b9452d906779b85d84bb900e87d82e..432c1b8699f9b9dec877ddb30b304b56415db478 100644
GIT binary patch
delta 15
WcmbPZH`i{1BtKJ(!DcCbCIJ8_WdsTU

delta 14
VcmbPhH^**+BtIj=W@&yV0RSQ}1AYJi


From febd214d682c445e39fbbbe50559670036a1029d Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Wed, 22 Jul 2026 10:49:05 +0800
Subject: [PATCH 44/45] fix: check the abort signal before the inline video
 fallback

The no-uploader inline path (and the post-upload-failure fall-through)
never consulted the delivery signal, so cancelling a turn while the video
bytes were being read still base64-encoded the file and appended the
degraded message to history. The inline branch now re-throws the abort
reason first, matching the upload catch.
---
 .../src/tools/support/video-delivery.ts       |  4 +++
 packages/agent-core/test/agent/basic.test.ts  | 31 ++++++++++++++++++-
 2 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/packages/agent-core/src/tools/support/video-delivery.ts b/packages/agent-core/src/tools/support/video-delivery.ts
index 291078f6d0..aec6ac364e 100644
--- a/packages/agent-core/src/tools/support/video-delivery.ts
+++ b/packages/agent-core/src/tools/support/video-delivery.ts
@@ -77,6 +77,10 @@ export async function deliverVideoContent(
       // Fall through to the inline form.
     }
   }
+  // Cancellation must also beat the no-uploader inline path: encoding up to
+  // 100MB after the user aborted only produces a part the caller would then
+  // persist against their intent.
+  if (signal?.aborted) throw abortReason(signal);
   const base64 = Buffer.from(input.data).toString('base64');
   return {
     type: 'video_url',
diff --git a/packages/agent-core/test/agent/basic.test.ts b/packages/agent-core/test/agent/basic.test.ts
index bf7eaefd83..1df4648ecf 100644
--- a/packages/agent-core/test/agent/basic.test.ts
+++ b/packages/agent-core/test/agent/basic.test.ts
@@ -5,7 +5,7 @@ import { mkdtempSync, truncateSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 
 import { FLAG_DEFINITIONS, FlagResolver } from '../../src/flags';
 import { createCommandKaos, testAgent } from './harness/agent';
@@ -305,6 +305,35 @@ describe('prompt-attached video resolution', () => {
     }
   });
 
+  it('ends the turn as cancelled when the user aborts before the inline fallback', async () => {
+    const ctx = testAgent();
+    ctx.configure({
+      // Anthropic: no upload channel, so resolution heads for the inline
+      // fallback — the abort must beat the base64 encode.
+      provider: { type: 'anthropic', apiKey: 'test-key', model: 'mock-model' },
+      modelCapabilities: VIDEO_CAPS,
+    });
+
+    const path = tempVideo();
+    const realReadBytes = ctx.agent.kaos.readBytes.bind(ctx.agent.kaos);
+    vi.spyOn(ctx.agent.kaos, 'readBytes').mockImplementation(async (p, length) => {
+      // The uncapped full-content read is the window the user cancels in.
+      if (length === undefined) await ctx.rpc.cancel({ turnId: 0 });
+      return realReadBytes(p, length);
+    });
+
+    await ctx.rpc.prompt({ input: [{ type: 'video_url', videoUrl: { url: fileUrl(path) } }] });
+    const events = await ctx.untilTurnEnd();
+
+    expect(events).toContainEqual(
+      expect.objectContaining({
+        event: 'turn.ended',
+        args: expect.objectContaining({ reason: 'cancelled' }),
+      }),
+    );
+    expect(ctx.agent.context.data().history).toEqual([]);
+  });
+
   it('degrades to a <video path> tag when the model lacks video_in (no upload)', async () => {
     const stub = await stubFilesServer();
     try {

From 57af4232403e8901e84249b520021832c0c106e4 Mon Sep 17 00:00:00 2001
From: Kaiyi <me@kaiyi.cool>
Date: Wed, 22 Jul 2026 10:49:11 +0800
Subject: [PATCH 45/45] fix: retry transient prompt video upload failures on
 later steps

A generic upload failure used to memoize its tag fallback for the rest of
the agent's lifetime, freezing a transient files-endpoint error into a
permanently degraded video. The resolver now marks failure-born fallbacks
as non-memoizable: the current request keeps the lightweight tag form and
the next step retries the upload. Structural outcomes (successful uploads,
capability and sniff fallbacks, no-hook inline) stay memoized for
step-retry stability.
---
 .../src/agent/media/videoResolverService.ts   | 36 ++++++++++++-------
 .../test/agent/media/videoResolver.test.ts    | 26 ++++++++++++++
 2 files changed, 50 insertions(+), 12 deletions(-)

diff --git a/packages/agent-core-v2/src/agent/media/videoResolverService.ts b/packages/agent-core-v2/src/agent/media/videoResolverService.ts
index 432c1b8699..ed41445443 100644
--- a/packages/agent-core-v2/src/agent/media/videoResolverService.ts
+++ b/packages/agent-core-v2/src/agent/media/videoResolverService.ts
@@ -15,7 +15,10 @@
  * token, and an upload interrupted by the step's aborted signal re-throws —
  * shape-agnostic, since abort rejections vary by provider — so cancellation
  * ends the request instead of memoizing a degraded fallback for the rest of
- * the agent's lifetime. Bound at Agent scope.
+ * the agent's lifetime. Resolution outcomes are memoized per (file, provider)
+ * for step/retry stability — except a transient upload failure, which
+ * degrades only the current request to the tag form so a later step retries
+ * the upload instead of freezing the fallback. Bound at Agent scope.
  */
 
 import { createHash } from 'node:crypto';
@@ -96,8 +99,8 @@ export class AgentVideoResolverService implements IAgentVideoResolverService {
     const memoed = this.resolved.get(cacheKey);
     if (memoed !== undefined) return memoed;
 
-    const part = await this.resolveUncached(ref, requester, cacheKey, signal);
-    this.resolved.set(cacheKey, part);
+    const { part, memoize } = await this.resolveUncached(ref, requester, cacheKey, signal);
+    if (memoize) this.resolved.set(cacheKey, part);
     return part;
   }
 
@@ -106,10 +109,13 @@ export class AgentVideoResolverService implements IAgentVideoResolverService {
     requester: ModelRequester,
     cacheKey: string,
     signal: AbortSignal | undefined,
-  ): Promise<ContentPart> {
+  ): Promise<{ part: ContentPart; memoize: boolean }> {
     const cachedLlmFileId = await this.readCachedUpload(cacheKey);
     if (cachedLlmFileId !== undefined) {
-      return { type: 'video_url', videoUrl: { url: `ms://${cachedLlmFileId}`, id: cachedLlmFileId } };
+      return {
+        part: { type: 'video_url', videoUrl: { url: `ms://${cachedLlmFileId}`, id: cachedLlmFileId } },
+        memoize: true,
+      };
     }
 
     let bytes: Buffer;
@@ -119,15 +125,15 @@ export class AgentVideoResolverService implements IAgentVideoResolverService {
       bytes = await readStream(file.stream());
       filename = file.meta.name;
     } catch {
-      return tag(ref);
+      return { part: tag(ref), memoize: true };
     }
 
     const fileType = detectFileType(filename, bytes.subarray(0, MEDIA_SNIFF_BYTES), 'media');
-    if (fileType.kind !== 'video') return tag(ref);
+    if (fileType.kind !== 'video') return { part: tag(ref), memoize: true };
     const mimeType = fileType.mimeType;
 
     const model = requester.model;
-    if (!model.capabilities.video_in) return tag(ref);
+    if (!model.capabilities.video_in) return { part: tag(ref), memoize: true };
     const inlineSupported = inlineVideoSupportedForProtocol(model.protocol);
 
     const uploader = createVideoUploader(requester, {
@@ -139,21 +145,27 @@ export class AgentVideoResolverService implements IAgentVideoResolverService {
       },
     });
     if (uploader === undefined) {
-      return inlineSupported ? inlineVideoPart(bytes, mimeType) : tag(ref);
+      return {
+        part: inlineSupported ? inlineVideoPart(bytes, mimeType) : tag(ref),
+        memoize: true,
+      };
     }
 
     try {
       const uploaded = await uploader({ data: bytes, mimeType, filename }, { signal });
       const llmFileId = uploaded.videoUrl.id ?? msFileIdFromUrl(uploaded.videoUrl.url);
       if (llmFileId !== undefined) await this.writeCachedUpload(cacheKey, llmFileId);
-      return uploaded;
+      return { part: uploaded, memoize: true };
     } catch (error) {
       if (signal?.aborted) throw error;
       if (isVideoUploadAuthError(error)) throw error;
       if (isVideoUploadUnsupportedError(error)) {
-        return inlineSupported ? inlineVideoPart(bytes, mimeType) : tag(ref);
+        return {
+          part: inlineSupported ? inlineVideoPart(bytes, mimeType) : tag(ref),
+          memoize: true,
+        };
       }
-      return tag(ref);
+      return { part: tag(ref), memoize: false };
     }
   }
 
diff --git a/packages/agent-core-v2/test/agent/media/videoResolver.test.ts b/packages/agent-core-v2/test/agent/media/videoResolver.test.ts
index 1630bcc243..5ce7630ed6 100644
--- a/packages/agent-core-v2/test/agent/media/videoResolver.test.ts
+++ b/packages/agent-core-v2/test/agent/media/videoResolver.test.ts
@@ -234,6 +234,32 @@ describe('AgentVideoResolverService', () => {
     expect(retry).toHaveBeenCalledTimes(1);
   });
 
+  it('retries the upload on a later step after a transient failure instead of freezing the tag', async () => {
+    let uploadCalls = 0;
+    const upload = vi.fn(async (): Promise<VideoURLPart> => {
+      uploadCalls += 1;
+      if (uploadCalls === 1) throw new Error('files endpoint unavailable');
+      return msPart('prov-1');
+    });
+    const resolver = new AgentVideoResolverService(
+      fileService(new Map([[FILE_ID, { name: 'clip.mp4', bytes: VIDEO_BYTES }]])),
+      blobStore(),
+      telemetry,
+    );
+    const message = videoMessage(buildKimiFileUrl(FILE_ID, FALLBACK_PATH));
+    const req = requester({ uploadVideo: upload });
+
+    const failed = await resolver.resolve([message], req);
+    expect(firstPart(failed)).toEqual({ type: 'text', text: `<video path="${FALLBACK_PATH}"></video>` });
+
+    const retried = await resolver.resolve([message], req);
+    expect(firstPart(retried)).toEqual(msPart('prov-1'));
+
+    const memoed = await resolver.resolve([message], req);
+    expect(firstPart(memoed)).toEqual(msPart('prov-1'));
+    expect(upload).toHaveBeenCalledTimes(2);
+  });
+
   it('tags when the bytes do not sniff as a video', async () => {
     const upload = vi.fn();
     const out = await new AgentVideoResolverService(