@lota-sdk/core 0.4.12 → 0.4.14

package/src/runtime/specialist-runner.ts

@@ -1,7 +1,9 @@
 import type { ToolSet } from 'ai'
 import { Schema, Effect } from 'effect'
 
-class SpecialistRunnerError extends Schema.TaggedErrorClass<SpecialistRunnerError>()('SpecialistRunnerError', {
+import { ERROR_TAGS } from '../effect/errors'
+
+class SpecialistRunnerError extends Schema.TaggedErrorClass<SpecialistRunnerError>()(ERROR_TAGS.SpecialistRunnerError, {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect),
 }) {}

package/src/runtime/team-consultation/team-consultation-orchestrator.ts

@@ -4,6 +4,7 @@ import { convertToModelMessages, tool as createTool } from 'ai'
 import { Schema, Deferred, Effect, Exit, Fiber, Queue, Ref, Scope } from 'effect'
 
 import type { ResolvedAgentConfig } from '../../config/agent-defaults'
+import { ERROR_TAGS } from '../../effect/errors'
 import { nowEpochMillis } from '../../utils/date-time'
 import { createTimedAbortSignal } from '../agent-stream-helpers'
 import { buildModelInputMessagesWithUploadMetadata, buildReadableUploadMetadataText } from '../chat-attachments'
@@ -15,7 +16,7 @@ import { buildTeamConsultationFailureMessage } from './team-consultation-prompts
 export type DefaultRepoSections = RepoSectionName[]
 const TEAM_CONSULTATION_TIMEOUT_MS = 90_000
 
-class TeamConsultationError extends Schema.TaggedErrorClass<TeamConsultationError>()('TeamConsultationError', {
+class TeamConsultationError extends Schema.TaggedErrorClass<TeamConsultationError>()(ERROR_TAGS.TeamConsultationError, {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect),
 }) {}
@@ -62,7 +63,7 @@ function selectTeamConsultationContextMessages(messages: ChatMessage[], latestUs
 }
 
 interface ParticipantObserver {
-  run<T>(fn: () => T | Promise<T>): Promise<T>
+  run<T>(fn: () => Promise<T>): Promise<T>
   recordError?: (error: unknown) => void
   recordAbort?: (error: unknown) => void
 }

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

@@ -1,7 +1,7 @@
 import { Schema, Effect } from 'effect'
 
 import type { RecordIdRef } from '../db/record-id'
-import { effectTryMaybeAsync as effectTryMaybeAsyncShared, makeEffectTryPromiseWithMessage } from '../effect/helpers'
+import { ERROR_TAGS } from '../effect/errors'
 import { buildAgentPromptContext } from './agent-prompt-context'
 import {
   buildIndexedRepositoriesContext,
@@ -24,20 +24,13 @@ 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),
-}) {}
+class ThreadTurnContextError extends Schema.TaggedErrorClass<ThreadTurnContextError>()(
+  ERROR_TAGS.ThreadTurnContextError,
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
 
-const effectTryPromise = makeEffectTryPromiseWithMessage(
-  (message, 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 }))
+function toThreadTurnContextError(message: string, cause: unknown): ThreadTurnContextError {
+  return new ThreadTurnContextError({ message, cause })
 }
 
 export const assembleThreadTurnContext = Effect.fn('ThreadTurnContext.assemble')(function* (params: {
@@ -55,38 +48,56 @@ export const assembleThreadTurnContext = Effect.fn('ThreadTurnContext.assemble')
   runtimeAdapters: LotaRuntimeAdapters
   pluginRuntime?: Record<string, unknown>
 }) {
-  const workspace = yield* effectTryPromise(() => params.workspacePromise, 'Failed to load thread workspace').pipe(
-    Effect.withSpan('ThreadTurnContext.loadWorkspace'),
-  )
+  const workspace = yield* Effect.tryPromise({
+    try: () => params.workspacePromise,
+    catch: (cause) => toThreadTurnContextError('Failed to load thread workspace', cause),
+  }).pipe(Effect.withSpan('ThreadTurnContext.loadWorkspace'))
 
-  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 workspaceProvider = params.workspaceProvider
+  const getLifecycleState = workspaceProvider?.getLifecycleState
+    ? (() => {
+        const run = workspaceProvider.getLifecycleState.bind(workspaceProvider)
+        return (workspaceRecord: Record<string, unknown>) => run(workspaceRecord)
+      })()
+    : undefined
+  const workspaceLifecycleState = getLifecycleState
+    ? yield* Effect.tryPromise({
+        try: () => getLifecycleState(workspace),
+        catch: (cause) => toThreadTurnContextError('Failed to load workspace lifecycle state', cause),
+      }).pipe(Effect.withSpan('ThreadTurnContext.loadWorkspaceLifecycleState'))
+    : undefined
+  const readProfileProjectionState = workspaceProvider?.readProfileProjectionState
+    ? (() => {
+        const run = workspaceProvider.readProfileProjectionState.bind(workspaceProvider)
+        return (workspaceRecord: Record<string, unknown>) => run(workspaceRecord)
+      })()
+    : undefined
+  const workspaceProfileState = readProfileProjectionState
+    ? yield* Effect.tryPromise({
+        try: () => readProfileProjectionState(workspace),
+        catch: (cause) => toThreadTurnContextError('Failed to load workspace profile state', cause),
+      }).pipe(Effect.withSpan('ThreadTurnContext.loadWorkspaceProfileState'))
+    : undefined
 
   const onboardingActive = workspaceLifecycleState?.bootstrapActive ?? false
-  const linearInstallation = yield* effectTryPromise(
-    () => getLinearInstallationByOrgId(params.pluginRuntime, params.orgRef),
-    'Failed to load Linear installation',
-  ).pipe(
+  const linearInstallation = yield* Effect.tryPromise({
+    try: () => getLinearInstallationByOrgId(params.pluginRuntime, params.orgRef),
+    catch: (cause) => toThreadTurnContextError('Failed to load Linear installation', cause),
+  }).pipe(
     Effect.catch(() => Effect.succeed(null)),
     Effect.withSpan('ThreadTurnContext.loadLinearInstallation'),
   )
-  const githubInstallation = yield* effectTryPromise(
-    () => getGithubInstallationForOrganization(params.pluginRuntime, params.orgIdString),
-    'Failed to load GitHub installation',
-  ).pipe(
+  const githubInstallation = yield* Effect.tryPromise({
+    try: () => getGithubInstallationForOrganization(params.pluginRuntime, params.orgIdString),
+    catch: (cause) => toThreadTurnContextError('Failed to load GitHub installation', cause),
+  }).pipe(
     Effect.catch(() => Effect.succeed(null)),
     Effect.withSpan('ThreadTurnContext.loadGithubInstallation'),
   )
-  const indexedRepoContext = yield* effectTryPromise(
-    () => buildIndexedRepositoriesContext(params.runtimeAdapters, params.orgIdString),
-    'Failed to build indexed repository context',
-  ).pipe(
+  const indexedRepoContext = yield* Effect.tryPromise({
+    try: () => buildIndexedRepositoriesContext(params.runtimeAdapters, params.orgIdString),
+    catch: (cause) => toThreadTurnContextError('Failed to build indexed repository context', cause),
+  }).pipe(
     Effect.catch(() =>
       Effect.succeed({
         provideRepoTool: false,
@@ -96,17 +107,31 @@ export const assembleThreadTurnContext = Effect.fn('ThreadTurnContext.assemble')
     ),
     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 listRecentDomainEvents = workspaceProvider?.listRecentDomainEvents
+    ? (() => {
+        const run = workspaceProvider.listRecentDomainEvents.bind(workspaceProvider)
+        return (workspaceId: RecordIdRef, limit?: number) => run(workspaceId, limit)
+      })()
+    : undefined
+  const recentDomainEvents = listRecentDomainEvents
+    ? yield* Effect.tryPromise({
+        try: () => listRecentDomainEvents(params.orgRef, 5),
+        catch: (cause) => toThreadTurnContextError('Failed to load recent domain events', cause),
+      }).pipe(Effect.withSpan('ThreadTurnContext.loadRecentDomainEvents'))
+    : []
+  const buildPromptSummary = workspaceProvider?.buildPromptSummary
+    ? (() => {
+        const run = workspaceProvider.buildPromptSummary.bind(workspaceProvider)
+        return (workspaceId: RecordIdRef) => run(workspaceId)
+      })()
+    : undefined
   const promptSummary =
-    params.workspaceProvider?.buildPromptSummary === undefined
+    buildPromptSummary === undefined
       ? undefined
-      : yield* effectTryMaybeAsync(
-          () => params.workspaceProvider?.buildPromptSummary?.(params.orgRef),
-          'Failed to build workspace prompt summary',
-        ).pipe(
+      : yield* Effect.tryPromise({
+          try: () => buildPromptSummary(params.orgRef),
+          catch: (cause) => toThreadTurnContextError('Failed to build workspace prompt summary', cause),
+        }).pipe(
           Effect.catch(() => Effect.as(Effect.void, undefined as string | undefined)),
           Effect.withSpan('ThreadTurnContext.buildPromptSummary'),
         )
@@ -120,41 +145,53 @@ export const assembleThreadTurnContext = Effect.fn('ThreadTurnContext.assemble')
     userName: params.userName ?? undefined,
     recentDomainEvents,
   })
+  const buildRetrievedKnowledgeSection = workspaceProvider?.buildRetrievedKnowledgeSection
+    ? (() => {
+        const run = workspaceProvider.buildRetrievedKnowledgeSection.bind(workspaceProvider)
+        return (input: Parameters<NonNullable<LotaRuntimeWorkspaceProvider['buildRetrievedKnowledgeSection']>>[0]) =>
+          run(input)
+      })()
+    : undefined
   const initialRetrievedKnowledgeSection: string | undefined = !params.messageText
     ? undefined
-    : 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'))
+    : buildRetrievedKnowledgeSection
+      ? yield* Effect.tryPromise({
+          try: () =>
+            buildRetrievedKnowledgeSection({
+              workspaceId: params.orgIdString,
+              userId: params.userIdString,
+              query: params.messageText,
+            }),
+          catch: (cause) => toThreadTurnContextError('Failed to build retrieved knowledge section', cause),
+        }).pipe(Effect.withSpan('ThreadTurnContext.buildRetrievedKnowledgeSection'))
+      : undefined
 
-  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: initialLinearInstalled,
-        githubInstalled: initialGithubInstalled,
-        indexedRepoContext,
-        promptContext: initialPromptContext,
-        workspaceLifecycleState,
-        workspaceProfileState,
-        promptSummary,
-        recentDomainEvents,
-        retrievedKnowledgeSection: initialRetrievedKnowledgeSection,
-      }),
-    'Failed to build thread context',
-  ).pipe(Effect.withSpan('ThreadTurnContext.buildContextHook'))
+  const buildContext = params.turnHooks.buildContext
+  const buildContextResultValue = buildContext
+    ? yield* Effect.tryPromise({
+        try: () =>
+          buildContext({
+            thread: params.thread,
+            threadRef: params.threadRef,
+            orgRef: params.orgRef,
+            userRef: params.userRef,
+            userName: params.userName,
+            workspace,
+            onboardingActive,
+            messageText: params.messageText,
+            linearInstalled: initialLinearInstalled,
+            githubInstalled: initialGithubInstalled,
+            indexedRepoContext,
+            promptContext: initialPromptContext,
+            workspaceLifecycleState,
+            workspaceProfileState,
+            promptSummary,
+            recentDomainEvents,
+            retrievedKnowledgeSection: initialRetrievedKnowledgeSection,
+          }),
+        catch: (cause) => toThreadTurnContextError('Failed to build thread context', cause),
+      }).pipe(Effect.withSpan('ThreadTurnContext.buildContextHook'))
+    : undefined
   const buildContextResult = isRecord(buildContextResultValue) ? buildContextResultValue : null
 
   const buildContextPromptDetails = readOptionalString(buildContextResult?.systemWorkspaceDetails)
@@ -171,31 +208,34 @@ export const assembleThreadTurnContext = Effect.fn('ThreadTurnContext.assemble')
   const githubInstalled =
     buildContextGithubInstalled !== undefined ? buildContextGithubInstalled : initialGithubInstalled
 
+  const buildExtraInstructionSections = params.turnHooks.buildExtraInstructionSections
   const hookInstructionSections = readInstructionSections(
-    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')),
+    buildExtraInstructionSections
+      ? yield* Effect.tryPromise({
+          try: () =>
+            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,
+            }),
+          catch: (cause) => toThreadTurnContextError('Failed to build extra instruction sections', cause),
+        }).pipe(Effect.withSpan('ThreadTurnContext.buildExtraInstructionSections'))
+      : undefined,
   )
 
   return {

package/src/runtime/turn-lifecycle.ts

@@ -2,79 +2,48 @@ import type { ChatMessage } from '@lota-sdk/shared'
 import { Schema, Effect } from 'effect'
 
 import { serverLogger } from '../config/logger'
-import { effectTryMaybeAsync } from '../effect/helpers'
+import { ERROR_TAGS } from '../effect/errors'
 
-export class TurnLifecycleError extends Schema.TaggedErrorClass<TurnLifecycleError>()('TurnLifecycleError', {
+export class TurnLifecycleError extends Schema.TaggedErrorClass<TurnLifecycleError>()(ERROR_TAGS.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: () => MaybeEffect<{ lastCompactedMessageId?: string | null; compactionSummary?: string | null }>
-  getUncompactedMessages: (cursor?: string) => MaybeEffect<ChatMessage[]>
+  getEntity: () => Effect.Effect<
+    { lastCompactedMessageId?: string | null; compactionSummary?: string | null },
+    TurnLifecycleError
+  >
+  getUncompactedMessages: (cursor?: string) => Effect.Effect<ChatMessage[], TurnLifecycleError>
   assessCompaction: (summaryText: string, messages: ChatMessage[]) => { shouldCompact: boolean }
-  enqueueCompaction: () => MaybeEffect<void>
+  enqueueCompaction: () => Effect.Effect<void, TurnLifecycleError>
   unregisterRun: (runId: string) => void
-  clearActiveRunId: (runId: string) => MaybeEffect<void>
+  clearActiveRunId: (runId: string) => Effect.Effect<void, TurnLifecycleError>
   disposeAbort: () => void
   activeStreamId?: string
-  clearActiveStreamId?: (streamId: string) => MaybeEffect<void>
+  clearActiveStreamId?: (streamId: string) => Effect.Effect<void, TurnLifecycleError>
 }): 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 }),
-    )
+    yield* params.clearActiveRunId(params.serverRunId)
     const activeStreamId = params.activeStreamId
     const clearActiveStreamId = params.clearActiveStreamId
     if (activeStreamId && clearActiveStreamId) {
-      yield* effectFromMaybeEffect(
-        () => clearActiveStreamId(activeStreamId),
-        (error) => new TurnLifecycleError({ message: String(error), cause: error }),
-      )
+      yield* clearActiveStreamId(activeStreamId)
     }
     params.disposeAbort()
 
     yield* Effect.gen(function* () {
-      const entity = yield* effectFromMaybeEffect(
-        () => params.getEntity(),
-        (error) => new TurnLifecycleError({ message: String(error), cause: error }),
-      )
+      const entity = yield* params.getEntity()
       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 uncompactedMessages = yield* params.getUncompactedMessages(cursor)
       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 }),
-        )
+        yield* params.enqueueCompaction()
       }
     }).pipe(
       Effect.catch((error: unknown) =>

package/src/services/agent-activity.service.ts

@@ -43,7 +43,7 @@ type AgentActivityDeps = {
 }
 
 class AgentActivityServiceError extends Schema.TaggedErrorClass<AgentActivityServiceError>()(
-  'AgentActivityServiceError',
+  '@lota-sdk/core/AgentActivityServiceError',
   { message: Schema.String, cause: Schema.Defect },
 ) {}