@lota-sdk/core 0.1.8 → 0.1.11

package/src/services/workstream-turn-preparation.ts

@@ -40,7 +40,7 @@ import { hasApprovalRespondedParts } from '../runtime/approval-continuation'
 import { buildModelInputMessagesWithUploadMetadata, buildReadableUploadMetadataText } from '../runtime/chat-attachments'
 import { hasMessageContent } from '../runtime/chat-message'
 import { waitForCompactionIfNeeded } from '../runtime/chat-run-orchestration'
-import { mergeStateDelta, parseWorkstreamState } from '../runtime/context-compaction'
+import { parseWorkstreamState } from '../runtime/context-compaction'
 import { CONTEXT_SIZE } from '../runtime/context-compaction-constants'
 import { createExecutionPlanInstructionSectionCache } from '../runtime/execution-plan'
 import { mergeInstructionSections } from '../runtime/instruction-sections'
@@ -54,13 +54,12 @@ import { getRuntimeAdapters, getToolProviders, getTurnHooks } from '../runtime/r
 import { shouldEnqueueSkillExtraction } from '../runtime/skill-extraction-policy'
 import { finalizeTurnRun } from '../runtime/turn-lifecycle'
 import {
-  appendCompactionContextToHistoryMessages,
+  appendPersistedWorkstreamContextToHistoryMessages,
   buildAgentHistoryMessages,
   buildConversationSummary,
   buildReadableUploadMetadataContext,
   collectToolOutputErrors,
   extractMessageText,
-  extractTrackerMessageText,
   toHistoryMessages,
   toOptionalTrimmedString,
 } from '../runtime/workstream-chat-helpers'
@@ -69,8 +68,7 @@ import {
   classifyPolicyClasses,
   resolveReasoningProfile,
 } from '../runtime/workstream-routing-policy'
-import { WorkstreamStateSchema } from '../runtime/workstream-state'
-import type { WorkstreamState, WorkstreamStateDelta } from '../runtime/workstream-state'
+import type { WorkstreamState } from '../runtime/workstream-state'
 import { chatRunRegistry } from '../services/chat-run-registry.service'
 import type { NormalizedWorkstream, WorkstreamRecord } from '../services/workstream.types'
 import { createTeamThinkTool } from '../tools/team-think.tool'
@@ -84,7 +82,6 @@ import { executionPlanService } from './execution-plan.service'
 import { learnedSkillService } from './learned-skill.service'
 import { memoryService } from './memory.service'
 import { recentActivityService } from './recent-activity.service'
-import { updateWorkstreamChangeTracker } from './workstream-change-tracker.service'
 import { workstreamMessageService } from './workstream-message.service'
 import { workstreamService } from './workstream.service'
 
@@ -143,58 +140,13 @@ export function parsePersistedWorkstreamState(value: unknown): WorkstreamState |
   return parseWorkstreamState(value)
 }
 
