@talex-touch/utils 1.0.42 → 1.0.44

package/renderer/hooks/use-intelligence-stats.ts

@@ -0,0 +1,290 @@
+import type { Ref } from 'vue'
+import { ref } from 'vue'
+import { useIntelligenceSdk } from './use-intelligence-sdk'
+
+/**
+ * Usage summary for a specific period
+ */
+interface IntelligenceUsageSummary {
+  period: string
+  periodType: 'minute' | 'day' | 'month'
+  requestCount: number
+  successCount: number
+  failureCount: number
+  totalTokens: number
+  promptTokens: number
+  completionTokens: number
+  totalCost: number
+  avgLatency: number
+}
+
+/**
+ * Audit log entry
+ */
+interface IntelligenceAuditLogEntry {
+  traceId: string
+  timestamp: number
+  capabilityId: string
+  provider: string
+  model: string
+  promptHash?: string
+  caller?: string
+  userId?: string
+  usage: {
+    promptTokens: number
+    completionTokens: number
+    totalTokens: number
+  }
+  latency: number
+  success: boolean
+  error?: string
+  estimatedCost?: number
+}
+
+/**
+ * Current usage for a caller
+ */
+interface CurrentUsage {
+  requestsThisMinute: number
+  requestsToday: number
+  requestsThisMonth: number
+  tokensThisMinute: number
+  tokensToday: number
+  tokensThisMonth: number
+  costToday: number
+  costThisMonth: number
+}
+
+/**
+ * Quota configuration
+ */
+interface QuotaConfig {
+  callerId: string
+  callerType: 'plugin' | 'user' | 'system'
+  requestsPerMinute?: number
+  requestsPerDay?: number
+  requestsPerMonth?: number
+  tokensPerMinute?: number
+  tokensPerDay?: number
+  tokensPerMonth?: number
+  costLimitPerDay?: number
+  costLimitPerMonth?: number
+  enabled?: boolean
+}
+
+/**
+ * Quota check result
+ */
+interface QuotaCheckResult {
+  allowed: boolean
+  reason?: string
+  remainingRequests?: number
+  remainingTokens?: number
+  remainingCost?: number
+}
+
+/**
+ * Query options for audit logs
+ */
+interface AuditLogQueryOptions {
+  caller?: string
+  capabilityId?: string
+  provider?: string
+  startTime?: number
+  endTime?: number
+  success?: boolean
+  limit?: number
+  offset?: number
+}
+
+interface IntelligenceStatsComposable {
+  // Audit logs
+  getAuditLogs: (options?: AuditLogQueryOptions) => Promise<IntelligenceAuditLogEntry[]>
+
+  // Usage statistics
+  getTodayStats: (callerId?: string) => Promise<IntelligenceUsageSummary | null>
+  getMonthStats: (callerId?: string) => Promise<IntelligenceUsageSummary | null>
+  getUsageStats: (
+    callerId: string,
+    periodType: 'day' | 'month',
+    startPeriod?: string,
+    endPeriod?: string,
+  ) => Promise<IntelligenceUsageSummary[]>
+
+  // Quota management
+  getQuota: (callerId: string, callerType?: 'plugin' | 'user' | 'system') => Promise<QuotaConfig | null>
+  setQuota: (config: QuotaConfig) => Promise<void>
+  deleteQuota: (callerId: string, callerType?: 'plugin' | 'user' | 'system') => Promise<void>
+  getAllQuotas: () => Promise<QuotaConfig[]>
+  checkQuota: (callerId: string, callerType?: 'plugin' | 'user' | 'system', estimatedTokens?: number) => Promise<QuotaCheckResult>
+  getCurrentUsage: (callerId: string, callerType?: 'plugin' | 'user' | 'system') => Promise<CurrentUsage>
+
+  // Export utilities
+  exportToCSV: (logs: IntelligenceAuditLogEntry[]) => string
+  exportToJSON: (logs: IntelligenceAuditLogEntry[]) => string
+  downloadAsFile: (content: string, filename: string, mimeType: string) => void
+
+  // Loading state
+  isLoading: Ref<boolean>
+  lastError: Ref<string | null>
+}
+
+/**
+ * Intelligence Statistics Composable for Vue components
+ *
+ * Provides access to audit logs, usage statistics, and quota management
+ *
+ * @example
+ * ```ts
+ * const { getTodayStats, getAuditLogs, exportToCSV } = useIntelligenceStats()
+ *
+ * // Get today's usage
+ * const stats = await getTodayStats()
+ * console.log(`Today: ${stats.requestCount} requests, $${stats.totalCost.toFixed(4)} cost`)
+ *
+ * // Get audit logs
+ * const logs = await getAuditLogs({ limit: 100 })
+ *
+ * // Export to CSV
+ * const csv = exportToCSV(logs)
+ * downloadAsFile(csv, 'audit-logs.csv', 'text/csv')
+ * ```
+ */
+/**
+ * @deprecated 请优先使用 useIntelligenceSdk() 直接调用统计相关能力。
+ */
+export function useIntelligenceStats(): IntelligenceStatsComposable {
+  const isLoading = ref(false)
+  const lastError = ref<string | null>(null)
+  const intelligenceSdk = useIntelligenceSdk()
+
+  async function withLoadingState<T>(operation: () => Promise<T>): Promise<T> {
+    isLoading.value = true
+    lastError.value = null
+
+    try {
+      return await operation()
+    }
+    catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error)
+      lastError.value = errorMessage
+      throw error
+    }
+    finally {
+      isLoading.value = false
+    }
+  }
+
+  // Export to CSV
+  function exportToCSV(logs: IntelligenceAuditLogEntry[]): string {
+    const headers = [
+      'Trace ID',
+      'Timestamp',
+      'Capability',
+      'Provider',
+      'Model',
+      'Caller',
+      'Prompt Tokens',
+      'Completion Tokens',
+      'Total Tokens',
+      'Estimated Cost',
+      'Latency (ms)',
+      'Success',
+      'Error',
+    ]
+
+    const rows = logs.map(log => [
+      log.traceId,
+      new Date(log.timestamp).toISOString(),
+      log.capabilityId,
+      log.provider,
+      log.model,
+      log.caller || '',
+      log.usage.promptTokens,
+      log.usage.completionTokens,
+      log.usage.totalTokens,
+      log.estimatedCost?.toFixed(6) || '',
+      log.latency,
+      log.success ? 'Yes' : 'No',
+      log.error || '',
+    ])
+
+    const csvContent = [
+      headers.join(','),
+      ...rows.map(row => row.map(cell => `"${String(cell).replace(/"/g, '""')}"`).join(',')),
+    ].join('\n')
+
+    return csvContent
+  }
+
+  // Export to JSON
+  function exportToJSON(logs: IntelligenceAuditLogEntry[]): string {
+    return JSON.stringify(logs, null, 2)
+  }
+
+  // Download as file
+  function downloadAsFile(content: string, filename: string, mimeType: string): void {
+    const blob = new Blob([content], { type: mimeType })
+    const url = URL.createObjectURL(blob)
+    const link = document.createElement('a')
+    link.href = url
+    link.download = filename
+    document.body.appendChild(link)
+    link.click()
+    document.body.removeChild(link)
+    URL.revokeObjectURL(url)
+  }
+
+  return {
+    // Audit logs
+    getAuditLogs: (options?: AuditLogQueryOptions) =>
+      withLoadingState(() => intelligenceSdk.getAuditLogs(options)),
+
+    // Usage statistics
+    getTodayStats: (callerId?: string) =>
+      withLoadingState(() => intelligenceSdk.getTodayStats(callerId)),
+
+    getMonthStats: (callerId?: string) =>
+      withLoadingState(() => intelligenceSdk.getMonthStats(callerId)),
+
+    getUsageStats: (callerId: string, periodType: 'day' | 'month', startPeriod?: string, endPeriod?: string) =>
+      withLoadingState(() =>
+        intelligenceSdk.getUsageStats({
+          callerId,
+          periodType,
+          startPeriod,
+          endPeriod,
+        }),
+      ),
+
+    // Quota management
+    getQuota: (callerId: string, callerType: 'plugin' | 'user' | 'system' = 'plugin') =>
+      withLoadingState(() => intelligenceSdk.getQuota({ callerId, callerType })),
+
+    setQuota: (config: QuotaConfig) =>
+      withLoadingState(() => intelligenceSdk.setQuota(config)),
+
+    deleteQuota: (callerId: string, callerType: 'plugin' | 'user' | 'system' = 'plugin') =>
+      withLoadingState(() => intelligenceSdk.deleteQuota({ callerId, callerType })),
+
+    getAllQuotas: () =>
+      withLoadingState(() => intelligenceSdk.getAllQuotas()),
+
+    checkQuota: (callerId: string, callerType: 'plugin' | 'user' | 'system' = 'plugin', estimatedTokens: number = 0) =>
+      withLoadingState(() =>
+        intelligenceSdk.checkQuota({ callerId, callerType, estimatedTokens }),
+      ),
+
+    getCurrentUsage: (callerId: string, callerType: 'plugin' | 'user' | 'system' = 'plugin') =>
+      withLoadingState(() => intelligenceSdk.getCurrentUsage({ callerId, callerType })),
+
+    // Export utilities
+    exportToCSV,
+    exportToJSON,
+    downloadAsFile,
+
+    // Loading state
+    isLoading,
+    lastError,
+  }
+}

