feat: send prompt-attached videos directly with the prompt

.changeset/fix-read-media-video-upload-fallback.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": patch
+---
+
+Fix ReadMediaFile failing on videos when the provider has no file upload channel — such videos now fall back to inline delivery.

.changeset/prompt-video-inline.md

@@ -0,0 +1,5 @@
+---
+"@moonshot-ai/kimi-code": minor
+---
+
+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.

apps/kimi-code/src/tui/kimi-tui.ts

@@ -1135,7 +1135,18 @@ export class KimiTUI {
       this.showError(LLM_NOT_SET_MESSAGE);
       return;
     }
-    const extraction = extractMediaAttachments(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) {

apps/kimi-code/src/tui/utils/image-placeholder.ts

@@ -1,17 +1,28 @@
 /**
- * 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:
+ * `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.
+ *
+ * `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. 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.
+ *   - 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.
@@ -20,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';
@@ -71,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
@@ -195,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 });

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';
 
@@ -40,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', () => {
@@ -135,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 {
@@ -165,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');

apps/kimi-code/test/tui/kimi-tui-message-flow.test.ts

@@ -157,7 +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 () => {}),
     steer: vi.fn(async () => {}),
     init: vi.fn(async () => {}),
     startBtw: vi.fn(async () => 'agent-btw'),
@@ -1554,6 +1555,63 @@ command = "vim"
     expect(transcript).not.toContain('review');
   });
 
+  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-'));
+    try {
+      const srcVideo = join(dir, 'clip.mp4');
+      await writeFile(srcVideo, 'video-bytes');
+      const attachment = imageStore.addVideo('video/mp4', srcVideo);
+
+      // 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}`);
+
+      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('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;
+    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}`);
+
+      expect(session.prompt).not.toHaveBeenCalled();
+      expect(driver.state.queuedMessages).toHaveLength(1);
+      const queued = driver.state.queuedMessages[0];
+      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(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;

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 };
     }

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 };
 

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 };
 

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">