@adhdev/daemon-core 0.8.52 → 0.8.53

package/src/providers/contracts.ts

@@ -33,7 +33,22 @@ export interface ReadChatResult {
 }
 
 import type { ChatMessage } from '../types.js';
-export type { ChatMessage };
+import {
+  flattenMessageParts,
+  normalizeInputEnvelope,
+  normalizeMessageParts,
+} from './io-contracts.js';
+export {
+  flattenMessageParts,
+  normalizeInputEnvelope,
+  normalizeMessageParts,
+} from './io-contracts.js';
+import type {
+  InputEnvelope,
+  InputPart,
+  MessagePart,
+} from './io-contracts.js';
+export type { ChatMessage, InputEnvelope, InputPart, MessagePart };
 
 export type AgentStatus = 
   | 'idle' 
@@ -52,7 +67,7 @@ export interface ModalInfo {
 
 export interface ProviderEffectMessage {
   role?: 'system' | 'assistant' | 'user';
-  content: string | ContentBlock[];
+  content: string | MessagePart[];
   kind?: string;
   senderName?: string;
 }
@@ -71,7 +86,7 @@ export interface ProviderEffectNotification {
   level?: 'info' | 'success' | 'warning';
   channels?: ProviderNotificationChannel[];
   preferenceKey?: ProviderNotificationPreferenceKey;
-  bubbleContent?: string | ContentBlock[];
+  bubbleContent?: string | MessagePart[];
 }
 
 export interface ProviderEffect {
@@ -87,9 +102,9 @@ export interface ProviderEffect {
   notification?: ProviderEffectNotification;
 }
 
-// ─── Rich Content Types (ACP Standard) ─────────────────
+// ─── Legacy ACP ContentBlock Types (compatibility adapter) ─────────────────
 // Based on ACP SDK v0.16.1 schema types.
-// All provider categories (ACP, IDE, Extension, CLI) use these as output standard.
+// Internal runtime code should prefer MessagePart/InputEnvelope from io-contracts.ts.
 
 /**
  * ContentBlock — ACP ContentBlock union type
@@ -192,29 +207,25 @@ export interface ToolCallLocation {
 
 // ─── Content Helpers ────────────────────────────────────
 
-/** Normalize content: string → ContentBlock[] */
-export function normalizeContent(content: string | ContentBlock[]): ContentBlock[] {
-  if (typeof content === 'string') {
-    return [{ type: 'text', text: content }];
-  }
-  return content;
+/** Normalize content into canonical message parts */
+export function normalizeContent(content: string | MessagePart[] | ContentBlock[]): MessagePart[] {
+  return normalizeMessageParts(content);
 }
 
-/** Flatten ContentBlock[] → string (backward compat / plain-text extraction) */
-export function flattenContent(content: string | ContentBlock[]): string {
+/** Flatten canonical/legacy content into a plain-text fallback string */
+export function flattenContent(content: string | MessagePart[] | ContentBlock[]): string {
   if (typeof content === 'string') return content;
-  return content
-    .filter((b): b is TextBlock => b.type === 'text')
-    .map(b => b.text)
-    .join('\n');
+  return flattenMessageParts(normalizeMessageParts(content));
 }
 
-/** SendMessage params — supports rich content (ACP PromptRequest compatible) */
+/** SendMessage params — canonical input envelope with legacy text/prompt compatibility */
 export interface SendMessageParams {
   /** Shortcut: text-only message */
   text?: string;
-  /** Rich content blocks (ACP ContentBlock[]) */
+  /** Rich content blocks (legacy ACP ContentBlock[]) */
   prompt?: ContentBlock[];
+  /** Canonical multipart runtime input */
+  input?: InputEnvelope;
 }
 
 // ─── sendMessage() return value ────────────────────────
@@ -332,6 +343,12 @@ export interface ProviderModule {
   icon?: string;
  /** Display name (short name) */
   displayName?: string;
+ /** Provider-definition version maintained in adhdev-providers */
+  providerVersion?: string;
+ /** Inventory/support status label maintained in adhdev-providers */
+  status?: string;
+ /** Inventory/support detail string maintained in adhdev-providers */
+  details?: string;
  /** Install instructions (shown when command is missing) */
   install?: string;
  /** Custom version detection command (e.g. 'cursor --version', 'claude -v') */
@@ -390,6 +407,14 @@ export interface ProviderModule {
     shell?: boolean;
     env?: Record<string, string>;
   };
+  /** Delay before submitting typed CLI input (provider-specific TUI tuning) */
+  sendDelayMs?: number;
+  /** Submit key used after typing into CLI PTY (default: carriage return) */
+  sendKey?: string;
+  /** How the CLI adapter decides when to submit typed input */
+  submitStrategy?: 'wait_for_echo' | 'immediate';
+  /** Keep this provider out of the upstream auto-updated bundle */
+  disableUpstream?: boolean;
   approvalKeys?: Record<number, string>;
   patterns?: {
     prompt?: RegExp[];
@@ -469,6 +494,14 @@ export interface ProviderModule {
  // ─── ACP Authentication (auth method definitions) ───
  /** ACP agent auth methods (multiple supported — in priority order) */
   auth?: AcpAuthMethod[];
+
+ // ─── Contract version / capability declaration ───
+  contractVersion?: number;
+  capabilities?: {
+    input?: { multipart?: boolean; mediaTypes?: Array<'text' | 'image' | 'audio' | 'video' | 'resource'> };
+    output?: { richContent?: boolean; mediaTypes?: Array<'text' | 'image' | 'audio' | 'video' | 'resource'> };
+    controls?: { typedResults?: boolean };
+  };
 }
 
 export interface ProviderResumeCapability {
@@ -674,6 +707,26 @@ export interface ProviderControlOption {
   group?: string;
 }
 
+export interface ControlListResult {
+  options: ProviderControlOption[];
+  currentValue?: string | number | boolean;
+  error?: string;
+}
+
+export interface ControlSetResult {
+  ok: boolean;
+  currentValue?: string | number | boolean;
+  effects?: ProviderEffect[];
+  error?: string;
+}
+
+export interface ControlInvokeResult {
+  ok: boolean;
+  currentValue?: string | number | boolean;
+  effects?: ProviderEffect[];
+  error?: string;
+}
+
 /**
  * ProviderControlDef — A single interactive control declared by a provider.
  *

package/src/providers/control-effects.ts

@@ -1,4 +1,11 @@
-import type { ProviderControlDef, ProviderEffect } from './contracts.js';
+import type {
+    ControlInvokeResult,
+    ControlListResult,
+    ControlSetResult,
+    ProviderControlDef,
+    ProviderControlOption,
+    ProviderEffect,
+} from './contracts.js';
 
 export type ProviderControlValue = string | number | boolean;
 
@@ -101,6 +108,84 @@ export function normalizeProviderEffects(data: any): ProviderEffect[] {
     return effects;
 }
 
+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 } : {}),
+        };
+    }
+
+    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 } : {}),
+    };
+}
+
+export function normalizeControlSetResult(data: any): ControlSetResult {
+    const currentValue = isScalarControlValue(data?.currentValue)
+        ? data.currentValue
+        : (isScalarControlValue(data?.value) ? data.value : undefined);
+    return {
+        ok: data?.ok === true || data?.success === true,
+        ...(currentValue !== undefined ? { currentValue } : {}),
+        ...(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)
+        ? data.currentValue
+        : (isScalarControlValue(data?.value) ? data.value : undefined);
+    return {
+        ok: data?.ok === true || data?.success === true,
+        ...(currentValue !== undefined ? { currentValue } : {}),
+        ...(Array.isArray(data?.effects) ? { effects: normalizeProviderEffects(data) } : {}),
+        ...(typeof data?.error === 'string' ? { error: data.error } : {}),
+    };
+}
+
+function normalizeControlOptions(options: unknown[]): ProviderControlOption[] {
+    return options
+        .map((option) => normalizeControlOption(option))
+        .filter((option): option is ProviderControlOption => !!option);
+}
+
+function normalizeControlOption(option: unknown): ProviderControlOption | null {
+    if (typeof option === 'string') {
+        return { value: option, label: option };
+    }
+    if (!option || typeof option !== 'object') return null;
+    const record = option as Record<string, unknown>;
+    const value = typeof record.value === 'string'
+        ? record.value
+        : (typeof record.id === 'string' ? record.id : null);
+    if (!value) return null;
+    const label = typeof record.label === 'string'
+        ? record.label
+        : (typeof record.name === 'string' ? record.name : value);
+    const normalized: ProviderControlOption = { value, label };
+    if (typeof record.description === 'string') normalized.description = record.description;
+    if (typeof record.group === 'string') normalized.group = record.group;
+    return normalized;
+}
+
+function isScalarControlValue(value: unknown): value is ProviderControlValue {
+    return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+}
+
 function normalizeControlValue(value: any): ProviderControlValue {
     if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
         return value;

package/src/providers/io-contracts.ts

@@ -0,0 +1,340 @@
+import type { ContentAnnotations } from './contracts.js'
+
+export type InputPart =
+  | TextInputPart
+  | ImageInputPart
+  | AudioInputPart
+  | VideoInputPart
+  | ResourceInputPart
+
+export interface TextInputPart {
+  type: 'text'
+  text: string
+}
+
+export interface ImageInputPart {
+  type: 'image'
+  mimeType: string
+  uri?: string
+  data?: string
+  alt?: string
+}
+
+export interface AudioInputPart {
+  type: 'audio'
+  mimeType: string
+  uri?: string
+  data?: string
+  transcript?: string
+}
+
+export interface VideoInputPart {
+  type: 'video'
+  mimeType: string
+  uri?: string
+  data?: string
+  posterUri?: string
+}
+
+export interface ResourceInputPart {
+  type: 'resource'
+  uri: string
+  mimeType?: string
+  name?: string
+  text?: string
+  data?: string
+}
+
+export interface InputEnvelope {
+  parts: InputPart[]
+  textFallback: string
+  metadata?: {
+    source?: 'dashboard' | 'shortcut_api' | 'provider_script' | 'session_replay'
+    clientTimestamp?: number
+  }
+}
+
+export type MessagePart =
+  | TextMessagePart
+  | ImageMessagePart
+  | AudioMessagePart
+  | VideoMessagePart
+  | ResourceLinkMessagePart
+  | ResourceMessagePart
+
+export interface TextMessagePart {
+  type: 'text'
+  text: string
+  annotations?: ContentAnnotations
+}
+
+export interface ImageMessagePart {
+  type: 'image'
+  mimeType: string
+  uri?: string
+  data?: string
+  annotations?: ContentAnnotations
+}
+
+export interface AudioMessagePart {
+  type: 'audio'
+  mimeType: string
+  uri?: string
+  data?: string
+  transcript?: string
+  annotations?: ContentAnnotations
+}
+
+export interface VideoMessagePart {
+  type: 'video'
+  mimeType: string
+  uri?: string
+  data?: string
+  posterUri?: string
+  annotations?: ContentAnnotations
+}
+
+export interface ResourceLinkMessagePart {
+  type: 'resource_link'
+  uri: string
+  name: string
+  mimeType?: string
+  size?: number
+}
+
+export interface ResourceMessagePart {
+  type: 'resource'
+  resource: {
+    uri: string
+    mimeType?: string | null
+    text?: string
+    blob?: string
+  }
+}
+
+export function normalizeInputEnvelope(input: unknown): InputEnvelope {
+  const normalized = normalizeInputEnvelopePayload(input)
+  const textFallback = normalized.textFallback ?? flattenInputParts(normalized.parts)
+  return {
+    parts: normalized.parts,
+    textFallback,
+    ...(normalized.metadata ? { metadata: normalized.metadata } : {}),
+  }
+}
+
+export function normalizeMessageParts(content: unknown): MessagePart[] {
+  if (typeof content === 'string') return [{ type: 'text', text: content }]
+  if (!Array.isArray(content)) {
+    if (content && typeof content === 'object' && typeof (content as { text?: unknown }).text === 'string') {
+      return [{ type: 'text', text: String((content as { text: string }).text) }]
+    }
+    return []
+  }
+
+  const parts: MessagePart[] = []
+  for (const raw of content) {
+    if (typeof raw === 'string') {
+      parts.push({ type: 'text', text: raw })
+      continue
+    }
+    if (!raw || typeof raw !== 'object') continue
+    const part = normalizeMessagePartObject(raw)
+    if (part) parts.push(part)
+  }
+  return parts
+}
+
+export function flattenMessageParts(parts: MessagePart[]): string {
+  return parts
+    .map((part) => {
+      if (part.type === 'text') return part.text
+      if (part.type === 'resource') return part.resource.text || ''
+      return ''
+    })
+    .filter((value) => value.length > 0)
+    .join('\n')
+}
+
+function normalizeInputEnvelopePayload(input: unknown): Omit<InputEnvelope, 'textFallback'> & { textFallback?: string } {
+  if (typeof input === 'string') {
+    return { parts: [{ type: 'text', text: input }], textFallback: input }
+  }
+
+  if (!input || typeof input !== 'object') {
+    return { parts: [], textFallback: '' }
+  }
+
+  const record = input as Record<string, unknown>
+  const nestedInput = record.input
+  if (nestedInput && typeof nestedInput === 'object') {
+    const nested = nestedInput as Record<string, unknown>
+    return {
+      parts: normalizeInputParts(nested.parts ?? nested.prompt),
+      textFallback: typeof nested.textFallback === 'string' ? nested.textFallback : undefined,
+      metadata: normalizeInputMetadata(nested.metadata),
+    }
+  }
+
+  const directText = typeof record.text === 'string'
+    ? record.text
+    : (typeof record.message === 'string' ? record.message : undefined)
+  if (directText !== undefined) {
+    return { parts: [{ type: 'text', text: directText }], textFallback: directText }
+  }
+
+  const directParts = normalizeInputParts(record.parts ?? record.prompt)
+  return {
+    parts: directParts,
+    textFallback: typeof record.textFallback === 'string' ? record.textFallback : undefined,
+    metadata: normalizeInputMetadata(record.metadata),
+  }
+}
+
+function normalizeInputMetadata(value: unknown): InputEnvelope['metadata'] | undefined {
+  if (!value || typeof value !== 'object') return undefined
+  const record = value as Record<string, unknown>
+  const metadata: InputEnvelope['metadata'] = {}
+  if (record.source === 'dashboard' || record.source === 'shortcut_api' || record.source === 'provider_script' || record.source === 'session_replay') {
+    metadata.source = record.source
+  }
+  if (typeof record.clientTimestamp === 'number' && Number.isFinite(record.clientTimestamp)) {
+    metadata.clientTimestamp = record.clientTimestamp
+  }
+  return Object.keys(metadata).length > 0 ? metadata : undefined
+}
+
+function normalizeInputParts(value: unknown): InputPart[] {
+  if (!Array.isArray(value)) return []
+  const parts: InputPart[] = []
+  for (const raw of value) {
+    if (typeof raw === 'string') {
+      parts.push({ type: 'text', text: raw })
+      continue
+    }
+    if (!raw || typeof raw !== 'object') continue
+    const part = normalizeInputPartObject(raw)
+    if (part) parts.push(part)
+  }
+  return parts
+}
+
+function normalizeInputPartObject(raw: Record<string, unknown>): InputPart | null {
+  const type = raw.type
+  if (type === 'text' && typeof raw.text === 'string') {
+    return { type, text: raw.text }
+  }
+  if (type === 'image' && typeof raw.mimeType === 'string') {
+    return {
+      type,
+      mimeType: raw.mimeType,
+      ...(typeof raw.uri === 'string' ? { uri: raw.uri } : {}),
+      ...(typeof raw.data === 'string' ? { data: raw.data } : {}),
+      ...(typeof raw.alt === 'string' ? { alt: raw.alt } : {}),
+    }
+  }
+  if (type === 'audio' && typeof raw.mimeType === 'string') {
+    return {
+      type,
+      mimeType: raw.mimeType,
+      ...(typeof raw.uri === 'string' ? { uri: raw.uri } : {}),
+      ...(typeof raw.data === 'string' ? { data: raw.data } : {}),
+      ...(typeof raw.transcript === 'string' ? { transcript: raw.transcript } : {}),
+    }
+  }
+  if (type === 'video' && typeof raw.mimeType === 'string') {
+    return {
+      type,
+      mimeType: raw.mimeType,
+      ...(typeof raw.uri === 'string' ? { uri: raw.uri } : {}),
+      ...(typeof raw.data === 'string' ? { data: raw.data } : {}),
+      ...(typeof raw.posterUri === 'string' ? { posterUri: raw.posterUri } : {}),
+    }
+  }
+  if (type === 'resource' && typeof raw.uri === 'string') {
+    return {
+      type,
+      uri: raw.uri,
+      ...(typeof raw.mimeType === 'string' ? { mimeType: raw.mimeType } : {}),
+      ...(typeof raw.name === 'string' ? { name: raw.name } : {}),
+      ...(typeof raw.text === 'string' ? { text: raw.text } : {}),
+      ...(typeof raw.data === 'string' ? { data: raw.data } : {}),
+    }
+  }
+  if (type === 'resource_link' && typeof raw.uri === 'string') {
+    return {
+      type: 'resource',
+      uri: raw.uri,
+      ...(typeof raw.mimeType === 'string' ? { mimeType: raw.mimeType } : {}),
+      ...(typeof raw.name === 'string' ? { name: raw.name } : {}),
+    }
+  }
+  return null
+}
+
+function normalizeMessagePartObject(raw: Record<string, unknown>): MessagePart | null {
+  const type = raw.type
+  if (type === 'text' && typeof raw.text === 'string') {
+    return { type, text: raw.text }
+  }
+  if (type === 'image' && typeof raw.mimeType === 'string') {
+    return {
+      type,
+      mimeType: raw.mimeType,
+      ...(typeof raw.uri === 'string' ? { uri: raw.uri } : {}),
+      ...(typeof raw.data === 'string' ? { data: raw.data } : {}),
+    }
+  }
+  if (type === 'audio' && typeof raw.mimeType === 'string') {
+    return {
+      type,
+      mimeType: raw.mimeType,
+      ...(typeof raw.uri === 'string' ? { uri: raw.uri } : {}),
+      ...(typeof raw.data === 'string' ? { data: raw.data } : {}),
+      ...(typeof raw.transcript === 'string' ? { transcript: raw.transcript } : {}),
+    }
+  }
+  if (type === 'video' && typeof raw.mimeType === 'string') {
+    return {
+      type,
+      mimeType: raw.mimeType,
+      ...(typeof raw.uri === 'string' ? { uri: raw.uri } : {}),
+      ...(typeof raw.data === 'string' ? { data: raw.data } : {}),
+      ...(typeof raw.posterUri === 'string' ? { posterUri: raw.posterUri } : {}),
+    }
+  }
+  if (type === 'resource_link' && typeof raw.uri === 'string' && typeof raw.name === 'string') {
+    return {
+      type,
+      uri: raw.uri,
+      name: raw.name,
+      ...(typeof raw.mimeType === 'string' ? { mimeType: raw.mimeType } : {}),
+      ...(typeof raw.size === 'number' ? { size: raw.size } : {}),
+    }
+  }
+  if (type === 'resource' && raw.resource && typeof raw.resource === 'object') {
+    const resource = raw.resource as Record<string, unknown>
+    if (typeof resource.uri !== 'string') return null
+    return {
+      type,
+      resource: {
+        uri: resource.uri,
+        ...(typeof resource.mimeType === 'string' || resource.mimeType === null ? { mimeType: resource.mimeType as string | null } : {}),
+        ...(typeof resource.text === 'string' ? { text: resource.text } : {}),
+        ...(typeof resource.blob === 'string' ? { blob: resource.blob } : {}),
+      },
+    }
+  }
+  return null
+}
+
+function flattenInputParts(parts: InputPart[]): string {
+  return parts
+    .map((part) => {
+      if (part.type === 'text') return part.text
+      if (part.type === 'audio') return part.transcript || ''
+      if (part.type === 'resource') return part.text || ''
+      return ''
+    })
+    .filter((value) => value.length > 0)
+    .join('\n')
+}

package/src/providers/provider-loader.ts

@@ -29,6 +29,7 @@ import type {
   ProviderSettingSchema,
   ResolvedProvider,
 } from './contracts.js';
+import { validateProviderDefinition } from './provider-schema.js';
 
 interface ProviderAvailabilityState {
   installed: boolean;
@@ -1288,20 +1289,24 @@ export class ProviderLoader {
             extensionIdPattern?: RegExp | string;
           };
 
-          if (!mod.type || !mod.name || !mod.category) {
-            this.log(`⚠ Invalid provider at ${jsonPath}: missing type/name/category`);
-          } else {
-            // Restore RegExp fields from JSON (extensionIdPattern)
-            if (typeof mod.extensionIdPattern === 'string') {
-              const flags = mod.extensionIdPattern_flags || '';
-              mod.extensionIdPattern = new RegExp(mod.extensionIdPattern, flags);
-            }
-            const { extensionIdPattern_flags, extensionIdPattern, ...providerFields } = mod;
-            const normalizedProvider: ProviderModule = {
-              ...providerFields,
-              ...(extensionIdPattern instanceof RegExp ? { extensionIdPattern } : {}),
-            };
+          // Restore RegExp fields from JSON (extensionIdPattern)
+          if (typeof mod.extensionIdPattern === 'string') {
+            const flags = mod.extensionIdPattern_flags || '';
+            mod.extensionIdPattern = new RegExp(mod.extensionIdPattern, flags);
+          }
+          const { extensionIdPattern_flags, extensionIdPattern, ...providerFields } = mod;
+          const normalizedProvider: ProviderModule = {
+            ...providerFields,
+            ...(extensionIdPattern instanceof RegExp ? { extensionIdPattern } : {}),
+          };
 
+          const validation = validateProviderDefinition(normalizedProvider);
+          for (const warning of validation.warnings) {
+            this.log(`⚠ ${jsonPath}: ${warning}`);
+          }
+          if (validation.errors.length > 0) {
+            this.log(`⚠ Invalid provider at ${jsonPath}: ${validation.errors.join('; ')}`);
+          } else {
             // Load scripts.js if exists (IDE/Extension)
             // Skip for compatibility-format providers — scripts loaded lazily in resolve()
             const hasCompatibility = Array.isArray(normalizedProvider.compatibility);