package/renderer/hooks/use-intelligence.ts

@@ -32,6 +32,7 @@ import type {
   IntelligenceInvokeResult,
   IntelligenceKeywordsExtractPayload,
   IntelligenceKeywordsExtractResult,
+  IntelligenceMessage,
   IntelligenceProviderConfig,
   IntelligenceRAGQueryPayload,
   IntelligenceRAGQueryResult,
@@ -48,7 +49,7 @@ import type {
   IntelligenceVisionOcrResult,
 } from '../../types/intelligence'
 import { ref } from 'vue'
-import { useChannel } from './use-channel'
+import { useIntelligenceSdk } from './use-intelligence-sdk'
 
 interface UseIntelligenceOptions {
   // Reserved for future options
@@ -92,6 +93,14 @@ interface IntelligenceComposable {
   // Text methods
   text: {
     chat: (payload: IntelligenceChatPayload, options?: IntelligenceInvokeOptions) => Promise<IntelligenceInvokeResult<string>>
+    chatLangChain: (params: {
+      messages: IntelligenceMessage[]
+      providerId?: string
+      model?: string
+      promptTemplate?: string
+      promptVariables?: Record<string, any>
+      metadata?: Record<string, any>
+    }) => Promise<IntelligenceInvokeResult<string>>
     translate: (payload: IntelligenceTranslatePayload, options?: IntelligenceInvokeOptions) => Promise<IntelligenceInvokeResult<string>>
     summarize: (payload: IntelligenceSummarizePayload, options?: IntelligenceInvokeOptions) => Promise<IntelligenceInvokeResult<string>>
     rewrite: (payload: IntelligenceRewritePayload, options?: IntelligenceInvokeOptions) => Promise<IntelligenceInvokeResult<string>>
@@ -171,39 +180,20 @@ interface IntelligenceComposable {
  * })
  * ```
  */
+/**
+ * @deprecated 请优先使用 useIntelligenceSdk() 直接调用 domain SDK。
+ */
 export function useIntelligence(_options: UseIntelligenceOptions = {}): IntelligenceComposable {
   const isLoading = ref(false)
   const lastError = ref<string | null>(null)
+  const intelligenceSdk = useIntelligenceSdk()
 
-  // Get the TouchChannel instance
-  const channel = useChannel()
-
-  // Helper for consistent response handling
-  interface ChannelResponse<T> {
-    ok: boolean
-    result?: T
-    error?: string
-  }
-
-  async function sendChannelRequest<T>(
-    eventName: string,
-    payload: any,
-  ): Promise<T> {
-    const response = await channel.send<any, ChannelResponse<T>>(eventName, payload)
-    if (!response?.ok) {
-      throw new Error(response?.error || 'Intelligence request failed')
-    }
-    return response.result as T
-  }
-
-  // Wrapper function that handles loading state and errors
   async function withLoadingState<T>(operation: () => Promise<T>): Promise<T> {
     isLoading.value = true
     lastError.value = null
 
     try {
-      const result = await operation()
-      return result
+      return await operation()
     }
     catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error)
@@ -215,278 +205,129 @@ export function useIntelligence(_options: UseIntelligenceOptions = {}): Intellig
     }
   }
 
+  const invokeCapability = <T = unknown>(
+    capabilityId: string,
+    payload: unknown,
+    options?: IntelligenceInvokeOptions,
+  ) => withLoadingState(() => intelligenceSdk.invoke<T>(capabilityId, payload, options))
+
   return {
-    // Core invoke
     invoke: <T = any>(capabilityId: string, payload: any, options?: IntelligenceInvokeOptions) =>
-      withLoadingState(() =>
-        sendChannelRequest<IntelligenceInvokeResult<T>>('intelligence:invoke', { capabilityId, payload, options }),
-      ),
+      withLoadingState(() => intelligenceSdk.invoke<T>(capabilityId, payload, options)),
 
-    // Provider testing
     testProvider: (config: IntelligenceProviderConfig) =>
       withLoadingState(() =>
-        sendChannelRequest<{
+        intelligenceSdk.testProvider(config) as Promise<{
           success: boolean
           message: string
           latency?: number
           timestamp: number
-        }>('intelligence:test-provider', { provider: config }),
+        }>,
       ),
 
-    // Capability testing
     testCapability: (params: { capabilityId: string, providerId?: string, userInput?: string, source?: any }) =>
       withLoadingState(() =>
-        sendChannelRequest<{
+        intelligenceSdk.testCapability(params) as Promise<{
           ok: boolean
           result: any
-        }>('intelligence:test-capability', params),
+        }>,
       ),
 
-    // Get capability test metadata
     getCapabilityTestMeta: (params: { capabilityId: string }) =>
-      sendChannelRequest<{
+      intelligenceSdk.getCapabilityTestMeta(params) as Promise<{
         requiresUserInput: boolean
         inputHint: string
-      }>('intelligence:get-capability-test-meta', params),
+      }>,
 
-    // Text methods
     text: {
       chat: (payload: IntelligenceChatPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<string>>('intelligence:invoke', {
-            capabilityId: 'text.chat',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<string>('text.chat', payload, options),
+
+      chatLangChain: params =>
+        withLoadingState(() => intelligenceSdk.chatLangChain(params)),
 
       translate: (payload: IntelligenceTranslatePayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<string>>('intelligence:invoke', {
-            capabilityId: 'text.translate',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<string>('text.translate', payload, options),
 
       summarize: (payload: IntelligenceSummarizePayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<string>>('intelligence:invoke', {
-            capabilityId: 'text.summarize',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<string>('text.summarize', payload, options),
 
       rewrite: (payload: IntelligenceRewritePayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<string>>('intelligence:invoke', {
-            capabilityId: 'text.rewrite',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<string>('text.rewrite', payload, options),
 
       grammarCheck: (payload: IntelligenceGrammarCheckPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceGrammarCheckResult>>('intelligence:invoke', {
-            capabilityId: 'text.grammar',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceGrammarCheckResult>('text.grammar', payload, options),
     },
 
-    // Embedding methods
     embedding: {
       generate: (payload: IntelligenceEmbeddingPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<number[]>>('intelligence:invoke', {
-            capabilityId: 'embedding.generate',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<number[]>('embedding.generate', payload, options),
     },
 
-    // Code methods
     code: {
       generate: (payload: IntelligenceCodeGeneratePayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceCodeGenerateResult>>('intelligence:invoke', {
-            capabilityId: 'code.generate',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceCodeGenerateResult>('code.generate', payload, options),
 
       explain: (payload: IntelligenceCodeExplainPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceCodeExplainResult>>('intelligence:invoke', {
-            capabilityId: 'code.explain',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceCodeExplainResult>('code.explain', payload, options),
 
       review: (payload: IntelligenceCodeReviewPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceCodeReviewResult>>('intelligence:invoke', {
-            capabilityId: 'code.review',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceCodeReviewResult>('code.review', payload, options),
 
       refactor: (payload: IntelligenceCodeRefactorPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceCodeRefactorResult>>('intelligence:invoke', {
-            capabilityId: 'code.refactor',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceCodeRefactorResult>('code.refactor', payload, options),
 
       debug: (payload: IntelligenceCodeDebugPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceCodeDebugResult>>('intelligence:invoke', {
-            capabilityId: 'code.debug',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceCodeDebugResult>('code.debug', payload, options),
     },
 
-    // Analysis methods
     analysis: {
       detectIntent: (payload: IntelligenceIntentDetectPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceIntentDetectResult>>('intelligence:invoke', {
-            capabilityId: 'intent.detect',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceIntentDetectResult>('intent.detect', payload, options),
 
       analyzeSentiment: (payload: IntelligenceSentimentAnalyzePayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceSentimentAnalyzeResult>>('intelligence:invoke', {
-            capabilityId: 'sentiment.analyze',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceSentimentAnalyzeResult>('sentiment.analyze', payload, options),
 
       extractContent: (payload: IntelligenceContentExtractPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceContentExtractResult>>('intelligence:invoke', {
-            capabilityId: 'content.extract',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceContentExtractResult>('content.extract', payload, options),
 
       extractKeywords: (payload: IntelligenceKeywordsExtractPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceKeywordsExtractResult>>('intelligence:invoke', {
-            capabilityId: 'keywords.extract',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceKeywordsExtractResult>('keywords.extract', payload, options),
 
       classify: (payload: IntelligenceClassificationPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceClassificationResult>>('intelligence:invoke', {
-            capabilityId: 'text.classify',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceClassificationResult>('text.classify', payload, options),
     },
 
-    // Vision methods
     vision: {
       ocr: (payload: IntelligenceVisionOcrPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceVisionOcrResult>>('intelligence:invoke', {
-            capabilityId: 'vision.ocr',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceVisionOcrResult>('vision.ocr', payload, options),
 
       caption: (payload: IntelligenceImageCaptionPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceImageCaptionResult>>('intelligence:invoke', {
-            capabilityId: 'image.caption',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceImageCaptionResult>('image.caption', payload, options),
 
       analyze: (payload: IntelligenceImageAnalyzePayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceImageAnalyzeResult>>('intelligence:invoke', {
-            capabilityId: 'image.analyze',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceImageAnalyzeResult>('image.analyze', payload, options),
 
       generate: (payload: IntelligenceImageGeneratePayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceImageGenerateResult>>('intelligence:invoke', {
-            capabilityId: 'image.generate',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceImageGenerateResult>('image.generate', payload, options),
     },
 
-    // RAG methods
     rag: {
       query: (payload: IntelligenceRAGQueryPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceRAGQueryResult>>('intelligence:invoke', {
-            capabilityId: 'rag.query',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceRAGQueryResult>('rag.query', payload, options),
 
       semanticSearch: (payload: IntelligenceSemanticSearchPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceSemanticSearchResult>>('intelligence:invoke', {
-            capabilityId: 'search.semantic',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceSemanticSearchResult>('search.semantic', payload, options),
 
       rerank: (payload: IntelligenceRerankPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceRerankResult>>('intelligence:invoke', {
-            capabilityId: 'search.rerank',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceRerankResult>('search.rerank', payload, options),
     },
 
-    // Agent methods
     agent: {
       run: (payload: IntelligenceAgentPayload, options?: IntelligenceInvokeOptions) =>
-        withLoadingState(() =>
-          sendChannelRequest<IntelligenceInvokeResult<IntelligenceAgentResult>>('intelligence:invoke', {
-            capabilityId: 'agent.run',
-            payload,
-            options,
-          }),
-        ),
+        invokeCapability<IntelligenceAgentResult>('agent.run', payload, options),
     },
 
-    // Reactive state
     isLoading,
     lastError,
   }