@lota-sdk/core 0.4.8 → 0.4.10

package/src/config/agent-defaults.ts

@@ -1,39 +1,72 @@
-import type { AgentFactory, AgentRuntimeConfigProvider, AgentToolBuilder } from './agent-types'
-
-function defaultBuildAgentTools(): Record<string, never> {
+import type { ToolSet } from 'ai'
+
+import { ConfigurationError } from '../effect/errors'
+import { resolveLotaService } from '../effect/runtime'
+import { AgentConfigServiceTag, AgentFactoryServiceTag } from '../effect/services'
+import type {
+  AgentFactory,
+  AgentRuntimeConfigParams,
+  AgentRuntimeConfigProvider,
+  AgentToolBuilder,
+} from './agent-types'
+
+function defaultBuildAgentTools(): ToolSet {
   return {}
 }
 
-function defaultGetAgentRuntimeConfig(): Record<string, never> {
-  return {}
+function defaultGetAgentRuntimeConfig(params: AgentRuntimeConfigParams) {
+  return {
+    id: params.agentId,
+    displayName: params.agentId,
+    mode: params.mode ?? (params.threadType === 'default' ? 'fixedThreadMode' : 'threadMode'),
+    maxSteps: 15,
+  }
 }
 
-// Agent configuration — these are defaults that consumers override via createLotaRuntime config
-export let agentDisplayNames: Record<string, string> = {}
-export let agentShortDisplayNames: Record<string, string> = {}
-export let agentDescriptions: Record<string, string> = {}
-export let routerModelId: string | undefined = undefined
-export let agentRoster: readonly string[] = []
-export let leadAgentId = ''
-export let teamConsultParticipants: readonly string[] = []
+function defaultGetCoreThreadProfile(coreType: string): CoreThreadProfile {
+  return { config: { coreType, agentId: '', title: '' }, members: [], tools: [], skills: [], instructions: '' }
+}
 
-export interface CoreThreadProfile {
-  config: { coreType: string; agentId: string; title: string }
-  members: readonly string[]
-  tools: readonly string[]
-  skills: readonly string[]
-  instructions: string
+function normalizeAgentLookupKey(value: string): string {
+  return value.trim().toLowerCase()
 }
 
-export let getCoreThreadProfile: (coreType: string) => CoreThreadProfile = (_coreType) => ({
-  config: { coreType: _coreType, agentId: '', title: '' },
-  members: [],
-  tools: [],
-  skills: [],
-  instructions: '',
-})
+export interface ResolvedAgentConfig {
+  readonly roster: readonly string[]
+  readonly leadAgentId: string
+  readonly displayNames: Record<string, string>
+  readonly shortDisplayNames: Record<string, string>
+  readonly descriptions: Record<string, string>
+  readonly routerModelId: string | undefined
+  readonly teamConsultParticipants: readonly string[]
+  readonly getCoreThreadProfile: (coreType: string) => CoreThreadProfile
+  readonly rosterSet: ReadonlySet<string>
+  readonly aliasMap: ReadonlyMap<string, string>
+}
+
+function buildAgentAliasMap(config: {
+  roster: readonly string[]
+  displayNames: Record<string, string>
+  shortDisplayNames: Record<string, string>
+}): Map<string, string> {
+  const map = new Map<string, string>()
+
+  for (const agent of config.roster) {
+    map.set(normalizeAgentLookupKey(agent), agent)
+    const displayName = config.displayNames[agent]
+    if (displayName) {
+      map.set(normalizeAgentLookupKey(displayName), agent)
+    }
+    const shortName = config.shortDisplayNames[agent]
+    if (shortName) {
+      map.set(normalizeAgentLookupKey(shortName), agent)
+    }
+  }
+
+  return map
+}
 
-export function configureAgents(config: {
+export function resolveAgentConfig(config: {
   roster: readonly string[]
   leadAgentId: string
   displayNames: Record<string, string>
@@ -42,75 +75,155 @@ export function configureAgents(config: {
   routerModelId?: string
   teamConsultParticipants: readonly string[]
   getCoreThreadProfile?: (coreType: string) => CoreThreadProfile
-}): void {
+}): ResolvedAgentConfig {
   if (!config.roster.includes(config.leadAgentId)) {
-    throw new Error(`Lead agent "${config.leadAgentId}" must be present in the configured roster.`)
+    throw new ConfigurationError({
+      message: `Lead agent "${config.leadAgentId}" must be present in the configured roster.`,
+      key: 'agents.leadAgentId',
+    })
+  }
+
+  const shortDisplayNames = config.shortDisplayNames ?? {}
+  const descriptions = config.descriptions ?? {}
+  const resolved: ResolvedAgentConfig = {
+    roster: [...config.roster],
+    leadAgentId: config.leadAgentId,
+    displayNames: { ...config.displayNames },
+    shortDisplayNames: { ...shortDisplayNames },
+    descriptions: { ...descriptions },
+    routerModelId: config.routerModelId,
+    teamConsultParticipants: [...config.teamConsultParticipants],
+    getCoreThreadProfile: config.getCoreThreadProfile ?? defaultGetCoreThreadProfile,
+    rosterSet: new Set(config.roster),
+    aliasMap: buildAgentAliasMap({ roster: config.roster, displayNames: config.displayNames, shortDisplayNames }),
   }
 
-  agentRoster = config.roster
-  leadAgentId = config.leadAgentId
-  agentDisplayNames = config.displayNames
-  agentShortDisplayNames = config.shortDisplayNames ?? {}
-  agentDescriptions = config.descriptions ?? {}
-  routerModelId = config.routerModelId
-  teamConsultParticipants = config.teamConsultParticipants
-  if (config.getCoreThreadProfile) {
-    getCoreThreadProfile = config.getCoreThreadProfile
+  return resolved
+}
+
+export interface ResolvedAgentFactoryConfig {
+  readonly createAgent: AgentFactory
+  readonly buildAgentTools: AgentToolBuilder
+  readonly getAgentRuntimeConfig: AgentRuntimeConfigProvider
+  readonly pluginRuntime?: Record<string, unknown>
+}
+
+export function resolveAgentFactoryConfig(config: {
+  createAgent?: AgentFactory
+  buildAgentTools?: AgentToolBuilder
+  getAgentRuntimeConfig?: AgentRuntimeConfigProvider
+  pluginRuntime?: Record<string, unknown>
+}): ResolvedAgentFactoryConfig {
+  return {
+    createAgent: config.createAgent ?? {},
+    buildAgentTools: config.buildAgentTools ?? defaultBuildAgentTools,
+    getAgentRuntimeConfig: config.getAgentRuntimeConfig ?? defaultGetAgentRuntimeConfig,
+    pluginRuntime: config.pluginRuntime,
   }
-  _agentRosterSet = null
-  _aliasMap = null
 }
 
-let _agentRosterSet: Set<string> | null = null
+export interface CoreThreadProfile {
+  config: { coreType: string; agentId: string; title: string }
+  members: readonly string[]
+  tools: readonly string[]
+  skills: readonly string[]
+  instructions: string
+}
+
+let currentResolvedAgentConfig: ResolvedAgentConfig | null = null
+let currentResolvedAgentFactoryConfig: ResolvedAgentFactoryConfig | null = null
+
+export function configureAgentRuntimeDefaults(params: {
+  agentConfig: ResolvedAgentConfig
+  agentFactoryConfig: ResolvedAgentFactoryConfig
+}): void {
+  currentResolvedAgentConfig = params.agentConfig
+  currentResolvedAgentFactoryConfig = params.agentFactoryConfig
+}
+
+export function clearAgentRuntimeDefaults(): void {
+  currentResolvedAgentConfig = null
+  currentResolvedAgentFactoryConfig = null
+}
+
+function resolveAgentConfigFromRuntime(): ResolvedAgentConfig {
+  return currentResolvedAgentConfig ?? resolveLotaService(AgentConfigServiceTag)
+}
+
+function resolveAgentFactoryConfigFromRuntime(): ResolvedAgentFactoryConfig {
+  return currentResolvedAgentFactoryConfig ?? resolveLotaService(AgentFactoryServiceTag)
+}
+
+export function getResolvedAgentConfig(): ResolvedAgentConfig {
+  return resolveAgentConfigFromRuntime()
+}
+
+export function getResolvedAgentFactoryConfig(): ResolvedAgentFactoryConfig {
+  return resolveAgentFactoryConfigFromRuntime()
+}
 
 export function isAgentName(value: unknown): value is string {
-  _agentRosterSet ??= new Set(agentRoster)
-  return typeof value === 'string' && _agentRosterSet.has(value)
+  return typeof value === 'string' && resolveAgentConfigFromRuntime().rosterSet.has(value)
+}
+
+export function getAgentRoster(): readonly string[] {
+  return resolveAgentConfigFromRuntime().roster
+}
+
+export function getAgentDisplayNames(): Record<string, string> {
+  return resolveAgentConfigFromRuntime().displayNames
+}
+
+export function getAgentShortDisplayNames(): Record<string, string> {
+  return resolveAgentConfigFromRuntime().shortDisplayNames
+}
+
+export function getAgentDescriptions(): Record<string, string> {
+  return resolveAgentConfigFromRuntime().descriptions
 }
 
 export function getLeadAgentId(): string {
-  return leadAgentId
+  return resolveAgentConfigFromRuntime().leadAgentId
 }
 
 export function getLeadAgentDisplayName(): string {
-  return agentDisplayNames[leadAgentId] ?? leadAgentId
+  const resolved = resolveAgentConfigFromRuntime()
+  return resolved.displayNames[resolved.leadAgentId] ?? resolved.leadAgentId
 }
 
-let _aliasMap: Map<string, string> | null = null
+export function getRouterModelId(): string | undefined {
+  return resolveAgentConfigFromRuntime().routerModelId
+}
+
+export function getTeamConsultParticipants(): readonly string[] {
+  return resolveAgentConfigFromRuntime().teamConsultParticipants
+}
+
+export function getCoreThreadProfile(coreType: string): CoreThreadProfile {
+  return resolveAgentConfigFromRuntime().getCoreThreadProfile(coreType)
+}
 
 export function resolveAgentNameAlias(value: unknown): string | undefined {
   if (typeof value !== 'string') return undefined
-  const lowered = value.trim().toLowerCase()
-  _aliasMap ??= (() => {
-    const map = new Map<string, string>()
-    for (const agent of agentRoster) {
-      map.set(agent.toLowerCase(), agent)
-      const displayName = agentDisplayNames[agent]
-      if (displayName) map.set(displayName.toLowerCase(), agent)
-      const shortName = agentShortDisplayNames[agent]
-      if (shortName) map.set(shortName.toLowerCase(), agent)
-    }
-    return map
-  })()
-  return _aliasMap.get(lowered)
+  return resolveAgentConfigFromRuntime().aliasMap.get(normalizeAgentLookupKey(value))
 }
 
-export let createAgent: AgentFactory = {}
+export function getCreateAgentRegistry(): AgentFactory {
+  return resolveAgentFactoryConfigFromRuntime().createAgent
+}
 
-export let buildAgentTools: AgentToolBuilder = defaultBuildAgentTools
-export let getAgentRuntimeConfig: AgentRuntimeConfigProvider = defaultGetAgentRuntimeConfig
-export let pluginRuntime: Record<string, unknown> | undefined = undefined
+export function buildAgentTools(...args: Parameters<AgentToolBuilder>): ReturnType<AgentToolBuilder> {
+  return resolveAgentFactoryConfigFromRuntime().buildAgentTools(...args)
+}
 
-export function configureAgentFactory(config: {
-  createAgent?: AgentFactory
-  buildAgentTools?: AgentToolBuilder
-  getAgentRuntimeConfig?: AgentRuntimeConfigProvider
-  pluginRuntime?: Record<string, unknown>
-}): void {
-  createAgent = config.createAgent ?? {}
-  buildAgentTools = config.buildAgentTools ?? defaultBuildAgentTools
-  getAgentRuntimeConfig = config.getAgentRuntimeConfig ?? defaultGetAgentRuntimeConfig
-  pluginRuntime = config.pluginRuntime
+export function getAgentRuntimeConfig(
+  ...args: Parameters<AgentRuntimeConfigProvider>
+): ReturnType<AgentRuntimeConfigProvider> {
+  return resolveAgentFactoryConfigFromRuntime().getAgentRuntimeConfig(...args)
+}
+
+export function getPluginRuntime(): Record<string, unknown> | undefined {
+  return resolveAgentFactoryConfigFromRuntime().pluginRuntime
 }
 
 const AGENT_MENTION_REGEX = /(^|[^\w])@([a-z][a-z0-9_-]*)\b/gi
@@ -122,15 +235,16 @@ export interface AgentMentionMatch {
   length: number
 }
 
-export function extractAgentMentions(message: string): AgentMentionMatch[] {
+export function extractAgentMentions(message: string, agentConfig?: ResolvedAgentConfig): AgentMentionMatch[] {
   const matches: AgentMentionMatch[] = []
   if (!message.trim()) return matches
 
+  const resolvedConfig = agentConfig ?? resolveAgentConfigFromRuntime()
   const regex = new RegExp(AGENT_MENTION_REGEX)
   for (const rawMatch of message.matchAll(regex)) {
     const prefix = rawMatch[1]
     const rawAgent = rawMatch[2].toLowerCase()
-    if (!isAgentName(rawAgent)) continue
+    if (!resolvedConfig.rosterSet.has(rawAgent)) continue
 
     const index = rawMatch.index + prefix.length
     matches.push({ agent: rawAgent, mention: `@${rawAgent}`, index, length: rawAgent.length + 1 })

package/src/config/agent-types.ts

@@ -1,11 +1,61 @@
+import type { ChatMode, CreateRoutedAgentOptions } from '@lota-sdk/shared'
+import type { ToolLoopAgent, ToolSet } from 'ai'
+
+import type { RecordIdRef } from '../db/record-id'
+import type { AgentRuntimeConfig, AgentRuntimeRuleOptions } from '../runtime/agent-runtime-policy'
+
+export interface AgentToolBuilderParams {
+  agentId: string
+  orgId: RecordIdRef
+  userId: RecordIdRef
+  userName?: string
+  orgIdString: string
+  threadId: RecordIdRef
+  threadType?: string
+  mode?: ChatMode
+  linearInstalled?: boolean
+  onboardingActive?: boolean
+  githubInstalled?: boolean
+  provideRepoTool?: boolean
+  defaultRepoSections?: unknown
+  memoryBlock: string
+  onAppendMemoryBlock: (value: string) => void
+  availableUploads?: unknown[]
+  includeExecutionPlanTools?: boolean
+  extraMessages?: unknown[]
+}
+
+export interface AgentRuntimeConfigParams {
+  agentId: string
+  threadType: string
+  mode?: ChatMode
+  skills?: string[]
+  onboardingActive: boolean
+  linearInstalled: boolean
+  systemWorkspaceDetails?: string
+  preSeededMemoriesSection?: string
+  retrievedKnowledgeSection?: string
+  threadMemoryBlock?: string
+  responseGuardSection?: string
+  learnedSkillsSection?: string
+  userMessageText?: string
+  additionalInstructionSections?: string[]
+  ruleOptions?: AgentRuntimeRuleOptions
+  context?: unknown
+}
+
+export type AgentCreator = <TTools extends ToolSet>(
+  options: CreateRoutedAgentOptions<TTools>,
+) => ToolLoopAgent<never, TTools>
+
 /**
  * Registry of agent factory functions keyed by agent name.
- * Each factory receives runtime args and returns an agent instance.
+ * Each factory receives routed agent options and returns a typed tool-loop agent.
  */
-export type AgentFactory = Record<string, (...args: unknown[]) => unknown>
+export type AgentFactory = Partial<Record<string, AgentCreator>>
 
 /** Builds the tool set for a given agent. */
-export type AgentToolBuilder = (...args: unknown[]) => unknown
+export type AgentToolBuilder = (params: AgentToolBuilderParams) => ToolSet | Promise<ToolSet>
 
 /** Returns runtime configuration for a given agent. */
-export type AgentRuntimeConfigProvider = (...args: unknown[]) => unknown
+export type AgentRuntimeConfigProvider = (params: AgentRuntimeConfigParams) => AgentRuntimeConfig<string>

package/src/config/background-processing.ts

@@ -12,7 +12,7 @@ const DEFAULT_CONFIG: BackgroundProcessingConfig = {
   memoryConsolidationFrequency: 10,
 }
 
-let resolvedConfig: BackgroundProcessingConfig = { ...DEFAULT_CONFIG }
+const resolvedConfig: BackgroundProcessingConfig = { ...DEFAULT_CONFIG }
 
 export function getBackgroundProcessingConfig(): BackgroundProcessingConfig {
   return resolvedConfig

package/src/config/constants.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod'
+import { ValidationError } from '../effect/errors'
 
 export const MEMORY = {
   DEFAULT_CANDIDATE_LIMIT: 12,
@@ -6,7 +6,13 @@ export const MEMORY = {
   MAX_KNN_LIMIT: 100,
 } as const
 
+export const DEFAULT_AI_GATEWAY_URL = 'https://ai-gateway.gobrainy.ai' as const
+
 /** Validates that a value is a safe integer for KNN queries. Throws if validation fails. */
 export function validateKnnLimit(limit: unknown): number {
-  return z.number().int().positive().max(MEMORY.MAX_KNN_LIMIT).parse(limit)
+  if (typeof limit !== 'number' || !Number.isInteger(limit) || limit <= 0 || limit > MEMORY.MAX_KNN_LIMIT) {
+    throw new ValidationError({ message: `Memory KNN limit must be a positive integer <= ${MEMORY.MAX_KNN_LIMIT}.` })
+  }
+
+  return limit
 }

package/src/config/index.ts

@@ -4,5 +4,4 @@ export * from './background-processing'
 export * from './constants'
 export * from './logger'
 export * from './model-constants'
-export * from './search'
 export * from './thread-defaults'