@lota-sdk/core 0.4.13 → 0.4.14

package/src/services/thread/thread-turn-execution.ts

@@ -6,7 +6,6 @@ import { Schema, Effect } from 'effect'
 import type { ResolvedAgentConfig } from '../../config/agent-defaults'
 import { aiLogger } from '../../config/logger'
 import type { RecordIdRef } from '../../db/record-id'
-import { effectTryMaybeAsync, effectTryPromise as effectTryPromiseShared } from '../../effect/helpers'
 import type { readRuntimeAgentIdentityOverrides } from '../../runtime/agent-identity-overrides'
 import { resolveRuntimeAgentDisplayName } from '../../runtime/agent-identity-overrides'
 import { OWNERSHIP_DISPATCH_BLOCKED_TOOL_NAMES } from '../../runtime/agent-runtime-policy'
@@ -68,7 +67,7 @@ interface VisibleAgentRunParams {
 
 interface VisibleAgentRunnerDeps<TBuildTurnToolParams> {
   agentConfig: ResolvedAgentConfig
-  agentFactoryConfig: { buildAgentTools: (params: TBuildTurnToolParams) => Promise<ToolSet> | ToolSet }
+  agentFactoryConfig: { buildAgentTools: (params: TBuildTurnToolParams) => Promise<ToolSet> }
   buildTurnToolParams: (params: {
     agentId: string
     mode: 'direct' | 'fixedThreadMode' | 'threadMode'
@@ -101,19 +100,6 @@ export function createThreadTurnVisibleAgentRunner<TBuildTurnToolParams>(
     { message: Schema.String, cause: Schema.optional(Schema.Defect) },
   ) {}
 
-  const effectTryPromise = <A, R = never>(
-    evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown, R>,
-    message: string,
-  ): Effect.Effect<A, ThreadTurnExecutionError, R> =>
-    effectTryPromiseShared(evaluate, (error) => new ThreadTurnExecutionError({ message, cause: error }))
-
-  function effectFromMaybePromise<A>(
-    evaluate: () => A | PromiseLike<A>,
-    message: string,
-  ): Effect.Effect<A, ThreadTurnExecutionError> {
-    return effectTryMaybeAsync(evaluate, (error) => new ThreadTurnExecutionError({ message, cause: error }))
-  }
-
   const buildAgentMetadataPatch = (agentId: string, agentName: string): NonNullable<MessageMetadata> => ({
     agentId,
     agentName,
@@ -131,7 +117,8 @@ export function createThreadTurnVisibleAgentRunner<TBuildTurnToolParams>(
       )
 
   const createObserver = (agentId: string) => ({
-    run: async <T>(fn: () => T | Promise<T>): Promise<T> => {
+    // @effect-diagnostics-next-line asyncFunction:off -- AI SDK observer callback signature.
+    run: async <T>(fn: () => Promise<T>): Promise<T> => {
       try {
         return await fn()
       } catch (error) {
@@ -204,8 +191,8 @@ export function createThreadTurnVisibleAgentRunner<TBuildTurnToolParams>(
   ) {
     let runMemoryBlock = deps.getMemoryBlock()
     const includeExecutionPlanTools = runParams.includeExecutionPlanTools ?? runParams.mode !== 'fixedThreadMode'
-    const builtTools = yield* effectFromMaybePromise(
-      () =>
+    const builtTools = yield* Effect.tryPromise({
+      try: () =>
         deps.agentFactoryConfig.buildAgentTools(
           deps.buildTurnToolParams({
             agentId: runParams.agentId,
@@ -219,27 +206,33 @@ export function createThreadTurnVisibleAgentRunner<TBuildTurnToolParams>(
             includeExecutionPlanTools,
           }),
         ),
-      `Failed to build tools for ${runParams.agentId}.`,
-    ).pipe(Effect.withSpan('ThreadTurnExecution.buildAgentTools'))
+      catch: (error) =>
+        new ThreadTurnExecutionError({ message: `Failed to build tools for ${runParams.agentId}.`, cause: error }),
+    }).pipe(Effect.withSpan('ThreadTurnExecution.buildAgentTools'))
     const rawTools = { ...builtTools, ...runParams.extraTools }
     const tools = runParams.filterTools ? runParams.filterTools(rawTools) : rawTools
     deps.streamCtx.memoryBlock = runMemoryBlock
     yield* failIfRunAborted()
-    const responseMessage = yield* effectTryPromise(
-      () =>
-        streamAgentResponse(deps.streamCtx, {
-          agentId: runParams.agentId,
-          mode: runParams.mode,
-          messages: deps.threadTurnMessageContext.buildRunInputMessages(runParams.extraMessages),
-          tools,
-          observer: createObserver(runParams.agentId),
-          skills: runParams.skills,
-          additionalInstructionSections: runParams.additionalInstructionSections,
-          includeExecutionPlanTools,
-          writer: deps.writer,
-        }),
-      `Failed to stream response for ${runParams.agentId}.`,
-    ).pipe(Effect.withSpan('ThreadTurnExecution.streamVisibleAgent'))
+    const responseMessage = yield* streamAgentResponse(deps.streamCtx, {
+      agentId: runParams.agentId,
+      mode: runParams.mode,
+      messages: deps.threadTurnMessageContext.buildRunInputMessages(runParams.extraMessages),
+      tools,
+      observer: createObserver(runParams.agentId),
+      skills: runParams.skills,
+      additionalInstructionSections: runParams.additionalInstructionSections,
+      includeExecutionPlanTools,
+      writer: deps.writer,
+    }).pipe(
+      Effect.mapError(
+        (error) =>
+          new ThreadTurnExecutionError({
+            message: `Failed to stream response for ${runParams.agentId}.`,
+            cause: error,
+          }),
+      ),
+      Effect.withSpan('ThreadTurnExecution.streamVisibleAgent'),
+    )
     deps.setMemoryBlock(runMemoryBlock)
 
     // Commit the response under `uninterruptible` so a late lease-lost or
@@ -248,16 +241,21 @@ export function createThreadTurnVisibleAgentRunner<TBuildTurnToolParams>(
     // this, a race between stream completion and lease refresh rejection
     // swallows the response without any error trace.
     return yield* Effect.uninterruptible(
-      effectTryPromise(
-        () =>
-          commitAssistantResponse(
-            responseMessage,
-            runParams.agentId,
-            resolveRuntimeAgentDisplayName(deps.agentConfig, deps.agentIdentityOverrides, runParams.agentId),
-            runParams.metadataPatch,
-          ),
-        `Failed to commit assistant response for ${runParams.agentId}.`,
-      ).pipe(Effect.withSpan('ThreadTurnExecution.commitAssistantResponse')),
+      commitAssistantResponse(
+        responseMessage,
+        runParams.agentId,
+        resolveRuntimeAgentDisplayName(deps.agentConfig, deps.agentIdentityOverrides, runParams.agentId),
+        runParams.metadataPatch,
+      ).pipe(
+        Effect.mapError(
+          (error) =>
+            new ThreadTurnExecutionError({
+              message: `Failed to commit assistant response for ${runParams.agentId}.`,
+              cause: error,
+            }),
+        ),
+        Effect.withSpan('ThreadTurnExecution.commitAssistantResponse'),
+      ),
     )
   })