@lota-sdk/core 0.1.14 → 0.1.16

package/src/runtime/helper-model.ts

@@ -7,6 +7,8 @@ import type {
 } from 'ai'
 import type { ZodSchema } from 'zod'
 
+import { isRecord, stringifyUnknown } from '../utils/string'
+
 export interface HelperToolLoopAgentOptions {
   instructions?: string
   maxOutputTokens?: number
@@ -47,12 +49,6 @@ export interface GenerateHelperTextParams {
 export interface GenerateHelperStructuredParams<T> extends Omit<GenerateHelperTextParams, 'tag'> {
   tag: string
   schema: ZodSchema<T>
-  textFallbackParser?: (text: string) => T | null
-  normalizeCandidate?: (candidate: unknown) => unknown
-}
-
-function isObject(value: unknown): value is Record<string, unknown> {
-  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
 }
 
 function getNumericField(value: Record<string, unknown>, key: string): number | null {
@@ -66,7 +62,7 @@ function getNumericField(value: Record<string, unknown>, key: string): number |
 }
 
 function getErrorStatus(error: unknown): number | null {
-  if (!isObject(error)) return null
+  if (!isRecord(error)) return null
   return getNumericField(error, 'status') ?? getNumericField(error, 'statusCode')
 }
 
@@ -74,44 +70,11 @@ function isRateLimitError(error: unknown): boolean {
   return getErrorStatus(error) === 429
 }
 
-function stringifyUnknown(value: unknown, maxChars: number): string | null {
-  if (value === null || value === undefined) return null
-  const raw = (() => {
-    if (typeof value === 'string') return value
-    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
-      return String(value)
-    }
-    if (typeof value === 'symbol') return value.description ? `Symbol(${value.description})` : 'Symbol()'
-    if (typeof value === 'function') return value.name ? `[function ${value.name}]` : '[function anonymous]'
-    if (Array.isArray(value)) {
-      try {
-        return JSON.stringify(value)
-      } catch {
-        return `[array(${value.length})]`
-      }
-    }
-
-    try {
-      return JSON.stringify(value)
-    } catch {
-      const maybeName =
-        isObject(value) && typeof (value as { constructor?: { name?: unknown } }).constructor?.name === 'string'
-          ? (value as { constructor?: { name?: string } }).constructor?.name
-          : 'Object'
-      return `[object ${maybeName}]`
-    }
-  })()
-
-  const normalized = raw.replace(/\s+/g, ' ').trim()
-  if (!normalized) return null
-  return normalized.length > maxChars ? `${normalized.slice(0, maxChars)}...` : normalized
-}
-
 function formatError(tag: string, error: unknown): Error {
   const status = getErrorStatus(error)
   const rateLimited = isRateLimitError(error)
   const message = error instanceof Error ? error.message : String(error)
-  const errorRecord = isObject(error) ? error : null
+  const errorRecord = isRecord(error) ? error : null
   const responseBody = errorRecord ? stringifyUnknown(errorRecord.responseBody, 600) : null
   const responseData = errorRecord ? stringifyUnknown(errorRecord.data, 600) : null
   const requestUrl = errorRecord ? stringifyUnknown(errorRecord.url, 200) : null
@@ -162,59 +125,6 @@ function formatSchemaIssueSummary(issues: Array<{ path: PropertyKey[]; message:
     .join('; ')
 }
 
-export function extractJsonObjectCandidates(text: string): string[] {
-  const trimmed = text.trim()
-  if (!trimmed) return []
-
-  const candidates: string[] = [trimmed]
-  const fencedMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i)
-  if (fencedMatch?.[1]) {
-    candidates.push(fencedMatch[1].trim())
-  }
-
-  let start = -1
-  let depth = 0
-  let inString = false
-  let escaping = false
-
-  for (let index = 0; index < trimmed.length; index += 1) {
-    const character = trimmed[index]
-
-    if (escaping) {
-      escaping = false
-      continue
-    }
-
-    if (character === '\\') {
-      escaping = true
-      continue
-    }
-
-    if (character === '"') {
-      inString = !inString
-      continue
-    }
-
-    if (inString) continue
-
-    if (character === '{') {
-      if (depth === 0) start = index
-      depth += 1
-      continue
-    }
-
-    if (character === '}') {
-      depth -= 1
-      if (depth === 0 && start >= 0) {
-        candidates.push(trimmed.slice(start, index + 1))
-        start = -1
-      }
-    }
-  }
-
-  return [...new Set(candidates.filter((candidate) => candidate.length > 0))]
-}
-
 function parseStructuredCandidate<T>(params: {
   schema: ZodSchema<T>
   candidate: unknown
@@ -224,7 +134,7 @@ function parseStructuredCandidate<T>(params: {
     return { data: direct.data, source: 'root' }
   }
 
-  if (isObject(params.candidate)) {
+  if (isRecord(params.candidate)) {
     for (const key of ['output', 'result', 'data'] as const) {
       const nested = params.candidate[key]
       const nestedParsed = params.schema.safeParse(nested)
@@ -237,66 +147,6 @@ function parseStructuredCandidate<T>(params: {
   return null
 }
 
-function parseStructuredTextFallback<T>(params: { schema: ZodSchema<T>; text: string }): T {
-  const candidates = extractJsonObjectCandidates(params.text)
-  if (candidates.length === 0) {
-    throw new Error('Structured fallback did not contain a JSON object candidate.')
-  }
-
-  let lastError = 'Structured fallback could not be parsed.'
-
-  for (const candidateText of candidates) {
-    let parsedJson: unknown
-
-    try {
-      parsedJson = JSON.parse(candidateText) as unknown
-    } catch {
-      lastError = 'Structured fallback JSON parsing failed.'
-      continue
-    }
-
-    const parsed = parseStructuredCandidate({ schema: params.schema, candidate: parsedJson })
-    if (parsed) {
-      return parsed.data
-    }
-
-    const issues = params.schema.safeParse(parsedJson)
-    if (!issues.success) {
-      lastError = `Structured fallback failed schema validation: ${formatSchemaIssueSummary(issues.error.issues)}`
-    }
-  }
-
-  throw new Error(lastError)
-}
-
-function parseStructuredTextWithFallbacks<T>(params: {
-  schema: ZodSchema<T>
-  text: string
-  textFallbackParser?: (text: string) => T | null
-}): T {
-  try {
-    return parseStructuredTextFallback({ schema: params.schema, text: params.text })
-  } catch (error) {
-    const parseError = error instanceof Error ? error : new Error(String(error))
-
-    if (params.textFallbackParser) {
-      const parsedCandidate = params.textFallbackParser(params.text)
-      if (parsedCandidate !== null) {
-        const validated = params.schema.safeParse(parsedCandidate)
-        if (validated.success) {
-          return validated.data
-        }
-
-        throw new Error(
-          `Custom text fallback failed schema validation: ${formatSchemaIssueSummary(validated.error.issues)}`,
-        )
-      }
-    }
-
-    throw parseError
-  }
-}
-
 export function createHelperModelRuntime() {
   async function generateHelperText(params: GenerateHelperTextParams): Promise<string> {
     const systemPrompt = resolveSystemPrompt({
@@ -359,52 +209,16 @@ export function createHelperModelRuntime() {
         return parsed.data
       }
 
-      if (params.normalizeCandidate && isObject(result.output)) {
-        const normalized = params.normalizeCandidate(result.output)
-        const normalizedParsed = parseStructuredCandidate({ schema: params.schema, candidate: normalized })
-        if (normalizedParsed) {
-          return normalizedParsed.data
-        }
-      }
-
-      if (typeof result.text === 'string' && result.text.trim().length > 0) {
-        return parseStructuredTextWithFallbacks({
-          schema: params.schema,
-          text: result.text,
-          textFallbackParser: params.textFallbackParser,
-        })
-      }
-
-      const fallbackParsed = params.schema.safeParse(result.output)
-      if (!fallbackParsed.success) {
+      const directParsed = params.schema.safeParse(result.output)
+      if (!directParsed.success) {
         throw new Error(
-          `Structured output failed schema validation: ${formatSchemaIssueSummary(fallbackParsed.error.issues)}`,
+          `Structured output failed schema validation: ${formatSchemaIssueSummary(directParsed.error.issues)}`,
         )
       }
 
-      return fallbackParsed.data
+      return directParsed.data
     } catch (error) {
-      const structuredError = formatError(params.tag, error)
-      const fallbackMessages: string[] = []
-      const fallbackPrompts = [
-        systemPrompt,
-        ...(baseSystemPrompt && baseSystemPrompt !== systemPrompt ? [baseSystemPrompt] : []),
-      ]
-
-      for (const fallbackPrompt of fallbackPrompts) {
-        try {
-          const fallbackText = await generateHelperText({ ...params, systemPrompt: fallbackPrompt })
-          return parseStructuredTextWithFallbacks({
-            schema: params.schema,
-            text: fallbackText,
-            textFallbackParser: params.textFallbackParser,
-          })
-        } catch (fallbackError) {
-          fallbackMessages.push(fallbackError instanceof Error ? fallbackError.message : String(fallbackError))
-        }
-      }
-
-      throw new Error(`${structuredError.message}; structured_fallback=${fallbackMessages.join(' | ')}`)
+      throw formatError(params.tag, error)
     }
   }
 

package/src/runtime/index.ts

@@ -6,6 +6,7 @@ export * from './chat-request-routing'
 export * from './chat-run-registry'
 export * from './context-compaction'
 export * from './execution-plan'
+export * from './graph-designer'
 export * from './helper-model'
 export * from './indexed-repositories-policy'
 export * from './instruction-sections'
@@ -13,6 +14,7 @@ export * from './memory-block'
 export * from './memory-digest-policy'
 export * from './memory-scope'
 export * from './llm-content'
+export * from './plugin-resolution'
 export * from './plugin-types'
 export * from './runtime-config'
 export * from './runtime-extensions'
@@ -23,4 +25,15 @@ export * from './team-consultation-prompts'
 export * from './turn-lifecycle'
 export * from './workstream-chat-helpers'
 export * from './workstream-routing-policy'
-export * from './workstream-state'
+export {
+  WorkstreamStateSchema,
+  type WorkstreamState,
+  type WorkstreamStateDelta,
+  StructuredWorkstreamStateDeltaSchema,
+  type StructuredWorkstreamStateDelta,
+  createEmptyStructuredWorkstreamStateDelta,
+  parseStructuredWorkstreamStateDelta,
+  StructuredCompactionOutputSchema,
+  type CompactionOutput,
+  createEmptyWorkstreamState,
+} from './workstream-state'

package/src/runtime/llm-content.ts

@@ -3,7 +3,7 @@ export function stripMemr3Sections(text: string): string {
   const answerMatch = normalized.match(/\[ANSWER\]\s*\n([\s\S]*)/i)
 
   if (answerMatch) {
-    return answerMatch[1]?.trim() ?? ''
+    return answerMatch[1].trim()
   }
 
   return normalized

package/src/runtime/memory-block.ts

@@ -1,4 +1,7 @@
+import { z } from 'zod'
+
 import { agentDisplayNames, agentShortDisplayNames, resolveAgentNameAlias } from '../config/agent-defaults'
+import { compactWhitespace } from '../utils/string'
 
 function escapeRegex(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
@@ -32,11 +35,9 @@ function createLabelPrefixRegex(labelRoles: readonly string[]): RegExp | null {
   return new RegExp(`^(?:${aliases.map((role) => escapeRegex(role)).join('|')})\\s*:\\s*`, 'i')
 }
 
-export interface MemoryBlockEntry {
-  role: string
-  content: string
-  timestamp: string
-}
+const MemoryBlockEntrySchema = z.object({ role: z.string(), content: z.string(), timestamp: z.string() })
+
+export type MemoryBlockEntry = z.infer<typeof MemoryBlockEntrySchema>
 
 export interface MemoryBlockRuntime {
   normalizeMemoryBlockEntry: (entry: string) => string
@@ -173,8 +174,7 @@ export function createMemoryBlockRuntime(options: CreateMemoryBlockRuntimeOption
       )
       .filter(Boolean)
 
-    const candidate = normalizedLines.join(' ').trim()
-    const collapsed = candidate.replace(/\s+/g, ' ').trim()
+    const collapsed = compactWhitespace(normalizedLines.join(' '))
     if (!collapsed) return ''
     return collapsed
   }
@@ -184,9 +184,8 @@ export function createMemoryBlockRuntime(options: CreateMemoryBlockRuntimeOption
     const trimmed = raw.trim()
     if (!trimmed.startsWith('[')) return []
     try {
-      const parsed: unknown = JSON.parse(trimmed)
-      if (!Array.isArray(parsed)) return []
-      return parsed as MemoryBlockEntry[]
+      const parsed = z.array(MemoryBlockEntrySchema).safeParse(JSON.parse(trimmed))
+      return parsed.success ? parsed.data : []
     } catch {
       return []
     }
@@ -213,8 +212,8 @@ export function createMemoryBlockRuntime(options: CreateMemoryBlockRuntimeOption
       .some((line) => {
         const match = line.match(/^([a-z][a-z0-9_ -]*)\s*:\s*(.+)$/i)
         if (!match) return false
-        const rowRole = normalizeMemoryBlockRole(match[1] ?? '')
-        const rowContent = match[2] ?? ''
+        const rowRole = normalizeMemoryBlockRole(match[1])
+        const rowContent = match[2]
         if (rowRole !== roleLower) return false
         return normalizeMemoryBlockEntry(rowContent) === normalizedTarget
       })

package/src/runtime/memory-pipeline.ts

@@ -1,3 +1,11 @@
+import { clampImportance, compactWhitespace } from '../utils/string'
+
+const SCORE_WEIGHTS = {
+  durability: { core: 0.35, standard: 0.2, weak: 0.05 },
+  type: { decision: 0.25, fact: 0.18, preference: 0.15, default: 0.1 },
+  maxContentLength: 120,
+} as const
+
 interface MemoryFactInput {
   content: string
   confidence: number
@@ -99,11 +107,6 @@ interface MemoryActionPlan<TRelation extends string = string> {
   relations: MemoryActionRelation<TRelation>[]
 }
 
-function clampImportance(value: number): number {
-  if (!Number.isFinite(value)) return 0
-  return Math.max(0, Math.min(1, value))
-}
-
 function normalizeMemoryKey(text: string): string {
   return text
     .toLowerCase()
@@ -117,9 +120,22 @@ function scoreFact<T extends MemoryFactInput>(fact: T): number {
   const durability = fact.durability ?? 'standard'
   const type = fact.type ?? 'fact'
 
-  const durabilityWeight = durability === 'core' ? 0.35 : durability === 'standard' ? 0.2 : 0.05
-  const typeWeight = type === 'decision' ? 0.25 : type === 'fact' ? 0.18 : 0.1
-  const lengthWeight = Math.min(fact.content.length, 120) / 120 / 10
+  const durabilityWeight =
+    durability === 'core'
+      ? SCORE_WEIGHTS.durability.core
+      : durability === 'standard'
+        ? SCORE_WEIGHTS.durability.standard
+        : SCORE_WEIGHTS.durability.weak
+  const typeWeight =
+    type === 'decision'
+      ? SCORE_WEIGHTS.type.decision
+      : type === 'fact'
+        ? SCORE_WEIGHTS.type.fact
+        : type === 'preference'
+          ? SCORE_WEIGHTS.type.preference
+          : SCORE_WEIGHTS.type.default
+  const lengthWeight =
+    Math.min(fact.content.length, SCORE_WEIGHTS.maxContentLength) / SCORE_WEIGHTS.maxContentLength / 10
 
   return confidence + durabilityWeight + typeWeight + lengthWeight
 }
@@ -160,7 +176,7 @@ export function postProcessMemoryFacts<T extends MemoryFactInput>(
   const deduped = new Map<string, T>()
 
   for (const fact of rawFacts) {
-    const content = typeof fact.content === 'string' ? fact.content.replace(/\s+/g, ' ').trim() : ''
+    const content = typeof fact.content === 'string' ? compactWhitespace(fact.content) : ''
     if (!content || content.length < minChars || content.length > maxChars) continue
     const normalizedFact = { ...fact, content }
     const key = normalizeFactForDedupe(content)
@@ -464,7 +480,7 @@ export function createMemoryActionPlan<TRelation extends string = string>(params
   }
 
   for (const [index, item] of params.updates.memory.entries()) {
-    const text = typeof item.text === 'string' ? item.text.replace(/\s+/g, ' ').trim() : ''
+    const text = typeof item.text === 'string' ? compactWhitespace(item.text) : ''
     const itemId = typeof item.id === 'string' ? item.id.trim() : ''
 
     switch (item.event) {

package/src/runtime/plugin-resolution.ts

@@ -0,0 +1,35 @@
+import { pluginRuntime } from '../config/agent-defaults'
+import { getRuntimeAdapters } from './runtime-extensions'
+
+export function getPluginService(path: string[]): ((...args: unknown[]) => unknown) | undefined {
+  let current: unknown = pluginRuntime
+  let owner: unknown = undefined
+  for (const key of path) {
+    if (current === null || current === undefined || typeof current !== 'object') return undefined
+    owner = current
+    current = (current as Record<string, unknown>)[key]
+  }
+  if (typeof current !== 'function') {
+    return undefined
+  }
+
+  return owner && typeof owner === 'object'
+    ? (current as (...args: unknown[]) => unknown).bind(owner)
+    : (current as (...args: unknown[]) => unknown)
+}
+
+export async function buildIndexedRepositoriesContext(
+  organizationId: string,
+): Promise<{ provideRepoTool: boolean; defaultSectionsByAgent: Record<string, unknown>; context: string }> {
+  const buildContext = getRuntimeAdapters().workstream?.buildIndexedRepositoriesContext
+  if (!buildContext) {
+    return { provideRepoTool: false, defaultSectionsByAgent: {}, context: '' }
+  }
+
+  const result = await buildContext(organizationId)
+  return {
+    provideRepoTool: result.provideRepoTool,
+    defaultSectionsByAgent: result.defaultSectionsByAgent,
+    context: result.context ?? '',
+  }
+}

package/src/runtime/plugin-types.ts

@@ -1,10 +1,82 @@
+import type {
+  CarryForwardPolicy,
+  CycleSchedule,
+  PlanDraft,
+  PlanNodeResult,
+  PlanNodeSpec,
+  PlanScheduleSpec,
+  SignalDeclaration,
+} from '@lota-sdk/shared'
+
+import type { RecordIdRef } from '../db/record-id'
+
+export interface PluginContextEnricher {
+  domain: string
+  enrich(params: {
+    objective: string
+    organizationId: string
+  }): Promise<{ data: Record<string, unknown>; confidence: number }>
+}
+
 export interface LotaPluginContributions {
   envKeys: readonly string[]
   schemaFiles: readonly (string | URL)[]
+  signals?: readonly SignalDeclaration[]
+}
+
+export interface PluginNodeExecutorContext {
+  organizationId: string
+  workstreamId: string
+  planId: string
+  nodeId: string
+  userId?: RecordIdRef
+  userName?: string
+}
+
+export interface PluginNodeExecutionParams {
+  operation: string
+  nodeSpec: PlanNodeSpec
+  inputs: Record<string, unknown>
+  context: PluginNodeExecutorContext
+}
+
+export interface PluginNodeExecutor {
+  supportedOperations: readonly string[]
+  executeNode(params: PluginNodeExecutionParams): Promise<PlanNodeResult>
+}
+
+export interface SystemNodeExecutor {
+  supportedOperations: readonly string[]
+  executeNode(params: PluginNodeExecutionParams): Promise<PlanNodeResult>
+}
+
+export interface PlaybookContribution {
+  name: string
+  description: string
+  tags: string[]
+  draft: PlanDraft
+  schedule?: PlanScheduleSpec
+  cycleSchedule?: CycleSchedule
+  carryForwardPolicy?: CarryForwardPolicy
+}
+
+export interface PlaybookContributor {
+  playbooks: readonly PlaybookContribution[]
+}
+
+export interface PluginDomainAgentDefinition {
+  agentId: string
+  displayName: string
+  capabilities: readonly string[]
 }
 
-export interface LotaPlugin<TServices = unknown, TTools = unknown> {
+export interface LotaPlugin<TServices = Record<string, unknown>, TTools = Record<string, unknown>> {
   services: TServices
+  nodeExecutor?: PluginNodeExecutor
   tools?: TTools
   contributions: LotaPluginContributions
+  playbookContributor?: PlaybookContributor
+  domainAgents?: readonly PluginDomainAgentDefinition[]
+  contextEnrichers?: readonly PluginContextEnricher[]
+  onSignal?: (signal: string, payload: unknown, source: string) => Promise<void> | void
 }

package/src/runtime/retrieval-adapters.ts

@@ -11,7 +11,7 @@ interface ScopedRetrievalResult<TCandidate> {
 export async function executeScopedRetrieval<TCandidate>(
   tasks: ScopedRetrievalTask<TCandidate>[],
 ): Promise<ScopedRetrievalResult<TCandidate>[]> {
-  return await Promise.all(tasks.map(async (task) => ({ scopeTag: task.scopeTag, candidates: await task.retrieve() })))
+  return Promise.all(tasks.map(async (task) => ({ scopeTag: task.scopeTag, candidates: await task.retrieve() })))
 }
 
 export function countScopedRetrievalCandidates<TCandidate>(scoped: ScopedRetrievalResult<TCandidate>[]): number {

package/src/runtime/runtime-config.ts

@@ -1,17 +1,17 @@
 import { z } from 'zod'
 
 import type { CoreWorkstreamProfile } from '../config/agent-defaults'
+import type { AgentFactory, AgentRuntimeConfigProvider, AgentToolBuilder } from '../config/agent-types'
 import type { LotaWorkstreamConfig, WorkstreamBootstrapWelcomeConfig } from '../config/workstream-defaults'
-import type { LotaPlugin } from './plugin-types'
+import type { NotificationService } from '../services/notification.service'
+import { isRecord } from '../utils/string'
+import type { GraphDesigner } from './graph-designer'
+import type { LotaPlugin, SystemNodeExecutor } from './plugin-types'
 import type { LotaRuntimeAdapters, LotaRuntimeTurnHooks } from './runtime-extensions'
 import type { LotaRuntimeWorkerExtensions } from './runtime-worker-registry'
 
 const logLevelValues = ['trace', 'debug', 'info', 'warning', 'error', 'fatal'] as const
 
-type LotaAgentFactoryRegistry = Record<string, (...args: unknown[]) => unknown>
-
-const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null
-
 function isStringOrUrl(value: unknown): value is string | URL {
   return typeof value === 'string' || value instanceof URL
 }
@@ -24,7 +24,7 @@ function isStringRecord(value: unknown): value is Record<string, string> {
   return isRecord(value) && Object.values(value).every((entry) => typeof entry === 'string')
 }
 
-function isAgentFactoryRegistry(value: unknown): value is LotaAgentFactoryRegistry {
+function isAgentFactoryRegistry(value: unknown): value is AgentFactory {
   return isRecord(value) && Object.values(value).every((entry) => typeof entry === 'function')
 }
 
@@ -32,10 +32,22 @@ function isPluginRuntimeRecord(value: unknown): value is Record<string, LotaPlug
   return isRecord(value)
 }
 
+function isSystemExecutorRecord(value: unknown): value is Record<string, SystemNodeExecutor> {
+  return isRecord(value)
+}
+
 function isToolProviderRecord(value: unknown): value is Record<string, unknown> {
   return isRecord(value)
 }
 
+function isNotificationService(value: unknown): value is NotificationService {
+  return isRecord(value) && isFunction(value.notify) && isFunction(value.remind) && isFunction(value.escalate)
+}
+
+function isGraphDesigner(value: unknown): value is GraphDesigner {
+  return isRecord(value) && isFunction(value.designGraph)
+}
+
 function isWorkerExtensionRecord(value: unknown): value is LotaRuntimeWorkerExtensions {
   if (!isRecord(value)) return false
 
@@ -85,15 +97,13 @@ const agentsConfigSchema = z
       })
       .optional(),
     createAgent: z
-      .custom<LotaAgentFactoryRegistry>(isAgentFactoryRegistry, {
-        error: 'agents.createAgent must be a function registry',
-      })
+      .custom<AgentFactory>(isAgentFactoryRegistry, { error: 'agents.createAgent must be a function registry' })
       .optional(),
     buildAgentTools: z
-      .custom<(...args: unknown[]) => unknown>(isFunction, { error: 'agents.buildAgentTools must be a function' })
+      .custom<AgentToolBuilder>(isFunction, { error: 'agents.buildAgentTools must be a function' })
       .optional(),
     getAgentRuntimeConfig: z
-      .custom<(...args: unknown[]) => unknown>(isFunction, { error: 'agents.getAgentRuntimeConfig must be a function' })
+      .custom<AgentRuntimeConfigProvider>(isFunction, { error: 'agents.getAgentRuntimeConfig must be a function' })
       .optional(),
   })
   .superRefine((value, ctx) => {
@@ -173,8 +183,11 @@ export const LotaRuntimeConfigSchema = z.object({
   extraSchemaFiles: z.array(z.custom<string | URL>(isStringOrUrl)).optional(),
   extraWorkers: z.custom<LotaRuntimeWorkerExtensions>(isWorkerExtensionRecord).optional(),
   pluginRuntime: z.custom<Record<string, LotaPlugin>>(isPluginRuntimeRecord).optional(),
+  systemExecutors: z.custom<Record<string, SystemNodeExecutor>>(isSystemExecutorRecord).optional(),
+  notificationService: z.custom<NotificationService>(isNotificationService).optional(),
   runtimeAdapters: z.custom<LotaRuntimeAdapters>(isRecord).optional(),
   turnHooks: z.custom<LotaRuntimeTurnHooks>(isRecord).optional(),
+  graphDesigner: z.custom<GraphDesigner>(isGraphDesigner).optional(),
 })
 
 export type LotaRuntimeConfig = z.input<typeof LotaRuntimeConfigSchema>
@@ -235,4 +248,4 @@ export function parseWorkerBootstrapEnv(env: Record<string, string | undefined>)
   return WORKER_BOOTSTRAP_ENV_SCHEMA.parse(env)
 }
 
-export type { LotaAgentFactoryRegistry, LotaWorkstreamConfig }
+export type { LotaWorkstreamConfig }