@lota-sdk/core 0.4.8 → 0.4.10

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

@@ -1,118 +0,0 @@
-import { stepCountIs } from 'ai'
-import type { ToolLoopAgent, ToolSet } from 'ai'
-
-import { createAgent, getAgentRuntimeConfig } from '../config/agent-defaults'
-import { aiLogger } from '../config/logger'
-
-type SocialChatAgent = ToolLoopAgent<never, ToolSet>
-
-interface ExecutableToolDefinition {
-  execute: (...args: unknown[]) => Promise<unknown>
-}
-
-const SOCIAL_CHAT_RETRIEVAL_TOOL_NAMES = [
-  'memorySearch',
-  'conversationSearch',
-  'queryKnowledge',
-  'researchTopic',
-  'searchWeb',
-  'fetchWebpage',
-  'inspectWebsite',
-] as const
-
-export function withLoggedSocialToolSet(
-  tools: ToolSet,
-  params: { agentId: string; channelId: string; threadId: string; executedToolNames: string[] },
-): ToolSet {
-  return Object.fromEntries(
-    Object.entries(tools).map(([toolName, toolDefinition]) => {
-      if (
-        typeof toolDefinition !== 'object' ||
-        !('execute' in toolDefinition) ||
-        typeof toolDefinition.execute !== 'function'
-      ) {
-        return [toolName, toolDefinition]
-      }
-
-      const executableTool = toolDefinition as typeof toolDefinition & ExecutableToolDefinition
-      return [
-        toolName,
-        {
-          ...toolDefinition,
-          execute: async (...args: unknown[]): Promise<unknown> => {
-            aiLogger.info`Slack social-chat tool start: agentId=${params.agentId}, tool=${toolName}, channelId=${params.channelId}, threadId=${params.threadId}`
-            try {
-              const result: unknown = await executableTool.execute(...args)
-              params.executedToolNames.push(toolName)
-              aiLogger.info`Slack social-chat tool finish: agentId=${params.agentId}, tool=${toolName}, channelId=${params.channelId}, threadId=${params.threadId}`
-              return result
-            } catch (error) {
-              aiLogger.warn`Slack social-chat tool failed: agentId=${params.agentId}, tool=${toolName}, channelId=${params.channelId}, threadId=${params.threadId}, error=${error}`
-              throw error
-            }
-          },
-        },
-      ]
-    }),
-  )
-}
-
-export async function runSocialAgentTurn(params: {
-  agentId: string
-  mode: 'fixedThreadMode' | 'threadMode'
-  threadType: 'group'
-  onboardingActive: boolean
-  linearInstalled: boolean
-  systemWorkspaceDetails?: string
-  preSeededMemoriesSection?: string
-  retrievedKnowledgeSection?: string
-  learnedSkillsSection?: string
-  userMessageText?: string
-  additionalInstructionSections?: string[]
-  prompt: string
-  tools: ToolSet
-  abortSignal: AbortSignal
-}): Promise<{ text: string; displayName: string }> {
-  const runtimeConfig = getAgentRuntimeConfig({
-    agentId: params.agentId,
-    threadType: params.threadType,
-    mode: params.mode,
-    onboardingActive: params.onboardingActive,
-    linearInstalled: params.linearInstalled,
-    systemWorkspaceDetails: params.systemWorkspaceDetails,
-    preSeededMemoriesSection: params.preSeededMemoriesSection,
-    retrievedKnowledgeSection: params.retrievedKnowledgeSection,
-    learnedSkillsSection: params.learnedSkillsSection,
-    userMessageText: params.userMessageText,
-    ruleOptions: {
-      includeMemr3Rule: SOCIAL_CHAT_RETRIEVAL_TOOL_NAMES.some((toolName) => toolName in params.tools),
-      includeDomainReasoningFallbackRule: params.agentId === 'cpo' || params.agentId === 'mentor',
-    },
-    additionalInstructionSections: params.additionalInstructionSections,
-  }) as Record<string, unknown>
-
-  const agentFactory = createAgent[runtimeConfig.id as string]
-  if (typeof agentFactory !== 'function') {
-    throw new Error(`Social chat agent factory is not configured for ${String(runtimeConfig.id)}`)
-  }
-
-  const agent = agentFactory({
-    mode: params.mode,
-    tools: params.tools,
-    extraInstructions: runtimeConfig.extraInstructions,
-    stopWhen: [stepCountIs(runtimeConfig.maxSteps as number)],
-  }) as SocialChatAgent
-  const response = await agent.generate({ prompt: params.prompt, abortSignal: params.abortSignal })
-  const text = response.text.trim()
-  if (!text) {
-    throw new Error(`Social chat agent ${params.agentId} returned an empty response.`)
-  }
-
-  return {
-    text,
-    displayName:
-      typeof runtimeConfig.displayName === 'string' && runtimeConfig.displayName.trim()
-        ? runtimeConfig.displayName.trim()
-        : params.agentId,
-  }
-}

