@lota-sdk/core 0.4.8 → 0.4.10

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

@@ -0,0 +1,630 @@
+import { createSlackAdapter } from '@chat-adapter/slack'
+import { createIoRedisState } from '@chat-adapter/state-ioredis'
+import type { IoRedisStateClientOptions } from '@chat-adapter/state-ioredis'
+import {
+  buildSlackSocialReplyMarkdown,
+  CONSULT_SPECIALIST_TOOL_NAME,
+  ConsultSpecialistArgsSchema,
+} from '@lota-sdk/shared'
+import type { ChatMessage, ConsultSpecialistArgs } from '@lota-sdk/shared'
+import { tool as createTool } from 'ai'
+import { Chat, ConsoleLogger } from 'chat'
+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 { 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 { LearnedSkillServiceTag } from '../../services/learned-skill.service'
+import type { MemoryServiceTag } from '../../services/memory/memory.service'
+import type { SocialChatHistoryError, makeSocialChatHistoryService } from '../../services/social-chat-history.service'
+import { safeEnqueue } from '../../utils/async'
+import { buildAgentPromptContext } from '../agent-prompt-context'
+import { createServerRunAbortController } from '../agent-stream-helpers'
+import type {
+  BuildSocialChatAgentToolsParams,
+  LotaRuntimeSocialChatConfig,
+  LotaSocialChatResolvedContext,
+} from '../runtime-config'
+import { getRuntimeAdapters } from '../runtime-extensions'
+import { runSpecialistSession } from '../specialist-runner'
+import {
+  buildAgentHistoryMessages,
+  extractMessageText,
+  toHistoryMessages,
+  toOptionalTrimmedString,
+} from '../thread-chat-helpers'
+import { runSocialAgentTurn, withLoggedSocialToolSet } from './social-chat-agent-runner'
+import {
+  collectThreadMessages,
+  createSocialChatCursorId,
+  normalizeSocialHistoryMessage,
+  readSlackAuthorName,
+  buildSocialChatThreadTranscript,
+} from './social-chat-history'
+import {
+  buildLeadSocialChatPrompt,
+  buildSocialChatIdentitySection,
+  buildSpecialistSocialChatPrompt,
+} from './social-chat-prompts'
+
+export interface SocialChatRuntimeServices {
+  learnedSkillService: Context.Service.Shape<typeof LearnedSkillServiceTag>
+  memoryService: Context.Service.Shape<typeof MemoryServiceTag>
+  socialChatHistoryService: ReturnType<typeof makeSocialChatHistoryService>
+}
+
+class SocialChatServiceError extends Schema.TaggedErrorClass<SocialChatServiceError>()('SocialChatServiceError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+const DEFAULT_SOCIAL_CHAT_AGENT_ID = 'socialChat'
+const DEFAULT_SOCIAL_CHAT_AGENT_DISPLAY_NAME = 'Lota'
+const DEFAULT_SOCIAL_CHAT_STATE_PREFIX = 'lota:social:chat-sdk'
+const DEFAULT_SOCIAL_CHAT_DEDUPE_TTL_MS = 15 * 60 * 1000
+const PRESEEDED_MEMORY_LOOKUP_LIMIT = 3
+
+export interface LotaRuntimeSocialChat {
+  enabled: boolean
+  initialize(): Promise<void>
+  shutdown(): Promise<void>
+  webhooks: { slack(request: Request, options?: WebhookOptions): Promise<Response> }
+}
+
+type SocialChatStateRedisClient = IoRedisStateClientOptions['client']
+
+interface SlackSocialMessageContext {
+  channelId: string
+  threadId: string
+  messageId: string
+  text: string
+  authorId?: string
+  authorName?: string
+}
+
+function createDisabledSocialChatRuntime(): LotaRuntimeSocialChat {
+  return {
+    enabled: false,
+    initialize: () => Promise.resolve(),
+    shutdown: () => Promise.resolve(),
+    webhooks: { slack: () => Promise.resolve(new Response('Social chat is disabled.', { status: 404 })) },
+  }
+}
+
+function createAssistantMessage(params: {
+  agentId: string
+  agentName: string
+  text: string
+  createdAt: number
+}): ChatMessage {
+  return {
+    id: Bun.randomUUIDv7(),
+    role: 'assistant',
+    parts: [{ type: 'text', text: params.text }],
+    metadata: { agentId: params.agentId, agentName: params.agentName, createdAt: params.createdAt },
+  }
+}
+
+function getAgentDisplayName(agentId: string): string {
+  return getAgentDisplayNames()[agentId] ?? agentId
+}
+
+function toSafeJobIdSegment(value: string): string {
+  return value.replace(/[^a-zA-Z0-9_-]/g, '_')
+}
+
+function createSocialMemoryDedupeKey(params: { workspaceId: string; threadId: string; messageId: string }): string {
+  return [
+    'social-memory',
+    toSafeJobIdSegment(params.workspaceId),
+    toSafeJobIdSegment(params.threadId),
+    toSafeJobIdSegment(params.messageId),
+  ].join('-')
+}
+
+function buildBuildToolsParams(params: {
+  agentId: string
+  context: LotaSocialChatResolvedContext
+  workspaceIdString: string
+  userIdString: string
+  messageContext: SlackSocialMessageContext
+  memoryBlock: string
+  onAppendMemoryBlock: (value: string) => void
+}): BuildSocialChatAgentToolsParams {
+  return {
+    agentId: params.agentId,
+    workspaceId: params.context.workspaceId,
+    workspaceIdString: params.workspaceIdString,
+    userId: params.context.userId,
+    userIdString: params.userIdString,
+    userName: params.context.userName,
+    platform: 'slack',
+    channelId: params.messageContext.channelId,
+    threadId: params.messageContext.threadId,
+    incomingMessageId: params.messageContext.messageId,
+    incomingText: params.messageContext.text,
+    memoryBlock: params.memoryBlock,
+    onAppendMemoryBlock: params.onAppendMemoryBlock,
+    context: null,
+  }
+}
+
+export function createSocialChatRuntime(params: {
+  redisClient: SocialChatStateRedisClient
+  socialChat?: LotaRuntimeSocialChatConfig
+  services: SocialChatRuntimeServices
+}): LotaRuntimeSocialChat {
+  const socialChatConfig = params.socialChat
+  const slackConfig = socialChatConfig?.slack
+  const slackEnabled = Boolean(slackConfig?.botToken?.trim() && slackConfig.signingSecret?.trim())
+
+  if (!socialChatConfig || !slackEnabled) {
+    return createDisabledSocialChatRuntime()
+  }
+
+  const socialAgentId = toOptionalTrimmedString(socialChatConfig.agentId) ?? DEFAULT_SOCIAL_CHAT_AGENT_ID
+  const socialAgentDisplayName =
+    toOptionalTrimmedString(socialChatConfig.agentDisplayName) ?? DEFAULT_SOCIAL_CHAT_AGENT_DISPLAY_NAME
+  const stateKeyPrefix =
+    toOptionalTrimmedString(socialChatConfig.stateRedisKeyPrefix) ?? DEFAULT_SOCIAL_CHAT_STATE_PREFIX
+  const chat = new Chat({
+    userName: toOptionalTrimmedString(slackConfig?.userName) ?? socialAgentDisplayName,
+    adapters: {
+      slack: createSlackAdapter({
+        botToken: slackConfig?.botToken,
+        signingSecret: slackConfig?.signingSecret,
+        userName: toOptionalTrimmedString(slackConfig?.userName) ?? socialAgentDisplayName,
+      }),
+    },
+    state: createIoRedisState({
+      client: params.redisClient,
+      keyPrefix: stateKeyPrefix,
+      logger: new ConsoleLogger('warn', 'lota-social-chat'),
+    }),
+    dedupeTtlMs: slackConfig?.dedupeTtlMs ?? DEFAULT_SOCIAL_CHAT_DEDUPE_TTL_MS,
+  })
+
+  const initialize = () => Effect.runPromise(effectTryPromise(() => chat.initialize()))
+  const shutdown = () => Effect.runPromise(effectTryPromise(() => chat.shutdown()))
+
+  const handleMessage = (
+    thread: Thread,
+    incomingMessage: Message,
+  ): Effect.Effect<
+    void,
+    Cause.UnknownError | ForbiddenError | SocialChatHistoryError | SocialChatServiceError,
+    never
+  > =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const { memoryService, learnedSkillService, socialChatHistoryService } = params.services
+        const currentContext = yield* Effect.context()
+        const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
+        const rawSlackMessage = incomingMessage.raw as { channel?: unknown } | undefined
+        const channelId = toOptionalTrimmedString(rawSlackMessage?.channel) ?? thread.channelId
+        const messageContext: SlackSocialMessageContext = {
+          channelId,
+          threadId: thread.id,
+          messageId: incomingMessage.id,
+          text: incomingMessage.text.trim(),
+          authorId: toOptionalTrimmedString(incomingMessage.author.userId) ?? undefined,
+          authorName: readSlackAuthorName(incomingMessage),
+        }
+        aiLogger.debug`Slack social-chat message received: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}, messageId=${messageContext.messageId}, author=${messageContext.authorName ?? 'unknown'}, textLength=${messageContext.text.length}`
+
+        const resolvedContext = yield* effectTryMaybeAsync(() =>
+          socialChatConfig.resolveContext({
+            platform: 'slack',
+            channelId: messageContext.channelId,
+            threadId: messageContext.threadId,
+            messageId: messageContext.messageId,
+            text: messageContext.text,
+            authorId: messageContext.authorId,
+            authorName: messageContext.authorName,
+          }),
+        )
+        const workspaceIdString = recordIdToString(resolvedContext.workspaceId, TABLES.ORGANIZATION)
+        const userIdString = recordIdToString(resolvedContext.userId, TABLES.USER)
+        aiLogger.debug`Slack social-chat context resolved: workspaceId=${workspaceIdString}, userId=${userIdString}`
+
+        const threadMessages = yield* effectTryPromise(() => collectThreadMessages(thread, incomingMessage))
+        const normalizedMessages = threadMessages
+          .map((message) =>
+            normalizeSocialHistoryMessage({
+              workspaceId: workspaceIdString,
+              channelId: messageContext.channelId,
+              agentId: socialAgentId,
+              agentDisplayName: socialAgentDisplayName,
+              message,
+            }),
+          )
+          .filter((message): message is NonNullable<typeof message> => message !== null)
+        yield* socialChatHistoryService.upsertMessages(normalizedMessages)
+
+        const historyBeforeReply = yield* socialChatHistoryService.listThreadMessages({
+          workspaceId: workspaceIdString,
+          threadId: messageContext.threadId,
+        })
+        const currentUserMessage =
+          historyBeforeReply.find((message) => message.messageId === incomingMessage.id) ?? historyBeforeReply.at(-1)
+        const priorHistory = currentUserMessage
+          ? historyBeforeReply.filter((message) => message.cursor.id !== currentUserMessage.cursor.id)
+          : historyBeforeReply
+
+        const workspaceProvider = getRuntimeAdapters().workspaceProvider
+        const getWorkspace = workspaceProvider?.getWorkspace
+          ? workspaceProvider.getWorkspace.bind(workspaceProvider)
+          : undefined
+        const getLifecycleState = workspaceProvider?.getLifecycleState
+          ? workspaceProvider.getLifecycleState.bind(workspaceProvider)
+          : undefined
+        const readProfileProjectionState = workspaceProvider?.readProfileProjectionState
+          ? workspaceProvider.readProfileProjectionState.bind(workspaceProvider)
+          : undefined
+        const listRecentDomainEvents = workspaceProvider?.listRecentDomainEvents
+          ? workspaceProvider.listRecentDomainEvents.bind(workspaceProvider)
+          : undefined
+        const buildPromptSummary = workspaceProvider?.buildPromptSummary
+          ? workspaceProvider.buildPromptSummary.bind(workspaceProvider)
+          : undefined
+        const buildRetrievedKnowledgeSection = workspaceProvider?.buildRetrievedKnowledgeSection
+          ? workspaceProvider.buildRetrievedKnowledgeSection.bind(workspaceProvider)
+          : undefined
+        const getConsultParticipants = socialChatConfig.getConsultParticipants
+
+        const workspace = getWorkspace
+          ? yield* effectTryMaybeAsync(() => getWorkspace(resolvedContext.workspaceId))
+          : {}
+        const lifecycleState = getLifecycleState
+          ? yield* effectTryMaybeAsync(() => getLifecycleState(workspace))
+          : undefined
+        const workspaceProfileState = readProfileProjectionState
+          ? yield* effectTryMaybeAsync(() => readProfileProjectionState(workspace))
+          : undefined
+        const recentDomainEvents = listRecentDomainEvents
+          ? yield* effectTryMaybeAsync(() => listRecentDomainEvents(resolvedContext.workspaceId, 5))
+          : ([] as Array<Record<string, unknown>>)
+        const promptSummary = buildPromptSummary
+          ? yield* effectTryMaybeAsync(() => buildPromptSummary(resolvedContext.workspaceId)).pipe(
+              Effect.orElseSucceed(() => undefined),
+            )
+          : undefined
+
+        const promptContext = buildAgentPromptContext({
+          workspaceName:
+            workspaceProfileState?.workspaceName ??
+            toOptionalTrimmedString((workspace as { name?: unknown }).name) ??
+            undefined,
+          summaryBlock: workspaceProfileState?.summaryBlock,
+          promptSummary,
+          userName: messageContext.authorName,
+          recentDomainEvents,
+        })
+        const retrievedKnowledgeSection =
+          lifecycleState?.bootstrapActive || messageContext.text.length === 0
+            ? undefined
+            : buildRetrievedKnowledgeSection
+              ? yield* effectTryMaybeAsync(() =>
+                  buildRetrievedKnowledgeSection({
+                    workspaceId: workspaceIdString,
+                    userId: userIdString,
+                    query: messageContext.text,
+                  }),
+                )
+              : undefined
+
+        const preSeededMemoriesSection = yield* memoryService
+          .getTopMemories({ orgId: workspaceIdString, agentName: socialAgentId, limit: PRESEEDED_MEMORY_LOOKUP_LIMIT })
+          .pipe(
+            Effect.mapError(
+              (cause) =>
+                new SocialChatServiceError({
+                  message: `Failed to load pre-seeded memories for ${socialAgentId}.`,
+                  cause,
+                }),
+            ),
+          )
+        const learnedSkillsSection = lifecycleState?.bootstrapActive
+          ? undefined
+          : yield* learnedSkillService
+              .retrieveForTurn({
+                orgId: workspaceIdString,
+                agentId: socialAgentId,
+                query: messageContext.text,
+                limit: 3,
+                minConfidence: 0.6,
+              })
+              .pipe(Effect.orElseSucceed(() => undefined))
+
+        let memoryBlock = ''
+        const consultedAgents = getConsultParticipants
+          ? yield* effectTryMaybeAsync(() =>
+              getConsultParticipants({
+                workspaceId: resolvedContext.workspaceId,
+                workspaceIdString,
+                platform: 'slack',
+              }),
+            )
+          : [...getTeamConsultParticipants()]
+        const consultParticipants = [...new Set(consultedAgents)].filter((agentId) => agentId !== socialAgentId)
+        const executedToolNames: string[] = []
+
+        const baseTools = withLoggedSocialToolSet(
+          yield* effectTryMaybeAsync(() =>
+            socialChatConfig.buildAgentTools(
+              buildBuildToolsParams({
+                agentId: socialAgentId,
+                context: resolvedContext,
+                workspaceIdString,
+                userIdString,
+                messageContext,
+                memoryBlock,
+                onAppendMemoryBlock: (value: string) => {
+                  memoryBlock = value
+                },
+              }),
+            ),
+          ),
+          {
+            agentId: socialAgentId,
+            channelId: messageContext.channelId,
+            threadId: messageContext.threadId,
+            executedToolNames,
+          },
+        )
+
+        const transcript = buildSocialChatThreadTranscript(historyBeforeReply)
+        const runAbort = yield* Effect.acquireRelease(
+          Effect.sync(() => createServerRunAbortController()),
+          (controller) => Effect.sync(() => controller.dispose()),
+        )
+
+        const consultSpecialistTool = createTool({
+          description: 'Consult one specialist teammate for targeted guidance before replying to the user.',
+          inputSchema: ConsultSpecialistArgsSchema,
+          execute: ({ agentId, task }: ConsultSpecialistArgs) =>
+            runPromiseWithCurrentContext(
+              Effect.gen(function* () {
+                if (!consultParticipants.includes(agentId)) {
+                  return yield* new ForbiddenError({
+                    message: `Agent "${agentId}" is not an allowed social-chat specialist.`,
+                  })
+                }
+
+                const { result: specialistRun } = yield* effectTryMaybeAsync(() =>
+                  runSpecialistSession({
+                    initialMemoryBlock: '',
+                    buildTools: ({ memoryBlock: currentMemoryBlock, onAppendMemoryBlock }) =>
+                      runPromiseWithCurrentContext(
+                        Effect.gen(function* () {
+                          const tools = yield* effectTryMaybeAsync(() =>
+                            socialChatConfig.buildAgentTools(
+                              buildBuildToolsParams({
+                                agentId,
+                                context: resolvedContext,
+                                workspaceIdString,
+                                userIdString,
+                                messageContext,
+                                memoryBlock: currentMemoryBlock,
+                                onAppendMemoryBlock,
+                              }),
+                            ),
+                          )
+
+                          return withLoggedSocialToolSet(tools, {
+                            agentId,
+                            channelId: messageContext.channelId,
+                            threadId: messageContext.threadId,
+                            executedToolNames,
+                          })
+                        }),
+                      ),
+                    run: ({ tools }) =>
+                      runPromiseWithCurrentContext(
+                        Effect.gen(function* () {
+                          const specialistPreSeededMemories = yield* memoryService
+                            .getTopMemories({
+                              orgId: workspaceIdString,
+                              agentName: agentId,
+                              limit: PRESEEDED_MEMORY_LOOKUP_LIMIT,
+                            })
+                            .pipe(
+                              Effect.mapError(
+                                (cause) =>
+                                  new SocialChatServiceError({
+                                    message: `Failed to load pre-seeded memories for specialist ${agentId}.`,
+                                    cause,
+                                  }),
+                              ),
+                            )
+                          const specialistLearnedSkills = lifecycleState?.bootstrapActive
+                            ? undefined
+                            : yield* learnedSkillService
+                                .retrieveForTurn({
+                                  orgId: workspaceIdString,
+                                  agentId,
+                                  query: task,
+                                  limit: 3,
+                                  minConfidence: 0.6,
+                                })
+                                .pipe(Effect.orElseSucceed(() => undefined))
+
+                          return yield* effectTryPromise(() =>
+                            runSocialAgentTurn({
+                              agentId,
+                              mode: 'fixedThreadMode',
+                              threadType: 'group',
+                              onboardingActive: lifecycleState?.bootstrapActive ?? false,
+                              linearInstalled: false,
+                              systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
+                              preSeededMemoriesSection: specialistPreSeededMemories,
+                              retrievedKnowledgeSection,
+                              learnedSkillsSection: specialistLearnedSkills,
+                              userMessageText: task,
+                              additionalInstructionSections: [
+                                `You are supporting ${socialAgentDisplayName} in a Slack social-chat thread. Stay within your role.`,
+                              ],
+                              tools,
+                              prompt: buildSpecialistSocialChatPrompt({
+                                requesterName: socialAgentDisplayName,
+                                agentName: getAgentDisplayName(agentId),
+                                task,
+                                transcript,
+                              }),
+                              abortSignal: runAbort.signal,
+                            }),
+                          )
+                        }),
+                      ),
+                  }),
+                )
+                const text = specialistRun.text
+                const createdAt = yield* Clock.currentTimeMillis
+
+                return createAssistantMessage({ agentId, agentName: getAgentDisplayName(agentId), text, createdAt })
+              }),
+            ),
+          toModelOutput: ({ output }) => {
+            const message = output
+            const agentName =
+              typeof message.metadata?.agentName === 'string' && message.metadata.agentName.trim().length > 0
+                ? message.metadata.agentName.trim()
+                : 'Specialist'
+            const summary = extractMessageText(message).trim()
+            return {
+              type: 'text',
+              value: summary ? `${agentName}: ${summary}` : `${agentName} completed the requested task.`,
+            }
+          },
+        })
+
+        yield* effectTryPromise(() => thread.startTyping('Thinking...')).pipe(Effect.orElseSucceed(() => undefined))
+        aiLogger.debug`Slack social-chat generating reply: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}`
+        const leadRun = yield* effectTryPromise(() =>
+          runSocialAgentTurn({
+            agentId: socialAgentId,
+            mode: 'threadMode',
+            threadType: 'group',
+            onboardingActive: lifecycleState?.bootstrapActive ?? false,
+            linearInstalled: false,
+            systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
+            preSeededMemoriesSection,
+            retrievedKnowledgeSection,
+            learnedSkillsSection,
+            userMessageText: messageContext.text,
+            additionalInstructionSections: [buildSocialChatIdentitySection(socialAgentDisplayName)],
+            tools: { ...baseTools, [CONSULT_SPECIALIST_TOOL_NAME]: consultSpecialistTool },
+            prompt: buildLeadSocialChatPrompt({
+              agentDisplayName: socialAgentDisplayName,
+              channelId: messageContext.channelId,
+              threadId: messageContext.threadId,
+              transcript,
+              latestUserMessage: messageContext.text,
+              latestAuthorName: messageContext.authorName,
+            }),
+            abortSignal: runAbort.signal,
+          }),
+        )
+        const responseText = leadRun.text
+
+        const replyMarkdown = buildSlackSocialReplyMarkdown({ replyMarkdown: responseText, executedToolNames })
+        const sentMessage = yield* effectTryPromise(() => thread.post({ markdown: replyMarkdown }))
+        aiLogger.debug`Slack social-chat reply posted: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}, replyMessageId=${sentMessage.id}`
+        const normalizedResponse = normalizeSocialHistoryMessage({
+          workspaceId: workspaceIdString,
+          channelId: messageContext.channelId,
+          agentId: socialAgentId,
+          agentDisplayName: socialAgentDisplayName,
+          message: sentMessage,
+          textOverride: responseText,
+        })
+        if (normalizedResponse) {
+          yield* socialChatHistoryService.upsertMessages([normalizedResponse])
+        }
+
+        const priorHistoryMessages = toHistoryMessages(priorHistory)
+        const agentMessages = normalizedResponse ? buildAgentHistoryMessages([normalizedResponse]) : []
+        if (messageContext.text && agentMessages.length > 0) {
+          yield* effectTryPromise(() =>
+            safeEnqueue(
+              () =>
+                enqueuePostChatMemory(
+                  {
+                    orgId: workspaceIdString,
+                    threadId: `social:slack:${messageContext.threadId}`,
+                    sourceId: createSocialChatCursorId({
+                      workspaceId: workspaceIdString,
+                      threadId: messageContext.threadId,
+                      messageId: messageContext.messageId,
+                    }),
+                    userMessage: messageContext.text,
+                    historyMessages: priorHistoryMessages,
+                    agentMessages,
+                    memoryBlock: memoryBlock.trim() ? memoryBlock : undefined,
+                    source: 'social_chat',
+                    sourceMetadata: {
+                      platform: 'slack',
+                      channelId: messageContext.channelId,
+                      threadId: messageContext.threadId,
+                      messageId: messageContext.messageId,
+                      authorId: messageContext.authorId,
+                      authorName: messageContext.authorName,
+                    },
+                  },
+                  {
+                    dedupeKey: createSocialMemoryDedupeKey({
+                      workspaceId: workspaceIdString,
+                      threadId: messageContext.threadId,
+                      messageId: messageContext.messageId,
+                    }),
+                  },
+                ),
+              { operationName: 'social post-chat memory extraction enqueue' },
+            ),
+          )
+        }
+
+        yield* effectTryPromise(() =>
+          safeEnqueue(() => enqueueRegularChatMemoryDigest({ orgId: workspaceIdString }), {
+            operationName: 'social regular chat memory digest enqueue',
+          }),
+        )
+        yield* effectTryPromise(() =>
+          safeEnqueue(() => enqueueSkillExtraction({ orgId: workspaceIdString }), {
+            operationName: 'social skill extraction enqueue',
+          }),
+        )
+      }),
+    )
+
+  chat.onNewMention((thread, message) => {
+    aiLogger.debug`Slack social-chat new mention received: threadId=${thread.id}, messageId=${message.id}`
+    return Effect.runPromise(
+      Effect.gen(function* () {
+        yield* effectTryPromise(() => thread.subscribe())
+        return yield* handleMessage(thread, message)
+      }),
+    )
+  })
+  chat.onSubscribedMessage((thread, message) => {
+    aiLogger.debug`Slack social-chat subscribed thread message received: threadId=${thread.id}, messageId=${message.id}`
+    return Effect.runPromise(handleMessage(thread, message))
+  })
+
+  return {
+    enabled: true,
+    initialize,
+    shutdown,
+    webhooks: {
+      slack: (request: Request, options?: WebhookOptions) =>
+        Effect.runPromise(effectTryPromise(() => chat.webhooks.slack(request, options))),
+    },
+  }
+}

