@lota-sdk/core 0.1.16 → 0.1.17

package/src/runtime/social-chat.ts

@@ -0,0 +1,752 @@
+import { createSlackAdapter } from '@chat-adapter/slack'
+import { createIoRedisState } from '@chat-adapter/state-ioredis'
+import {
+  buildSlackSocialReplyMarkdown,
+  CONSULT_SPECIALIST_TOOL_NAME,
+  ConsultSpecialistArgsSchema,
+  stripSlackToolExecutionNoticeMarkdown,
+} from '@lota-sdk/shared'
+import type { ChatMessage, ConsultSpecialistArgs } from '@lota-sdk/shared'
+import { stepCountIs, tool as createTool } from 'ai'
+import type { ToolLoopAgent, ToolSet } from 'ai'
+import { Chat, ConsoleLogger } from 'chat'
+import type { Message, Thread, WebhookOptions } from 'chat'
+import type IORedis from 'ioredis'
+
+import {
+  agentDisplayNames,
+  createAgent,
+  getAgentRuntimeConfig,
+  teamConsultParticipants,
+} from '../config/agent-defaults'
+import { aiLogger } from '../config/logger'
+import { recordIdToString } from '../db/record-id'
+import { TABLES } from '../db/tables'
+import { enqueuePostChatMemory } from '../queues/post-chat-memory.queue'
+import { enqueueRegularChatMemoryDigest } from '../queues/regular-chat-memory-digest.queue'
+import { enqueueSkillExtraction } from '../queues/skill-extraction.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 { buildAgentHistoryMessages, extractMessageText, toHistoryMessages } from './workstream-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
+
+type SocialChatAgent = ToolLoopAgent<never, ToolSet>
+
+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 toOptionalTrimmedString(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined
+  const normalized = value.trim()
+  return normalized.length > 0 ? normalized : undefined
+}
+
+function readSlackAuthorName(message: Message): string | undefined {
+  return (
+    toOptionalTrimmedString(message.author.fullName) ??
+    toOptionalTrimmedString(message.author.userName) ??
+    toOptionalTrimmedString(message.author.userId)
+  )
+}
+
+function buildSocialChatIdentitySection(agentDisplayName: string): string {
+  return [
+    '<social-chat-agent>',
+    `You are ${agentDisplayName}, the social chat agent for this workspace.`,
+    '- You respond inside Slack threads.',
+    '- Use the available tools, memories, learned skills, and workspace knowledge before guessing.',
+    '- If the answer may depend on prior workspace decisions, preferences, promises, history, or relationship context, check memory with the available memory tools before answering.',
+    '- If the user shares a URL or asks about a website/page, read it with fetchWebpage before answering. Do not summarize website contents from prior knowledge.',
+    '- When another roster agent is better suited for a question, consult that specialist and then synthesize the final answer yourself.',
+    '- Keep the final reply crisp and readable for Slack unless the user explicitly asks for depth.',
+    '</social-chat-agent>',
+  ].join('\n')
+}
+
+function buildThreadTranscript(
+  messages: Array<{
+    role: 'user' | 'assistant'
+    parts: Array<Record<string, unknown>>
+    metadata?: Record<string, unknown>
+  }>,
+): string {
+  const historyMessages = toHistoryMessages(messages)
+  if (historyMessages.length === 0) return 'No prior thread history.'
+
+  return historyMessages
+    .map((message) =>
+      message.role === 'user' ? `User: ${message.content}` : `${message.agentName ?? 'Assistant'}: ${message.content}`,
+    )
+    .join('\n\n')
+}
+
+function buildLeadAgentPrompt(params: {
+  agentDisplayName: string
+  channelId: string
+  threadId: string
+  transcript: string
+  latestUserMessage: string
+  latestAuthorName?: string
+}): string {
+  return [
+    `Platform: Slack`,
+    `Channel ID: ${params.channelId}`,
+    `Thread ID: ${params.threadId}`,
+    `Current Slack author: ${params.latestAuthorName ?? 'Unknown'}`,
+    '',
+    `You are replying as ${params.agentDisplayName}.`,
+    '',
+    '<thread-transcript>',
+    params.transcript,
+    '</thread-transcript>',
+    '',
+    'Latest user message:',
+    params.latestUserMessage,
+  ].join('\n')
+}
+
+function buildSpecialistPrompt(params: {
+  requesterName: string
+  agentName: string
+  task: string
+  transcript: string
+}): string {
+  return [
+    `${params.requesterName} needs specialist help from ${params.agentName}.`,
+    '',
+    '<thread-transcript>',
+    params.transcript,
+    '</thread-transcript>',
+    '',
+    'Specialist task:',
+    params.task,
+    '',
+    'Answer only with the specialist guidance that should be used in the final Slack reply.',
+  ].join('\n')
+}
+
+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 createCursorId(message: { workspaceId: string; threadId: string; messageId: string }): string {
+  return `social:slack:${message.workspaceId}:${message.threadId}:${message.messageId}`
+}
+
+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('-')
+}
+
+interface ExecutableToolDefinition {
+  execute: (...args: unknown[]) => Promise<unknown>
+}
+
+function withLoggedToolSet(
+  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
+            }
+          },
+        },
+      ]
+    }),
+  )
+}
+
+function normalizeSocialHistoryMessage(params: {
+  workspaceId: string
+  channelId: string
+  agentId: string
+  agentDisplayName: string
+  message: Message
+  textOverride?: string
+}): {
+  source: 'social'
+  sourceId: string
+  platform: 'slack'
+  workspaceId: string
+  channelId: string
+  threadId: string
+  messageId: string
+  role: 'user' | 'assistant'
+  parts: Array<Record<string, unknown>>
+  metadata?: Record<string, unknown>
+  cursor: { createdAt: Date; id: string }
+} | null {
+  const role: 'user' | 'assistant' = params.message.author.isMe ? 'assistant' : 'user'
+  const text = toOptionalTrimmedString(
+    role === 'assistant'
+      ? stripSlackToolExecutionNoticeMarkdown(params.textOverride ?? params.message.text)
+      : (params.textOverride ?? params.message.text),
+  )
+  const fileParts = params.message.attachments.map((attachment) => ({
+    type: 'file',
+    filename: attachment.name ?? 'attachment',
+    mediaType: attachment.mimeType ?? 'application/octet-stream',
+    sizeBytes: typeof attachment.size === 'number' ? attachment.size : null,
+    storageKey: attachment.url ?? 'external',
+  }))
+  const parts = [...(text ? [{ type: 'text', text }] : []), ...fileParts]
+  if (parts.length === 0) return null
+
+  const createdAt = params.message.metadata.dateSent
+  const metadata: Record<string, unknown> = {
+    platform: 'slack',
+    channelId: params.channelId,
+    threadId: params.message.threadId,
+    messageId: params.message.id,
+    authorId: params.message.author.userId,
+    authorName: readSlackAuthorName(params.message),
+  }
+  if (role === 'assistant') {
+    metadata.agentId = params.agentId
+    metadata.agentName = params.agentDisplayName
+  }
+
+  return {
+    source: 'social',
+    sourceId: `slack:${params.channelId}:${params.message.threadId}`,
+    platform: 'slack',
+    workspaceId: params.workspaceId,
+    channelId: params.channelId,
+    threadId: params.message.threadId,
+    messageId: params.message.id,
+    role,
+    parts,
+    metadata,
+    cursor: {
+      createdAt,
+      id: createCursorId({
+        workspaceId: params.workspaceId,
+        threadId: params.message.threadId,
+        messageId: params.message.id,
+      }),
+    },
+  }
+}
+
+async function collectThreadMessages(thread: Thread, incomingMessage: Message): Promise<Message[]> {
+  try {
+    const messages: Message[] = []
+    for await (const message of thread.allMessages) {
+      messages.push(message)
+    }
+    return messages.length > 0 ? messages : [incomingMessage]
+  } catch {
+    return thread.recentMessages.length > 0 ? [...thread.recentMessages] : [incomingMessage]
+  }
+}
+
+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),
+      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().services?.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),
+      summaryBlock: workspaceProfileState?.summaryBlock,
+      structuredProfile: workspaceProfileState?.structuredProfile,
+      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 runtimeConfig = getAgentRuntimeConfig({
+      agentId: socialAgentId,
+      workstreamMode: 'group',
+      mode: 'workstreamMode',
+      onboardingActive: lifecycleState?.bootstrapActive ?? false,
+      linearInstalled: false,
+      systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
+      preSeededMemoriesSection,
+      retrievedKnowledgeSection,
+      learnedSkillsSection,
+      additionalInstructionSections: [buildSocialChatIdentitySection(socialAgentDisplayName)],
+    }) 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 consultParticipants = [
+      ...new Set(
+        (await socialChatConfig.getConsultParticipants?.({
+          workspaceId: resolvedContext.workspaceId,
+          workspaceIdString,
+          platform: 'slack',
+        })) ?? [...teamConsultParticipants],
+      ),
+    ].filter((agentId) => agentId !== socialAgentId)
+    const executedToolNames: string[] = []
+
+    const baseTools = withLoggedToolSet(
+      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 = buildThreadTranscript(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.`)
+        }
+
+        let specialistMemoryBlock = ''
+        const specialistTools = withLoggedToolSet(
+          await socialChatConfig.buildAgentTools(
+            buildBuildToolsParams({
+              agentId,
+              context: resolvedContext,
+              workspaceIdString,
+              userIdString,
+              messageContext,
+              memoryBlock: specialistMemoryBlock,
+              onAppendMemoryBlock: (value: string) => {
+                specialistMemoryBlock = value
+              },
+            }),
+          ),
+          { agentId, channelId: messageContext.channelId, threadId: messageContext.threadId, executedToolNames },
+        )
+        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
+                }),
+        ])
+
+        const specialistRuntimeConfig = getAgentRuntimeConfig({
+          agentId,
+          workstreamMode: 'group',
+          mode: 'fixedWorkstreamMode',
+          onboardingActive: lifecycleState?.bootstrapActive ?? false,
+          linearInstalled: false,
+          systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
+          preSeededMemoriesSection: specialistPreSeededMemories,
+          retrievedKnowledgeSection,
+          learnedSkillsSection: specialistLearnedSkills,
+          additionalInstructionSections: [
+            `You are supporting ${socialAgentDisplayName} in a Slack social-chat thread. Stay within your role.`,
+          ],
+        }) as Record<string, unknown>
+        const specialistFactory = createAgent[specialistRuntimeConfig.id as string]
+        if (typeof specialistFactory !== 'function') {
+          throw new Error(`Social specialist agent factory is not configured for ${String(specialistRuntimeConfig.id)}`)
+        }
+
+        const specialistAgent = specialistFactory({
+          mode: 'fixedWorkstreamMode',
+          tools: specialistTools,
+          extraInstructions: specialistRuntimeConfig.extraInstructions,
+          stopWhen: [stepCountIs(specialistRuntimeConfig.maxSteps as number)],
+        }) as SocialChatAgent
+        const specialistResponse = await specialistAgent.generate({
+          prompt: buildSpecialistPrompt({
+            requesterName: socialAgentDisplayName,
+            agentName: agentDisplayNames[agentId] ?? agentId,
+            task,
+            transcript,
+          }),
+          abortSignal: runAbort.signal,
+        })
+        const text = specialistResponse.text.trim()
+        if (!text) {
+          throw new Error(`Specialist ${agentId} returned an empty response.`)
+        }
+
+        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.`,
+        }
+      },
+    })
+
+    const agent = agentFactory({
+      mode: 'workstreamMode',
+      tools: { ...baseTools, [CONSULT_SPECIALIST_TOOL_NAME]: consultSpecialistTool },
+      extraInstructions: runtimeConfig.extraInstructions,
+      stopWhen: [stepCountIs(runtimeConfig.maxSteps as number)],
+    }) as SocialChatAgent
+
+    await thread.startTyping('Thinking...').catch(() => undefined)
+    aiLogger.info`Slack social-chat generating reply: channelId=${messageContext.channelId}, threadId=${messageContext.threadId}`
+    const response = await agent.generate({
+      prompt: buildLeadAgentPrompt({
+        agentDisplayName: socialAgentDisplayName,
+        channelId: messageContext.channelId,
+        threadId: messageContext.threadId,
+        transcript,
+        latestUserMessage: messageContext.text,
+        latestAuthorName: messageContext.authorName,
+      }),
+      abortSignal: runAbort.signal,
+    })
+    const responseText = response.text.trim()
+    if (!responseText) {
+      throw new Error('Social chat agent returned an empty response.')
+    }
+
+    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,
+              workstreamId: `social:slack:${messageContext.threadId}`,
+              sourceId: createCursorId({
+                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)
+      },
+    },
+  }
+}