@adhdev/daemon-core 0.9.76-rc.60 → 0.9.76-rc.62

package/src/providers/acp-provider-instance.ts

@@ -48,7 +48,7 @@ import {
 } from '@agentclientprotocol/sdk';
 import type { ProviderModule, ContentBlock, InputEnvelope, ToolCallInfo, ToolCallContent as TCC, ToolKind, ToolCallStatus as TCS } from './contracts.js';
 import { normalizeContent, flattenContent, normalizeInputEnvelope } from './contracts.js';
-import { assertProviderSupportsDeclaredInput } from './provider-input-support.js';
+import { assertProviderSupportsDeclaredInput, getEffectiveMessageInputSupport } from './provider-input-support.js';
 import type { ProviderInstance, ProviderState, AcpProviderState, ProviderErrorReason, ProviderEvent, InstanceContext, SessionModalState } from './provider-instance.js';
 import { StatusMonitor } from './status-monitor.js';
 import { buildLegacyModelModeSummaryMetadata } from './summary-metadata.js';
@@ -121,6 +121,41 @@ function appendPromptText(promptParts: ContentBlock[], text: string | undefined)
     promptParts.push({ type: 'text', text: normalized });
 }
 
+function getUriDisplayName(uri: string | undefined, fallback: string): string {
+    if (!uri) return fallback;
+    try {
+        const pathname = uri.startsWith('file://') ? new URL(uri).pathname : uri;
+        return pathname.split(/[\\/]/).filter(Boolean).pop() || fallback;
+    } catch {
+        return uri.split(/[\\/]/).filter(Boolean).pop() || fallback;
+    }
+}
+
+function appendResourceLink(
+    promptParts: ContentBlock[],
+    uri: string,
+    fallbackName: string,
+    mimeType?: string,
+    description?: string,
+    metadata?: Pick<Extract<ContentBlock, { type: 'resource_link' }>, 'title' | 'size' | 'annotations'> & { name?: string },
+): void {
+    promptParts.push({
+        type: 'resource_link',
+        uri,
+        name: metadata?.name || getUriDisplayName(uri, fallbackName),
+        ...(metadata?.title ? { title: metadata.title } : {}),
+        ...(mimeType ? { mimeType } : {}),
+        ...(description ? { description } : {}),
+        ...(typeof metadata?.size === 'number' ? { size: metadata.size } : {}),
+        ...(metadata?.annotations ? { annotations: metadata.annotations } : {}),
+    });
+}
+
+function appendMediaFallbackText(promptParts: ContentBlock[], label: string, details: Array<string | undefined>): void {
+    const normalizedDetails = details.map((value) => typeof value === 'string' ? value.trim() : '').filter(Boolean);
+    appendPromptText(promptParts, `[${[label, ...normalizedDetails].join(': ')}]`);
+}
+
 export function buildAcpPromptParts(input: InputEnvelope, agentCapabilities?: Record<string, any>): ContentBlock[] {
     const caps = getPromptCapabilityFlags(agentCapabilities);
     const promptParts: ContentBlock[] = [];
@@ -132,59 +167,82 @@ export function buildAcpPromptParts(input: InputEnvelope, agentCapabilities?: Re
         }
 
         if (part.type === 'image') {
-            if (!caps.image) {
-                throw new Error('ACP agent does not support input type: image');
-            }
-            if (!part.data) {
-                throw new Error('ACP image input requires inline image data');
+            if (caps.image && part.data) {
+                promptParts.push({
+                    type: 'image',
+                    data: part.data,
+                    mimeType: part.mimeType,
+                    ...(part.uri ? { uri: part.uri } : {}),
+                    ...(part.alt ? { alt: part.alt } : {}),
+                });
+                if (part.alt) appendPromptText(promptParts, part.alt);
+            } else if (part.uri) {
+                appendResourceLink(promptParts, part.uri, 'image', part.mimeType, part.alt);
+                if (part.alt) appendPromptText(promptParts, part.alt);
+            } else {
+                appendMediaFallbackText(promptParts, 'Image attachment', [part.alt, part.mimeType]);
             }
-            promptParts.push({
-                type: 'image',
-                data: part.data,
-                mimeType: part.mimeType,
-                ...(part.uri ? { uri: part.uri } : {}),
-            });
             continue;
         }
 
         if (part.type === 'audio') {
-            if (!caps.audio) {
-                throw new Error('ACP agent does not support input type: audio');
-            }
-            if (!part.data) {
-                throw new Error('ACP audio input requires inline audio data');
+            if (caps.audio && part.data) {
+                promptParts.push({
+                    type: 'audio',
+                    data: part.data,
+                    mimeType: part.mimeType,
+                    ...(part.uri ? { uri: part.uri } : {}),
+                    ...(part.transcript ? { transcript: part.transcript } : {}),
+                });
+                if (part.transcript) appendPromptText(promptParts, part.transcript);
+            } else if (part.uri) {
+                appendResourceLink(promptParts, part.uri, 'audio', part.mimeType, part.transcript);
+                if (part.transcript) appendPromptText(promptParts, part.transcript);
+            } else {
+                appendMediaFallbackText(promptParts, 'Audio attachment', [part.transcript, part.mimeType]);
             }
-            promptParts.push({
-                type: 'audio',
-                data: part.data,
-                mimeType: part.mimeType,
-            });
             continue;
         }
 
         if (part.type === 'resource') {
-            if (!caps.embeddedContext) {
-                throw new Error('ACP agent does not support input type: resource');
-            }
-            if (part.text) {
+            if (caps.embeddedContext && part.text) {
                 promptParts.push({
                     type: 'resource',
                     resource: { uri: part.uri, text: part.text, mimeType: part.mimeType ?? null },
                 });
                 continue;
             }
-            if (part.data) {
+            if (caps.embeddedContext && part.data) {
                 promptParts.push({
                     type: 'resource',
                     resource: { uri: part.uri, blob: part.data, mimeType: part.mimeType ?? null },
                 });
                 continue;
             }
-            throw new Error('ACP resource input requires embedded text or binary data');
+            appendResourceLink(promptParts, part.uri, part.name || 'resource', part.mimeType, part.text);
+            if (part.text) appendPromptText(promptParts, part.text);
+            continue;
+        }
+
+        if (part.type === 'resource_link') {
+            appendResourceLink(promptParts, part.uri, part.name, part.mimeType, part.description, {
+                name: part.name,
+                ...(part.title ? { title: part.title } : {}),
+                ...(typeof part.size === 'number' ? { size: part.size } : {}),
+                ...(part.annotations ? { annotations: part.annotations } : {}),
+            });
+            continue;
         }
 
         if (part.type === 'video') {
-            throw new Error('ACP agent does not support input type: video');
+            // ACP v0.16 prompt capabilities do not advertise native video input. Preserve meaning by
+            // sending a linked resource when possible, plus transcript/descriptive text when present.
+            if (part.uri) {
+                appendResourceLink(promptParts, part.uri, 'video', part.mimeType, part.transcript);
+                if (part.transcript) appendPromptText(promptParts, part.transcript);
+            } else {
+                appendMediaFallbackText(promptParts, 'Video attachment', [part.transcript, part.mimeType]);
+            }
         }
     }
 
@@ -346,6 +404,7 @@ export class AcpProviderInstance implements ProviderInstance {
             lastUpdated: Date.now(),
             settings: this.settings,
             pendingEvents: this.flushEvents(),
+            messageInput: getEffectiveMessageInputSupport(this.provider, this.agentCapabilities),
  // ACP-specific: expose available models/modes for dashboard
             acpConfigOptions: this.configOptions,
             acpModes: this.availableModes,
@@ -962,6 +1021,7 @@ export class AcpProviderInstance implements ProviderInstance {
                         data: b.data,
                         mimeType: b.mimeType,
                         ...(b.uri ? { uri: b.uri } : {}),
+                        ...(b.alt ? { alt: b.alt } : {}),
                     };
                 }
                 if (b.type === 'audio') {
@@ -969,14 +1029,31 @@ export class AcpProviderInstance implements ProviderInstance {
                         type: 'audio',
                         data: b.data,
                         mimeType: b.mimeType,
+                        ...(b.uri ? { uri: b.uri } : {}),
+                        ...(b.transcript ? { transcript: b.transcript } : {}),
                     };
                 }
+                if (b.type === 'video') {
+                    return b.uri
+                        ? {
+                            type: 'resource_link',
+                            uri: b.uri,
+                            name: path.basename(b.uri),
+                            mimeType: b.mimeType,
+                            ...(b.transcript ? { description: b.transcript } : {}),
+                        }
+                        : { type: 'text', text: b.transcript || `[Video attachment: ${b.mimeType}]` };
+                }
                 if (b.type === 'resource_link') {
                     return {
                         type: 'resource_link',
                         uri: b.uri,
                         name: b.name,
+                        ...(b.title ? { title: b.title } : {}),
+                        ...(b.description ? { description: b.description } : {}),
                         ...(b.mimeType ? { mimeType: b.mimeType } : {}),
+                        ...(typeof b.size === 'number' ? { size: b.size } : {}),
+                        ...(b.annotations ? { annotations: b.annotations } : {}),
                     };
                 }
                 if (b.type === 'resource') return { type: 'resource', resource: b.resource };
@@ -1056,7 +1133,7 @@ export class AcpProviderInstance implements ProviderInstance {
 
         switch (update.sessionUpdate) {
             case 'agent_message_chunk': {
-                const content = update.content;
+                const content: any = update.content;
                 if (content.type === 'text') {
                     this.partialContent += content.text;
                 } else if (content.type === 'image') {
@@ -1071,6 +1148,17 @@ export class AcpProviderInstance implements ProviderInstance {
                         type: 'audio',
                         data: content.data,
                         mimeType: content.mimeType,
+                        ...(content.uri ? { uri: content.uri } : {}),
+                        ...(content.transcript ? { transcript: content.transcript } : {}),
+                    });
+                } else if (content.type === 'video') {
+                    this.partialBlocks.push({
+                        type: 'video',
+                        data: content.data,
+                        mimeType: content.mimeType,
+                        ...(content.uri ? { uri: content.uri } : {}),
+                        ...(content.transcript ? { transcript: content.transcript } : {}),
+                        ...(content.posterUri ? { posterUri: content.posterUri } : {}),
                     });
                 } else if (content.type === 'resource_link') {
                     this.partialBlocks.push({

package/src/providers/chat-message-normalization.ts

@@ -5,6 +5,43 @@ export const BUILTIN_CHAT_MESSAGE_KINDS = ['standard', 'thought', 'tool', 'termi
 export type BuiltinChatMessageKind = typeof BUILTIN_CHAT_MESSAGE_KINDS[number];
 export type ChatMessageKind = BuiltinChatMessageKind | (string & {});
 
+export const CHAT_MESSAGE_VISIBILITIES = ['user', 'debug', 'internal', 'hidden'] as const;
+export const CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES = ['visible', 'chat', 'user', 'debug', 'internal', 'hidden'] as const;
+export const CHAT_MESSAGE_AUDIENCES = ['chat', 'debug', 'trace', 'internal'] as const;
+export const CHAT_MESSAGE_SOURCES = [
+  'assistant_text',
+  'tool_call',
+  'terminal_command',
+  'runtime_activity',
+  'runtime_status',
+  'provider_chrome',
+  'control',
+] as const;
+export const CHAT_MESSAGE_ACTIVITY_SOURCES = ['tool_call', 'terminal_command', 'runtime_activity'] as const;
+export const CHAT_MESSAGE_INTERNAL_SOURCES = ['runtime_status', 'provider_chrome', 'control'] as const;
+
+export type ChatMessageVisibility = typeof CHAT_MESSAGE_VISIBILITIES[number] | (string & {});
+export type ChatMessageTranscriptVisibility = typeof CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES[number] | (string & {});
+export type ChatMessageAudience = typeof CHAT_MESSAGE_AUDIENCES[number] | (string & {});
+export type ChatMessageSource = typeof CHAT_MESSAGE_SOURCES[number] | (string & {});
+export type ChatMessageTranscriptSurface = 'chat' | 'activity' | 'internal';
+
+export interface ChatMessageVisibilityClassification {
+  surface: ChatMessageTranscriptSurface;
+  isUserFacing: boolean;
+  isActivityFacing: boolean;
+  isInternal: boolean;
+  explicitUserFacing: boolean;
+  explicitHidden: boolean;
+  role: string;
+  kind: ChatMessageKind;
+  visibility: string;
+  transcriptVisibility: string;
+  audience: string;
+  source: string;
+}
+
+
 const KNOWN_CHAT_MESSAGE_KINDS = new Set<string>(BUILTIN_CHAT_MESSAGE_KINDS);
 const CHAT_MESSAGE_KIND_ALIASES: Record<string, BuiltinChatMessageKind> = {
   text: 'standard',
@@ -183,71 +220,195 @@ function readStringField(value: unknown): string {
   return typeof value === 'string' ? value.trim().toLowerCase() : '';
 }
 
-function readVisibilityField(message: ChatMessage, meta: Record<string, unknown> | null): string {
+function readRecordField(message: ChatMessage, meta: Record<string, unknown> | null, key: string): unknown {
   const record = message as ChatMessage & Record<string, unknown>;
-  return readStringField(record.visibility ?? record.transcriptVisibility ?? meta?.visibility ?? meta?.transcriptVisibility);
+  return record[key] ?? meta?.[key];
+}
+
+function readVisibilityField(message: ChatMessage, meta: Record<string, unknown> | null): string {
+  return readStringField(readRecordField(message, meta, 'visibility'));
 }
 
-function isExplicitlyHiddenFromTranscript(message: ChatMessage, meta: Record<string, unknown> | null): boolean {
+function readTranscriptVisibilityField(message: ChatMessage, meta: Record<string, unknown> | null): string {
   const record = message as ChatMessage & Record<string, unknown>;
-  const visibility = readVisibilityField(message, meta);
-  const audience = readStringField(record.audience ?? meta?.audience);
-  const source = readStringField(record.source ?? meta?.source);
-
-  return visibility === 'hidden'
-    || visibility === 'debug'
-    || visibility === 'internal'
-    || audience === 'debug'
-    || audience === 'trace'
-    || audience === 'internal'
-    || source === 'runtime_status'
-    || source === 'runtime_activity'
-    || source === 'provider_chrome'
-    || source === 'control'
-    || record.internal === true
-    || record.isInternal === true
-    || record.debug === true
-    || meta?.internal === true
-    || meta?.isInternal === true
-    || meta?.debug === true
-    || meta?.statusOnly === true
-    || meta?.controlOnly === true;
-}
-
-function isExplicitlyVisibleInTranscript(message: ChatMessage, meta: Record<string, unknown> | null): boolean {
+  return readStringField(record.transcriptVisibility ?? meta?.transcriptVisibility ?? record.visibility ?? meta?.visibility);
+}
+
+const EXPLICIT_HIDDEN_VISIBILITIES = new Set(['hidden', 'debug', 'internal']);
+const EXPLICIT_VISIBLE_VISIBILITIES = new Set(['visible', 'user', 'chat']);
+const HIDDEN_AUDIENCES = new Set(['debug', 'trace', 'internal']);
+const ACTIVITY_SOURCE_SET = new Set<string>(CHAT_MESSAGE_ACTIVITY_SOURCES);
+const INTERNAL_SOURCE_SET = new Set<string>(CHAT_MESSAGE_INTERNAL_SOURCES);
+
+function hasBooleanMarker(message: ChatMessage, meta: Record<string, unknown> | null, keys: string[]): boolean {
   const record = message as ChatMessage & Record<string, unknown>;
-  const visibility = readVisibilityField(message, meta);
-  const audience = readStringField(record.audience ?? meta?.audience);
-  return visibility === 'visible'
-    || visibility === 'user'
-    || visibility === 'chat'
-    || audience === 'chat'
-    || record.userFacing === true
-    || meta?.userFacing === true;
+  return keys.some((key) => record[key] === true || meta?.[key] === true);
+}
+
+function isActivityKind(kind: ChatMessageKind): boolean {
+  return kind === 'thought' || kind === 'tool' || kind === 'terminal';
+}
+
+function isOrdinaryVisibleTurn(message: ChatMessage, role: string, kind: ChatMessageKind): boolean {
+  if (role === 'user' || role === 'human') return kind === 'standard' || kind === '';
+  if (role === 'assistant') return kind === 'standard' || kind === '';
+  return false;
 }
 
 /**
- * Product chat transcript visibility contract.
+ * Shared transcript visibility protocol for all ADHDev provider chat messages.
  *
- * read_chat/debug paths may preserve every normalized message, including tool,
- * terminal, thought, status, and control rows. The default user-facing chat UX
- * should only render meaningful conversation turns unless a producer explicitly
- * marks a non-standard row as user-facing. This keeps internal tool/status/control
- * plumbing out of the ordinary transcript without matching provider-specific text.
+ * Producers can stamp visibility/audience/source/userFacing/internal/debug either
+ * at the top level or under `meta`. Consumers should use this classifier instead
+ * of matching command text, icons, provider names, or terminal UI fragments.
  */
-export function isUserFacingChatMessage(message: ChatMessage | null | undefined): boolean {
-  if (!message) return false;
-  const meta = readMessageMeta(message);
-  if (isExplicitlyHiddenFromTranscript(message, meta)) return false;
-  if (isExplicitlyVisibleInTranscript(message, meta)) return true;
+export function classifyChatMessageVisibility(message: ChatMessage | null | undefined): ChatMessageVisibilityClassification {
+  if (!message) {
+    return {
+      surface: 'internal',
+      isUserFacing: false,
+      isActivityFacing: false,
+      isInternal: true,
+      explicitUserFacing: false,
+      explicitHidden: true,
+      role: '',
+      kind: 'standard',
+      visibility: '',
+      transcriptVisibility: '',
+      audience: '',
+      source: '',
+    };
+  }
 
+  const meta = readMessageMeta(message);
   const role = typeof message.role === 'string' ? message.role.trim().toLowerCase() : '';
   const kind = resolveChatMessageKind(message);
-  if (role === 'user' || role === 'human') return kind === 'standard' || kind === '';
-  if (role === 'assistant') return kind === 'standard' || kind === '';
-  return false;
+  const visibility = readVisibilityField(message, meta);
+  const transcriptVisibility = readTranscriptVisibilityField(message, meta);
+  const audience = readStringField(readRecordField(message, meta, 'audience'));
+  const source = readStringField(readRecordField(message, meta, 'source'));
+  const explicitHidden = EXPLICIT_HIDDEN_VISIBILITIES.has(visibility)
+    || EXPLICIT_HIDDEN_VISIBILITIES.has(transcriptVisibility)
+    || HIDDEN_AUDIENCES.has(audience)
+    || hasBooleanMarker(message, meta, ['internal', 'isInternal', 'debug', 'statusOnly', 'controlOnly']);
+  const explicitUserFacing = EXPLICIT_VISIBLE_VISIBILITIES.has(visibility)
+    || EXPLICIT_VISIBLE_VISIBILITIES.has(transcriptVisibility)
+    || audience === 'chat'
+    || hasBooleanMarker(message, meta, ['userFacing']);
+
+  if (explicitHidden) {
+    const activityLike = isActivityKind(kind) || ACTIVITY_SOURCE_SET.has(source);
+    return {
+      surface: activityLike ? 'activity' : 'internal',
+      isUserFacing: false,
+      isActivityFacing: activityLike,
+      isInternal: !activityLike,
+      explicitUserFacing,
+      explicitHidden,
+      role,
+      kind,
+      visibility,
+      transcriptVisibility,
+      audience,
+      source,
+    };
+  }
+
+  if (explicitUserFacing) {
+    return {
+      surface: 'chat',
+      isUserFacing: true,
+      isActivityFacing: false,
+      isInternal: false,
+      explicitUserFacing,
+      explicitHidden,
+      role,
+      kind,
+      visibility,
+      transcriptVisibility,
+      audience,
+      source,
+    };
+  }
+
+  if (INTERNAL_SOURCE_SET.has(source) || role === 'system' || kind === 'system') {
+    return {
+      surface: 'internal',
+      isUserFacing: false,
+      isActivityFacing: false,
+      isInternal: true,
+      explicitUserFacing,
+      explicitHidden,
+      role,
+      kind,
+      visibility,
+      transcriptVisibility,
+      audience,
+      source,
+    };
+  }
+
+  if (ACTIVITY_SOURCE_SET.has(source) || isActivityKind(kind)) {
+    return {
+      surface: 'activity',
+      isUserFacing: false,
+      isActivityFacing: true,
+      isInternal: false,
+      explicitUserFacing,
+      explicitHidden,
+      role,
+      kind,
+      visibility,
+      transcriptVisibility,
+      audience,
+      source,
+    };
+  }
+
+  const isUserFacing = isOrdinaryVisibleTurn(message, role, kind);
+  return {
+    surface: isUserFacing ? 'chat' : 'internal',
+    isUserFacing,
+    isActivityFacing: false,
+    isInternal: !isUserFacing,
+    explicitUserFacing,
+    explicitHidden,
+    role,
+    kind,
+    visibility,
+    transcriptVisibility,
+    audience,
+    source,
+  };
+}
+
+export function isUserFacingChatMessage(message: ChatMessage | null | undefined): boolean {
+  return classifyChatMessageVisibility(message).isUserFacing;
+}
+
+export function isActivityChatMessage(message: ChatMessage | null | undefined): boolean {
+  return classifyChatMessageVisibility(message).isActivityFacing;
+}
+
+export function isInternalChatMessage(message: ChatMessage | null | undefined): boolean {
+  return classifyChatMessageVisibility(message).isInternal;
 }
 
 export function filterUserFacingChatMessages<T extends ChatMessage>(messages: T[] | null | undefined): T[] {
   return (Array.isArray(messages) ? messages : []).filter((message) => isUserFacingChatMessage(message));
 }
+
+export function filterActivityChatMessages<T extends ChatMessage>(messages: T[] | null | undefined): T[] {
+  return (Array.isArray(messages) ? messages : []).filter((message) => isActivityChatMessage(message));
+}
+
+export function filterInternalChatMessages<T extends ChatMessage>(messages: T[] | null | undefined): T[] {
+  return (Array.isArray(messages) ? messages : []).filter((message) => isInternalChatMessage(message));
+}
+
+export function filterChatMessagesByVisibility<T extends ChatMessage>(
+  messages: T[] | null | undefined,
+  surface: ChatMessageTranscriptSurface,
+): T[] {
+  return (Array.isArray(messages) ? messages : []).filter((message) => classifyChatMessageVisibility(message).surface === surface);
+}

package/src/providers/cli-provider-instance.ts

@@ -10,8 +10,8 @@ import * as path from 'path';
 import * as crypto from 'crypto';
 import * as fs from 'fs';
 import { createRequire } from 'node:module';
-import { normalizeInputEnvelope, type ProviderModule, flattenContent } from './contracts.js';
-import { assertTextOnlyInput } from './provider-input-support.js';
+import { normalizeInputEnvelope, type ProviderModule, flattenContent, type InputEnvelope, type InputPart } from './contracts.js';
+import { assertProviderSupportsDeclaredInput, getEffectiveMessageInputSupport } from './provider-input-support.js';
 import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext, ProviderErrorReason, HotChatSessionState, SessionModalState } from './provider-instance.js';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
@@ -35,6 +35,95 @@ type PersistableCliHistoryMessage = {
     receivedAt?: number;
 };
 
+const IMAGE_MIME_EXTENSIONS: Record<string, string> = {
+    'image/png': '.png',
+    'image/jpeg': '.jpg',
+    'image/jpg': '.jpg',
+    'image/gif': '.gif',
+    'image/webp': '.webp',
+    'image/bmp': '.bmp',
+    'image/tiff': '.tiff',
+    'image/svg+xml': '.svg',
+};
+
+function filePathFromUri(uri: string): string | null {
+    if (!uri) return null;
+    if (uri.startsWith('file://')) {
+        try {
+            return decodeURIComponent(new URL(uri).pathname);
+        } catch {
+            return uri.slice('file://'.length);
+        }
+    }
+    if (path.isAbsolute(uri)) return uri;
+    return null;
+}
+
+function extensionForImageMime(mimeType: string): string {
+    return IMAGE_MIME_EXTENSIONS[mimeType.toLowerCase()] || '.img';
+}
+
+function safeInputImageBasename(index: number, mimeType: string): string {
+    const extension = extensionForImageMime(mimeType);
+    const suffix = crypto.randomBytes(6).toString('hex');
+    return `adhdev-input-image-${Date.now()}-${index}-${suffix}${extension}`;
+}
+
+function materializeImageDataPart(part: Extract<InputPart, { type: 'image' }>, index: number, dir: string): string | null {
+    if (!part.data) return null;
+    const rawData = part.data.includes(',') ? part.data.split(',').pop() || '' : part.data;
+    if (!rawData) return null;
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, safeInputImageBasename(index, part.mimeType));
+    fs.writeFileSync(filePath, Buffer.from(rawData, 'base64'));
+    return filePath;
+}
+
+export function buildCliStructuredInputPrompt(
+    input: InputEnvelope,
+    options: { materializeDir?: string } = {},
+): string {
+    const promptParts: string[] = [];
+    const imageRefs: string[] = [];
+    const resourceRefs: string[] = [];
+    const materializeDir = options.materializeDir || path.join(os.tmpdir(), 'adhdev-input-media');
+
+    input.parts.forEach((part, index) => {
+        if (part.type === 'text' && part.text.trim()) {
+            promptParts.push(part.text.trim());
+            return;
+        }
+
+        if (part.type === 'image') {
+            const localPath = typeof part.uri === 'string' ? filePathFromUri(part.uri) : null;
+            const materializedPath = !localPath && part.data ? materializeImageDataPart(part, index, materializeDir) : null;
+            const ref = localPath || materializedPath || part.uri || '';
+            if (ref) imageRefs.push(ref);
+            if (part.alt?.trim()) promptParts.push(part.alt.trim());
+            return;
+        }
+
+        if (part.type === 'resource_link') {
+            resourceRefs.push([part.title, part.name, part.description, part.uri].filter(Boolean).join('\n'));
+            return;
+        }
+
+        if (part.type === 'resource') {
+            resourceRefs.push([part.name, part.text, part.uri].filter(Boolean).join('\n'));
+        }
+    });
+
+    if (input.textFallback.trim()) promptParts.push(input.textFallback.trim());
+
+    const ordered = [
+        ...imageRefs,
+        ...promptParts,
+        ...resourceRefs,
+    ].filter((value, index, values) => value.trim().length > 0 && values.indexOf(value) === index);
+
+    return ordered.join('\n');
+}
+
 function normalizePersistableCliHistoryContent(content: unknown): string {
     return flattenContent(content as any).replace(/\s+/g, ' ').trim();
 }
@@ -476,6 +565,7 @@ export class CliProviderInstance implements ProviderInstance {
             resume: this.provider.resume,
             controlValues: surface.controlValues,
             providerControls: this.provider.controls,
+            messageInput: getEffectiveMessageInputSupport(this.provider),
             summaryMetadata: surface.summaryMetadata as any,
             errorMessage: this.errorMessage,
             errorReason: this.errorReason,
@@ -532,9 +622,10 @@ export class CliProviderInstance implements ProviderInstance {
     onEvent(event: string, data?: any): void {
         if (event === 'send_message') {
             const input = normalizeInputEnvelope(data);
-            assertTextOnlyInput(this.provider, input);
-            if (input.textFallback) {
-                void this.adapter.sendMessage(input.textFallback).catch((e: any) => {
+            assertProviderSupportsDeclaredInput(this.provider, input);
+            const promptText = buildCliStructuredInputPrompt(input);
+            if (promptText) {
+                void this.adapter.sendMessage(promptText).catch((e: any) => {
                     LOG.warn('CLI', `[${this.type}] send_message failed: ${e?.message || e}`);
                 });
             }