@lota-sdk/core 0.4.7 → 0.4.9

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

@@ -0,0 +1,594 @@
+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 } from 'effect'
+import { Cause, Clock, Effect } 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 { 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>
+}
+
+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, never> =>
+    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.info`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.info`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 Cause.UnknownError(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 = createServerRunAbortController()
+
+      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 Cause.UnknownError(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.info`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.info`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.info`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.info`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))
 }