-export function extractFirstAbsoluteUrl(text: string): URL | null {
-  const match = text.match(/https?:\/\/[^\s)]+/i)
-  if (!match) return null
+export function stripExecutionPlanFieldsFromWorkstreamState(
+  state: WorkstreamState | null | undefined,
+  hasExecutionPlan: boolean,
+): WorkstreamState | null | undefined {
+  if (!state || !hasExecutionPlan) return state
 
-  const normalized = match[0].replace(/[.,;!?]+$/g, '')
-  try {
-    return new URL(normalized)
-  } catch {
-    return null
-  }
-}
-
-export function taskRequestsWebsiteRefresh(task: string, forceRefresh: boolean): boolean {
-  return forceRefresh || /\b(refresh|re-run|rerun|run again|extract again|re-extract|overwrite|recrawl)\b/i.test(task)
-}
-
-export function buildInspectWebsiteTrackerTitle(input: unknown): string {
-  if (!input || typeof input !== 'object') return 'Inspect website intelligence'
-
-  const task = typeof (input as { task?: unknown }).task === 'string' ? (input as { task: string }).task.trim() : ''
-  const forceRefresh = (input as { forceRefresh?: unknown }).forceRefresh === true
-  const hostname = extractFirstAbsoluteUrl(task)?.hostname.replace(/^www\./, '') ?? null
-
-  if (hostname && taskRequestsWebsiteRefresh(task, forceRefresh)) {
-    return `Overwrite website-intelligence artifacts for ${hostname}`
-  }
-  if (hostname) {
-    return `Inspect website intelligence for ${hostname}`
-  }
-  return taskRequestsWebsiteRefresh(task, forceRefresh)
-    ? 'Overwrite website-intelligence artifacts'
-    : 'Inspect website intelligence'
-}
-
-export function emitTransientWorkstreamTrackerState(params: {
-  writer?: UIMessageStreamWriter<ChatMessage>
-  workstreamRecord: WorkstreamRecord
-  existingState: WorkstreamState
-  delta: WorkstreamStateDelta
-}): WorkstreamState {
-  const nextState = mergeStateDelta(params.existingState, params.delta, () => Date.now())
-
-  if (params.writer) {
-    params.writer.write({
-      type: 'data-workstreamTracker',
-      data: workstreamService.toPublicWorkstreamDetail({ ...params.workstreamRecord, state: nextState })
-        .workstreamState as unknown as Record<string, unknown>,
-      transient: true,
-    })
-  }
-
-  return nextState
+  return { ...state, currentPlan: null, tasks: [], artifacts: [] }
 }
 
 export async function waitForWorkstreamCompactionIfNeeded(workstreamId: RecordIdRef): Promise<WorkstreamRecord> {
@@ -277,6 +229,7 @@ export interface WorkstreamTurnParams {
   inputMessage: ChatMessage
   persistInputMessage?: boolean
   abortSignal?: AbortSignal
+  streamId?: string
 }
 
 export interface WorkstreamApprovalContinuationParams {
@@ -287,6 +240,7 @@ export interface WorkstreamApprovalContinuationParams {
   userName?: string | null
   approvalMessages: ChatMessage[]
   abortSignal?: AbortSignal
+  streamId?: string
 }
 
 export type WorkstreamRunCoreParams = {
@@ -296,9 +250,11 @@ export type WorkstreamRunCoreParams = {
   userRef: RecordIdRef
   userName?: string | null
   abortSignal?: AbortSignal
+  streamId?: string
 } & (
   | { kind: 'userTurn'; inputMessage: ChatMessage; persistInputMessage?: boolean }
   | { kind: 'approvalContinuation'; approvalMessages: ChatMessage[] }
+  | { kind: 'nativeToolApprovalTurn'; approvalMessages: ChatMessage[] }
 )
 
 export interface PreparedWorkstreamTurn {
@@ -364,7 +320,8 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
 
   let inputMessage: ChatMessage | undefined
   const shouldPersistInputMessage = params.kind === 'userTurn' ? params.persistInputMessage !== false : false
-  const shouldProcessPostRunSideEffects = params.kind === 'approvalContinuation' || shouldPersistInputMessage
+  const shouldProcessPostRunSideEffects =
+    params.kind === 'approvalContinuation' || params.kind === 'nativeToolApprovalTurn' || shouldPersistInputMessage
   if (params.kind === 'userTurn') {
     inputMessage = hydrateMessageFileUrls(withMessageCreatedAt(params.inputMessage))
     if (inputMessage.role !== 'user') {
@@ -383,7 +340,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     throw new WorkstreamTurnError('A chat run is already active.', 409)
   }
 
-  if (params.kind === 'approvalContinuation') {
+  if (params.kind === 'approvalContinuation' || params.kind === 'nativeToolApprovalTurn') {
     const approvedAssistantMessage = [...params.approvalMessages]
       .reverse()
       .find((m) => m.role === 'assistant' && hasApprovalRespondedParts(m))
@@ -395,9 +352,10 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
 
   const workspacePromise = workspaceProvider ? workspaceProvider.getWorkspace(orgRef) : Promise.resolve({})
   const initialWorkstreamState = parsePersistedWorkstreamState(workstreamRecord.state)
+  const persistedCompactionCursor = toOptionalTrimmedString(workstreamRecord.lastCompactedMessageId) ?? undefined
   const persistedLiveHistoryPromise = workstreamMessageService.listMessagesAfterCursor(
     workstreamRef,
-    toOptionalTrimmedString(workstreamRecord.lastCompactedMessageId) ?? undefined,
+    persistedCompactionCursor,
   )
   const persistedRecentHistoryPromise = workstreamMessageService.listRecentMessages(workstreamRef, 64)
 
@@ -595,11 +553,38 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     disabled: onboardingActive,
     loadPlan: async () => await executionPlanService.getActivePlanForWorkstream(workstreamRef),
   })
+  const getExecutionPlan = async () => await executionPlanInstructionSectionCache.getPlan()
   const getExecutionPlanInstructionSections = async (): Promise<string[] | undefined> =>
     await executionPlanInstructionSectionCache.getSections()
   const invalidateExecutionPlanInstructionSections = () => {
     executionPlanInstructionSectionCache.invalidate()
   }
+  const getWorkstreamStateSection = async (): Promise<string | undefined> => {
+    const executionPlan = await getExecutionPlan()
+    return contextCompactionRuntime.formatWorkstreamStateForPrompt(
+      stripExecutionPlanFieldsFromWorkstreamState(workstreamState, Boolean(executionPlan)),
+    )
+  }
+  const respondedBy = recordIdToString(userRef, TABLES.USER)
+  if (params.kind === 'approvalContinuation') {
+    const appliedApproval = await executionPlanService.applyApprovalResponseFromMessages({
+      workstreamId: workstreamRef,
+      approvalMessages: params.approvalMessages,
+      respondedBy,
+    })
+    if (appliedApproval) {
+      invalidateExecutionPlanInstructionSections()
+    }
+  } else if (userMessage) {
+    const appliedHumanInput = await executionPlanService.applyHumanInputFromUserMessage({
+      workstreamId: workstreamRef,
+      message: userMessage,
+      respondedBy,
+    })
+    if (appliedHumanInput) {
+      invalidateExecutionPlanInstructionSections()
+    }
+  }
   const preSeededMemoriesByAgent = new Map<string, string | undefined>()
   const getPreSeededMemoriesSection = async (agentId: string): Promise<string | undefined> => {
     if (preSeededMemoriesByAgent.has(agentId)) {
@@ -630,9 +615,12 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
     return section
   }
 
-  const persistedChatSummary = typeof workstreamRecord.chatSummary === 'string' ? workstreamRecord.chatSummary : ''
+  const persistedCompactionSummary =
+    persistedCompactionCursor && typeof workstreamRecord.compactionSummary === 'string'
+      ? workstreamRecord.compactionSummary
+      : ''
   const messagesForContext = userMessage ? upsertChatHistoryMessage(liveHistory, userMessage) : liveHistory
-  let currentMessages = contextCompactionRuntime.prependSummaryMessage(persistedChatSummary, messagesForContext)
+  let currentMessages = contextCompactionRuntime.prependSummaryMessage(persistedCompactionSummary, messagesForContext)
   const referenceUserMessageId = referenceUserMessage?.id ?? ''
   const listReadableUploads = (extraMessages: ChatMessage[] = []) =>
     listReadableUploadsFromChatMessages({
@@ -654,6 +642,9 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
         const serverRunId = Bun.randomUUIDv7()
         const runAbort = createServerRunAbortController(params.abortSignal)
         await workstreamService.setActiveRunId(workstreamRef, serverRunId)
+        if (params.streamId) {
+          await workstreamService.setActiveStreamId(workstreamRef, params.streamId)
+        }
         chatRunRegistry.register(serverRunId, runAbort.controller)
 
         try {
@@ -745,7 +736,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               preSeededMemoriesSection: await getPreSeededMemoriesSection(resolvedAgentId),
               retrievedKnowledgeSection,
               workstreamMemoryBlock: memoryBlock,
-              workstreamStateSection: contextCompactionRuntime.formatWorkstreamStateForPrompt(workstreamState),
+              workstreamStateSection: await getWorkstreamStateSection(),
               learnedSkillsSection: await getLearnedSkillsSection(resolvedAgentId),
               additionalInstructionSections: mergeInstructionSections(
                 executionPlanInstructionSections,
@@ -811,8 +802,6 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               },
             }) as ReadableStream<ChatStreamChunk>
             const reader = uiStream.getReader()
-            let liveTrackerState: WorkstreamState = workstreamState ?? parseWorkstreamState(null)
-            const liveTrackedToolCalls = new Map<string, string>()
             try {
               for (;;) {
                 const { done, value } = await reader.read()
@@ -820,71 +809,6 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 if (streamParams.writer) {
                   streamParams.writer.write(value)
                 }
-                if (value.type === 'tool-input-available' && value.toolName === 'inspectWebsite') {
-                  const title = buildInspectWebsiteTrackerTitle(value.input)
-                  liveTrackedToolCalls.set(value.toolCallId, title)
-                  liveTrackerState = emitTransientWorkstreamTrackerState({
-                    writer: streamParams.writer,
-                    workstreamRecord,
-                    existingState: liveTrackerState,
-                    delta: {
-                      taskUpdates: [
-                        {
-                          title,
-                          status: 'in-progress',
-                          owner: streamParams.agentId,
-                          externalId: value.toolCallId,
-                          sourceMessageIds: [],
-                        },
-                      ],
-                    },
-                  })
-                }
-                if (
-                  value.type === 'tool-output-available' &&
-                  value.preliminary !== true &&
-                  liveTrackedToolCalls.has(value.toolCallId)
-                ) {
-                  liveTrackerState = emitTransientWorkstreamTrackerState({
-                    writer: streamParams.writer,
-                    workstreamRecord,
-                    existingState: liveTrackerState,
-                    delta: {
-                      taskUpdates: [
-                        {
-                          title: liveTrackedToolCalls.get(value.toolCallId) ?? 'Inspect website intelligence',
-                          status: 'done',
-                          owner: streamParams.agentId,
-                          externalId: value.toolCallId,
-                          sourceMessageIds: [],
-                        },
-                      ],
-                    },
-                  })
-                  liveTrackedToolCalls.delete(value.toolCallId)
-                }
-                if (
-                  (value.type === 'tool-output-error' || value.type === 'tool-output-denied') &&
-                  liveTrackedToolCalls.has(value.toolCallId)
-                ) {
-                  liveTrackerState = emitTransientWorkstreamTrackerState({
-                    writer: streamParams.writer,
-                    workstreamRecord,
-                    existingState: liveTrackerState,
-                    delta: {
-                      taskUpdates: [
-                        {
-                          title: liveTrackedToolCalls.get(value.toolCallId) ?? 'Inspect website intelligence',
-                          status: 'blocked',
-                          owner: streamParams.agentId,
-                          externalId: value.toolCallId,
-                          sourceMessageIds: [],
-                        },
-                      ],
-                    },
-                  })
-                  liveTrackedToolCalls.delete(value.toolCallId)
-                }
               }
             } finally {
               reader.releaseLock()
@@ -959,6 +883,12 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             )
           }
 
+          // Execution-plan approval continuations mutate plan state and persist the approval message,
+          // but they do not begin a new visible agent turn.
+          if (params.kind === 'approvalContinuation') {
+            return
+          }
+
           const consultSpecialistTool = createTool({
             description: 'Consult one specialist teammate for domain-specific guidance before replying to the user.',
             inputSchema: ConsultSpecialistArgsSchema,
@@ -1003,7 +933,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 preSeededMemoriesSection: await getPreSeededMemoriesSection(agentId),
                 retrievedKnowledgeSection,
                 workstreamMemoryBlock: specialistMemoryBlock,
-                workstreamStateSection: contextCompactionRuntime.formatWorkstreamStateForPrompt(workstreamState),
+                workstreamStateSection: await getWorkstreamStateSection(),
                 learnedSkillsSection: await getLearnedSkillsSection(agentId),
                 additionalInstructionSections: mergeInstructionSections(
                   specialistExecutionPlanInstructionSections,
@@ -1115,17 +1045,6 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               throw new WorkstreamTurnError('Direct workstreams require an assigned agent.', 400)
             }
             await runVisibleAgent({ agentId: workstream.agentId, mode: 'direct' })
-          } else if (params.kind === 'userTurn') {
-            await runVisibleAgent({
-              agentId: visibleWorkstreamAgentId ?? 'chief',
-              mode: 'workstreamMode',
-              skills: coreWorkstreamProfile?.skills ? [...coreWorkstreamProfile.skills] : undefined,
-              additionalInstructionSections: mergeInstructionSections(coreInstructionSections, hookInstructionSections),
-              extraTools: {
-                [CONSULT_SPECIALIST_TOOL_NAME]: consultSpecialistTool,
-                ...(teamThinkTool ? { [CONSULT_TEAM_TOOL_NAME]: teamThinkTool } : {}),
-              },
-            })
           } else {
             await runVisibleAgent({
               agentId: visibleWorkstreamAgentId ?? 'chief',
@@ -1141,9 +1060,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
         } finally {
           try {
             const latestWorkstreamRecord = await workstreamService.getById(workstreamRef)
-            const latestPersistedState = WorkstreamStateSchema.safeParse(latestWorkstreamRecord.state).success
-              ? WorkstreamStateSchema.parse(latestWorkstreamRecord.state)
-              : null
+            const latestPersistedState = parsePersistedWorkstreamState(latestWorkstreamRecord.state)
 
             await finalizeTurnRun({
               serverRunId,
@@ -1165,60 +1082,17 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               unregisterRun: (runId) => chatRunRegistry.unregister(runId),
               clearActiveRunId: (runId) => workstreamService.clearActiveRunIdIfMatches(workstreamRef, runId),
               disposeAbort: () => runAbort.dispose(),
+              activeStreamId: params.streamId,
+              clearActiveStreamId: (streamId) =>
+                workstreamService.clearActiveStreamIdIfMatches(workstreamRef, streamId),
             })
 
-            let trackerAwareWorkstreamRecord = latestWorkstreamRecord
-            let trackerAwarePersistedState = latestPersistedState
-
-            if (!onboardingActive && allAssistantMessages.length > 0) {
-              const activeExecutionPlan = await executionPlanService.getActivePlanForWorkstream(workstreamRef)
-              const trackerUpdated = await updateWorkstreamChangeTracker({
-                workstreamId: workstreamRef,
-                title: latestWorkstreamRecord.title ?? workstream.title,
-                mode: workstream.mode,
-                ...(workstream.coreType ? { coreType: workstream.coreType } : {}),
-                ...(visibleWorkstreamAgentId ? { visibleAgentId: visibleWorkstreamAgentId } : {}),
-                hasActiveExecutionPlan: activeExecutionPlan !== null,
-                previousSummary:
-                  typeof latestWorkstreamRecord.chatSummary === 'string' ? latestWorkstreamRecord.chatSummary : null,
-                existingState: latestPersistedState,
-                userMessageText: referenceUserMessage ? extractMessageText(referenceUserMessage).trim() : null,
-                assistantMessages: allAssistantMessages
-                  .map((message) => {
-                    const text = extractTrackerMessageText(message).trim()
-                    if (!text) return null
-                    const label =
-                      typeof message.metadata?.agentName === 'string' && message.metadata.agentName.trim().length > 0
-                        ? message.metadata.agentName.trim()
-                        : typeof message.metadata?.agentId === 'string' && message.metadata.agentId.trim().length > 0
-                          ? message.metadata.agentId.trim()
-                          : (visibleWorkstreamAgentId ?? 'Assistant')
-                    return { label, text }
-                  })
-                  .filter((message): message is { label: string; text: string } => Boolean(message)),
-              })
-
-              if (trackerUpdated) {
-                const trackedWorkstreamRecord = await workstreamService.getWorkstreamRecord(workstreamRef)
-                trackerAwareWorkstreamRecord = trackedWorkstreamRecord
-                trackerAwarePersistedState = parsePersistedWorkstreamState(trackedWorkstreamRecord.state)
-                if (writer) {
-                  writer.write({
-                    type: 'data-workstreamTracker',
-                    data: workstreamService.toPublicWorkstreamDetail(trackedWorkstreamRecord)
-                      .workstreamState as unknown as Record<string, unknown>,
-                    transient: true,
-                  })
-                }
-              }
-            }
-
             if (allAssistantMessages.length > 0 && shouldProcessPostRunSideEffects) {
               const turnCount = await workstreamService.incrementTurnCount(workstreamRef)
               const agentMessages = buildAgentHistoryMessages(allAssistantMessages)
-              const historyMessagesForMemory = appendCompactionContextToHistoryMessages(
+              const historyMessagesForMemory = appendPersistedWorkstreamContextToHistoryMessages(
                 toHistoryMessages(recentHistory),
-                { chatSummary: trackerAwareWorkstreamRecord.chatSummary, persistedState: trackerAwarePersistedState },
+                { compactionSummary: latestWorkstreamRecord.compactionSummary, persistedState: latestPersistedState },
               )
 
               const userMessageText = referenceUserMessage ? extractMessageText(referenceUserMessage).trim() : ''
@@ -1283,7 +1157,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                         agentId: visibleWorkstreamAgentId ?? 'chief',
                         agentName: agentDisplayNames[visibleWorkstreamAgentId ?? 'chief'],
                         workstreamId: workstreamIdString,
-                        workstreamTitle: trackerAwareWorkstreamRecord.title ?? workstream.title,
+                        workstreamTitle: latestWorkstreamRecord.title ?? workstream.title,
                         workstreamMode: workstream.mode,
                         ...(workstream.coreType ? { coreType: workstream.coreType } : {}),
                         userMessageText,
@@ -1350,8 +1224,8 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
                 onboardingActive,
                 referenceUserMessage,
                 assistantMessages: allAssistantMessages,
-                latestWorkstreamRecord: trackerAwareWorkstreamRecord,
-                latestPersistedState: trackerAwarePersistedState,
+                latestWorkstreamRecord,
+                latestPersistedState,
                 context: buildContextResult,
               })
             }

package/src/services/workstream-turn.ts

@@ -21,6 +21,18 @@ export async function createWorkstreamApprovalContinuationStream(params: Workstr
   })
 }
 
+export async function createWorkstreamNativeToolApprovalStream(params: WorkstreamApprovalContinuationParams) {
+  const prepared = await prepareWorkstreamRunCore({ ...params, kind: 'nativeToolApprovalTurn' })
+
+  return createUIMessageStream<ChatMessage>({
+    originalMessages: prepared.originalMessages,
+    onError: (error) => (error instanceof Error ? error.message : 'Native tool approval stream failed.'),
+    execute: async ({ writer }) => {
+      await prepared.run(writer)
+    },
+  })
+}
+
 export async function createWorkstreamTurnStream(params: WorkstreamTurnParams) {
   const prepared = await prepareWorkstreamRunCore({ ...params, kind: 'userTurn' })