@lota-sdk/core 0.4.9 → 0.4.10

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

@@ -1,7 +1,7 @@
 import { ConsultTeamArgsSchema, withMessageCreatedAt } from '@lota-sdk/shared'
 import type { ChatMessage, ConsultTeamResultData } from '@lota-sdk/shared'
 import { convertToModelMessages, tool as createTool } from 'ai'
-import { Schema, Effect, Fiber, Queue, Ref } from 'effect'
+import { Schema, Deferred, Effect, Exit, Fiber, Queue, Ref, Scope } from 'effect'
 
 import { getAgentDisplayNames, getTeamConsultParticipants } from '../../config/agent-defaults'
 import { nowEpochMillis } from '../../utils/date-time'
@@ -114,8 +114,6 @@ interface ConsultTeamStreamResources {
   workerFiber: Fiber.Fiber<unknown, unknown>
 }
 
-type TeamConsultationResourcesError = TeamConsultationError
-
 function createConsultTeamStreamResources(params: {
   task: string
   uploadMetadataText: string
@@ -272,7 +270,10 @@ function createConsultTeamStreamResources(params: {
 }
 
 class ConsultTeamSnapshotIterable implements AsyncIterableIterator<ConsultTeamResultData> {
-  private readonly initPromise: Promise<ConsultTeamStreamResources>
+  private readonly scope: Scope.Closeable
+  private readonly resourcesDeferred: Deferred.Deferred<ConsultTeamStreamResources, TeamConsultationError>
+  private readonly buildEffect: Effect.Effect<ConsultTeamStreamResources, TeamConsultationError>
+  private initStarted = false
   private closed = false
   private completed = false
 
@@ -291,38 +292,52 @@ class ConsultTeamSnapshotIterable implements AsyncIterableIterator<ConsultTeamRe
       return agentDisplayNames[agentId] ?? agentId
     }
 
-    this.initPromise = Effect.runPromise(
-      createConsultTeamStreamResources({
-        task,
-        uploadMetadataText,
-        teamConsultParticipants,
-        resolveDisplayName,
-        historyMessages: params.historyMessages,
-        latestUserMessageId: params.latestUserMessageId,
-        availableUploads: params.availableUploads,
-        systemWorkspaceDetails: params.systemWorkspaceDetails,
-        getPreSeededMemoriesSection: params.getPreSeededMemoriesSection,
-        retrievedKnowledgeSection: params.retrievedKnowledgeSection,
-        abortSignal: params.abortSignal,
-        participantRunner: params.participantRunner,
-        onReadError: params.onReadError,
-      }),
-    )
+    this.scope = Scope.makeUnsafe()
+    this.resourcesDeferred = Deferred.makeUnsafe<ConsultTeamStreamResources, TeamConsultationError>()
+    this.buildEffect = createConsultTeamStreamResources({
+      task,
+      uploadMetadataText,
+      teamConsultParticipants,
+      resolveDisplayName,
+      historyMessages: params.historyMessages,
+      latestUserMessageId: params.latestUserMessageId,
+      availableUploads: params.availableUploads,
+      systemWorkspaceDetails: params.systemWorkspaceDetails,
+      getPreSeededMemoriesSection: params.getPreSeededMemoriesSection,
+      retrievedKnowledgeSection: params.retrievedKnowledgeSection,
+      abortSignal: params.abortSignal,
+      participantRunner: params.participantRunner,
+      onReadError: params.onReadError,
+    })
   }
 
-  private initResourcesEffect(): Effect.Effect<ConsultTeamStreamResources, TeamConsultationResourcesError> {
-    return Effect.tryPromise({
-      try: () => this.initPromise,
-      catch: (error) =>
-        new TeamConsultationError({ message: 'Failed to initialize team consultation stream.', cause: error }),
-    })
+  /**
+   * Acquire-release: on first call, build the stream resources and register
+   * cleanup as a finalizer in the iterable's scope. Subsequent calls await the
+   * cached `Deferred`. If init fails, no finalizer is registered, so closing
+   * the scope is a no-op for the leaked-resource path.
+   */
+  private acquireResourcesEffect(): Effect.Effect<ConsultTeamStreamResources, TeamConsultationError> {
+    if (this.initStarted) {
+      return Deferred.await(this.resourcesDeferred)
+    }
+    this.initStarted = true
+
+    const acquire = Effect.acquireRelease(this.buildEffect, ({ snapshotQueue, workerFiber }) =>
+      Fiber.interrupt(workerFiber).pipe(Effect.andThen(Queue.shutdown(snapshotQueue))),
+    ).pipe(Scope.provide(this.scope))
+
+    return acquire.pipe(
+      Effect.exit,
+      Effect.flatMap((exit) =>
+        Deferred.done(this.resourcesDeferred, exit).pipe(Effect.andThen(Deferred.await(this.resourcesDeferred))),
+      ),
+    )
   }
 
-  private cleanupEffect(
-    snapshotQueue: Queue.Queue<ConsultTeamSnapshotItem>,
-    workerFiber: Fiber.Fiber<unknown, unknown>,
-  ): Effect.Effect<void, never> {
-    return Effect.andThen(Fiber.interrupt(workerFiber), Queue.shutdown(snapshotQueue))
+  /** Close the scope idempotently. Runs cleanup finalizers iff init succeeded. */
+  private closeScopeEffect(): Effect.Effect<void, never> {
+    return Scope.close(this.scope, Exit.void).pipe(Effect.catchCause(() => Effect.void))
   }
 
   [Symbol.asyncIterator](): AsyncIterableIterator<ConsultTeamResultData> {
@@ -337,7 +352,7 @@ class ConsultTeamSnapshotIterable implements AsyncIterableIterator<ConsultTeamRe
     return Effect.runPromise(
       Effect.gen(
         function* (this: ConsultTeamSnapshotIterable) {
-          const { snapshotQueue, workerFiber } = yield* this.initResourcesEffect()
+          const { snapshotQueue } = yield* this.acquireResourcesEffect()
 
           if (this.completed) {
             return { done: true, value: undefined as never }
@@ -346,40 +361,31 @@ class ConsultTeamSnapshotIterable implements AsyncIterableIterator<ConsultTeamRe
           const item = yield* Queue.take(snapshotQueue)
           if (item === DONE) {
             this.completed = true
-            yield* this.cleanupEffect(snapshotQueue, workerFiber)
+            this.closed = true
+            yield* this.closeScopeEffect()
             return { done: true, value: undefined as never }
           }
 
           return { done: false, value: item }
         }.bind(this),
+      ).pipe(
+        Effect.tapCause(() =>
+          Effect.sync(() => {
+            this.closed = true
+          }).pipe(Effect.andThen(this.closeScopeEffect())),
+        ),
       ),
     )
   }
 
   return(): Promise<IteratorResult<ConsultTeamResultData>> {
     this.closed = true
-    return Effect.runPromise(
-      Effect.gen(
-        function* (this: ConsultTeamSnapshotIterable) {
-          const { snapshotQueue, workerFiber } = yield* this.initResourcesEffect()
-          yield* this.cleanupEffect(snapshotQueue, workerFiber)
-          return { done: true, value: undefined as never }
-        }.bind(this),
-      ),
-    )
+    return Effect.runPromise(this.closeScopeEffect().pipe(Effect.as({ done: true, value: undefined as never })))
   }
 
   throw(error: unknown): Promise<never> {
     this.closed = true
-    return Effect.runPromise(
-      Effect.gen(
-        function* (this: ConsultTeamSnapshotIterable) {
-          const { snapshotQueue, workerFiber } = yield* this.initResourcesEffect()
-          yield* this.cleanupEffect(snapshotQueue, workerFiber)
-          return yield* Effect.fail(error as never)
-        }.bind(this),
-      ),
-    )
+    return Effect.runPromise(this.closeScopeEffect().pipe(Effect.andThen(Effect.fail(error as never))))
   }
 }
 

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

@@ -3,10 +3,7 @@ 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 { effectTryMaybeAsync as effectTryMaybeAsyncShared, makeEffectTryPromiseWithMessage } from '../effect/helpers'
 import { buildAgentPromptContext } from './agent-prompt-context'
 import {
   buildIndexedRepositoriesContext,
@@ -35,9 +32,9 @@ class ThreadTurnContextError extends Schema.TaggedErrorClass<ThreadTurnContextEr
   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 }))
-}
+const effectTryPromise = makeEffectTryPromiseWithMessage(
+  (message, cause) => new ThreadTurnContextError({ message, cause }),
+)
 
 function effectTryMaybeAsync<A>(
   evaluate: () => A | PromiseLike<A>,
@@ -129,16 +126,16 @@ const assembleThreadTurnContextEffect = Effect.fn('ThreadTurnContext.assemble')(
           Effect.withSpan('ThreadTurnContext.buildPromptSummary'),
         )
 
-  let linearInstalled = Boolean(linearInstallation)
-  let githubInstalled = Boolean(githubInstallation)
-  let promptContext = buildAgentPromptContext({
+  const initialLinearInstalled = Boolean(linearInstallation)
+  const initialGithubInstalled = Boolean(githubInstallation)
+  const initialPromptContext = buildAgentPromptContext({
     workspaceName: workspaceProfileState?.workspaceName ?? readOptionalString(workspace.name) ?? undefined,
     summaryBlock: workspaceProfileState?.summaryBlock,
     promptSummary,
     userName: params.userName ?? undefined,
     recentDomainEvents,
   })
-  let retrievedKnowledgeSection: string | undefined = !params.messageText
+  const initialRetrievedKnowledgeSection: string | undefined = !params.messageText
     ? undefined
     : yield* effectTryMaybeAsync(
         () =>
@@ -161,36 +158,33 @@ const assembleThreadTurnContextEffect = Effect.fn('ThreadTurnContext.assemble')(
         workspace,
         onboardingActive,
         messageText: params.messageText,
-        linearInstalled,
-        githubInstalled,
+        linearInstalled: initialLinearInstalled,
+        githubInstalled: initialGithubInstalled,
         indexedRepoContext,
-        promptContext,
+        promptContext: initialPromptContext,
         workspaceLifecycleState,
         workspaceProfileState,
         promptSummary,
         recentDomainEvents,
-        retrievedKnowledgeSection,
+        retrievedKnowledgeSection: initialRetrievedKnowledgeSection,
       }),
     'Failed to build thread context',
   ).pipe(Effect.withSpan('ThreadTurnContext.buildContextHook'))
   const buildContextResult = isRecord(buildContextResultValue) ? buildContextResultValue : null
 
   const buildContextPromptDetails = readOptionalString(buildContextResult?.systemWorkspaceDetails)
-  if (buildContextPromptDetails) {
-    promptContext = { systemWorkspaceDetails: buildContextPromptDetails }
-  }
+  const promptContext = buildContextPromptDetails
+    ? { systemWorkspaceDetails: buildContextPromptDetails }
+    : initialPromptContext
   const buildContextRetrievedKnowledge = readOptionalString(buildContextResult?.retrievedKnowledgeSection)
-  if (buildContextRetrievedKnowledge !== undefined) {
-    retrievedKnowledgeSection = buildContextRetrievedKnowledge
-  }
+  const retrievedKnowledgeSection =
+    buildContextRetrievedKnowledge !== undefined ? buildContextRetrievedKnowledge : initialRetrievedKnowledgeSection
   const buildContextLinearInstalled = readOptionalBoolean(buildContextResult?.linearInstalled)
-  if (buildContextLinearInstalled !== undefined) {
-    linearInstalled = buildContextLinearInstalled
-  }
+  const linearInstalled =
+    buildContextLinearInstalled !== undefined ? buildContextLinearInstalled : initialLinearInstalled
   const buildContextGithubInstalled = readOptionalBoolean(buildContextResult?.githubInstalled)
-  if (buildContextGithubInstalled !== undefined) {
-    githubInstalled = buildContextGithubInstalled
-  }
+  const githubInstalled =
+    buildContextGithubInstalled !== undefined ? buildContextGithubInstalled : initialGithubInstalled
 
   const hookInstructionSections = readInstructionSections(
     yield* effectTryMaybeAsync(

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

@@ -446,7 +446,7 @@ export function createAgentActivityService(deps: AgentActivityDeps | (() => Agen
 export type AgentActivityService = ReturnType<typeof createAgentActivityService>
 
 export class AgentActivityServiceTag extends Context.Service<AgentActivityServiceTag, AgentActivityService>()(
-  'AgentActivityService',
+  '@lota-sdk/core/AgentActivityService',
 ) {}
 
 export const AgentActivityServiceLive = Layer.effect(