@lota-sdk/core 0.1.5

package/src/runtime/workstream-chat-helpers.ts

@@ -0,0 +1,187 @@
+import { agentDisplayNames, resolveAgentNameAlias } from '../config/agent-defaults'
+import type { ChatMessageLike, ReadableUploadMetadataLike } from './chat-types'
+
+export interface WorkstreamHistoryMessage {
+  role: 'user' | 'agent'
+  content: string
+  agentName?: string
+}
+
+function getAgentName(message: ChatMessageLike): string | undefined {
+  const metadata = message.metadata
+  if (!metadata || typeof metadata !== 'object') return undefined
+  const value = (metadata as Record<string, unknown>).agentName
+  if (typeof value !== 'string' || !value.trim()) return undefined
+  const resolvedAgentName = resolveAgentNameAlias(value)
+  return resolvedAgentName ? (agentDisplayNames[resolvedAgentName] ?? value.trim()) : value.trim()
+}
+
+function truncateTrackerText(value: string, maxChars: number): string {
+  return value.length <= maxChars ? value : `${value.slice(0, maxChars).trimEnd()}...`
+}
+
+function toTrackerToolLine(part: ChatMessageLike['parts'][number]): string | null {
+  if (typeof part !== 'object') return null
+  const record = part as Record<string, unknown>
+  const type = typeof record.type === 'string' ? record.type : null
+  if (!type?.startsWith('tool-')) return null
+
+  const toolName = type.slice('tool-'.length) || 'unknown'
+  const state = typeof record.state === 'string' ? record.state : null
+  const input = record.input
+  const output = record.output
+
+  const inputTask =
+    input && typeof input === 'object' && typeof (input as Record<string, unknown>).task === 'string'
+      ? truncateTrackerText(((input as Record<string, unknown>).task as string).trim(), 220)
+      : null
+  const outputSummary =
+    output && typeof output === 'object' && typeof (output as Record<string, unknown>).summary === 'string'
+      ? truncateTrackerText(((output as Record<string, unknown>).summary as string).trim(), 220)
+      : null
+  const outputResult =
+    output && typeof output === 'object' && typeof (output as Record<string, unknown>).result === 'string'
+      ? truncateTrackerText(((output as Record<string, unknown>).result as string).trim(), 220)
+      : null
+  const errorText = typeof record.errorText === 'string' ? truncateTrackerText(record.errorText.trim(), 220) : null
+
+  if (state === 'output-error') {
+    return errorText ? `Tool ${toolName} failed: ${errorText}` : `Tool ${toolName} failed.`
+  }
+
+  if (state !== 'output-available') {
+    return inputTask ? `Tool ${toolName} ran for: ${inputTask}` : `Tool ${toolName} ran.`
+  }
+
+  if (outputSummary) return `Tool ${toolName} completed: ${outputSummary}`
+  if (inputTask) return `Tool ${toolName} completed for: ${inputTask}`
+  if (outputResult) return `Tool ${toolName} completed: ${outputResult}`
+  return `Tool ${toolName} completed.`
+}
+
+export function extractMessageText(message: ChatMessageLike): string {
+  return message.parts
+    .flatMap((part) => (part.type === 'text' && typeof part.text === 'string' ? [part.text] : []))
+    .join('\n')
+    .trim()
+}
+
+export function extractTrackerMessageText(message: ChatMessageLike): string {
+  const textParts = message.parts.flatMap((part) =>
+    part.type === 'text' && typeof part.text === 'string' ? [part.text] : [],
+  )
+  const toolParts = message.parts
+    .map((part) => toTrackerToolLine(part))
+    .filter((value): value is string => Boolean(value))
+
+  return [...textParts, ...toolParts].join('\n').trim()
+}
+
+export function toHistoryMessages(messages: ChatMessageLike[], maxItems = 24): WorkstreamHistoryMessage[] {
+  return messages
+    .map((message): WorkstreamHistoryMessage | null => {
+      const content = extractMessageText(message)
+      if (!content) return null
+
+      if (message.role === 'user') {
+        return { role: 'user', content }
+      }
+      if (message.role === 'assistant') {
+        const agentName = getAgentName(message)
+        return { role: 'agent', content, ...(agentName ? { agentName } : {}) }
+      }
+      return null
+    })
+    .filter((message): message is WorkstreamHistoryMessage => message !== null)
+    .slice(-maxItems)
+}
+
+export function buildConversationSummary(params: {
+  userMessageText: string
+  assistantMessages: ChatMessageLike[]
+}): string {
+  const lines: string[] = []
+  if (params.userMessageText.trim()) {
+    lines.push(`User: ${params.userMessageText.trim()}`)
+  }
+
+  for (const message of params.assistantMessages) {
+    const content = extractMessageText(message)
+    if (!content) continue
+    const agentName = getAgentName(message)
+    lines.push(agentName ? `${agentName}: ${content}` : `Assistant: ${content}`)
+  }
+
+  return lines.join('\n\n').trim()
+}
+
+export function buildAgentHistoryMessages(messages: ChatMessageLike[]): Array<{ content: string; agentName?: string }> {
+  return toHistoryMessages(messages)
+    .filter((message) => message.role === 'agent')
+    .map((message) => ({ content: message.content, ...(message.agentName ? { agentName: message.agentName } : {}) }))
+}
+
+export function appendCompactionContextToHistoryMessages(
+  historyMessages: WorkstreamHistoryMessage[],
+  params: { chatSummary?: string | null; persistedState?: unknown },
+): WorkstreamHistoryMessage[] {
+  const nextHistoryMessages = [...historyMessages]
+  const chatSummary = typeof params.chatSummary === 'string' ? params.chatSummary.trim() : ''
+  if (chatSummary) {
+    nextHistoryMessages.push({ role: 'agent', content: `Compacted chat summary:\n${chatSummary}` })
+  }
+
+  if (params.persistedState !== undefined && params.persistedState !== null) {
+    nextHistoryMessages.push({
+      role: 'agent',
+      content: `Structured workstream state:\n${JSON.stringify(params.persistedState)}`,
+    })
+  }
+
+  return nextHistoryMessages
+}
+
+export function buildReadableUploadMetadataContext(uploads: ReadableUploadMetadataLike[]): string | undefined {
+  if (uploads.length === 0) return undefined
+
+  return [
+    'Uploaded files metadata:',
+    ...uploads.map((upload) => {
+      const sizeSegment = upload.sizeBytes === null ? '' : `, sizeBytes=${upload.sizeBytes}`
+      return `- ${upload.filename} (${upload.mediaType}${sizeSegment}) storageKey=${upload.storageKey}`
+    }),
+  ].join('\n')
+}
+
+export function toOptionalTrimmedString(value: unknown): string | null {
+  if (typeof value !== 'string') return null
+  const normalized = value.trim()
+  return normalized.length > 0 ? normalized : null
+}
+
+export function collectToolOutputErrors(params: {
+  responseMessage: ChatMessageLike
+}): Array<{ toolName: string; toolCallId: string; errorText: string }> {
+  const errors: Array<{ toolName: string; toolCallId: string; errorText: string }> = []
+
+  for (const part of params.responseMessage.parts) {
+    if (typeof part !== 'object') continue
+    if (part.type !== undefined && typeof part.type !== 'string') continue
+    if (!part.type?.startsWith('tool-')) continue
+    if ((part as Record<string, unknown>).state !== 'output-error') continue
+
+    const toolName = part.type.slice('tool-'.length) || 'unknown'
+    const toolCallId =
+      typeof (part as Record<string, unknown>).toolCallId === 'string' && (part as Record<string, unknown>).toolCallId
+        ? ((part as Record<string, unknown>).toolCallId as string)
+        : 'unknown'
+    const errorTextRaw = (part as Record<string, unknown>).errorText
+    const errorText =
+      typeof errorTextRaw === 'string' && errorTextRaw.trim()
+        ? errorTextRaw.trim()
+        : 'Tool execution failed without explicit error text.'
+    errors.push({ toolName, toolCallId, errorText })
+  }
+
+  return errors
+}

