@lota-sdk/core 0.4.8 → 0.4.9

package/src/services/thread-turn.ts

@@ -1,172 +0,0 @@
-import type { ChatMessage } from '@lota-sdk/shared'
-import { createUIMessageStream } from 'ai'
-
-import { lotaDebugLogger } from '../config/debug-logger'
-import { ensureRecordId, recordIdToString } from '../db/record-id'
-import { TABLES } from '../db/tables'
-import { hasApprovalRespondedParts, isApprovalContinuationRequest } from '../runtime/approval-continuation'
-import { shouldPlanNodeUseVisibleTurn } from '../runtime/execution-plan-visibility'
-import { wrapResponseWithKeepalive } from '../utils/sse-keepalive'
-import { planExecutorService } from './plan-executor.service'
-import { planRunService } from './plan-run.service'
-import { prepareThreadRunCore } from './thread-turn-preparation.service'
-import type {
-  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 { PreparedThreadTurnResult }
-export type { ThreadPlanTurnParams }
-
-export async function createThreadApprovalContinuationStream(params: ThreadApprovalContinuationParams) {
-  const timer = lotaDebugLogger.timer('turn:approval-continuation')
-  const prepared = await prepareThreadRunCore({ ...params, kind: 'approvalContinuation' })
-  timer.step('prepare')
-
-  return createUIMessageStream<ChatMessage>({
-    originalMessages: prepared.originalMessages,
-    onError: (error) => (error instanceof Error ? error.message : 'Approval continuation stream failed.'),
-    execute: async ({ writer }) => {
-      await prepared.run(writer)
-      timer.step('run')
-    },
-  })
-}
-
-export async function createThreadNativeToolApprovalStream(params: ThreadApprovalContinuationParams) {
-  const timer = lotaDebugLogger.timer('turn:native-tool-approval')
-  const prepared = await prepareThreadRunCore({ ...params, kind: 'nativeToolApprovalTurn' })
-  timer.step('prepare')
-
-  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)
-      timer.step('run')
-    },
-  })
-}
-
-export async function createThreadTurnStream(params: ThreadTurnParams) {
-  const timer = lotaDebugLogger.timer('turn:user-turn')
-  const prepared = await prepareThreadRunCore({ ...params, kind: 'userTurn' })
-  timer.step('prepare')
-
-  return createUIMessageStream<ChatMessage>({
-    originalMessages: prepared.originalMessages,
-    onError: (error) => (error instanceof Error ? error.message : 'Chat stream failed.'),
-    execute: async ({ writer }) => {
-      await prepared.run(writer)
-      timer.step('run')
-    },
-  })
-}
-
-export async function runThreadTurnInBackground(params: ThreadTurnParams): Promise<PreparedThreadTurnResult> {
-  const timer = lotaDebugLogger.timer('turn:background')
-  const prepared = await prepareThreadRunCore({ ...params, kind: 'userTurn' })
-  timer.step('prepare')
-  const result = await prepared.run()
-  timer.step('run')
-  return result
-}
-
-export async function triggerPlanNodeTurn(params: {
-  runId: string
-  nodeId: string
-  abortSignal?: AbortSignal
-  streamId?: string
-}): Promise<PreparedThreadTurnResult> {
-  const timer = lotaDebugLogger.timer('turn:plan-turn')
-  let run = await planRunService.getRunById(params.runId)
-  const spec = await planRunService.getPlanSpecById(run.planSpecId)
-  const nodeSpec = await planRunService.getNodeSpecByNodeId(spec.id, params.nodeId)
-
-  if (!shouldPlanNodeUseVisibleTurn(spec, nodeSpec) || nodeSpec.owner.executorType !== 'agent') {
-    throw new Error(`Plan node "${params.nodeId}" is not eligible for a visible plan turn.`)
-  }
-
-  let nodeRun = await planRunService.getNodeRunByNodeId(run.id, params.nodeId)
-  if (nodeRun.status === 'ready') {
-    await planExecutorService.transitionNodeToRunning({ runId: params.runId, nodeId: params.nodeId })
-    run = await planRunService.getRunById(params.runId)
-    nodeRun = await planRunService.getNodeRunByNodeId(run.id, params.nodeId)
-  }
-
-  if (nodeRun.status !== 'running') {
-    return { assistantMessages: [], inputMessageId: undefined }
-  }
-
-  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),
-    planRunService.listNodeRuns(run.id),
-    userService
-      .getUser(recordIdToString(userRef, TABLES.USER))
-      .then((user) => user.name)
-      .catch(() => undefined),
-  ])
-  const inputArtifacts = artifacts
-    .filter((artifact) => nodeSpec.upstreamNodeIds.includes(artifact.nodeId))
-    .map((artifact) => ({
-      name: artifact.name,
-      kind: artifact.kind,
-      ...(artifact.description ? { description: artifact.description } : {}),
-      ...(artifact.content !== undefined ? { content: artifact.content } : {}),
-      ...(artifact.payload !== undefined ? { payload: artifact.payload } : {}),
-      ...(artifact.publishedArtifactId
-        ? { publishedArtifactId: recordIdToString(artifact.publishedArtifactId, TABLES.ARTIFACT) }
-        : {}),
-    }))
-  const upstreamNodeSpecs = new Map(
-    (await planRunService.listNodeSpecs(spec.id)).map((upstreamNodeSpec) => [
-      upstreamNodeSpec.nodeId,
-      upstreamNodeSpec,
-    ]),
-  )
-  const upstreamHandoffs = nodeRuns
-    .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',
-      summary: candidate.latestNotes ?? undefined,
-    }))
-  timer.step('load-plan-turn-context')
-
-  const prepared = await prepareThreadRunCore({
-    kind: 'planTurn',
-    thread,
-    threadRef: ensureRecordId(run.threadId, TABLES.THREAD),
-    orgRef: ensureRecordId(run.organizationId, TABLES.ORGANIZATION),
-    userRef,
-    userName,
-    abortSignal: params.abortSignal,
-    streamId: params.streamId,
-    planTurn: {
-      runId: params.runId,
-      nodeId: params.nodeId,
-      planTitle: spec.title,
-      nodeSpec,
-      nodeRun,
-      resolvedInput: nodeRun.resolvedInput ?? {},
-      inputArtifacts,
-      upstreamHandoffs,
-    },
-  })
-  timer.step('prepare')
-
-  const result = await prepared.run()
-  timer.step('run')
-  return result
-}