@lota-sdk/core 0.4.10 → 0.4.11

package/src/runtime/social-chat/social-chat.ts

@@ -13,14 +13,13 @@ import type { Message, Thread, WebhookOptions } from 'chat'
 import type { Context, Cause } from 'effect'
 import { Clock, Effect, Schema } from 'effect'
 
-import { getAgentDisplayNames, getTeamConsultParticipants } from '../../config/agent-defaults'
+import type { ResolvedAgentConfig, ResolvedAgentFactoryConfig } from '../../config/agent-defaults'
 import { aiLogger } from '../../config/logger'
 import { recordIdToString } from '../../db/record-id'
 import { TABLES } from '../../db/tables'
 import { ForbiddenError } from '../../effect/errors'
 import { effectTryMaybeAsync, effectTryPromise } from '../../effect/helpers'
-import { enqueueRegularChatMemoryDigest, enqueueSkillExtraction } from '../../queues/organization-learning.queue'
-import { enqueuePostChatMemory } from '../../queues/post-chat-memory.queue'
+import type { LotaQueuesRuntime } from '../../queues/queues.service'
 import type { LearnedSkillServiceTag } from '../../services/learned-skill.service'
 import type { MemoryServiceTag } from '../../services/memory/memory.service'
 import type { SocialChatHistoryError, makeSocialChatHistoryService } from '../../services/social-chat-history.service'
@@ -32,7 +31,7 @@ import type {
   LotaRuntimeSocialChatConfig,
   LotaSocialChatResolvedContext,
 } from '../runtime-config'