package/src/runtime/social-chat.ts

@@ -1,516 +0,0 @@
-import { createSlackAdapter } from '@chat-adapter/slack'
-import { createIoRedisState } 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 IORedis from 'ioredis'
-
-import { agentDisplayNames, teamConsultParticipants } from '../config/agent-defaults'
-import { aiLogger } from '../config/logger'
-import { recordIdToString } from '../db/record-id'
-import { TABLES } from '../db/tables'
-import { enqueueRegularChatMemoryDigest, enqueueSkillExtraction } from '../queues/organization-learning.queue'
-import { enqueuePostChatMemory } from '../queues/post-chat-memory.queue'
-import type {
-  BuildSocialChatAgentToolsParams,
-  LotaRuntimeSocialChatConfig,
-  LotaSocialChatResolvedContext,
-} from '../runtime/runtime-config'
-import { getRuntimeAdapters } from '../runtime/runtime-extensions'
-import { learnedSkillService } from '../services/learned-skill.service'
-import { memoryService } from '../services/memory.service'
-import { socialChatHistoryService } from '../services/social-chat-history.service'
-import { safeEnqueue } from '../utils/async'
-import { buildAgentPromptContext } from './agent-prompt-context'
-import { createServerRunAbortController } from './agent-stream-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'
-import { runSpecialistSession } from './specialist-runner'
-import {
-  buildAgentHistoryMessages,
-  extractMessageText,
-  toHistoryMessages,
-  toOptionalTrimmedString,
-} from './thread-chat-helpers'
-
-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> }
-}
-
-interface SlackSocialMessageContext {
-  channelId: string
-  threadId: string
-  messageId: string
-  text: string
-  authorId?: string
-  authorName?: string
-}
-
-function createDisabledSocialChatRuntime(): LotaRuntimeSocialChat {
-  return {
-    enabled: false,
-    async initialize() {},
-    async shutdown() {},
-    webhooks: {
-      async slack() {
-        return new Response('Social chat is disabled.', { status: 404 })
-      },
-    },
-  }
-}
-
-function createAssistantMessage(params: { agentId: string; agentName: string; text: string }): ChatMessage {
-  return {
-    id: Bun.randomUUIDv7(),
-    role: 'assistant',
-    parts: [{ type: 'text', text: params.text }],
-    metadata: { agentId: params.agentId, agentName: params.agentName, createdAt: Date.now() },
-  }
-}
-
-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: IORedis
-  socialChat?: LotaRuntimeSocialChatConfig
-}): 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 = async () => {
-    await chat.initialize()
-  }
-
-  const shutdown = async () => {
-    await chat.shutdown()
-  }
-
-  const handleMessage = async (thread: Thread, incomingMessage: Message) => {
-    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 = await 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 = await 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)
-    await socialChatHistoryService.upsertMessages(normalizedMessages)
-
-    const historyBeforeReply = await 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 workspace = workspaceProvider ? await workspaceProvider.getWorkspace(resolvedContext.workspaceId) : {}
-    const lifecycleState = workspaceProvider ? await workspaceProvider.getLifecycleState?.(workspace) : undefined
-    const workspaceProfileState = workspaceProvider
-      ? await workspaceProvider.readProfileProjectionState?.(workspace)
-      : undefined
-    const [recentDomainEvents, promptSummary] = await Promise.all([
-      workspaceProvider?.listRecentDomainEvents?.(resolvedContext.workspaceId, 5) ??
-        Promise.resolve([] as Array<Record<string, unknown>>),
-      workspaceProvider?.buildPromptSummary
-        ? workspaceProvider.buildPromptSummary(resolvedContext.workspaceId).catch(() => undefined)
-        : Promise.resolve(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
-        : await workspaceProvider?.buildRetrievedKnowledgeSection?.({
-            workspaceId: workspaceIdString,
-            userId: userIdString,
-            query: messageContext.text,
-          })
-
-    const [preSeededMemoriesSection, learnedSkillsSection] = await Promise.all([
-      memoryService.getTopMemories({
-        orgId: workspaceIdString,
-        agentName: socialAgentId,
-        limit: PRESEEDED_MEMORY_LOOKUP_LIMIT,
-      }),
-      lifecycleState?.bootstrapActive
-        ? Promise.resolve(undefined)
-        : learnedSkillService
-            .retrieveForTurn({
-              orgId: workspaceIdString,
-              agentId: socialAgentId,
-              query: messageContext.text,
-              limit: 3,
-              minConfidence: 0.6,
-            })
-            .catch((error) => {
-              aiLogger.warn`Failed to retrieve learned skills for ${socialAgentId}: ${error}`
-              return undefined
-            }),
-    ])
-
-    let memoryBlock = ''
-    const consultParticipants = [
-      ...new Set(
-        (await socialChatConfig.getConsultParticipants?.({
-          workspaceId: resolvedContext.workspaceId,
-          workspaceIdString,
-          platform: 'slack',
-        })) ?? [...teamConsultParticipants],
-      ),
-    ].filter((agentId) => agentId !== socialAgentId)
-    const executedToolNames: string[] = []
-
-    const baseTools = withLoggedSocialToolSet(
-      await 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: async ({ agentId, task }: ConsultSpecialistArgs) => {
-        if (!consultParticipants.includes(agentId)) {
-          throw new Error(`Agent "${agentId}" is not an allowed social-chat specialist.`)
-        }
-
-        const { result: specialistRun } = await runSpecialistSession({
-          initialMemoryBlock: '',
-          buildTools: async ({ memoryBlock: currentMemoryBlock, onAppendMemoryBlock }) =>
-            withLoggedSocialToolSet(
-              await socialChatConfig.buildAgentTools(
-                buildBuildToolsParams({
-                  agentId,
-                  context: resolvedContext,
-                  workspaceIdString,
-                  userIdString,
-                  messageContext,
-                  memoryBlock: currentMemoryBlock,
-                  onAppendMemoryBlock,
-                }),
-              ),
-              { agentId, channelId: messageContext.channelId, threadId: messageContext.threadId, executedToolNames },
-            ),
-          run: async ({ tools }) => {
-            const [specialistPreSeededMemories, specialistLearnedSkills] = await Promise.all([
-              memoryService.getTopMemories({
-                orgId: workspaceIdString,
-                agentName: agentId,
-                limit: PRESEEDED_MEMORY_LOOKUP_LIMIT,
-              }),
-              lifecycleState?.bootstrapActive
-                ? Promise.resolve(undefined)
-                : learnedSkillService
-                    .retrieveForTurn({ orgId: workspaceIdString, agentId, query: task, limit: 3, minConfidence: 0.6 })
-                    .catch((error) => {
-                      aiLogger.warn`Failed to retrieve learned skills for ${agentId}: ${error}`
-                      return undefined
-                    }),
-            ])
-
-            return await 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: agentDisplayNames[agentId] ?? agentId,
-                task,
-                transcript,
-              }),
-              abortSignal: runAbort.signal,
-            })
-          },
-        })
-        const text = specialistRun.text
-
-        return createAssistantMessage({ agentId, agentName: agentDisplayNames[agentId] ?? agentId, text })
-      },
-      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.`,
-        }
-      },
-    })
-
-    await thread.startTyping('Thinking...').catch(() => undefined)
-    aiLogger.info`Slack social-chat generating reply: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}`
-    const leadRun = await 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 = await 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) {
-      await socialChatHistoryService.upsertMessages([normalizedResponse])
-    }
-
-    const priorHistoryMessages = toHistoryMessages(priorHistory)
-    const agentMessages = normalizedResponse ? buildAgentHistoryMessages([normalizedResponse]) : []
-    if (messageContext.text && agentMessages.length > 0) {
-      await 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' },
-      )
-    }
-
-    await safeEnqueue(() => enqueueRegularChatMemoryDigest({ orgId: workspaceIdString }), {
-      operationName: 'social regular chat memory digest enqueue',
-    })
-    await safeEnqueue(() => enqueueSkillExtraction({ orgId: workspaceIdString }), {
-      operationName: 'social skill extraction enqueue',
-    })
-  }
-
-  chat.onNewMention(async (thread, message) => {
-    aiLogger.info`Slack social-chat new mention received: threadId=${thread.id}, messageId=${message.id}`
-    await thread.subscribe()
-    await handleMessage(thread, message)
-  })
-  chat.onSubscribedMessage(async (thread, message) => {
-    aiLogger.info`Slack social-chat subscribed thread message received: threadId=${thread.id}, messageId=${message.id}`
-    await handleMessage(thread, message)
-  })
-
-  return {
-    enabled: true,
-    initialize,
-    shutdown,
-    webhooks: {
-      async slack(request: Request, options?: WebhookOptions) {
-        return chat.webhooks.slack(request, options)
-      },
-    },
-  }
-}