@lota-sdk/core 0.1.15 → 0.1.16

package/src/services/context-enrichment.service.ts

@@ -0,0 +1,33 @@
+import type { ContextEnrichment } from '@lota-sdk/shared'
+
+import { serverLogger } from '../config/logger'
+import { getRuntimeConfig } from '../runtime/runtime-config'
+
+class ContextEnrichmentService {
+  async enrichForPlanCreation(params: { objective: string; organizationId: string }): Promise<ContextEnrichment[]> {
+    const pluginRuntime = getRuntimeConfig().pluginRuntime ?? {}
+    const enrichers = Object.values(pluginRuntime).flatMap((plugin) => plugin.contextEnrichers ?? [])
+
+    if (enrichers.length === 0) return []
+
+    const results = await Promise.allSettled(
+      enrichers.map((enricher) =>
+        enricher.enrich({ objective: params.objective, organizationId: params.organizationId }),
+      ),
+    )
+
+    const enrichments: ContextEnrichment[] = []
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i]
+      if (result.status === 'fulfilled') {
+        enrichments.push({ domain: enrichers[i].domain, data: result.value.data, confidence: result.value.confidence })
+      } else {
+        serverLogger.warn`Context enricher "${enrichers[i].domain}" failed: ${result.reason}`
+      }
+    }
+
+    return enrichments.sort((a, b) => b.confidence - a.confidence)
+  }
+}
+
+export const contextEnrichmentService = new ContextEnrichmentService()

package/src/services/coordination-registry.service.ts

@@ -0,0 +1,117 @@
+import type { SignalDeclaration } from '@lota-sdk/shared'
+
+import { serverLogger } from '../config/logger'
+import type { LotaPlugin } from '../runtime/plugin-types'
+import { getRuntimeConfig } from '../runtime/runtime-config'
+import type { PlanValidationIssueInput } from './plan-validator.service'
+
+export interface EmittedSignal {
+  signal: string
+  payload: unknown
+  sourcePlugin: string
+  consumers: string[]
+  emittedAt: Date
+}
+
+const MAX_EMITTED_SIGNALS = 1000
+
+class CoordinationRegistryService {
+  private producers = new Map<string, string[]>()
+  private consumers = new Map<string, string[]>()
+  private _emittedSignals: EmittedSignal[] = []
+
+  register(pluginRef: string, signals: SignalDeclaration[]): void {
+    for (const signal of signals) {
+      if (signal.direction === 'produces') {
+        const existing = this.producers.get(signal.signalName) ?? []
+        existing.push(pluginRef)
+        this.producers.set(signal.signalName, existing)
+      } else {
+        const existing = this.consumers.get(signal.signalName) ?? []
+        existing.push(pluginRef)
+        this.consumers.set(signal.signalName, existing)
+      }
+    }
+  }
+
+  async emit(signal: string, payload: unknown, sourcePlugin: string): Promise<void> {
+    const consumers = this.consumers.get(signal) ?? []
+
+    this._emittedSignals.push({ signal, payload, sourcePlugin, consumers: [...consumers], emittedAt: new Date() })
+    if (this._emittedSignals.length > MAX_EMITTED_SIGNALS) {
+      this._emittedSignals.shift()
+    }
+
+    serverLogger.debug(
+      `Signal "${signal}" emitted by "${sourcePlugin}" — ${consumers.length} consumer(s): ${consumers.join(', ') || 'none'}`,
+    )
+
+    if (consumers.length === 0) return
+
+    let pluginRuntime: Record<string, unknown> = {}
+    try {
+      pluginRuntime = getRuntimeConfig().pluginRuntime ?? {}
+    } catch {
+      // Runtime not yet configured — skip plugin dispatch
+    }
+
+    for (const consumerRef of consumers) {
+      const plugin = pluginRuntime[consumerRef] as LotaPlugin | undefined
+      if (plugin?.onSignal) {
+        try {
+          await plugin.onSignal(signal, payload, sourcePlugin)
+        } catch (error) {
+          serverLogger.warn`Signal handler for "${consumerRef}" failed on signal "${signal}": ${error}`
+        }
+      }
+    }
+  }
+
+  getEmittedSignals(signalName?: string): EmittedSignal[] {
+    if (!signalName) return [...this._emittedSignals]
+    return this._emittedSignals.filter((entry) => entry.signal === signalName)
+  }
+
+  getProducers(signalName: string): string[] {
+    return this.producers.get(signalName) ?? []
+  }
+
+  getConsumers(signalName: string): string[] {
+    return this.consumers.get(signalName) ?? []
+  }
+
+  validate(): PlanValidationIssueInput[] {
+    const issues: PlanValidationIssueInput[] = []
+
+    for (const [signalName] of this.producers) {
+      if ((this.consumers.get(signalName) ?? []).length === 0) {
+        issues.push({
+          severity: 'warning',
+          code: 'signal_no_consumer',
+          message: `Signal "${signalName}" is produced but has no consumers.`,
+        })
+      }
+    }
+
+    for (const [signalName] of this.consumers) {
+      if ((this.producers.get(signalName) ?? []).length === 0) {
+        issues.push({
+          severity: 'warning',
+          code: 'signal_no_producer',
+          message: `Signal "${signalName}" is consumed but has no producers.`,
+        })
+      }
+    }
+
+    return issues
+  }
+
+  /** Reset internal state. Intended for testing. */
+  _reset(): void {
+    this.producers.clear()
+    this.consumers.clear()
+    this._emittedSignals = []
+  }
+}
+
+export const coordinationRegistryService = new CoordinationRegistryService()

