@lota-sdk/core 0.1.24 → 0.1.25

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

@@ -0,0 +1,119 @@
+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: 'fixedWorkstreamMode' | 'workstreamMode'
+  workstreamMode: '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,
+    workstreamMode: params.workstreamMode,
+    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: {
+      includeExecutionPlanRule: false,
+      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-history.ts

@@ -0,0 +1,110 @@
+import { stripSlackToolExecutionNoticeMarkdown } from '@lota-sdk/shared'
+import type { Message, Thread } from 'chat'
+
+import type { SocialChatHistoryMessage } from '../services/social-chat-history.service'
+import { toHistoryMessages, toOptionalTrimmedString } from './workstream-chat-helpers'
+
+export function readSlackAuthorName(message: Message): string | undefined {
+  return (
+    toOptionalTrimmedString(message.author.fullName) ??
+    toOptionalTrimmedString(message.author.userName) ??
+    toOptionalTrimmedString(message.author.userId) ??
+    undefined
+  )
+}
+
+export function buildSocialChatThreadTranscript(
+  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')
+}
+
+export function createSocialChatCursorId(message: {
+  workspaceId: string
+  threadId: string
+  messageId: string
+}): string {
+  return `social:slack:${message.workspaceId}:${message.threadId}:${message.messageId}`
+}
+
+export function normalizeSocialHistoryMessage(params: {
+  workspaceId: string
+  channelId: string
+  agentId: string
+  agentDisplayName: string
+  message: Message
+  textOverride?: string
+}): SocialChatHistoryMessage | 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 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: params.message.metadata.dateSent,
+      id: createSocialChatCursorId({
+        workspaceId: params.workspaceId,
+        threadId: params.message.threadId,
+        messageId: params.message.id,
+      }),
+    },
+  }
+}
+
+export 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]
+  }
+}

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

@@ -0,0 +1,58 @@
+export 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')
+}
+
+export function buildLeadSocialChatPrompt(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')
+}
+
+export function buildSpecialistSocialChatPrompt(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')
+}