@adhdev/daemon-core 0.8.65 → 0.8.67

package/dist/providers/extension-provider-instance.d.ts

@@ -46,10 +46,12 @@ export declare class ExtensionProviderInstance implements ProviderInstance {
     private applyProviderResponse;
     private appendRuntimeSystemMessage;
     private appendRuntimeMessage;
+    private buildSyntheticTurnKey;
     /**
-     * Assign stable receivedAt to extension messages.
-     * Same pattern as IdeProviderInstance.readChat() prevByHash —
-     * preserves first-seen timestamp across polling cycles.
+     * Assign stable receivedAt / synthetic _turnKey to extension messages.
+     * Same transcript should keep the same identity across polling cycles and
+     * stream resets, while repeated identical text later in the transcript still
+     * produces a distinct completion marker via the occurrence suffix.
      */
     private assignReceivedAt;
     private mergeConversationMessages;

package/dist/providers/provider-input-support.d.ts

@@ -0,0 +1,9 @@
+import type { InputEnvelope, ProviderModule } from './contracts.js';
+type InputMediaType = 'text' | 'image' | 'audio' | 'video' | 'resource';
+export declare function assertTextOnlyInput(provider: Pick<ProviderModule, 'name' | 'type'> | null | undefined, input: InputEnvelope): void;
+export declare function getDeclaredProviderInputSupport(provider?: Pick<ProviderModule, 'capabilities'> | null): {
+    multipart: boolean;
+    mediaTypes: Set<InputMediaType>;
+};
+export declare function assertProviderSupportsDeclaredInput(provider: Pick<ProviderModule, 'name' | 'type' | 'capabilities'> | null | undefined, input: InputEnvelope): void;
+export {};

package/dist/providers/read-chat-contract.d.ts

@@ -0,0 +1,2 @@
+import type { ReadChatResult } from './contracts.js';
+export declare function validateReadChatResultPayload(raw: unknown, source?: string): ReadChatResult & Record<string, unknown>;

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.8.65",
-  "description": "ADHDev local session host core — session registry, protocol, buffers",
+  "version": "0.8.67",
+  "description": "ADHDev local session host core \u2014 session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.8.65",
-  "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
+  "version": "0.8.67",
+  "description": "ADHDev daemon core \u2014 CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {

package/src/agent-stream/provider-adapter.ts

@@ -13,6 +13,7 @@ import type {
 } from './types.js';
 import type { ProviderModule, ProviderScripts } from '../providers/contracts.js';
 import { extractProviderControlValues, normalizeProviderEffects } from '../providers/control-effects.js';
+import { validateReadChatResultPayload } from '../providers/read-chat-contract.js';
 import { resolveProviderStateSurface } from '../providers/provider-patch-state.js';
 import { normalizeChatMessages } from '../providers/chat-message-normalization.js';
 
@@ -149,26 +150,31 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
                 }
                 return state;
             }
+            const validated = validateReadChatResultPayload(data, `${this.agentType} readChat`);
+            const validatedStatus = (validated as any).status as string;
+            const streamStatus = validatedStatus === 'generating' || validatedStatus === 'long_generating'
+                ? 'streaming'
+                : validatedStatus;
             const state: AgentStreamState = {
                 agentType: this.agentType,
                 agentName: this.agentName,
                 extensionId: this.extensionId,
-                status: data.status || 'idle',
-                messages: normalizeChatMessages(Array.isArray(data.messages) ? data.messages : []) as any,
-                inputContent: data.inputContent || '',
-                activeModal: data.activeModal,
+                status: streamStatus as AgentStreamState['status'],
+                messages: normalizeChatMessages(validated.messages) as any,
+                inputContent: typeof validated.inputContent === 'string' ? validated.inputContent : '',
+                ...(validated.activeModal ? { activeModal: validated.activeModal } : {}),
             };