package/src/services/document-chunk.service.ts

@@ -66,7 +66,7 @@ export class DocumentChunkService {
   }
 
   async embedQuery(query: string): Promise<number[]> {
-    return await this.embeddings.embedQuery(query)
+    return this.embeddings.embedQuery(query)
   }
 
   async syncVersionedChunks<TRecord, TPayload>(params: {

package/src/services/domain-agent-executor.service.ts

@@ -0,0 +1,71 @@
+import type { OwnershipDispatchContext, PlanArtifactSubmission, PlanNodeResult, PlanNodeSpec } from '@lota-sdk/shared'
+
+import type { LotaPlugin, PluginDomainAgentDefinition } from '../runtime/plugin-types'
+import { getRuntimeConfig } from '../runtime/runtime-config'
+import type { PlanValidationIssueInput } from './plan-validator.service'
+
+class DomainAgentExecutorService {
+  private registry = new Map<string, { pluginRef: string; definition: PluginDomainAgentDefinition }>()
+
+  configure(pluginRuntime: Record<string, LotaPlugin>): void {
+    this.registry.clear()
+    for (const [pluginRef, plugin] of Object.entries(pluginRuntime)) {
+      if (plugin.domainAgents) {
+        for (const def of plugin.domainAgents) {
+          this.registry.set(def.agentId, { pluginRef, definition: def })
+        }
+      }
+    }
+  }
+
+  hasAgent(agentId: string): boolean {
+    return this.registry.has(agentId)
+  }
+
+  validateOwner(agentId: string, nodeId: string): PlanValidationIssueInput[] {
+    if (!this.registry.has(agentId)) {
+      return [
+        {
+          severity: 'blocking',
+          code: 'domain_agent_missing',
+          message: `Node "${nodeId}" references unknown domain agent "${agentId}".`,
+          nodeId,
+        },
+      ]
+    }
+    return []
+  }
+
+  async executeNode(params: {
+    nodeSpec: PlanNodeSpec
+    resolvedInput: Record<string, unknown>
+    inputArtifacts: PlanArtifactSubmission[]
+    context: OwnershipDispatchContext
+  }): Promise<PlanNodeResult> {
+    const entry = this.registry.get(params.nodeSpec.owner.ref)
+    if (!entry) {
+      throw new Error(`Domain agent "${params.nodeSpec.owner.ref}" not registered.`)
+    }
+
+    const plugin = (getRuntimeConfig().pluginRuntime as Record<string, LotaPlugin | undefined> | undefined)?.[
+      entry.pluginRef
+    ]
+    if (!plugin?.nodeExecutor) {
+      throw new Error(`Plugin "${entry.pluginRef}" does not have a nodeExecutor.`)
+    }
+
+    return plugin.nodeExecutor.executeNode({
+      operation: `domain-agent:${entry.definition.agentId}`,
+      nodeSpec: params.nodeSpec,
+      inputs: params.resolvedInput,
+      context: {
+        organizationId: params.context.organizationId,
+        workstreamId: params.context.workstreamId,
+        planId: params.context.planId,
+        nodeId: params.context.nodeId,
+      },
+    })
+  }
+}
+
+export const domainAgentExecutorService = new DomainAgentExecutorService()