-import { getRuntimeAdapters } from '../runtime-extensions'
+import type { LotaRuntimeAdapters } from '../runtime-extensions'
 import { runSpecialistSession } from '../specialist-runner'
 import {
   buildAgentHistoryMessages,
@@ -58,6 +57,8 @@ export interface SocialChatRuntimeServices {
   learnedSkillService: Context.Service.Shape<typeof LearnedSkillServiceTag>
   memoryService: Context.Service.Shape<typeof MemoryServiceTag>
   socialChatHistoryService: ReturnType<typeof makeSocialChatHistoryService>
+  runtimeAdapters: LotaRuntimeAdapters
+  queues: LotaQueuesRuntime
 }
 
 class SocialChatServiceError extends Schema.TaggedErrorClass<SocialChatServiceError>()('SocialChatServiceError', {
@@ -112,8 +113,8 @@ function createAssistantMessage(params: {
   }
 }
 
-function getAgentDisplayName(agentId: string): string {
-  return getAgentDisplayNames()[agentId] ?? agentId
+function getAgentDisplayName(agentConfig: ResolvedAgentConfig, agentId: string): string {
+  return agentConfig.displayNames[agentId] ?? agentId
 }
 
 function toSafeJobIdSegment(value: string): string {
@@ -157,6 +158,8 @@ function buildBuildToolsParams(params: {
 }
 
 export function createSocialChatRuntime(params: {
+  agentConfig: ResolvedAgentConfig
+  agentFactoryConfig: ResolvedAgentFactoryConfig
   redisClient: SocialChatStateRedisClient
   socialChat?: LotaRuntimeSocialChatConfig
   services: SocialChatRuntimeServices
@@ -205,6 +208,8 @@ export function createSocialChatRuntime(params: {
     Effect.scoped(
       Effect.gen(function* () {
         const { memoryService, learnedSkillService, socialChatHistoryService } = params.services
+        const agentConfig = params.agentConfig
+        const agentFactoryConfig = params.agentFactoryConfig
         const currentContext = yield* Effect.context()
         const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
         const rawSlackMessage = incomingMessage.raw as { channel?: unknown } | undefined
@@ -258,7 +263,7 @@ export function createSocialChatRuntime(params: {
           ? historyBeforeReply.filter((message) => message.cursor.id !== currentUserMessage.cursor.id)
           : historyBeforeReply
 
-        const workspaceProvider = getRuntimeAdapters().workspaceProvider
+        const workspaceProvider = params.services.runtimeAdapters.workspaceProvider
         const getWorkspace = workspaceProvider?.getWorkspace
           ? workspaceProvider.getWorkspace.bind(workspaceProvider)
           : undefined
@@ -352,7 +357,7 @@ export function createSocialChatRuntime(params: {
                 platform: 'slack',
               }),
             )
-          : [...getTeamConsultParticipants()]
+          : [...agentConfig.teamConsultParticipants]
         const consultParticipants = [...new Set(consultedAgents)].filter((agentId) => agentId !== socialAgentId)
         const executedToolNames: string[] = []
 
@@ -380,7 +385,7 @@ export function createSocialChatRuntime(params: {
           },
         )
 
-        const transcript = buildSocialChatThreadTranscript(historyBeforeReply)
+        const transcript = buildSocialChatThreadTranscript(agentConfig, historyBeforeReply)
         const runAbort = yield* Effect.acquireRelease(
           Effect.sync(() => createServerRunAbortController()),
           (controller) => Effect.sync(() => controller.dispose()),
@@ -458,6 +463,7 @@ export function createSocialChatRuntime(params: {
 
                           return yield* effectTryPromise(() =>
                             runSocialAgentTurn({
+                              agentFactoryConfig,
                               agentId,
                               mode: 'fixedThreadMode',
                               threadType: 'group',
@@ -474,7 +480,7 @@ export function createSocialChatRuntime(params: {
                               tools,
                               prompt: buildSpecialistSocialChatPrompt({
                                 requesterName: socialAgentDisplayName,
-                                agentName: getAgentDisplayName(agentId),
+                                agentName: getAgentDisplayName(agentConfig, agentId),
                                 task,
                                 transcript,
                               }),
@@ -488,7 +494,12 @@ export function createSocialChatRuntime(params: {
                 const text = specialistRun.text
                 const createdAt = yield* Clock.currentTimeMillis
 
-                return createAssistantMessage({ agentId, agentName: getAgentDisplayName(agentId), text, createdAt })
+                return createAssistantMessage({
+                  agentId,
+                  agentName: getAgentDisplayName(agentConfig, agentId),
+                  text,
+                  createdAt,
+                })
               }),
             ),
           toModelOutput: ({ output }) => {
@@ -509,6 +520,7 @@ export function createSocialChatRuntime(params: {
         aiLogger.debug`Slack social-chat generating reply: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}`
         const leadRun = yield* effectTryPromise(() =>
           runSocialAgentTurn({
+            agentFactoryConfig,
             agentId: socialAgentId,
             mode: 'threadMode',
             threadType: 'group',
@@ -549,13 +561,13 @@ export function createSocialChatRuntime(params: {
           yield* socialChatHistoryService.upsertMessages([normalizedResponse])
         }
 
-        const priorHistoryMessages = toHistoryMessages(priorHistory)
-        const agentMessages = normalizedResponse ? buildAgentHistoryMessages([normalizedResponse]) : []
+        const priorHistoryMessages = toHistoryMessages(agentConfig, priorHistory)
+        const agentMessages = normalizedResponse ? buildAgentHistoryMessages(agentConfig, [normalizedResponse]) : []
         if (messageContext.text && agentMessages.length > 0) {
           yield* effectTryPromise(() =>
             safeEnqueue(
               () =>
-                enqueuePostChatMemory(
+                params.services.queues.postChatMemory.enqueuePostChatMemory(
                   {
                     orgId: workspaceIdString,
                     threadId: `social:slack:${messageContext.threadId}`,
@@ -592,14 +604,17 @@ export function createSocialChatRuntime(params: {
         }
 
         yield* effectTryPromise(() =>
-          safeEnqueue(() => enqueueRegularChatMemoryDigest({ orgId: workspaceIdString }), {
-            operationName: 'social regular chat memory digest enqueue',
-          }),
+          safeEnqueue(
+            () =>
+              params.services.queues.organizationLearning.enqueueRegularChatMemoryDigest({ orgId: workspaceIdString }),
+            { operationName: 'social regular chat memory digest enqueue' },
+          ),
         )
         yield* effectTryPromise(() =>
-          safeEnqueue(() => enqueueSkillExtraction({ orgId: workspaceIdString }), {
-            operationName: 'social skill extraction enqueue',
-          }),
+          safeEnqueue(
+            () => params.services.queues.organizationLearning.enqueueSkillExtraction({ orgId: workspaceIdString }),
+            { operationName: 'social skill extraction enqueue' },
+          ),
         )
       }),
     )

package/src/runtime/team-consultation/team-consultation-orchestrator.ts

@@ -3,7 +3,7 @@ import type { ChatMessage, ConsultTeamResultData } from '@lota-sdk/shared'
 import { convertToModelMessages, tool as createTool } from 'ai'
 import { Schema, Deferred, Effect, Exit, Fiber, Queue, Ref, Scope } from 'effect'
 
-import { getAgentDisplayNames, getTeamConsultParticipants } from '../../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { nowEpochMillis } from '../../utils/date-time'
 import { createTimedAbortSignal } from '../agent-stream-helpers'
 import { buildModelInputMessagesWithUploadMetadata, buildReadableUploadMetadataText } from '../chat-attachments'
@@ -91,6 +91,7 @@ export interface TeamConsultationParticipantRunner {
 }
 
 export interface CreateConsultTeamToolParams {
+  agentConfig: ResolvedAgentConfig
   historyMessages: ChatMessage[]
   latestUserMessageId: string
   availableUploads: ReadableUploadMetadataLike[]
@@ -278,9 +279,9 @@ class ConsultTeamSnapshotIterable implements AsyncIterableIterator<ConsultTeamRe
   private completed = false
 
   constructor(params: CreateConsultTeamToolParams, task: string) {
-    const teamConsultParticipants = getTeamConsultParticipants()
+    const teamConsultParticipants = params.agentConfig.teamConsultParticipants
     const uploadMetadataText = buildReadableUploadMetadataText(params.availableUploads)
-    const agentDisplayNames = getAgentDisplayNames()
+    const agentDisplayNames = params.agentConfig.displayNames
     const resolveDisplayName = (agentId: string) => {
       if (params.displayNamesById && Object.hasOwn(params.displayNamesById, agentId)) {
         const override = params.displayNamesById[agentId]
@@ -390,8 +391,8 @@ class ConsultTeamSnapshotIterable implements AsyncIterableIterator<ConsultTeamRe
 }
 
 export function createConsultTeamTool(params: CreateConsultTeamToolParams) {
-  const teamConsultParticipants = getTeamConsultParticipants()
-  const agentDisplayNames = getAgentDisplayNames()
+  const teamConsultParticipants = params.agentConfig.teamConsultParticipants
+  const agentDisplayNames = params.agentConfig.displayNames
   const resolveDisplayName = (agentId: string) => {
     if (params.displayNamesById && Object.hasOwn(params.displayNamesById, agentId)) {
       const override = params.displayNamesById[agentId]

package/src/runtime/team-consultation/team-consultation-prompts.ts

@@ -1,12 +1,17 @@
-import { getAgentDisplayNames, getLeadAgentDisplayName } from '../../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 
-function resolveDisplayName(agentId: string): string {
-  return getAgentDisplayNames()[agentId] ?? agentId
+function resolveDisplayName(agentConfig: ResolvedAgentConfig, agentId: string): string {
+  return agentConfig.displayNames[agentId] ?? agentId
 }
 
-export function buildTeamConsultationResponseGuard(params: { agentId: string; task: string }) {
-  const agentName = resolveDisplayName(params.agentId)
-  const leadAgentDisplayName = getLeadAgentDisplayName()
+export function buildTeamConsultationResponseGuard(params: {
+  agentConfig: ResolvedAgentConfig
+  agentId: string
+  task: string
+}) {
+  const agentName = resolveDisplayName(params.agentConfig, params.agentId)
+  const leadAgentDisplayName =
+    params.agentConfig.displayNames[params.agentConfig.leadAgentId] ?? params.agentConfig.leadAgentId
   const mentorConstraint =
     params.agentId === 'mentor'
       ? ['- As Mentor, answer as an experienced operator reviewing launch discipline, not as a coach or therapist.']

package/src/runtime/thread-chat-helpers.ts

@@ -1,7 +1,8 @@
 import { toTimestamp } from '@lota-sdk/shared'
 import type { ChatMessage } from '@lota-sdk/shared'
 
-import { getAgentDisplayNames, resolveAgentNameAlias } from '../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
+import { resolveAgentNameAlias } from '../config/agent-defaults'
 import type { ChatMessageLike, ReadableUploadMetadataLike } from './chat-types'
 
 export interface ThreadHistoryMessage {
@@ -29,13 +30,13 @@ export function readInstructionSections(value: unknown): string[] {
     .filter((section) => section.length > 0)
 }
 
-function getAgentName(message: ChatMessageLike): string | undefined {
+function getAgentName(agentConfig: ResolvedAgentConfig, message: ChatMessageLike): string | undefined {
   const metadata = message.metadata
   if (!metadata || typeof metadata !== 'object') return undefined
   const value = (metadata as Record<string, unknown>).agentName
   if (typeof value !== 'string' || !value.trim()) return undefined
-  const resolvedAgentName = resolveAgentNameAlias(value)
-  return resolvedAgentName ? (getAgentDisplayNames()[resolvedAgentName] ?? value.trim()) : value.trim()
+  const resolvedAgentName = resolveAgentNameAlias(agentConfig, value)
+  return resolvedAgentName ? (agentConfig.displayNames[resolvedAgentName] ?? value.trim()) : value.trim()
 }
 
 export function extractMessageText(message: ChatMessageLike): string {
@@ -45,7 +46,11 @@ export function extractMessageText(message: ChatMessageLike): string {
     .trim()
 }
 
-export function toHistoryMessages(messages: ChatMessageLike[], maxItems = 24): ThreadHistoryMessage[] {
+export function toHistoryMessages(
+  agentConfig: ResolvedAgentConfig,
+  messages: ChatMessageLike[],
+  maxItems = 24,
+): ThreadHistoryMessage[] {
   return messages
     .map((message): ThreadHistoryMessage | null => {
       const content = extractMessageText(message)
@@ -55,7 +60,7 @@ export function toHistoryMessages(messages: ChatMessageLike[], maxItems = 24): T
         return { role: 'user', content }
       }
       if (message.role === 'assistant') {
-        const agentName = getAgentName(message)
+        const agentName = getAgentName(agentConfig, message)
         return { role: 'agent', content, ...(agentName ? { agentName } : {}) }
       }
       return null
@@ -65,6 +70,7 @@ export function toHistoryMessages(messages: ChatMessageLike[], maxItems = 24): T
 }
 
 export function buildConversationSummary(params: {
+  agentConfig: ResolvedAgentConfig
   userMessageText: string
   assistantMessages: ChatMessageLike[]
 }): string {
@@ -76,15 +82,18 @@ export function buildConversationSummary(params: {
   for (const message of params.assistantMessages) {
     const content = extractMessageText(message)
     if (!content) continue
-    const agentName = getAgentName(message)
+    const agentName = getAgentName(params.agentConfig, message)
     lines.push(agentName ? `${agentName}: ${content}` : `Assistant: ${content}`)
   }
 
   return lines.join('\n\n').trim()
 }
 
-export function buildAgentHistoryMessages(messages: ChatMessageLike[]): Array<{ content: string; agentName?: string }> {
-  return toHistoryMessages(messages)
+export function buildAgentHistoryMessages(
+  agentConfig: ResolvedAgentConfig,
+  messages: ChatMessageLike[],
+): Array<{ content: string; agentName?: string }> {
+  return toHistoryMessages(agentConfig, messages)
     .filter((message) => message.role === 'agent')
     .map((message) => ({ content: message.content, ...(message.agentName ? { agentName: message.agentName } : {}) }))
 }

package/src/runtime/thread-turn-context.ts

@@ -1,8 +1,6 @@
 import { Schema, Effect } from 'effect'
 
 import type { RecordIdRef } from '../db/record-id'
-import { recordIdToString } from '../db/record-id'
-import { TABLES } from '../db/tables'
 import { effectTryMaybeAsync as effectTryMaybeAsyncShared, makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { buildAgentPromptContext } from './agent-prompt-context'
 import {
@@ -11,10 +9,9 @@ import {
   getLinearInstallationByOrgId,
 } from './plugin-resolution'
 import type {
+  LotaRuntimeAdapters,
   LotaRuntimeIndexedRepositoriesContext,
   LotaRuntimeTurnHooks,
-  LotaRuntimeWorkspaceLifecycleState,
-  LotaRuntimeWorkspaceProjectionState,
   LotaRuntimeWorkspaceProvider,
 } from './runtime-extensions'
 import { readInstructionSections, readOptionalString } from './thread-chat-helpers'
@@ -43,21 +40,7 @@ function effectTryMaybeAsync<A>(
   return effectTryMaybeAsyncShared(evaluate, (cause) => new ThreadTurnContextError({ message, cause }))
 }
 
-interface AssembledThreadTurnContext {
-  workspace: Record<string, unknown>
-  workspaceLifecycleState: LotaRuntimeWorkspaceLifecycleState | undefined
-  workspaceProfileState: LotaRuntimeWorkspaceProjectionState | undefined
-  onboardingActive: boolean
-  linearInstalled: boolean
-  githubInstalled: boolean
-  indexedRepoContext: LotaRuntimeIndexedRepositoriesContext
-  promptContext: { systemWorkspaceDetails?: string }
-  retrievedKnowledgeSection: string | undefined
-  buildContextResult: Record<string, unknown> | null
-  hookInstructionSections: string[]
-}
-
-const assembleThreadTurnContextEffect = Effect.fn('ThreadTurnContext.assemble')(function* (params: {
+export const assembleThreadTurnContext = Effect.fn('ThreadTurnContext.assemble')(function* (params: {
   thread: unknown
   threadRef: RecordIdRef
   orgRef: RecordIdRef
@@ -69,6 +52,8 @@ const assembleThreadTurnContextEffect = Effect.fn('ThreadTurnContext.assemble')(
   workspacePromise: Promise<Record<string, unknown>>
   workspaceProvider?: LotaRuntimeWorkspaceProvider
   turnHooks: LotaRuntimeTurnHooks
+  runtimeAdapters: LotaRuntimeAdapters
+  pluginRuntime?: Record<string, unknown>
 }) {
   const workspace = yield* effectTryPromise(() => params.workspacePromise, 'Failed to load thread workspace').pipe(
     Effect.withSpan('ThreadTurnContext.loadWorkspace'),
@@ -85,21 +70,21 @@ const assembleThreadTurnContextEffect = Effect.fn('ThreadTurnContext.assemble')(
 
   const onboardingActive = workspaceLifecycleState?.bootstrapActive ?? false
   const linearInstallation = yield* effectTryPromise(
-    () => getLinearInstallationByOrgId(params.orgRef),
+    () => getLinearInstallationByOrgId(params.pluginRuntime, params.orgRef),
     'Failed to load Linear installation',
   ).pipe(
     Effect.catch(() => Effect.succeed(null)),
     Effect.withSpan('ThreadTurnContext.loadLinearInstallation'),
   )
   const githubInstallation = yield* effectTryPromise(
-    () => getGithubInstallationForOrganization(params.orgIdString),
+    () => getGithubInstallationForOrganization(params.pluginRuntime, params.orgIdString),
     'Failed to load GitHub installation',
   ).pipe(
     Effect.catch(() => Effect.succeed(null)),
     Effect.withSpan('ThreadTurnContext.loadGithubInstallation'),
   )
   const indexedRepoContext = yield* effectTryPromise(
-    () => buildIndexedRepositoriesContext(params.orgIdString),
+    () => buildIndexedRepositoriesContext(params.runtimeAdapters, params.orgIdString),
     'Failed to build indexed repository context',
   ).pipe(
     Effect.catch(() =>
@@ -227,28 +212,3 @@ const assembleThreadTurnContextEffect = Effect.fn('ThreadTurnContext.assemble')(
     hookInstructionSections,
   }
 })
-
-export function assembleThreadTurnContext(params: {
-  thread: unknown
-  threadRef: RecordIdRef
-  orgRef: RecordIdRef
-  userRef: RecordIdRef
-  userName?: string | null
-  orgIdString: string
-  userIdString: string
-  messageText: string
-  workspacePromise: Promise<Record<string, unknown>>
-  workspaceProvider?: LotaRuntimeWorkspaceProvider
-  turnHooks: LotaRuntimeTurnHooks
-}): Promise<AssembledThreadTurnContext> {
-  return Effect.runPromise(
-    assembleThreadTurnContextEffect(params).pipe(
-      Effect.annotateSpans({
-        threadId: recordIdToString(params.threadRef, TABLES.THREAD),
-        orgId: params.orgIdString,
-        userId: params.userIdString,
-        messageLength: params.messageText.length,
-      }),
-    ),
-  )
-}

package/src/runtime/turn-lifecycle.ts

@@ -86,17 +86,9 @@ export function finalizeTurnRunEffect(params: {
   })
 }
 
-export function finalizeTurnRun(params: {
-  serverRunId: string
-  getEntity: () => MaybeEffect<{ lastCompactedMessageId?: string | null; compactionSummary?: string | null }>
-  getUncompactedMessages: (cursor?: string) => MaybeEffect<ChatMessage[]>
-  assessCompaction: (summaryText: string, messages: ChatMessage[]) => { shouldCompact: boolean }
-  enqueueCompaction: () => MaybeEffect<void>
-  unregisterRun: (runId: string) => void
-  clearActiveRunId: (runId: string) => MaybeEffect<void>
-  disposeAbort: () => void
-  activeStreamId?: string
-  clearActiveStreamId?: (streamId: string) => MaybeEffect<void>
-}): Promise<void> {
-  return Effect.runPromise(finalizeTurnRunEffect(params))
-}
+/**
+ * Alias for `finalizeTurnRunEffect`. Kept as the public name consumers use.
+ * Callers pipe the returned Effect through their own runtime rather than
+ * relying on a process-wide promise adapter.
+ */
+export { finalizeTurnRunEffect as finalizeTurnRun }