package/src/runtime/workstream-routing-policy.ts

@@ -0,0 +1,301 @@
+import { extractAgentMentions } from '../config/agent-defaults'
+
+export type MessageRoute =
+  | { type: 'direct'; agents: [string] }
+  | { type: 'mentions'; agents: string[] }
+  | { type: 'group-default'; agents: [string] }
+
+export type ReasoningProfileName = 'fast' | 'standard' | 'deep'
+
+export interface ReasoningProfile {
+  name: ReasoningProfileName
+  maxSteps: number
+  toolCallBudget: number
+  maxInputTokensHint: number
+}
+
+export type HighImpactResponseClass =
+  | 'architecture-recommendation'
+  | 'gtm-strategy'
+  | 'pricing-positioning'
+  | 'product-capability-claim'
+  | 'community-targeting'
+  | 'mutating-operation'
+
+export type PolicyClass = 'external-mutation' | 'security-privacy' | 'legal-compliance' | 'financial-decision'
+
+export function uniqueMentionOrder(message: string): string[] {
+  const ordered: string[] = []
+  const seen = new Set<string>()
+  for (const mention of extractAgentMentions(message)) {
+    const agent = mention.agent
+    if (seen.has(agent)) continue
+    seen.add(agent)
+    ordered.push(agent)
+  }
+  return ordered
+}
+
+const GTM_STRONG_INTENT_PATTERNS: RegExp[] = [
+  /\bgo[-\s]?to[-\s]?market\b/i,
+  /\bgtm\b/i,
+  /\bcontent\s+marketing\b/i,
+  /\bcontent\s+strategy\b/i,
+  /\bdemand\s+generation\b/i,
+  /\bdistribution\s+strategy\b/i,
+  /\bpositioning\s+strategy\b/i,
+  /\blaunch\s+strategy\b/i,
+  /\blaunch\s+plan\b/i,
+]
+
+const GTM_WEAK_INTENT_PATTERNS: RegExp[] = [/\blaunch\b/i, /\bcommunity\b/i, /\bdistribution\b/i, /\bpositioning\b/i]
+
+export function isGtmIntentMessage(message: string): boolean {
+  const text = message.trim()
+  if (!text) return false
+
+  if (GTM_STRONG_INTENT_PATTERNS.some((pattern) => pattern.test(text))) {
+    return true
+  }
+
+  let weakMatches = 0
+  for (const pattern of GTM_WEAK_INTENT_PATTERNS) {
+    if (pattern.test(text)) weakMatches += 1
+    if (weakMatches >= 2) return true
+  }
+  return false
+}
+
+const HIGH_IMPACT_CLASS_PATTERNS: Array<{ className: HighImpactResponseClass; patterns: RegExp[] }> = [
+  {
+    className: 'architecture-recommendation',
+    patterns: [
+      /\barchitecture\b/i,
+      /\btech(?:nical)?\s+stack\b/i,
+      /\binfra(?:structure)?\b/i,
+      /\brefactor\b/i,
+      /\bsystem\s+design\b/i,
+    ],
+  },
+  {
+    className: 'gtm-strategy',
+    patterns: [
+      /\bgo[-\s]?to[-\s]?market\b/i,
+      /\bgtm\b/i,
+      /\bdistribution\s+strategy\b/i,
+      /\blaunch\s+strategy\b/i,
+      /\bcontent\s+strategy\b/i,
+      /\bdemand\s+gen(?:eration)?\b/i,
+    ],
+  },
+  {
+    className: 'pricing-positioning',
+    patterns: [/\bpricing\b/i, /\bpositioning\b/i, /\bpackaging\b/i, /\bfreemium\b/i, /\bbilling\b/i],
+  },
+  {
+    className: 'product-capability-claim',
+    patterns: [
+      /\bdoes\s+it\s+(already\s+)?(support|have|do)\b/i,
+      /\bwhat\s+can\s+(it|we)\s+do\b/i,
+      /\bis\s+this\s+implemented\b/i,
+      /\bcurrent(?:ly)?\s+supports?\b/i,
+      /\bcapabilities?\b/i,
+    ],
+  },
+  {
+    className: 'community-targeting',
+    patterns: [
+      /\bwhere\s+to\s+post\b/i,
+      /\bcommunity\b/i,
+      /\btarget\s+audience\b/i,
+      /\bchannels?\b/i,
+      /\bdistribution\s+channels?\b/i,
+    ],
+  },
+  {
+    className: 'mutating-operation',
+    patterns: [
+      /\bdelete\s+(issue|comment|task|record|workspace|project)\b/i,
+      /\bremove\s+(issue|comment|task|record|workspace|project)\b/i,
+      /\bupdate\s+(issue|comment|task|record|workspace|project)\b/i,
+      /\bcreate\s+(issue|comment|task|record|workspace|project)\b/i,
+      /\bchange\s+(issue|comment|task|record|workspace|project)\b/i,
+      /\barchive\b/i,
+      /\bskip\s+onboarding\b/i,
+      /\bproceed\s+in\s+onboarding\b/i,
+    ],
+  },
+]
+
+const POLICY_CLASS_PATTERNS: Array<{ className: PolicyClass; patterns: RegExp[] }> = [
+  {
+    className: 'external-mutation',
+    patterns: [
+      /\bdelete\s+(issue|comment|task|record|workspace|project)\b/i,
+      /\bremove\s+(issue|comment|task|record|workspace|project)\b/i,
+      /\bupdate\s+(issue|comment|task|record|workspace|project)\b/i,
+      /\bcreate\s+(issue|comment|task|record|workspace|project)\b/i,
+      /\bchange\s+(issue|comment|task|record|workspace|project)\b/i,
+      /\barchive\b/i,
+      /\bskip\s+onboarding\b/i,
+      /\bproceed\s+in\s+onboarding\b/i,
+    ],
+  },
+  {
+    className: 'security-privacy',
+    patterns: [
+      /\bsecurity\b/i,
+      /\bprivacy\b/i,
+      /\bpii\b/i,
+      /\bauth(?:entication|orization)?\b/i,
+      /\bencrypt(?:ion|ed)?\b/i,
+      /\bpermission(?:s)?\b/i,
+      /\baccess\s+control\b/i,
+      /\bsecret(?:s)?\b/i,
+    ],
+  },
+  {
+    className: 'legal-compliance',
+    patterns: [
+      /\blegal\b/i,
+      /\bcompliance\b/i,
+      /\bregulation(?:s)?\b/i,
+      /\bgdpr\b/i,
+      /\bhipaa\b/i,
+      /\bsoc\s*2\b/i,
+      /\blicense\b/i,
+      /\bterms?\b/i,
+    ],
+  },
+  {
+    className: 'financial-decision',
+    patterns: [
+      /\bpricing\b/i,
+      /\bbilling\b/i,
+      /\brevenue\b/i,
+      /\bbudget\b/i,
+      /\bburn\s+rate\b/i,
+      /\brunway\b/i,
+      /\bfundrais(?:e|ing)\b/i,
+      /\bcash\s+flow\b/i,
+    ],
+  },
+]
+
+const REASONING_PROFILES: Record<ReasoningProfileName, ReasoningProfile> = {
+  fast: { name: 'fast', maxSteps: 5, toolCallBudget: 3, maxInputTokensHint: 12_000 },
+  standard: { name: 'standard', maxSteps: 10, toolCallBudget: 6, maxInputTokensHint: 24_000 },
+  deep: { name: 'deep', maxSteps: 15, toolCallBudget: 10, maxInputTokensHint: 36_000 },
+}
+
+const STRATEGIC_COMPLEXITY_PATTERNS: RegExp[] = [
+  /\bstrategy\b/i,
+  /\btrade[-\s]?off\b/i,
+  /\bcompare\b/i,
+  /\broadmap\b/i,
+  /\barchitecture\b/i,
+  /\bconstraints?\b/i,
+  /\bprioriti(?:y|es)\b/i,
+]
+
+const CROSS_SOURCE_COMPLEXITY_PATTERNS: RegExp[] = [
+  /\bcitation\b/i,
+  /\bevidence\b/i,
+  /\bsource\b/i,
+  /\bground(?:ed|ing)\b/i,
+  /\brepo\b/i,
+  /\bmemory\b/i,
+]
+
+const STANDARD_FLOOR_INTENT_PATTERNS: RegExp[] = [
+  /\bplan(?:ning)?\b/i,
+  /\bthink(?:ing)?\b/i,
+  /\bcareful(?:ly)?\b/i,
+  /\bimportant\b/i,
+  /\bcritical(?:ly)?\b/i,
+  /\bthorough(?:ly)?\b/i,
+]
+
+export function classifyHighImpactResponse(params: { message: string }): { classes: HighImpactResponseClass[] } {
+  const message = params.message.trim()
+  if (!message) return { classes: [] }
+
+  const classes: HighImpactResponseClass[] = []
+  for (const entry of HIGH_IMPACT_CLASS_PATTERNS) {
+    if (entry.patterns.some((pattern) => pattern.test(message))) {
+      classes.push(entry.className)
+    }
+  }
+
+  return { classes }
+}
+
+export function classifyPolicyClasses(params: { message: string }): { classes: PolicyClass[] } {
+  const message = params.message.trim()
+  if (!message) return { classes: [] }
+
+  const classes: PolicyClass[] = []
+  for (const entry of POLICY_CLASS_PATTERNS) {
+    if (entry.patterns.some((pattern) => pattern.test(message))) {
+      classes.push(entry.className)
+    }
+  }
+
+  return { classes }
+}
+
+export function resolveReasoningProfile(params: {
+  message: string
+  forceDeep?: boolean
+  explicitProfile?: ReasoningProfileName
+}): ReasoningProfile {
+  if (params.explicitProfile) {
+    return REASONING_PROFILES[params.explicitProfile]
+  }
+
+  const text = params.message.trim()
+  if (!text) {
+    return REASONING_PROFILES.standard
+  }
+
+  let score = 0
+  if (text.length >= 700) score += 3
+  else if (text.length >= 350) score += 2
+  else if (text.length >= 180) score += 1
+
+  const numberedListCount = (text.match(/\n\s*\d+\./g) ?? []).length
+  if (numberedListCount >= 3) score += 2
+  else if (numberedListCount >= 1) score += 1
+
+  if (STRATEGIC_COMPLEXITY_PATTERNS.some((pattern) => pattern.test(text))) score += 2
+  if (CROSS_SOURCE_COMPLEXITY_PATTERNS.some((pattern) => pattern.test(text))) score += 2
+  if (params.forceDeep) score += 2
+  if (STANDARD_FLOOR_INTENT_PATTERNS.some((pattern) => pattern.test(text))) {
+    score += 3
+  }
+
+  if (score >= 7) return REASONING_PROFILES.deep
+  if (score >= 3) return REASONING_PROFILES.standard
+  return REASONING_PROFILES.fast
+}
+
+export function resolveMessageRoute(params: {
+  workstreamMode: 'direct' | 'group'
+  workstreamAgentId?: string
+  message: string
+}): MessageRoute {
+  if (params.workstreamMode === 'direct') {
+    return { type: 'direct', agents: [params.workstreamAgentId ?? 'chief'] }
+  }
+
+  const mentions = uniqueMentionOrder(params.message)
+  if (mentions.length > 0) {
+    return { type: 'mentions', agents: mentions }
+  }
+
+  if (isGtmIntentMessage(params.message)) {
+    return { type: 'group-default', agents: ['cmo'] }
+  }
+
+  return { type: 'group-default', agents: ['chief'] }
+}