@lota-sdk/core 0.4.8 → 0.4.9

package/src/runtime/thread-turn-context.ts

@@ -1,6 +1,18 @@
+import { Schema, Effect } from 'effect'
+
 import type { RecordIdRef } from '../db/record-id'
+import { recordIdToString } from '../db/record-id'
+import { TABLES } from '../db/tables'
+import {
+  effectTryMaybeAsync as effectTryMaybeAsyncShared,
+  effectTryPromise as effectTryPromiseShared,
+} from '../effect/helpers'
 import { buildAgentPromptContext } from './agent-prompt-context'
-import { buildIndexedRepositoriesContext, getPluginService } from './plugin-resolution'
+import {
+  buildIndexedRepositoriesContext,
+  getGithubInstallationForOrganization,
+  getLinearInstallationByOrgId,
+} from './plugin-resolution'
 import type {
   LotaRuntimeIndexedRepositoriesContext,
   LotaRuntimeTurnHooks,
@@ -8,12 +20,32 @@ import type {
   LotaRuntimeWorkspaceProjectionState,
   LotaRuntimeWorkspaceProvider,
 } from './runtime-extensions'
-import { asRecord, readInstructionSections, readOptionalString } from './thread-chat-helpers'
+import { readInstructionSections, readOptionalString } from './thread-chat-helpers'
 
 function readOptionalBoolean(value: unknown): boolean | undefined {
   return typeof value === 'boolean' ? value : undefined
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}
+
+class ThreadTurnContextError extends Schema.TaggedErrorClass<ThreadTurnContextError>()('ThreadTurnContextError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+function effectTryPromise<A>(thunk: () => PromiseLike<A>, message: string): Effect.Effect<A, ThreadTurnContextError> {
+  return effectTryPromiseShared(thunk, (cause) => new ThreadTurnContextError({ message, cause }))
+}
+
+function effectTryMaybeAsync<A>(
+  evaluate: () => A | PromiseLike<A>,
+  message: string,
+): Effect.Effect<A, ThreadTurnContextError> {
+  return effectTryMaybeAsyncShared(evaluate, (cause) => new ThreadTurnContextError({ message, cause }))
+}
+
 interface AssembledThreadTurnContext {
   workspace: Record<string, unknown>
   workspaceLifecycleState: LotaRuntimeWorkspaceLifecycleState | undefined
@@ -28,7 +60,7 @@ interface AssembledThreadTurnContext {
   hookInstructionSections: string[]
 }
 
-export async function assembleThreadTurnContext(params: {
+const assembleThreadTurnContextEffect = Effect.fn('ThreadTurnContext.assemble')(function* (params: {
   thread: unknown
   threadRef: RecordIdRef
   orgRef: RecordIdRef
@@ -40,54 +72,67 @@ export async function assembleThreadTurnContext(params: {
   workspacePromise: Promise<Record<string, unknown>>
   workspaceProvider?: LotaRuntimeWorkspaceProvider
   turnHooks: LotaRuntimeTurnHooks
-  onStep?: (name: string) => void
-}): Promise<AssembledThreadTurnContext> {
-  const workspace = await params.workspacePromise
-  params.onStep?.('fetch-workspace')
+}) {
+  const workspace = yield* effectTryPromise(() => params.workspacePromise, 'Failed to load thread workspace').pipe(
+    Effect.withSpan('ThreadTurnContext.loadWorkspace'),
+  )
 
-  const [workspaceLifecycleState, workspaceProfileState] = await Promise.all([
-    params.workspaceProvider ? params.workspaceProvider.getLifecycleState?.(workspace) : Promise.resolve(undefined),
-    params.workspaceProvider
-      ? params.workspaceProvider.readProfileProjectionState?.(workspace)
-      : Promise.resolve(undefined),
-  ])
-  params.onStep?.('workspace-state')
+  const workspaceLifecycleState = yield* effectTryMaybeAsync(
+    () => params.workspaceProvider?.getLifecycleState?.(workspace),
+    'Failed to load workspace lifecycle state',
+  ).pipe(Effect.withSpan('ThreadTurnContext.loadWorkspaceLifecycleState'))
+  const workspaceProfileState = yield* effectTryMaybeAsync(
+    () => params.workspaceProvider?.readProfileProjectionState?.(workspace),
+    'Failed to load workspace profile state',
+  ).pipe(Effect.withSpan('ThreadTurnContext.loadWorkspaceProfileState'))
 
   const onboardingActive = workspaceLifecycleState?.bootstrapActive ?? false
-  const getLinearInstallationByOrgId = getPluginService([
-    'linear',
-    'services',
-    'linearService',
-    'getInstallationByOrgId',
-  ])
-  const getGithubInstallationForOrganization = getPluginService([
-    'github',
-    'services',
-    'githubService',
-    'getInstallationForOrganization',
-  ])
-  const [linearInstallation, githubInstallation, indexedRepoContext, recentDomainEvents, promptSummary] =
-    await Promise.all([
-      getLinearInstallationByOrgId
-        ? (getLinearInstallationByOrgId(params.orgRef) as Promise<unknown>)
-        : Promise.resolve(null),
-      getGithubInstallationForOrganization
-        ? (getGithubInstallationForOrganization(params.orgIdString) as Promise<unknown>)
-        : Promise.resolve(null),
-      buildIndexedRepositoriesContext(params.orgIdString),
-      params.workspaceProvider?.listRecentDomainEvents?.(params.orgRef, 5) ??
-        Promise.resolve([] as Array<Record<string, unknown>>),
-      params.workspaceProvider?.buildPromptSummary
-        ? params.workspaceProvider.buildPromptSummary(params.orgRef).catch(() => undefined)
-        : Promise.resolve(undefined),
-    ])
-  params.onStep?.('parallel-context-fetch(plugins+repos+events+summary)')
+  const linearInstallation = yield* effectTryPromise(
+    () => getLinearInstallationByOrgId(params.orgRef),
+    'Failed to load Linear installation',
+  ).pipe(
+    Effect.catch(() => Effect.succeed(null)),
+    Effect.withSpan('ThreadTurnContext.loadLinearInstallation'),
+  )
+  const githubInstallation = yield* effectTryPromise(
+    () => getGithubInstallationForOrganization(params.orgIdString),
+    'Failed to load GitHub installation',
+  ).pipe(
+    Effect.catch(() => Effect.succeed(null)),
+    Effect.withSpan('ThreadTurnContext.loadGithubInstallation'),
+  )
+  const indexedRepoContext = yield* effectTryPromise(
+    () => buildIndexedRepositoriesContext(params.orgIdString),
+    'Failed to build indexed repository context',
+  ).pipe(
+    Effect.catch(() =>
+      Effect.succeed({
+        provideRepoTool: false,
+        defaultSectionsByAgent: {},
+        context: '',
+      } as LotaRuntimeIndexedRepositoriesContext),
+    ),
+    Effect.withSpan('ThreadTurnContext.buildIndexedRepositoriesContext'),
+  )
+  const recentDomainEvents = yield* effectTryMaybeAsync(
+    () => params.workspaceProvider?.listRecentDomainEvents?.(params.orgRef, 5) ?? [],
+    'Failed to load recent domain events',
+  ).pipe(Effect.withSpan('ThreadTurnContext.loadRecentDomainEvents'))
+  const promptSummary =
+    params.workspaceProvider?.buildPromptSummary === undefined
+      ? undefined
+      : yield* effectTryMaybeAsync(
+          () => params.workspaceProvider?.buildPromptSummary?.(params.orgRef),
+          'Failed to build workspace prompt summary',
+        ).pipe(
+          Effect.catch(() => Effect.as(Effect.void, undefined as string | undefined)),
+          Effect.withSpan('ThreadTurnContext.buildPromptSummary'),
+        )
 
   let linearInstalled = Boolean(linearInstallation)
   let githubInstalled = Boolean(githubInstallation)
   let promptContext = buildAgentPromptContext({
-    workspaceName:
-      workspaceProfileState?.workspaceName ?? readOptionalString((workspace as { name?: unknown }).name) ?? undefined,
+    workspaceName: workspaceProfileState?.workspaceName ?? readOptionalString(workspace.name) ?? undefined,
     summaryBlock: workspaceProfileState?.summaryBlock,
     promptSummary,
     userName: params.userName ?? undefined,
@@ -95,35 +140,40 @@ export async function assembleThreadTurnContext(params: {
   })
   let retrievedKnowledgeSection: string | undefined = !params.messageText
     ? undefined
-    : await params.workspaceProvider?.buildRetrievedKnowledgeSection?.({
-        workspaceId: params.orgIdString,
-        userId: params.userIdString,
-        query: params.messageText,
-      })
-  params.onStep?.('rag-knowledge-retrieval')
-
-  const buildContextResult = asRecord(
-    await params.turnHooks.buildContext?.({
-      thread: params.thread,
-      threadRef: params.threadRef,
-      orgRef: params.orgRef,
-      userRef: params.userRef,
-      userName: params.userName,
-      workspace,
-      onboardingActive,
-      messageText: params.messageText,
-      linearInstalled,
-      githubInstalled,
-      indexedRepoContext,
-      promptContext,
-      workspaceLifecycleState,
-      workspaceProfileState,
-      promptSummary,
-      recentDomainEvents,
-      retrievedKnowledgeSection,
-    }),
-  )
-  params.onStep?.('hook:buildContext')
+    : yield* effectTryMaybeAsync(
+        () =>
+          params.workspaceProvider?.buildRetrievedKnowledgeSection?.({
+            workspaceId: params.orgIdString,
+            userId: params.userIdString,
+            query: params.messageText,
+          }),
+        'Failed to build retrieved knowledge section',
+      ).pipe(Effect.withSpan('ThreadTurnContext.buildRetrievedKnowledgeSection'))
+
+  const buildContextResultValue = yield* effectTryMaybeAsync(
+    () =>
+      params.turnHooks.buildContext?.({
+        thread: params.thread,
+        threadRef: params.threadRef,
+        orgRef: params.orgRef,
+        userRef: params.userRef,
+        userName: params.userName,
+        workspace,
+        onboardingActive,
+        messageText: params.messageText,
+        linearInstalled,
+        githubInstalled,
+        indexedRepoContext,
+        promptContext,
+        workspaceLifecycleState,
+        workspaceProfileState,
+        promptSummary,
+        recentDomainEvents,
+        retrievedKnowledgeSection,
+      }),
+    'Failed to build thread context',
+  ).pipe(Effect.withSpan('ThreadTurnContext.buildContextHook'))
+  const buildContextResult = isRecord(buildContextResultValue) ? buildContextResultValue : null
 
   const buildContextPromptDetails = readOptionalString(buildContextResult?.systemWorkspaceDetails)
   if (buildContextPromptDetails) {
@@ -143,28 +193,31 @@ export async function assembleThreadTurnContext(params: {
   }
 
   const hookInstructionSections = readInstructionSections(
-    await params.turnHooks.buildExtraInstructionSections?.({
-      thread: params.thread,
-      threadRef: params.threadRef,
-      orgRef: params.orgRef,
-      userRef: params.userRef,
-      userName: params.userName,
-      workspace,
-      onboardingActive,
-      messageText: params.messageText,
-      linearInstalled,
-      githubInstalled,
-      indexedRepoContext,
-      promptContext,
-      workspaceLifecycleState,
-      workspaceProfileState,
-      promptSummary,
-      recentDomainEvents,
-      retrievedKnowledgeSection,
-      context: buildContextResult,
-    }),
+    yield* effectTryMaybeAsync(
+      () =>
+        params.turnHooks.buildExtraInstructionSections?.({
+          thread: params.thread,
+          threadRef: params.threadRef,
+          orgRef: params.orgRef,
+          userRef: params.userRef,
+          userName: params.userName,
+          workspace,
+          onboardingActive,
+          messageText: params.messageText,
+          linearInstalled,
+          githubInstalled,
+          indexedRepoContext,
+          promptContext,
+          workspaceLifecycleState,
+          workspaceProfileState,
+          promptSummary,
+          recentDomainEvents,
+          retrievedKnowledgeSection,
+          context: buildContextResult,
+        }),
+      'Failed to build extra instruction sections',
+    ).pipe(Effect.withSpan('ThreadTurnContext.buildExtraInstructionSections')),
   )
-  params.onStep?.('hook:buildExtraInstructionSections')
 
   return {
     workspace,
@@ -179,4 +232,29 @@ export async function assembleThreadTurnContext(params: {
     buildContextResult,
     hookInstructionSections,
   }
+})
+
+export function assembleThreadTurnContext(params: {
+  thread: unknown
+  threadRef: RecordIdRef
+  orgRef: RecordIdRef
+  userRef: RecordIdRef
+  userName?: string | null
+  orgIdString: string
+  userIdString: string
+  messageText: string
+  workspacePromise: Promise<Record<string, unknown>>
+  workspaceProvider?: LotaRuntimeWorkspaceProvider
+  turnHooks: LotaRuntimeTurnHooks
+}): Promise<AssembledThreadTurnContext> {
+  return Effect.runPromise(
+    assembleThreadTurnContextEffect(params).pipe(
+      Effect.annotateSpans({
+        threadId: recordIdToString(params.threadRef, TABLES.THREAD),
+        orgId: params.orgIdString,
+        userId: params.userIdString,
+        messageLength: params.messageText.length,
+      }),
+    ),
+  )
 }

package/src/runtime/turn-lifecycle.ts

@@ -1,36 +1,102 @@
 import type { ChatMessage } from '@lota-sdk/shared'
+import { Schema, Effect } from 'effect'
 
-export async function finalizeTurnRun(params: {
+import { serverLogger } from '../config/logger'
+import { effectTryMaybeAsync } from '../effect/helpers'
+
+export class TurnLifecycleError extends Schema.TaggedErrorClass<TurnLifecycleError>()('TurnLifecycleError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+type MaybeAsync<A> = A | PromiseLike<A>
+type MaybeEffect<A> = MaybeAsync<A> | Effect.Effect<A, TurnLifecycleError>
+
+function effectFromMaybeEffect<A>(
+  evaluate: () => MaybeEffect<A>,
+  onError: (error: unknown) => TurnLifecycleError,
+): Effect.Effect<A, TurnLifecycleError> {
+  return Effect.suspend(() => {
+    try {
+      const result = evaluate()
+      return Effect.isEffect(result)
+        ? result.pipe(Effect.mapError(onError))
+        : effectTryMaybeAsync(() => result, onError)
+    } catch (error) {
+      return Effect.fail(onError(error))
+    }
+  })
+}
+
+export function finalizeTurnRunEffect(params: {
   serverRunId: string
-  getEntity: () => Promise<{ lastCompactedMessageId?: string | null; compactionSummary?: string | null }>
-  getUncompactedMessages: (cursor?: string) => Promise<ChatMessage[]>
+  getEntity: () => MaybeEffect<{ lastCompactedMessageId?: string | null; compactionSummary?: string | null }>
+  getUncompactedMessages: (cursor?: string) => MaybeEffect<ChatMessage[]>
   assessCompaction: (summaryText: string, messages: ChatMessage[]) => { shouldCompact: boolean }
-  enqueueCompaction: () => Promise<void>
+  enqueueCompaction: () => MaybeEffect<void>
   unregisterRun: (runId: string) => void
-  clearActiveRunId: (runId: string) => Promise<void>
+  clearActiveRunId: (runId: string) => MaybeEffect<void>
   disposeAbort: () => void
   activeStreamId?: string
-  clearActiveStreamId?: (streamId: string) => Promise<void>
-}): Promise<void> {
-  // Clear the active run immediately so new messages are not blocked
-  params.unregisterRun(params.serverRunId)
-  await params.clearActiveRunId(params.serverRunId)
-  if (params.activeStreamId && params.clearActiveStreamId) {
-    await params.clearActiveStreamId(params.activeStreamId)
-  }
-  params.disposeAbort()
-
-  try {
-    const entity = await params.getEntity()
-    const cursor = typeof entity.lastCompactedMessageId === 'string' ? entity.lastCompactedMessageId : undefined
-    const uncompactedMessages = await params.getUncompactedMessages(cursor)
-    const summaryText = typeof entity.compactionSummary === 'string' ? entity.compactionSummary : ''
-    const { shouldCompact } = params.assessCompaction(summaryText, uncompactedMessages)
-
-    if (shouldCompact) {
-      await params.enqueueCompaction()
+  clearActiveStreamId?: (streamId: string) => MaybeEffect<void>
+}): Effect.Effect<void, TurnLifecycleError> {
+  return Effect.gen(function* () {
+    // Clear the active run immediately so new messages are not blocked
+    params.unregisterRun(params.serverRunId)
+    yield* effectFromMaybeEffect(
+      () => params.clearActiveRunId(params.serverRunId),
+      (error) => new TurnLifecycleError({ message: String(error), cause: error }),
+    )
+    const activeStreamId = params.activeStreamId
+    const clearActiveStreamId = params.clearActiveStreamId
+    if (activeStreamId && clearActiveStreamId) {
+      yield* effectFromMaybeEffect(
+        () => clearActiveStreamId(activeStreamId),
+        (error) => new TurnLifecycleError({ message: String(error), cause: error }),
+      )
     }
-  } catch {
-    // compaction assessment errors should not surface to callers
-  }
+    params.disposeAbort()
+
+    yield* Effect.gen(function* () {
+      const entity = yield* effectFromMaybeEffect(
+        () => params.getEntity(),
+        (error) => new TurnLifecycleError({ message: String(error), cause: error }),
+      )
+      const cursor = typeof entity.lastCompactedMessageId === 'string' ? entity.lastCompactedMessageId : undefined
+      const uncompactedMessages = yield* effectFromMaybeEffect(
+        () => params.getUncompactedMessages(cursor),
+        (error) => new TurnLifecycleError({ message: String(error), cause: error }),
+      )
+      const summaryText = typeof entity.compactionSummary === 'string' ? entity.compactionSummary : ''
+      const { shouldCompact } = params.assessCompaction(summaryText, uncompactedMessages)
+
+      if (shouldCompact) {
+        yield* effectFromMaybeEffect(
+          () => params.enqueueCompaction(),
+          (error) => new TurnLifecycleError({ message: String(error), cause: error }),
+        )
+      }
+    }).pipe(
+      Effect.catch((error: unknown) =>
+        Effect.sync(() => {
+          serverLogger.error`Failed to assess/enqueue compaction: ${error}`
+        }),
+      ),
+    )
+  })
+}
+
+export function finalizeTurnRun(params: {
+  serverRunId: string
+  getEntity: () => MaybeEffect<{ lastCompactedMessageId?: string | null; compactionSummary?: string | null }>
+  getUncompactedMessages: (cursor?: string) => MaybeEffect<ChatMessage[]>
+  assessCompaction: (summaryText: string, messages: ChatMessage[]) => { shouldCompact: boolean }
+  enqueueCompaction: () => MaybeEffect<void>
+  unregisterRun: (runId: string) => void
+  clearActiveRunId: (runId: string) => MaybeEffect<void>
+  disposeAbort: () => void
+  activeStreamId?: string
+  clearActiveStreamId?: (streamId: string) => MaybeEffect<void>
+}): Promise<void> {
+  return Effect.runPromise(finalizeTurnRunEffect(params))
 }