package/src/runtime/specialist-runner.ts

@@ -1,18 +1,44 @@
 import type { ToolSet } from 'ai'
+import { Schema, Effect } from 'effect'
 
-export async function runSpecialistSession<TResult>(params: {
+class SpecialistRunnerError extends Schema.TaggedErrorClass<SpecialistRunnerError>()('SpecialistRunnerError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+function runSpecialistSessionEffect<TResult>(params: {
   initialMemoryBlock: string
   buildTools: (options: { memoryBlock: string; onAppendMemoryBlock: (value: string) => void }) => Promise<ToolSet>
   run: (options: { tools: ToolSet; memoryBlock: string }) => Promise<TResult>
-}): Promise<{ result: TResult; memoryBlock: string }> {
-  let specialistMemoryBlock = params.initialMemoryBlock
-  const tools = await params.buildTools({
-    memoryBlock: specialistMemoryBlock,
-    onAppendMemoryBlock: (value) => {
-      specialistMemoryBlock = value
-    },
+}): Effect.Effect<{ result: TResult; memoryBlock: string }, SpecialistRunnerError> {
+  return Effect.gen(function* () {
+    let specialistMemoryBlock = params.initialMemoryBlock
+    const tools = yield* Effect.tryPromise({
+      try: () =>
+        params.buildTools({
+          memoryBlock: specialistMemoryBlock,
+          onAppendMemoryBlock: (value) => {
+            specialistMemoryBlock = value
+          },
+        }),
+      catch: (error: unknown) =>
+        new SpecialistRunnerError({ message: 'Failed to build specialist tools', cause: error }),
+    })
+
+    const result = yield* Effect.tryPromise({
+      try: () => params.run({ tools, memoryBlock: specialistMemoryBlock }),
+      catch: (error: unknown) =>
+        new SpecialistRunnerError({ message: 'Failed to run specialist session', cause: error }),
+    })
+
+    return { result, memoryBlock: specialistMemoryBlock }
   })
+}
 
-  const result = await params.run({ tools, memoryBlock: specialistMemoryBlock })
-  return { result, memoryBlock: specialistMemoryBlock }
+export function runSpecialistSession<TResult>(params: {
+  initialMemoryBlock: string
+  buildTools: (options: { memoryBlock: string; onAppendMemoryBlock: (value: string) => void }) => Promise<ToolSet>
+  run: (options: { tools: ToolSet; memoryBlock: string }) => Promise<TResult>
+}): Promise<{ result: TResult; memoryBlock: string }> {
+  return Effect.runPromise(runSpecialistSessionEffect(params))
 }