@lota-sdk/core 0.2.3 → 0.3.1

package/src/services/{workstream-turn.ts → thread-turn.ts}

@@ -1,4 +1,4 @@
-import type { ChatMessage, PlanNodeHandoffContext } from '@lota-sdk/shared'
+import type { ChatMessage } from '@lota-sdk/shared'
 import { createUIMessageStream } from 'ai'
 
 import { lotaDebugLogger } from '../config/debug-logger'
@@ -9,24 +9,24 @@ import { shouldPlanNodeUseVisibleTurn } from '../runtime/execution-plan-visibili
 import { wrapResponseWithKeepalive } from '../utils/sse-keepalive'
 import { planExecutorService } from './plan-executor.service'
 import { planRunService } from './plan-run.service'
-import { userService } from './user.service'
-import { prepareWorkstreamRunCore } from './workstream-turn-preparation.service'
+import { prepareThreadRunCore } from './thread-turn-preparation.service'
 import type {
-  PreparedWorkstreamTurnResult,
-  WorkstreamApprovalContinuationParams,
-  WorkstreamPlanTurnParams,
-  WorkstreamTurnParams,
-} from './workstream-turn-preparation.service'
-import { workstreamService } from './workstream.service'
+  PreparedThreadTurnResult,
+  ThreadApprovalContinuationParams,
+  ThreadPlanTurnParams,
+  ThreadTurnParams,
+} from './thread-turn-preparation.service'
+import { threadService } from './thread.service'
+import { userService } from './user.service'
 
 export { hasApprovalRespondedParts, isApprovalContinuationRequest }
 export { wrapResponseWithKeepalive }
-export type { PreparedWorkstreamTurnResult }
-export type { WorkstreamPlanTurnParams }
+export type { PreparedThreadTurnResult }
+export type { ThreadPlanTurnParams }
 
-export async function createWorkstreamApprovalContinuationStream(params: WorkstreamApprovalContinuationParams) {
+export async function createThreadApprovalContinuationStream(params: ThreadApprovalContinuationParams) {
   const timer = lotaDebugLogger.timer('turn:approval-continuation')
-  const prepared = await prepareWorkstreamRunCore({ ...params, kind: 'approvalContinuation' })
+  const prepared = await prepareThreadRunCore({ ...params, kind: 'approvalContinuation' })
   timer.step('prepare')
 
   return createUIMessageStream<ChatMessage>({
@@ -39,9 +39,9 @@ export async function createWorkstreamApprovalContinuationStream(params: Workstr
   })
 }
 
-export async function createWorkstreamNativeToolApprovalStream(params: WorkstreamApprovalContinuationParams) {
+export async function createThreadNativeToolApprovalStream(params: ThreadApprovalContinuationParams) {
   const timer = lotaDebugLogger.timer('turn:native-tool-approval')
-  const prepared = await prepareWorkstreamRunCore({ ...params, kind: 'nativeToolApprovalTurn' })
+  const prepared = await prepareThreadRunCore({ ...params, kind: 'nativeToolApprovalTurn' })
   timer.step('prepare')
 
   return createUIMessageStream<ChatMessage>({
@@ -54,9 +54,9 @@ export async function createWorkstreamNativeToolApprovalStream(params: Workstrea
   })
 }
 
-export async function createWorkstreamTurnStream(params: WorkstreamTurnParams) {
+export async function createThreadTurnStream(params: ThreadTurnParams) {
   const timer = lotaDebugLogger.timer('turn:user-turn')
-  const prepared = await prepareWorkstreamRunCore({ ...params, kind: 'userTurn' })
+  const prepared = await prepareThreadRunCore({ ...params, kind: 'userTurn' })
   timer.step('prepare')
 
   return createUIMessageStream<ChatMessage>({
@@ -69,11 +69,9 @@ export async function createWorkstreamTurnStream(params: WorkstreamTurnParams) {
   })
 }
 
-export async function runWorkstreamTurnInBackground(
-  params: WorkstreamTurnParams,
-): Promise<PreparedWorkstreamTurnResult> {
+export async function runThreadTurnInBackground(params: ThreadTurnParams): Promise<PreparedThreadTurnResult> {
   const timer = lotaDebugLogger.timer('turn:background')
-  const prepared = await prepareWorkstreamRunCore({ ...params, kind: 'userTurn' })
+  const prepared = await prepareThreadRunCore({ ...params, kind: 'userTurn' })
   timer.step('prepare')
   const result = await prepared.run()
   timer.step('run')
@@ -85,7 +83,7 @@ export async function triggerPlanNodeTurn(params: {
   nodeId: string
   abortSignal?: AbortSignal
   streamId?: string
-}): Promise<PreparedWorkstreamTurnResult> {
+}): Promise<PreparedThreadTurnResult> {
   const timer = lotaDebugLogger.timer('turn:plan-turn')
   let run = await planRunService.getRunById(params.runId)
   const spec = await planRunService.getPlanSpecById(run.planSpecId)
@@ -106,8 +104,8 @@ export async function triggerPlanNodeTurn(params: {
     return { assistantMessages: [], inputMessageId: undefined }
   }
 
-  const workstream = await workstreamService.getWorkstream(run.workstreamId)
-  const userRef = ensureRecordId(workstream.userId, TABLES.USER)
+  const thread = await threadService.getThread(run.threadId)
+  const userRef = ensureRecordId(thread.userId, TABLES.USER)
 
   const [artifacts, nodeRuns, userName] = await Promise.all([
     planRunService.listArtifacts(run.id),
@@ -122,8 +120,6 @@ export async function triggerPlanNodeTurn(params: {
     .map((artifact) => ({
       name: artifact.name,
       kind: artifact.kind,
-      pointer: artifact.pointer,
-      ...(artifact.schemaRef ? { schemaRef: artifact.schemaRef } : {}),
       ...(artifact.description ? { description: artifact.description } : {}),
       ...(artifact.payload !== undefined ? { payload: artifact.payload } : {}),
     }))
@@ -134,20 +130,20 @@ export async function triggerPlanNodeTurn(params: {
     ]),
   )
   const upstreamHandoffs = nodeRuns
-    .filter((candidate) => nodeSpec.upstreamNodeIds.includes(candidate.nodeId) && candidate.handoffContext)
+    .filter((candidate) => nodeSpec.upstreamNodeIds.includes(candidate.nodeId) && candidate.latestNotes)
     .map((candidate) => ({
       nodeId: candidate.nodeId,
       label: upstreamNodeSpecs.get(candidate.nodeId)?.label ?? candidate.nodeId,
       ownerRef: upstreamNodeSpecs.get(candidate.nodeId)?.owner.ref ?? 'system',
       ownerType: upstreamNodeSpecs.get(candidate.nodeId)?.owner.executorType ?? 'system',
-      handoffContext: candidate.handoffContext as PlanNodeHandoffContext,
+      summary: candidate.latestNotes ?? undefined,
     }))
   timer.step('load-plan-turn-context')
 
-  const prepared = await prepareWorkstreamRunCore({
+  const prepared = await prepareThreadRunCore({
     kind: 'planTurn',
-    workstream,
-    workstreamRef: ensureRecordId(run.workstreamId, TABLES.WORKSTREAM),
+    thread,
+    threadRef: ensureRecordId(run.threadId, TABLES.THREAD),
     orgRef: ensureRecordId(run.organizationId, TABLES.ORGANIZATION),
     userRef,
     userName,