-            if (typeof data.title === 'string' && data.title.trim()) {
-                state.title = data.title.trim();
+            if (typeof validated.title === 'string' && validated.title.trim()) {
+                state.title = validated.title.trim();
             }
-            const controlValues = extractProviderControlValues(this.provider.controls, data);
+            const controlValues = extractProviderControlValues(this.provider.controls, validated);
             const surface = resolveProviderStateSurface({
                 controlValues,
-                summaryMetadata: data.summaryMetadata,
+                summaryMetadata: validated.summaryMetadata,
             });
             if (surface.controlValues) state.controlValues = surface.controlValues;
             if (surface.summaryMetadata) state.summaryMetadata = surface.summaryMetadata as any;
-            const effects = normalizeProviderEffects(data);
+            const effects = normalizeProviderEffects(validated);
             if (effects.length > 0) state.effects = effects;
             if (state.messages.length > 0) {
                 this.lastSuccessState = state;

package/src/cli-adapters/provider-cli-adapter.ts

@@ -45,6 +45,7 @@ import {
     type CliTraceEntry,
 } from './provider-cli-shared.js';
 import { buildChatMessage } from '../providers/chat-message-normalization.js';
+import { validateReadChatResultPayload } from '../providers/read-chat-contract.js';
 import {
     buildCliParseInput,
     buildCliTraceParseSnapshot,
@@ -1395,6 +1396,9 @@ export class ProviderCliAdapter implements CliAdapter {
                 runtimeSettings: this.runtimeSettings,
             });
             const parsed = this.cliScripts.parseOutput(input);
+            if (parsed && typeof parsed === 'object') {
+                Object.assign(parsed, validateReadChatResultPayload(parsed, `${this.cliType} parseOutput`));
+            }
             const refinedStatus = this.refineDetectedStatus(typeof parsed?.status === 'string' ? parsed.status : null, input.recentBuffer, input.screenText);
             if (parsed && refinedStatus && parsed.status !== refinedStatus) {
                 parsed.status = refinedStatus;

package/src/commands/chat-commands.ts

@@ -6,6 +6,8 @@
 import type { CommandResult, CommandHelpers } from './handler.js';
 import type { CliAdapter } from '../cli-adapter-types.js';
 import { flattenContent, normalizeInputEnvelope, type InputEnvelope, type ProviderModule, type ProviderScripts } from '../providers/contracts.js';
+import { assertProviderSupportsDeclaredInput, assertTextOnlyInput } from '../providers/provider-input-support.js';
+import { validateReadChatResultPayload } from '../providers/read-chat-contract.js';
 import type { ProviderInstance } from '../providers/provider-instance.js';
 import { readChatHistory } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
@@ -80,7 +82,7 @@ function isExtensionTransport(transport: SessionTransport | null): boolean {
     return transport === 'cdp-webview';
 }
 
-function buildRecentSendKey(h: CommandHelpers, args: any, provider: ProviderModule | undefined, text: string): string {
+function buildRecentSendKey(h: CommandHelpers, args: any, provider: ProviderModule | undefined, signature: string): string {
     const transport = getTargetTransport(h, provider) || 'unknown';
     const target =
         args?.targetSessionId
@@ -89,7 +91,13 @@ function buildRecentSendKey(h: CommandHelpers, args: any, provider: ProviderModu
         || h.currentProviderType
         || h.currentManagerKey
         || 'unknown';
-    return `${transport}:${target}:${text.trim()}`;
+    return `${transport}:${target}:${signature.trim()}`;
+}
+
+function buildSendInputSignature(input: InputEnvelope): string {
+    const text = typeof input.textFallback === 'string' ? input.textFallback.trim() : '';
+    if (text) return text;
+    return JSON.stringify(input.parts || []);
 }
 
 function getSendChatInputEnvelope(args: any): InputEnvelope {
@@ -292,14 +300,20 @@ function computeReadChatSync(messages: ChatMessage[], cursor: Required<ReadChatC
 }
 
 function buildReadChatCommandResult(payload: Record<string, any>, args: any): CommandResult {
-    const messages = normalizeReadChatMessages(payload);
+    let validatedPayload: Record<string, any>;
+    try {
+        validatedPayload = validateReadChatResultPayload(payload, 'read_chat command result') as Record<string, any>;
+    } catch (error: any) {
+        return { success: false, error: error?.message || String(error) };
+    }
+    const messages = normalizeReadChatMessages(validatedPayload);
     const cursor = normalizeReadChatCursor(args);
     if (!cursor.knownMessageCount && !cursor.lastMessageSignature && cursor.tailLimit > 0 && messages.length > cursor.tailLimit) {
         const tailMessages = messages.slice(-cursor.tailLimit);
         const lastMessageSignature = getChatMessageSignature(tailMessages[tailMessages.length - 1]);
         return {
             success: true,
-            ...payload,
+            ...validatedPayload,
             messages: tailMessages,
             syncMode: 'full',
             replaceFrom: 0,
@@ -310,7 +324,7 @@ function buildReadChatCommandResult(payload: Record<string, any>, args: any): Co
     const sync = computeReadChatSync(messages, cursor);
     return {
         success: true,
-        ...payload,
+        ...validatedPayload,
         messages: sync.messages,
         syncMode: sync.syncMode,
         replaceFrom: sync.replaceFrom,
@@ -405,12 +419,24 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
         const adapter = getTargetedCliAdapter(h, args, provider?.type);
         if (adapter) {
             _log(`${transport} adapter: ${adapter.cliType}`);
-            const status = adapter.getStatus();
+            const parsedStatus = typeof adapter.getScriptParsedStatus === 'function'
+                ? parseMaybeJson(adapter.getScriptParsedStatus())
+                : null;
+            const parsedRecord = parsedStatus && typeof parsedStatus === 'object'
+                ? parsedStatus as Record<string, any>
+                : null;
+            const status = parsedRecord || adapter.getStatus();
+            const title = typeof parsedRecord?.title === 'string' ? parsedRecord.title : undefined;
+            const providerSessionId = typeof parsedRecord?.providerSessionId === 'string'
+                ? parsedRecord.providerSessionId
+                : undefined;
             if (status) {
                 return buildReadChatCommandResult({
                     messages: status.messages || [],
                     status: status.status,
                     activeModal: status.activeModal,
+                    ...(title ? { title } : {}),
+                    ...(providerSessionId ? { providerSessionId } : {}),
                 }, args);
             }
         }
@@ -425,25 +451,26 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                 let parsed = evalResult.result;
                 if (typeof parsed === 'string') { try { parsed = JSON.parse(parsed); } catch { } }
                 if (parsed && typeof parsed === 'object') {
-                    _log(`Extension OK: ${parsed.messages?.length || 0} msgs`);
+                    const validated = validateReadChatResultPayload(parsed, 'extension read_chat');
+                    _log(`Extension OK: ${validated.messages?.length || 0} msgs`);
                     traceProviderEvent(args, 'provider', 'extension.read_chat.success', {
                         h,
                         provider,
                         payload: {
                             method: 'evaluateProviderScript',
                             result: evalResult.result,
-                            parsed,
-                            messageCount: Array.isArray(parsed.messages) ? parsed.messages.length : 0,
+                            parsed: validated,
+                            messageCount: Array.isArray(validated.messages) ? validated.messages.length : 0,
                         },
                     });
                     h.historyWriter.appendNewMessages(
                         provider?.type || 'unknown_extension',
-                        toHistoryPersistedMessages(normalizeReadChatMessages(parsed)),
-                        parsed.title,
+                        toHistoryPersistedMessages(normalizeReadChatMessages(validated)),
+                        validated.title,
                         args?.targetSessionId,
                         historySessionId,
                     );
-                    return buildReadChatCommandResult(parsed, args);
+                    return buildReadChatCommandResult(validated as Record<string, any>, args);
                 }
             }
         } catch (e: any) {
@@ -500,15 +527,16 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                 let parsed: any = raw;
                 if (typeof parsed === 'string') { try { parsed = JSON.parse(parsed); } catch { } }
                 if (parsed && typeof parsed === 'object') {
-                    _log(`Webview OK: ${parsed.messages?.length || 0} msgs`);
+                    const validated = validateReadChatResultPayload(parsed, 'webview read_chat');
+                    _log(`Webview OK: ${validated.messages?.length || 0} msgs`);
                 h.historyWriter.appendNewMessages(
                     provider?.type || getCurrentProviderType(h, 'unknown_webview'),
-                    toHistoryPersistedMessages(normalizeReadChatMessages(parsed)),
-                    parsed.title,
+                    toHistoryPersistedMessages(normalizeReadChatMessages(validated)),
+                    validated.title,
                     args?.targetSessionId,
                     historySessionId,
                 );
-                    return buildReadChatCommandResult(parsed, args);
+                    return buildReadChatCommandResult(validated as Record<string, any>, args);
                 }
             }
         } catch (e: any) {
@@ -526,25 +554,26 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                 let parsed: any = evalResult.result;
                 if (typeof parsed === 'string') { try { parsed = JSON.parse(parsed); } catch { } }
                 if (parsed && typeof parsed === 'object' && parsed.messages?.length > 0) {
-                    _log(`OK: ${parsed.messages?.length} msgs`);
+                    const validated = validateReadChatResultPayload(parsed, 'ide read_chat');
+                    _log(`OK: ${validated.messages?.length} msgs`);
                     traceProviderEvent(args, 'provider', 'ide.read_chat.success', {
                         h,
                         provider,
                         payload: {
                             method: 'evaluate',
                             result: evalResult.result,
-                            parsed,
-                            messageCount: Array.isArray(parsed.messages) ? parsed.messages.length : 0,
+                            parsed: validated,
+                            messageCount: Array.isArray(validated.messages) ? validated.messages.length : 0,
                         },
                     });
                     h.historyWriter.appendNewMessages(
                         provider?.type || getCurrentProviderType(h, 'unknown_ide'),
-                        toHistoryPersistedMessages(normalizeReadChatMessages(parsed)),
-                        parsed.title,
+                        toHistoryPersistedMessages(normalizeReadChatMessages(validated)),
+                        validated.title,
                         args?.targetSessionId,
                         historySessionId,
                     );
-                    return buildReadChatCommandResult(parsed, args);
+                    return buildReadChatCommandResult(validated as Record<string, any>, args);
                 }
             }
         } catch (e: any) {
@@ -564,11 +593,12 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
 export async function handleSendChat(h: CommandHelpers, args: any): Promise<CommandResult> {
     const input = getSendChatInputEnvelope(args);
     const text = input.textFallback;
-    if (!text) return { success: false, error: 'text required' };
+    const hasInput = input.parts.length > 0 || (typeof text === 'string' && text.trim().length > 0);
+    if (!hasInput) return { success: false, error: 'input required' };
     const _log = (msg: string) => LOG.debug('Command', `[send_chat] ${msg}`);
     const provider = h.getProvider(args?.agentType);
     const transport = getTargetTransport(h, provider);
-    const dedupeKey = buildRecentSendKey(h, args, provider, text);
+    const dedupeKey = buildRecentSendKey(h, args, provider, buildSendInputSignature(input));
 
     const _logSendSuccess = (method: string, targetAgent?: string) => {
         // Sending and transcript persistence are intentionally decoupled.
@@ -582,12 +612,28 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
         return { success: true, sent: false, deduplicated: true };
     }
 
-    // PTY / ACP transport: transmit via adapter
-    if (isCliLikeTransport(transport)) {
+    if (transport === 'acp') {
+        const target = getTargetInstance(h, args);
+        if (!target || target.category !== 'acp') {
+            return { success: false, error: `ACP instance not found for ${provider?.type || args?.agentType || 'unknown'}` };
+        }
+        try {
+            assertProviderSupportsDeclaredInput(provider, input);
+            target.onEvent('send_message', { input });
+            return _logSendSuccess('acp-instance', target.type);
+        } catch (e: any) {
+            return { success: false, error: `acp send failed: ${e.message}` };
+        }
+    }
+
+    // PTY transport: text-only send via adapter
+    if (transport === 'pty') {
         const adapter = getTargetedCliAdapter(h, args, provider?.type);
         if (adapter) {
             _log(`${transport} adapter: ${adapter.cliType}`);
             try {
+                assertTextOnlyInput(provider, input);
+                if (!text) return { success: false, error: 'text required for PTY send' };
                 await adapter.sendMessage(text);
                 return _logSendSuccess(`${transport}-adapter`, adapter.cliType);
             } catch (e: any) {
@@ -596,6 +642,9 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
         }
     }
 
+    assertTextOnlyInput(provider, input);
+    if (!text) return { success: false, error: 'text required' };
+
     // Extension transport: via AgentStreamManager
     if (isExtensionTransport(transport)) {
         _log(`Extension: ${provider?.type || 'unknown_extension'}`);

package/src/commands/cli-manager.ts

@@ -23,6 +23,7 @@ import { AcpProviderInstance } from '../providers/acp-provider-instance.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { ProviderLoader } from '../providers/provider-loader.js';
 import { normalizeInputEnvelope, type ProviderModule, type ProviderResumeCapability } from '../providers/contracts.js';
+import { assertProviderSupportsDeclaredInput, assertTextOnlyInput } from '../providers/provider-input-support.js';
 import type { CliAdapter } from '../cli-adapter-types.js';
 import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import type { SessionRegistry } from '../sessions/registry.js';
@@ -950,6 +951,12 @@ export class DaemonCliManager {
 
                 if (action === 'send_chat') {
                     const input = normalizeInputEnvelope(args?.input ? { input: args.input } : args);
+                    const provider = this.providerLoader.resolve(agentType) || this.providerLoader.getMeta(agentType);
+                    if (provider?.category === 'acp') {
+                        assertProviderSupportsDeclaredInput(provider, input);
+                    } else {
+                        assertTextOnlyInput(provider, input);
+                    }
                     const message = input.textFallback;
                     if (!message) throw new Error('message required for send_chat');
                     await adapter.sendMessage(message);

package/src/commands/stream-commands.ts

@@ -179,7 +179,7 @@ export function normalizeProviderScriptArgs(args: any, scriptName?: string): Rec
 
 function buildControlScriptResult(scriptName: string, payload: any): Record<string, unknown> {
     if (!payload || typeof payload !== 'object') return {};
-    if (Array.isArray(payload.options) || Array.isArray(payload.models) || Array.isArray(payload.modes)) {
+    if (Array.isArray(payload.options)) {
         return { controlResult: normalizeControlListResult(payload) };
     }
 
@@ -189,7 +189,7 @@ function buildControlScriptResult(scriptName: string, payload: any): Record<stri
     if (looksLikeValueMutation) {
         return { controlResult: normalizeControlSetResult(payload) };
     }
-    if (payload.ok !== undefined || payload.success !== undefined || Array.isArray(payload.effects)) {
+    if (payload.ok !== undefined || Array.isArray(payload.effects) || typeof payload.error === 'string') {
         return { controlResult: normalizeControlInvokeResult(payload) };
     }
     return {};

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

@@ -46,8 +46,9 @@ import {
     type ToolCallStatus,
     type SessionConfigOption,
 } from '@agentclientprotocol/sdk';
-import type { ProviderModule, ContentBlock, InputEnvelope, InputPart, ToolCallInfo, ToolCallContent as TCC, ToolKind, ToolCallStatus as TCS } from './contracts.js';
+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 type { ProviderInstance, ProviderState, AcpProviderState, ProviderErrorReason, ProviderEvent, InstanceContext } from './provider-instance.js';
 import { StatusMonitor } from './status-monitor.js';
 import { buildLegacyModelModeSummaryMetadata } from './summary-metadata.js';
@@ -112,27 +113,6 @@ function getPromptCapabilityFlags(agentCapabilities?: Record<string, any>): Prom
     };
 }
 
-function getResourceNameFromUri(uri: string, fallback: string): string {
-    try {
-        if (uri.startsWith('file://')) {
-            return path.basename(new URL(uri).pathname) || fallback;
-        }
-        return path.basename(uri) || fallback;
-    } catch {
-        return fallback;
-    }
-}
-
-function inputPartToResourceLink(part: Extract<InputPart, { type: 'image' | 'audio' | 'video' | 'resource' }>, fallbackName: string): ContentBlock | null {
-    if (!part.uri) return null;
-    return {
-        type: 'resource_link',
-        uri: part.uri,
-        name: getResourceNameFromUri(part.uri, fallbackName),
-        ...(part.mimeType ? { mimeType: part.mimeType } : {}),
-    };
-}
-
 function appendPromptText(promptParts: ContentBlock[], text: string | undefined): void {
     const normalized = typeof text === 'string' ? text.trim() : '';
     if (!normalized) return;
@@ -152,61 +132,64 @@ export function buildAcpPromptParts(input: InputEnvelope, agentCapabilities?: Re
         }
 
         if (part.type === 'image') {
-            if (caps.image && part.data) {
-                promptParts.push({
-                    type: 'image',
-                    data: part.data,
-                    mimeType: part.mimeType,
-                    ...(part.uri ? { uri: part.uri } : {}),
-                });
-                continue;
+            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');
             }
-            const fallback = inputPartToResourceLink(part, 'image');
-            if (fallback) promptParts.push(fallback);
-            appendPromptText(promptParts, part.alt || (!part.uri ? `Attached image (${part.mimeType})` : undefined));
+            promptParts.push({
+                type: 'image',
+                data: part.data,
+                mimeType: part.mimeType,
+                ...(part.uri ? { uri: part.uri } : {}),
+            });
             continue;
         }
 
         if (part.type === 'audio') {
-            if (caps.audio && part.data) {
-                promptParts.push({
-                    type: 'audio',
-                    data: part.data,
-                    mimeType: part.mimeType,
-                });
-                continue;
+            if (!caps.audio) {
+                throw new Error('ACP agent does not support input type: audio');
             }
-            const fallback = inputPartToResourceLink(part, 'audio');
-            if (fallback) promptParts.push(fallback);
-            appendPromptText(promptParts, part.transcript || (!part.uri ? `Attached audio (${part.mimeType})` : undefined));
+            if (!part.data) {
+                throw new Error('ACP audio input requires inline audio data');
+            }
+            promptParts.push({
+                type: 'audio',
+                data: part.data,
+                mimeType: part.mimeType,
+            });
             continue;
         }
 
         if (part.type === 'resource') {
-            if (caps.embeddedContext && (part.text || part.data)) {
+            if (!caps.embeddedContext) {
+                throw new Error('ACP agent does not support input type: resource');
+            }
+            if (part.text) {
                 promptParts.push({
                     type: 'resource',
-                    resource: part.text
-                        ? { uri: part.uri, text: part.text, mimeType: part.mimeType ?? null }
-                        : { uri: part.uri, blob: part.data || '', mimeType: part.mimeType ?? null },
+                    resource: { uri: part.uri, text: part.text, mimeType: part.mimeType ?? null },
                 });
                 continue;
             }
-            const fallback = inputPartToResourceLink(part, part.name || 'resource');
-            if (fallback) promptParts.push(fallback);
-            appendPromptText(promptParts, part.text || (!part.uri && part.name ? part.name : undefined));
-            continue;
+            if (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');
         }
 
         if (part.type === 'video') {
-            const fallback = inputPartToResourceLink(part, 'video');
-            if (fallback) promptParts.push(fallback);
-            appendPromptText(promptParts, !part.uri ? `Attached video (${part.mimeType})` : undefined);
+            throw new Error('ACP agent does not support input type: video');
         }
     }
 
     if (!promptParts.some((part) => part.type === 'text') && input.textFallback) {
-        promptParts.unshift({ type: 'text', text: input.textFallback });
+        appendPromptText(promptParts, input.textFallback);
     }
 
     return promptParts;
@@ -366,6 +349,7 @@ export class AcpProviderInstance implements ProviderInstance {
     onEvent(event: string, data?: any): void {
         if (event === 'send_message') {
             const input = normalizeInputEnvelope(data)
+            assertProviderSupportsDeclaredInput(this.provider, input)
             const promptParts = buildAcpPromptParts(input, this.agentCapabilities)
             this.sendPrompt(input.textFallback, promptParts.length > 0 ? promptParts : undefined).catch(e =>
                 this.log.warn(`[${this.type}] sendPrompt error: ${e?.message}`)

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

@@ -11,6 +11,7 @@ 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 type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
@@ -412,6 +413,7 @@ 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) => {
                     LOG.warn('CLI', `[${this.type}] send_message failed: ${e?.message || e}`);

package/src/providers/control-effects.ts

@@ -171,51 +171,43 @@ export function buildPersistedProviderEffectMessage(effect: ProviderEffect | nul
 }
 
 export function normalizeControlListResult(data: any): ControlListResult {
-    if (data && typeof data === 'object' && Array.isArray(data.options)) {
-        return {
-            options: normalizeControlOptions(data.options),
-            ...(isScalarControlValue(data.currentValue) ? { currentValue: data.currentValue } : {}),
-            ...(typeof data.error === 'string' ? { error: data.error } : {}),
-        };
+    if (!data || typeof data !== 'object' || !Array.isArray(data.options)) {
+        throw new Error('Provider control list results must use the typed shape { options, currentValue?, error? }');
     }
-
-    const rawOptions = Array.isArray(data?.models)
-        ? data.models
-        : Array.isArray(data?.modes)
-            ? data.modes
-            : Array.isArray(data?.options)
-                ? data.options
-                : [];
-    const options = normalizeControlOptions(rawOptions);
     return {
-        options,
-        ...(isScalarControlValue(data?.current) ? { currentValue: data.current } : {}),
-        ...(isScalarControlValue(data?.currentValue) ? { currentValue: data.currentValue } : {}),
-        ...(typeof data?.error === 'string' ? { error: data.error } : {}),
+        options: normalizeControlOptions(data.options),
+        ...(isScalarControlValue(data.currentValue) ? { currentValue: data.currentValue } : {}),
+        ...(typeof data.error === 'string' ? { error: data.error } : {}),
     };
 }
 
 export function normalizeControlSetResult(data: any): ControlSetResult {
-    const currentValue = isScalarControlValue(data?.currentValue)
+    if (!data || typeof data !== 'object' || typeof data.ok !== 'boolean') {
+        throw new Error('Provider control set results must use the typed shape { ok, currentValue?, effects?, error? }');
+    }
+    const currentValue = isScalarControlValue(data.currentValue)
         ? data.currentValue
-        : (isScalarControlValue(data?.value) ? data.value : undefined);
+        : (isScalarControlValue(data.value) ? data.value : undefined);
     return {
-        ok: data?.ok === true || data?.success === true,
+        ok: data.ok,
         ...(currentValue !== undefined ? { currentValue } : {}),
-        ...(Array.isArray(data?.effects) ? { effects: normalizeProviderEffects(data) } : {}),
-        ...(typeof data?.error === 'string' ? { error: data.error } : {}),
+        ...(Array.isArray(data.effects) ? { effects: normalizeProviderEffects(data) } : {}),
+        ...(typeof data.error === 'string' ? { error: data.error } : {}),
     };
 }
 
 export function normalizeControlInvokeResult(data: any): ControlInvokeResult {
-    const currentValue = isScalarControlValue(data?.currentValue)
+    if (!data || typeof data !== 'object' || typeof data.ok !== 'boolean') {
+        throw new Error('Provider control invoke results must use the typed shape { ok, currentValue?, effects?, error? }');
+    }
+    const currentValue = isScalarControlValue(data.currentValue)
         ? data.currentValue
-        : (isScalarControlValue(data?.value) ? data.value : undefined);
+        : (isScalarControlValue(data.value) ? data.value : undefined);
     return {
-        ok: data?.ok === true || data?.success === true,
+        ok: data.ok,
         ...(currentValue !== undefined ? { currentValue } : {}),
-        ...(Array.isArray(data?.effects) ? { effects: normalizeProviderEffects(data) } : {}),
-        ...(typeof data?.error === 'string' ? { error: data.error } : {}),
+        ...(Array.isArray(data.effects) ? { effects: normalizeProviderEffects(data) } : {}),
+        ...(typeof data.error === 'string' ? { error: data.error } : {}),
     };
 }