@adhdev/daemon-core 0.8.64 → 0.8.66

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

@@ -343,20 +343,49 @@ export class ExtensionProviderInstance implements ProviderInstance {
         }
     }
 
+    private buildSyntheticTurnKey(message: any, occurrence: number): string {
+        const role = typeof message?.role === 'string' ? message.role : '';
+        const kind = typeof message?.kind === 'string' ? message.kind : '';
+        const senderName = typeof message?.senderName === 'string' ? message.senderName : '';
+        const content = flattenContent(message?.content)
+            .replace(/\s+/g, ' ')
+            .trim()
+            .slice(0, 500);
+        return `${role}|${kind}|${senderName}|${content}|${occurrence}`;
+    }
+
     /**
-     * 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(messages: any[]): any[] {
         const now = Date.now();
         const nextHashes = new Map<string, number>();
+        const occurrenceByBaseKey = new Map<string, number>();
 
         for (const msg of messages) {
-            const hash = `${msg.role}:${(msg.content || '').slice(0, 100)}`;
-            const prevTime = this.prevMessageHashes.get(hash);
+            const explicitTurnKey = typeof msg?._turnKey === 'string' && msg._turnKey.trim()
+                ? msg._turnKey.trim()
+                : '';
+            const explicitId = typeof msg?.id === 'string' && msg.id.trim()
+                ? `id:${msg.id.trim()}`
+                : '';
+            const explicitIndex = typeof msg?.index === 'number' && Number.isFinite(msg.index)
+                ? `idx:${msg.index}`
+                : '';
+            const baseKey = explicitTurnKey || explicitId || explicitIndex || `${msg?.role || ''}:${flattenContent(msg?.content || '').slice(0, 500)}`;
+            const occurrence = (occurrenceByBaseKey.get(baseKey) || 0) + 1;
+            occurrenceByBaseKey.set(baseKey, occurrence);
+            const syntheticTurnKey = explicitTurnKey || explicitId || explicitIndex || this.buildSyntheticTurnKey(msg, occurrence);
+            if (!explicitTurnKey && !explicitId && !explicitIndex) {
+                msg._turnKey = syntheticTurnKey;
+            }
+
+            const prevTime = this.prevMessageHashes.get(syntheticTurnKey);
             msg.receivedAt = prevTime || now;
-            nextHashes.set(hash, msg.receivedAt);
+            nextHashes.set(syntheticTurnKey, msg.receivedAt);
         }
 
         this.prevMessageHashes = nextHashes;

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

@@ -18,6 +18,7 @@ import { StatusMonitor } from './status-monitor.js';
 import { ChatHistoryWriter } from '../config/chat-history.js';
 import { LOG } from '../logging/logger.js';
 import { buildPersistedProviderEffectMessage, normalizeProviderEffects } from './control-effects.js';
+import { validateReadChatResultPayload } from './read-chat-contract.js';
 import type { ChatMessage } from '../types.js';
 import { formatAutoApprovalMessage, pickApprovalButton } from './approval-utils.js';
 import { mergeProviderPatchState, resolveProviderStateSurface } from './provider-patch-state.js';
@@ -311,7 +312,7 @@ export class IdeProviderInstance implements ProviderInstance {
             }
 
             if (!raw || typeof raw !== 'object') return;
-            const chat = raw as ReadChatPayload;
+            const chat = validateReadChatResultPayload(raw, `${this.type} readChat`) as ReadChatPayload;
 
  // Modal filter
             let { activeModal } = chat;

package/src/providers/provider-input-support.ts

@@ -0,0 +1,71 @@
+import type { InputEnvelope, ProviderModule } from './contracts.js'
+
+type InputMediaType = 'text' | 'image' | 'audio' | 'video' | 'resource'
+
+const VALID_INPUT_MEDIA_TYPES = new Set<InputMediaType>(['text', 'image', 'audio', 'video', 'resource'])
+
+function getProviderLabel(provider?: Pick<ProviderModule, 'name' | 'type'> | null): string {
+  return provider?.name || provider?.type || 'This provider'
+}
+
+function hasNonEmptyFallbackText(input: InputEnvelope): boolean {
+  return typeof input.textFallback === 'string' && input.textFallback.trim().length > 0
+}
+
+function getRequestedInputMediaTypes(input: InputEnvelope): InputMediaType[] {
+  const types = new Set<InputMediaType>()
+  if (hasNonEmptyFallbackText(input) && !input.parts.some((part) => part.type === 'text')) {
+    types.add('text')
+  }
+  for (const part of input.parts) {
+    if (VALID_INPUT_MEDIA_TYPES.has(part.type as InputMediaType)) {
+      types.add(part.type as InputMediaType)
+    }
+  }
+  return Array.from(types)
+}
+
+function getEffectiveSemanticPartCount(input: InputEnvelope): number {
+  let count = input.parts.length
+  if (hasNonEmptyFallbackText(input) && !input.parts.some((part) => part.type === 'text')) {
+    count += 1
+  }
+  return count
+}
+
+export function assertTextOnlyInput(provider: Pick<ProviderModule, 'name' | 'type'> | null | undefined, input: InputEnvelope): void {
+  const unsupported = getRequestedInputMediaTypes(input).filter((type) => type !== 'text')
+  if (unsupported.length === 0) return
+  const label = getProviderLabel(provider)
+  const suffix = unsupported.length === 1 ? '' : 's'
+  throw new Error(`${label} only supports text input; unsupported input type${suffix}: ${unsupported.join(', ')}`)
+}
+
+export function getDeclaredProviderInputSupport(provider?: Pick<ProviderModule, 'capabilities'> | null): {
+  multipart: boolean
+  mediaTypes: Set<InputMediaType>
+} {
+  const rawMediaTypes = Array.isArray(provider?.capabilities?.input?.mediaTypes)
+    ? provider?.capabilities?.input?.mediaTypes.filter((type): type is InputMediaType => VALID_INPUT_MEDIA_TYPES.has(type as InputMediaType))
+    : []
+
+  return {
+    multipart: provider?.capabilities?.input?.multipart === true,
+    mediaTypes: new Set<InputMediaType>(rawMediaTypes.length > 0 ? rawMediaTypes : ['text']),
+  }
+}
+
+export function assertProviderSupportsDeclaredInput(provider: Pick<ProviderModule, 'name' | 'type' | 'capabilities'> | null | undefined, input: InputEnvelope): void {
+  const label = getProviderLabel(provider)
+  const support = getDeclaredProviderInputSupport(provider)
+  const requestedTypes = getRequestedInputMediaTypes(input)
+  const unsupported = requestedTypes.filter((type) => !support.mediaTypes.has(type))
+  if (unsupported.length > 0) {
+    const suffix = unsupported.length === 1 ? '' : 's'
+    throw new Error(`${label} does not support input type${suffix}: ${unsupported.join(', ')}`)
+  }
+
+  if (getEffectiveSemanticPartCount(input) > 1 && !support.multipart) {
+    throw new Error(`${label} does not support multipart input`)
+  }
+}

package/src/providers/provider-schema.ts

@@ -1,5 +1,7 @@
 import type { ProviderControlDef, ProviderControlType, ProviderModule } from './contracts.js'
 
+const VALID_CAPABILITY_MEDIA_TYPES = new Set(['text', 'image', 'audio', 'video', 'resource'])
+
 const KNOWN_PROVIDER_FIELDS = new Set<string>([
   'type',
   'name',
@@ -50,6 +52,7 @@ const KNOWN_PROVIDER_FIELDS = new Set<string>([
   'sendDelayMs',
   'sendKey',
   'submitStrategy',
+  'timeouts',
   'disableUpstream',
 ])
 
@@ -88,6 +91,7 @@ export function validateProviderDefinition(raw: unknown): ProviderValidationResu
   }
 
   const category = provider.category
+  const controls = Array.isArray(provider.controls) ? provider.controls : []
   if ((category === 'cli' || category === 'acp')) {
     const spawn = provider.spawn
     const command = spawn && typeof spawn === 'object'
@@ -110,13 +114,68 @@ export function validateProviderDefinition(raw: unknown): ProviderValidationResu
     warnings.push('Extension providers should have extensionId')
   }
 
-  for (const control of Array.isArray(provider.controls) ? provider.controls : []) {
+  validateCapabilities(provider as unknown as ProviderModule, controls, errors)
+
+  for (const control of controls) {
     validateControl(control as ProviderControlDef, errors)
   }
 
   return { errors, warnings }
 }
 
+function validateCapabilities(provider: ProviderModule, controls: ProviderControlDef[], errors: string[]): void {
+  const capabilities = provider.capabilities
+  if (provider.contractVersion === 2) {
+    if (!capabilities || typeof capabilities !== 'object') {
+      errors.push('contractVersion 2 providers must declare capabilities')
+      return
+    }
+  }
+  if (!capabilities || typeof capabilities !== 'object') {
+    return
+  }
+
+  const input = capabilities.input
+  if (!input || typeof input !== 'object') {
+    errors.push('capabilities.input is required')
+  } else {
+    if (typeof input.multipart !== 'boolean') {
+      errors.push('capabilities.input.multipart must be boolean')
+    }
+    if (!Array.isArray(input.mediaTypes) || input.mediaTypes.length === 0) {
+      errors.push('capabilities.input.mediaTypes must be a non-empty array')
+    } else if (input.mediaTypes.some((type) => typeof type !== 'string' || !VALID_CAPABILITY_MEDIA_TYPES.has(type))) {
+      errors.push(`capabilities.input.mediaTypes must only include: ${Array.from(VALID_CAPABILITY_MEDIA_TYPES).join(', ')}`)
+    }
+  }
+
+  const output = capabilities.output
+  if (!output || typeof output !== 'object') {
+    errors.push('capabilities.output is required')
+  } else {
+    if (typeof output.richContent !== 'boolean') {
+      errors.push('capabilities.output.richContent must be boolean')
+    }
+    if (!Array.isArray(output.mediaTypes) || output.mediaTypes.length === 0) {
+      errors.push('capabilities.output.mediaTypes must be a non-empty array')
+    } else if (output.mediaTypes.some((type) => typeof type !== 'string' || !VALID_CAPABILITY_MEDIA_TYPES.has(type))) {
+      errors.push(`capabilities.output.mediaTypes must only include: ${Array.from(VALID_CAPABILITY_MEDIA_TYPES).join(', ')}`)
+    }
+  }
+
+  const controlCapabilities = capabilities.controls
+  if (!controlCapabilities || typeof controlCapabilities !== 'object') {
+    errors.push('capabilities.controls is required')
+    return
+  }
+  if (typeof controlCapabilities.typedResults !== 'boolean') {
+    errors.push('capabilities.controls.typedResults must be boolean')
+  }
+  if (controls.length > 0 && controlCapabilities.typedResults !== true) {
+    errors.push('providers declaring controls must set capabilities.controls.typedResults=true')
+  }
+}
+
 function validateControl(control: ProviderControlDef, errors: string[]): void {
   if (!control || typeof control !== 'object') {
     errors.push('controls: each control must be an object')

package/src/providers/read-chat-contract.ts

@@ -0,0 +1,136 @@
+import type { MessagePart, ModalInfo, ReadChatResult } from './contracts.js'
+import { normalizeMessageParts } from './contracts.js'
+import type { ChatMessage } from '../types.js'
+
+const VALID_STATUSES = ['idle', 'generating', 'waiting_approval', 'error', 'panel_hidden', 'streaming', 'long_generating'] as const
+const VALID_ROLES = ['user', 'assistant', 'system', 'human'] as const
+
+type ValidStatus = typeof VALID_STATUSES[number]
+type ValidRole = typeof VALID_ROLES[number]
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value)
+}
+
+function isFiniteNumber(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value)
+}
+
+function validateStatus(status: unknown, source: string): ValidStatus {
+  if (typeof status !== 'string' || !VALID_STATUSES.includes(status as ValidStatus)) {
+    throw new Error(`${source}: status must be one of ${VALID_STATUSES.join(', ')}`)
+  }
+  return status as ValidStatus
+}
+
+function validateRole(role: unknown, source: string, index: number): ValidRole {
+  if (typeof role !== 'string' || !VALID_ROLES.includes(role as ValidRole)) {
+    throw new Error(`${source}: messages[${index}].role must be one of ${VALID_ROLES.join(', ')}`)
+  }
+  return role as ValidRole
+}
+
+function validateMessageContent(content: unknown, source: string, index: number): string | MessagePart[] {
+  if (typeof content === 'string') return content
+  if (Array.isArray(content)) return normalizeMessageParts(content as any)
+  throw new Error(`${source}: messages[${index}].content must be a string or structured content array`)
+}
+
+function validateMessage(message: unknown, source: string, index: number): ChatMessage {
+  if (!isPlainObject(message)) {
+    throw new Error(`${source}: messages[${index}] must be an object`)
+  }
+
+  const normalized: ChatMessage = {
+    role: validateRole(message.role, source, index),
+    content: validateMessageContent(message.content, source, index),
+  }
+
+  if (typeof message.kind === 'string') normalized.kind = message.kind as any
+  if (typeof message.id === 'string') normalized.id = message.id
+  if (isFiniteNumber(message.index)) normalized.index = message.index
+  if (isFiniteNumber(message.timestamp)) normalized.timestamp = message.timestamp
+  if (isFiniteNumber(message.receivedAt)) normalized.receivedAt = message.receivedAt
+  if (Array.isArray(message.toolCalls)) normalized.toolCalls = message.toolCalls as any
+  if (isPlainObject(message.meta)) normalized.meta = message.meta as any
+  if (typeof message.senderName === 'string') normalized.senderName = message.senderName
+  if (typeof (message as any)._type === 'string') normalized._type = (message as any)._type
+  if (typeof (message as any)._sub === 'string') normalized._sub = (message as any)._sub
+
+  return normalized
+}
+
+function validateModal(activeModal: unknown, status: ValidStatus, source: string): ModalInfo | null | undefined {
+  if (activeModal == null) {
+    if (status === 'waiting_approval') {
+      throw new Error(`${source}: waiting_approval status requires activeModal with buttons`)
+    }
+    return activeModal === null ? null : undefined
+  }
+  if (!isPlainObject(activeModal)) {
+    throw new Error(`${source}: activeModal must be an object when provided`)
+  }
+  if (typeof activeModal.message !== 'string') {
+    throw new Error(`${source}: activeModal.message must be a string`)
+  }
+  if (!Array.isArray(activeModal.buttons) || activeModal.buttons.some((button) => typeof button !== 'string' || !button.trim())) {
+    throw new Error(`${source}: activeModal.buttons must be a non-empty string array`)
+  }
+  const normalized: ModalInfo = {
+    message: activeModal.message,
+    buttons: activeModal.buttons.map((button) => button.trim()),
+  }
+  if (isFiniteNumber(activeModal.width)) normalized.width = activeModal.width
+  if (isFiniteNumber(activeModal.height)) normalized.height = activeModal.height
+  return normalized
+}
+
+function validateControlValues(controlValues: unknown, source: string): Record<string, string | number | boolean> | undefined {
+  if (controlValues === undefined) return undefined
+  if (!isPlainObject(controlValues)) {
+    throw new Error(`${source}: controlValues must be an object when provided`)
+  }
+  const normalized: Record<string, string | number | boolean> = {}
+  for (const [key, value] of Object.entries(controlValues)) {
+    if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
+      throw new Error(`${source}: controlValues.${key} must be string, number, or boolean`)
+    }
+    normalized[key] = value
+  }
+  return normalized
+}
+
+export function validateReadChatResultPayload(raw: unknown, source = 'read_chat'): ReadChatResult & Record<string, unknown> {
+  if (!isPlainObject(raw)) {
+    throw new Error(`${source}: payload must be an object`)
+  }
+
+  const status = validateStatus(raw.status, source)
+  if (!Array.isArray(raw.messages)) {
+    throw new Error(`${source}: messages must be an array`)
+  }
+  const messages = raw.messages.map((message, index) => validateMessage(message, source, index))
+  const activeModal = validateModal(raw.activeModal, status, source)
+  const controlValues = validateControlValues(raw.controlValues, source)
+
+  const normalized: ReadChatResult & Record<string, unknown> = {
+    status: status as any,
+    messages,
+  }
+
+  if (activeModal !== undefined) normalized.activeModal = activeModal
+  if (typeof raw.id === 'string') normalized.id = raw.id
+  if (typeof raw.title === 'string') normalized.title = raw.title
+  if (typeof raw.agentType === 'string') normalized.agentType = raw.agentType
+  if (typeof raw.agentName === 'string') normalized.agentName = raw.agentName
+  if (typeof raw.extensionId === 'string') normalized.extensionId = raw.extensionId
+  if (typeof raw.inputContent === 'string') normalized.inputContent = raw.inputContent
+  if (typeof raw.isVisible === 'boolean') normalized.isVisible = raw.isVisible
+  if (typeof raw.isWelcomeScreen === 'boolean') normalized.isWelcomeScreen = raw.isWelcomeScreen
+  if (controlValues) normalized.controlValues = controlValues
+  if (raw.summaryMetadata !== undefined) normalized.summaryMetadata = raw.summaryMetadata as any
+  if (Array.isArray(raw.effects)) normalized.effects = raw.effects as any
+  if (typeof raw.providerSessionId === 'string') normalized.providerSessionId = raw.providerSessionId
+
+  return normalized
+}