@lota-sdk/core 0.4.13 → 0.4.14

package/src/system-agents/title-generator.agent.ts

@@ -1,7 +1,7 @@
 import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 
-import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_FAST_REASONING_MODEL_ID,
@@ -30,15 +30,16 @@ Return only the title text. No quotes, no labels, no explanation.
 </output-format>
 </agent-instructions>`
 
-export function createThreadTitleGeneratorAgent(options: CreateHelperToolLoopAgentOptions) {
-  return new ToolLoopAgent({
-    id: 'thread-title-generator',
-    model: aiGatewayChatModel(OPENROUTER_FAST_REASONING_MODEL_ID),
-    headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
-    providerOptions: OPENROUTER_MINIMAL_REASONING_PROVIDER_OPTIONS,
-    ...resolveHelperAgentOptions(options, {
-      instructions: THREAD_TITLE_GENERATOR_PROMPT,
-      maxOutputTokens: THREAD_TITLE_MAX_TOKENS,
-    }),
-  })
+export function makeThreadTitleGeneratorAgentFactory(models: AiGatewayModels) {
+  return (options: CreateHelperToolLoopAgentOptions) =>
+    new ToolLoopAgent({
+      id: 'thread-title-generator',
+      model: models.chatModel(OPENROUTER_FAST_REASONING_MODEL_ID),
+      headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
+      providerOptions: OPENROUTER_MINIMAL_REASONING_PROVIDER_OPTIONS,
+      ...resolveHelperAgentOptions(options, {
+        instructions: THREAD_TITLE_GENERATOR_PROMPT,
+        maxOutputTokens: THREAD_TITLE_MAX_TOKENS,
+      }),
+    })
 }

package/src/tools/fetch-webpage.tool.ts

@@ -12,6 +12,7 @@ import { toRecord, WEB_TOOL_TIMEOUT_MS } from './web-tool-shared'
 
 export interface FetchWebpageToolContext {
   firecrawl: Firecrawl
+  runPromise: <A, E>(effect: Effect.Effect<A, E, never>, options?: { signal?: AbortSignal }) => Promise<A>
 }
 
 class FetchWebpageToolError extends Schema.TaggedErrorClass<FetchWebpageToolError>()(
@@ -102,7 +103,7 @@ function buildFetchCitations(url: string, document: unknown): WebCitation[] {
 
 export const fetchWebpageTool = {
   name: 'fetchWebpage',
-  create: ({ firecrawl }: FetchWebpageToolContext) =>
+  create: ({ firecrawl, runPromise }: FetchWebpageToolContext) =>
     tool({
       description: 'Retrieve and parse a single webpage.',
       inputSchema: z
@@ -113,18 +114,16 @@ export const fetchWebpageTool = {
           maxAge: z.number().int().min(1).optional(),
         })
         .strict(),
-      execute: ({
-        url,
-        formats,
-        onlyMainContent,
-        maxAge,
-      }: {
-        url: string
-        formats?: z.infer<typeof FormatSchema>[]
-        onlyMainContent?: boolean
-        maxAge?: number
-      }) =>
-        Effect.runPromise(
+      execute: (
+        {
+          url,
+          formats,
+          onlyMainContent,
+          maxAge,
+        }: { url: string; formats?: z.infer<typeof FormatSchema>[]; onlyMainContent?: boolean; maxAge?: number },
+        { abortSignal }: { abortSignal?: AbortSignal } = {},
+      ) =>
+        runPromise(
           Effect.gen(function* () {
             const result = yield* Effect.tryPromise({
               try: () =>
@@ -141,6 +140,7 @@ export const fetchWebpageTool = {
             })
             return { url, document: summarizeDocument(url, result), citations: buildFetchCitations(url, result) }
           }).pipe(Effect.withSpan('tool.fetchWebpage.execute')),
+          abortSignal ? { signal: abortSignal } : undefined,
         ),
     }),
 } as const satisfies ToolDefinition<FetchWebpageToolContext>

package/src/tools/memory-block.tool.ts

@@ -18,12 +18,14 @@ export function createMemoryBlockTool({
   threadId,
   agentLabel,
   threadService,
+  runPromise,
   getCurrentBlock,
   onAppend,
 }: {
   threadId: RecordIdRef
   agentLabel: string
   threadService: MemoryBlockThreadService
+  runPromise: <A, E>(effect: Effect.Effect<A, E, never>) => Promise<A>
   getCurrentBlock?: () => string
   onAppend?: (value: string) => void
 }) {
@@ -48,7 +50,7 @@ export function createMemoryBlockTool({
 
       void safeEnqueue(
         () =>
-          Effect.runPromise(
+          runPromise(
             Effect.gen(function* () {
               const updated = yield* threadService.appendMemoryBlock(threadId, prepared.formatted)
               onAppend?.(updated)

package/src/tools/plan-approval.tool.ts

@@ -21,14 +21,15 @@ export function createPlanApprovalTool(params: {
   threadId: RecordIdRef
   actorId: string
   executionPlanService: PlanApprovalExecutionPlanService
+  runPromise: <A, E>(effect: Effect.Effect<A, E, never>, options?: { signal?: AbortSignal }) => Promise<A>
 }) {
   return tool({
     description:
       'Approve, reject, or request changes to a plan that is pending approval. Use approve to start execution, reject to abort it, or modify to request a revised plan.',
     inputSchema: PlanApprovalArgsSchema,
     outputSchema: PlanApprovalToolResultDataSchema,
-    execute: (input) =>
-      Effect.runPromise(
+    execute: (input, { abortSignal }: { abortSignal?: AbortSignal } = {}) =>
+      params.runPromise(
         Effect.gen(function* () {
           switch (input.action) {
             case 'approve': {
@@ -71,6 +72,7 @@ export function createPlanApprovalTool(params: {
             }
           }
         }),
+        abortSignal ? { signal: abortSignal } : undefined,
       ),
   })
 }

package/src/tools/read-file-parts.tool.ts

@@ -3,6 +3,7 @@ import { Schema, Effect } from 'effect'
 import { z } from 'zod'
 
 import type { ToolDefinition } from '../ai/definitions'
+import { ERROR_TAGS } from '../effect/errors'
 import type { makeAttachmentService } from '../services/attachment.service'
 import type { ReadableUploadMetadata } from '../storage/attachment-types'
 
@@ -15,6 +16,7 @@ export interface ReadFilePartsToolContext {
   userId: string
   uploads: ReadableUploadMetadata[]
   attachmentService: ReadFilePartsAttachmentService
+  runPromise: <A, E>(effect: Effect.Effect<A, E, never>, options?: { signal?: AbortSignal }) => Promise<A>
 }
 
 function toUploadSummary(upload: ReadableUploadMetadata) {
@@ -26,7 +28,7 @@ function toUploadSummary(upload: ReadableUploadMetadata) {
   }
 }
 
-class ReadFilePartsError extends Schema.TaggedErrorClass<ReadFilePartsError>()('ReadFilePartsError', {
+class ReadFilePartsError extends Schema.TaggedErrorClass<ReadFilePartsError>()(ERROR_TAGS.ReadFilePartsError, {
   message: Schema.String,
 }) {}
 
@@ -47,15 +49,18 @@ function resolveUploadTargetEffect(params: {
 
 export const readFilePartsTool = {
   name: 'readFileParts',
-  create: ({ orgId, userId, uploads, attachmentService }: ReadFilePartsToolContext) =>
+  create: ({ orgId, userId, uploads, attachmentService, runPromise }: ReadFilePartsToolContext) =>
     tool({
       description:
         'Read uploaded file content by part. Call with no args to list uploads metadata, then call with storageKey and part (25 pages per part).',
       inputSchema: z
         .object({ storageKey: z.string().trim().min(1).optional(), part: z.number().int().positive().default(1) })
         .strict(),
-      execute: ({ storageKey, part }: { storageKey?: string; part?: number }) =>
-        Effect.runPromise(
+      execute: (
+        { storageKey, part }: { storageKey?: string; part?: number },
+        { abortSignal }: { abortSignal?: AbortSignal } = {},
+      ) =>
+        runPromise(
           Effect.gen(function* () {
             const availableUploads = uploads.map(toUploadSummary)
             const selected = yield* resolveUploadTargetEffect({ uploads, storageKey })
@@ -86,6 +91,7 @@ export const readFilePartsTool = {
 
             return { availableUploads, selectedUpload: toUploadSummary(selected), ...parts }
           }),
+          abortSignal ? { signal: abortSignal } : undefined,
         ),
     }),
 } as const satisfies ToolDefinition<ReadFilePartsToolContext>

package/src/tools/remember-memory.tool.ts

@@ -24,10 +24,12 @@ export function createRememberMemoryTool({
   orgId,
   agentName,
   memoryService,
+  runPromise,
 }: {
   orgId: RecordIdRef
   agentName: string
   memoryService: RememberMemoryService
+  runPromise: <A, E>(effect: Effect.Effect<A, E, never>) => Promise<A>
 }) {
   return tool({
     description:
@@ -42,7 +44,7 @@ export function createRememberMemoryTool({
       const orgIdString = recordIdToString(orgId, TABLES.ORGANIZATION)
       void safeEnqueue(
         () =>
-          Effect.runPromise(
+          runPromise(
             Effect.gen(function* () {
               const assessment = yield* memoryService.assessMemoryCandidate({ orgId: orgIdString, content: trimmed })
               if (!assessment) {

package/src/tools/research-topic.tool.ts

@@ -1,6 +1,7 @@
 import type Firecrawl from '@mendable/firecrawl-js'
+import type { Effect } from 'effect'
 
-import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayStrictSemanticCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_FAST_REASONING_MODEL_ID,
@@ -13,19 +14,22 @@ import { searchWebTool } from './search-web.tool'
 
 export interface ResearchTopicToolContext {
   firecrawl: Firecrawl
+  aiGatewayModels: AiGatewayModels
+  runPromise: <A, E>(effect: Effect.Effect<A, E, never>, options?: { signal?: AbortSignal }) => Promise<A>
 }
 
 export const researchTopicTool = createDelegatedAgentToolWithContext<ResearchTopicToolContext>({
   id: 'researchTopic',
   description:
     'Delegate a research task to a dedicated research agent that searches the web, fetches pages, and returns a synthesized markdown report.',
-  model: () => aiGatewayChatModel(OPENROUTER_FAST_REASONING_MODEL_ID),
+  model: ({ aiGatewayModels }) => aiGatewayModels.chatModel(OPENROUTER_FAST_REASONING_MODEL_ID),
   providerOptions: OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS,
   headers: buildAiGatewayStrictSemanticCacheHeaders('researchTopic'),
   instructions: RESEARCHER_PROMPT,
-  createTools: ({ firecrawl }) => ({
-    searchWeb: searchWebTool.create({ firecrawl }),
-    fetchWebpage: fetchWebpageTool.create({ firecrawl }),
+  createTools: ({ firecrawl, runPromise }) => ({
+    searchWeb: searchWebTool.create({ firecrawl, runPromise }),
+    fetchWebpage: fetchWebpageTool.create({ firecrawl, runPromise }),
   }),
   maxSteps: 6,
+  getRunPromise: (context) => context.runPromise,
 })

package/src/tools/search-web.tool.ts

@@ -4,6 +4,7 @@ import { Effect, Schema } from 'effect'
 import { z } from 'zod'
 
 import type { ToolDefinition } from '../ai/definitions'
+import { ERROR_TAGS } from '../effect/errors'
 import { withTimeout } from '../utils/async'
 import { nowIsoDateTimeString } from '../utils/date-time'
 import { readStringField, truncateOptionalText } from '../utils/string'
@@ -12,9 +13,10 @@ import { toRecord, WEB_TOOL_TIMEOUT_MS } from './web-tool-shared'
 
 export interface SearchWebToolContext {
   firecrawl: Firecrawl
+  runPromise: <A, E>(effect: Effect.Effect<A, E, never>, options?: { signal?: AbortSignal }) => Promise<A>
 }
 
-class SearchWebToolError extends Schema.TaggedErrorClass<SearchWebToolError>()('@lota-sdk/core/SearchWebToolError', {
+class SearchWebToolError extends Schema.TaggedErrorClass<SearchWebToolError>()(ERROR_TAGS.SearchWebToolError, {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect),
 }) {}
@@ -139,7 +141,7 @@ function buildWebCitations(results: { web?: unknown[]; news?: unknown[]; images?
 
 export const searchWebTool = {
   name: 'searchWeb',
-  create: ({ firecrawl }: SearchWebToolContext) =>
+  create: ({ firecrawl, runPromise }: SearchWebToolContext) =>
     tool({
       description: 'Search the web for real-time information.',
       inputSchema: z
@@ -151,20 +153,17 @@ export const searchWebTool = {
           tbs: z.string().optional(),
         })
         .strict(),
-      execute: ({
-        query,
-        limit,
-        sources,
-        location,
-        tbs,
-      }: {
-        query: string
-        limit?: number
-        sources?: ('web' | 'news' | 'images')[]
-        location?: string
-        tbs?: string
-      }) =>
-        Effect.runPromise(
+      execute: (
+        {
+          query,
+          limit,
+          sources,
+          location,
+          tbs,
+        }: { query: string; limit?: number; sources?: ('web' | 'news' | 'images')[]; location?: string; tbs?: string },
+        { abortSignal }: { abortSignal?: AbortSignal } = {},
+      ) =>
+        runPromise(
           Effect.gen(function* () {
             const results = yield* Effect.tryPromise({
               try: () =>
@@ -185,6 +184,7 @@ export const searchWebTool = {
               citations: buildWebCitations(results),
             }
           }).pipe(Effect.withSpan('tool.searchWeb.execute')),
+          abortSignal ? { signal: abortSignal } : undefined,
         ),
     }),
 } as const satisfies ToolDefinition<SearchWebToolContext>

package/src/tools/search.tool.ts

@@ -15,18 +15,24 @@ const ConversationSearchInputSchema = z.object({ query: z.string().min(1), type:
 type MemorySearchService = Pick<ReturnType<typeof createMemoryService>, 'searchAllMemoriesBatched'>
 type ConversationSearchService = Pick<ReturnType<typeof makeThreadMessageService>, 'searchMessagesEffect'>
 
+type SearchToolRunPromise = <A, E>(effect: Effect.Effect<A, E, never>, options?: { signal?: AbortSignal }) => Promise<A>
+
 export function createMemorySearchTool(
   agentConfig: ResolvedAgentConfig,
   orgIdString: string,
   memoryService: MemorySearchService,
+  runPromise: SearchToolRunPromise,
   agentName?: string,
   options?: { fastMode?: boolean; allowMultiScopeRerank?: boolean },
 ) {
   return tool({
     description: 'Search organization and agent memories relevant to a query.',
     inputSchema: MemorySearchInputSchema,
-    execute: ({ query }: z.infer<typeof MemorySearchInputSchema>) =>
-      Effect.runPromise(
+    execute: (
+      { query }: z.infer<typeof MemorySearchInputSchema>,
+      { abortSignal }: { abortSignal?: AbortSignal } = {},
+    ) =>
+      runPromise(
         Effect.gen(function* () {
           const normalizedQuery = query.trim()
           const retrieval = yield* memoryService.searchAllMemoriesBatched({
@@ -41,16 +47,24 @@ export function createMemorySearchTool(
           const reminder = `Remember: you searched for "${normalizedQuery}". Use the highest-relevance retrieved lines above to answer.`
           return { query: normalizedQuery, retrieval, reminder }
         }),
+        abortSignal ? { signal: abortSignal } : undefined,
       ),
   })
 }
 
-export function createConversationSearchTool(threadId: RecordIdRef, threadMessageService: ConversationSearchService) {
+export function createConversationSearchTool(
+  threadId: RecordIdRef,
+  threadMessageService: ConversationSearchService,
+  runPromise: SearchToolRunPromise,
+) {
   return tool({
     description: 'Search prior chat messages by role and query text.',
     inputSchema: ConversationSearchInputSchema,
-    execute: ({ query, type }: z.infer<typeof ConversationSearchInputSchema>) =>
-      Effect.runPromise(
+    execute: (
+      { query, type }: z.infer<typeof ConversationSearchInputSchema>,
+      { abortSignal }: { abortSignal?: AbortSignal } = {},
+    ) =>
+      runPromise(
         Effect.gen(function* () {
           const normalizedQuery = query.trim()
           const results = yield* threadMessageService.searchMessagesEffect({
@@ -61,6 +75,7 @@ export function createConversationSearchTool(threadId: RecordIdRef, threadMessag
           })
           return { query: normalizedQuery, type, count: results.length, results }
         }),
+        abortSignal ? { signal: abortSignal } : undefined,
       ),
   })
 }

package/src/tools/team-think.tool.ts

@@ -7,7 +7,7 @@ import { aiLogger } from '../config/logger'
 import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
-import { effectTryMaybeAsync as effectTryMaybeAsyncShared } from '../effect/helpers'
+import { ERROR_TAGS } from '../effect/errors'
 import {
   AgentConfigServiceTag,
   AgentFactoryServiceTag,
@@ -35,29 +35,25 @@ function buildTeamThinkAgentToolsEffect(
     return Effect.succeed({ tools: {} })
   }
 
-  return effectTryMaybeAsync(() => builder(params), 'Failed to build team-think agent tools.')
+  return Effect.tryPromise({
+    try: () => builder(params),
+    catch: (error) => new TeamThinkRuntimeError({ message: 'Failed to build team-think agent tools.', cause: error }),
+  })
 }
 
 const TEAM_THINK_AGENT_MAX_RETRIES = 1
 const TEAM_THINK_AGENT_MAX_STEPS = 3
 
 class TeamThinkAgentFactoryNotConfiguredError extends Schema.TaggedErrorClass<TeamThinkAgentFactoryNotConfiguredError>()(
-  'TeamThinkAgentFactoryNotConfiguredError',
+  '@lota-sdk/core/TeamThinkAgentFactoryNotConfiguredError',
   { agentId: Schema.String },
 ) {}
 
-class TeamThinkRuntimeError extends Schema.TaggedErrorClass<TeamThinkRuntimeError>()('TeamThinkRuntimeError', {
+class TeamThinkRuntimeError extends Schema.TaggedErrorClass<TeamThinkRuntimeError>()(ERROR_TAGS.TeamThinkRuntimeError, {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect),
 }) {}
 
-function effectTryMaybeAsync<A>(
-  evaluate: () => A | PromiseLike<A>,
-  message: string,
-): Effect.Effect<A, TeamThinkRuntimeError> {
-  return effectTryMaybeAsyncShared(evaluate, (error) => new TeamThinkRuntimeError({ message, cause: error }))
-}
-
 export function createTeamThinkTool(params: {
   historyMessages: ChatMessage[]
   latestUserMessageId: string
@@ -76,6 +72,7 @@ export function createTeamThinkTool(params: {
   context?: unknown
   toolProviders?: ToolSet
   abortSignal: AbortSignal
+  runPromise: <A, E>(effect: Effect.Effect<A, E, never>, options?: { signal?: AbortSignal }) => Promise<A>
 }) {
   return Effect.gen(function* () {
     const turnHooks = yield* TurnHooksServiceTag
@@ -87,35 +84,54 @@ export function createTeamThinkTool(params: {
     )
     const participantRunner: TeamConsultationParticipantRunner = {
       buildParticipantAgent(agentId, runParams) {
-        return Effect.runPromise(
+        return params.runPromise(
           Effect.gen(function* () {
+            // Capture the fiber context of the managed runtime and replay it
+            // for observer callbacks that cross the Effect → Promise boundary
+            // (AI SDK agent observers). This preserves spans/loggers across
+            // the callback edge — it is NOT an ambient-runtime slot; the
+            // captured context lives only for this participant's fiber.
             const currentContext = yield* Effect.context()
             const runPromiseWithCurrentContext = Effect.runPromiseWith(currentContext)
-            const dynamicInstructionSections = yield* effectTryMaybeAsync(
-              () => params.getAdditionalInstructionSections?.(),
-              'Failed to load dynamic team-think instruction sections.',
-            )
+            const getAdditionalInstructionSections = params.getAdditionalInstructionSections
+            const dynamicInstructionSections = getAdditionalInstructionSections
+              ? yield* Effect.tryPromise({
+                  try: () => getAdditionalInstructionSections(),
+                  catch: (error) =>
+                    new TeamThinkRuntimeError({
+                      message: 'Failed to load dynamic team-think instruction sections.',
+                      cause: error,
+                    }),
+                })
+              : undefined
+            const resolveAgent = turnHooks.resolveAgent
             const agentResolution = asRecord(
-              yield* effectTryMaybeAsync(
-                () =>
-                  turnHooks.resolveAgent?.({
-                    agentId,
-                    mode: 'fixedThreadMode',
-                    thread: null,
-                    threadRef: params.threadId,
-                    orgRef: params.orgId,
-                    userRef: params.userId,
-                    onboardingActive: false,
-                    linearInstalled: false,
-                    githubInstalled: params.githubInstalled,
-                    additionalInstructionSections: mergeInstructionSections(
-                      dynamicInstructionSections,
-                      params.additionalInstructionSections,
-                    ),
-                    context: (params.context as Record<string, unknown> | null | undefined) ?? null,
-                  }),
-                'Failed to resolve team-think participant agent.',
-              ),
+              resolveAgent
+                ? yield* Effect.tryPromise({
+                    try: () =>
+                      resolveAgent({
+                        agentId,
+                        mode: 'fixedThreadMode',
+                        thread: null,
+                        threadRef: params.threadId,
+                        orgRef: params.orgId,
+                        userRef: params.userId,
+                        onboardingActive: false,
+                        linearInstalled: false,
+                        githubInstalled: params.githubInstalled,
+                        additionalInstructionSections: mergeInstructionSections(
+                          dynamicInstructionSections,
+                          params.additionalInstructionSections,
+                        ),
+                        context: (params.context as Record<string, unknown> | null | undefined) ?? null,
+                      }),
+                    catch: (error) =>
+                      new TeamThinkRuntimeError({
+                        message: 'Failed to resolve team-think participant agent.',
+                        cause: error,
+                      }),
+                  })
+                : undefined,
             )
             const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? agentId
             const config = agentFactoryConfig.getAgentRuntimeConfig({
@@ -169,9 +185,16 @@ export function createTeamThinkTool(params: {
               stopWhen: [stepCountIs(maxSteps)],
             })
             const observer = {
-              run: <T>(fn: () => T | Promise<T>): Promise<T> =>
+              run: <T>(fn: () => Promise<T>): Promise<T> =>
                 runPromiseWithCurrentContext(
-                  effectTryMaybeAsync(fn, `Team-think participant run failed (${agentId}).`),
+                  Effect.tryPromise({
+                    try: () => fn(),
+                    catch: (error) =>
+                      new TeamThinkRuntimeError({
+                        message: `Team-think participant run failed (${agentId}).`,
+                        cause: error,
+                      }),
+                  }),
                 ),
               recordError: (error: unknown) => {
                 aiLogger.error`Team-think participant failed (${agentId}): ${error}`

package/src/utils/async.ts

@@ -1,16 +1,16 @@
 import { Cause, Duration, Effect, Exit, Schema } from 'effect'
 
 import { serverLogger } from '../config/logger'
-import { TimeoutError } from '../effect/errors'
+import { ERROR_TAGS, TimeoutError } from '../effect/errors'
 import { getErrorMessage, toError } from './errors'
 
-class TimedOperationError extends Schema.TaggedErrorClass<TimedOperationError>()('TimedOperationError', {
+class TimedOperationError extends Schema.TaggedErrorClass<TimedOperationError>()(ERROR_TAGS.TimedOperationError, {
   operation: Schema.String,
   cause: Schema.Defect,
 }) {}
 
 function isTimedOperationError(error: unknown): error is TimedOperationError {
-  return typeof error === 'object' && error !== null && '_tag' in error && error._tag === 'TimedOperationError'
+  return typeof error === 'object' && error !== null && '_tag' in error && error._tag === ERROR_TAGS.TimedOperationError
 }
 
 export function withTimeout<T>(promise: Promise<T>, ms: number, operation: string): Promise<T> {
@@ -46,8 +46,8 @@ export function createSafeEnqueue(logger: { warn: (message: string) => void }) {
 
 const _defaultSafeEnqueue = createSafeEnqueue({ warn: (message: string) => serverLogger.warn`${message}` })
 export function safeEnqueue<T>(
-  operation: () => T | Promise<T>,
+  operation: () => Promise<T>,
   options: { operationName: string; onError?: (error: unknown) => void; logPrefix?: string },
 ): Promise<T | void> {
-  return _defaultSafeEnqueue(() => Promise.resolve(operation()), options)
+  return _defaultSafeEnqueue(operation, options)
 }

package/src/utils/errors.ts

@@ -1,8 +1,8 @@
 export { getErrorMessage } from '@lota-sdk/shared'
 import { Data, Match } from 'effect'
 
-import type { EffectError, ValidationIssue } from '../effect/errors'
-import { BaseServicePersistenceError, isEffectError } from '../effect/errors'
+import type { BaseServicePersistenceError, EffectError, ValidationIssue } from '../effect/errors'
+import { ERROR_TAGS, isEffectError } from '../effect/errors'
 
 export function toError(value: unknown): Error {
   return value instanceof Error ? value : new Error(String(value))
@@ -129,29 +129,30 @@ export function toAppErrorResponse(error: AppErrorLike): AppErrorResponse {
 }
 
 function isBaseServicePersistenceError(error: EffectError): error is BaseServicePersistenceError {
-  return error._tag === BaseServicePersistenceError.name
+  return error._tag === ERROR_TAGS.BaseServicePersistenceError
 }
 
 const toHttpErrorMatch = Match.type<Exclude<EffectError, BaseServicePersistenceError>>().pipe(
-  Match.tag('NotFoundError', (e) => httpError(e.message, 'NOT_FOUND', 404)),
-  Match.tag('BadRequestError', (e) => httpError(e.message, 'BAD_REQUEST', 400)),
-  Match.tag('ValidationError', (e) => httpError(e.message, 'VALIDATION_ERROR', 400)),
-  Match.tag('ConflictError', (e) => httpError(e.message, 'CONFLICT', 409)),
-  Match.tag('ForbiddenError', (e) => httpError(e.message, 'FORBIDDEN', 403)),
-  Match.tag('ThreadTurnError', (e) =>
+  Match.tag(ERROR_TAGS.NotFoundError, (e) => httpError(e.message, 'NOT_FOUND', 404)),
+  Match.tag(ERROR_TAGS.BadRequestError, (e) => httpError(e.message, 'BAD_REQUEST', 400)),
+  Match.tag(ERROR_TAGS.ValidationError, (e) => httpError(e.message, 'VALIDATION_ERROR', 400)),
+  Match.tag(ERROR_TAGS.ConflictError, (e) => httpError(e.message, 'CONFLICT', 409)),
+  Match.tag(ERROR_TAGS.ForbiddenError, (e) => httpError(e.message, 'FORBIDDEN', 403)),
+  Match.tag(ERROR_TAGS.ThreadTurnError, (e) =>
     httpError(e.message, e.reason === 'conflict' ? 'CONFLICT' : 'BAD_REQUEST', e.reason === 'conflict' ? 409 : 400),
   ),
-  Match.tag('ActiveThreadRunConflictError', (e) => httpError(e.message, 'CONFLICT', 409)),
-  Match.tag('ConfigurationError', (e) => httpError(e.message, 'INTERNAL_SERVER_ERROR', 500)),
-  Match.tag('DatabaseError', () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
-  Match.tag('RedisError', () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
-  Match.tag('TimeoutError', (e) =>
+  Match.tag(ERROR_TAGS.ActiveThreadRunConflictError, (e) => httpError(e.message, 'CONFLICT', 409)),
+  Match.tag(ERROR_TAGS.ConfigurationError, (e) => httpError(e.message, 'INTERNAL_SERVER_ERROR', 500)),
+  Match.tag(ERROR_TAGS.DatabaseError, () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
+  Match.tag(ERROR_TAGS.RedisError, () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
+  Match.tag(ERROR_TAGS.RuntimeLifecycleError, () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
+  Match.tag(ERROR_TAGS.TimeoutError, (e) =>
     httpError(`Operation "${e.operation}" timed out after ${e.ms}ms`, 'INTERNAL_SERVER_ERROR', 500),
   ),
-  Match.tag('LockAcquisitionError', () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
-  Match.tag('LockLostError', () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
-  Match.tag('AiGenerationError', (e) => httpError(e.message, 'INTERNAL_SERVER_ERROR', 500)),
-  Match.tag('ServiceError', () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
+  Match.tag(ERROR_TAGS.LockAcquisitionError, () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
+  Match.tag(ERROR_TAGS.LockLostError, () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
+  Match.tag(ERROR_TAGS.AiGenerationError, (e) => httpError(e.message, 'INTERNAL_SERVER_ERROR', 500)),
+  Match.tag(ERROR_TAGS.ServiceError, () => httpError('Internal server error', 'INTERNAL_SERVER_ERROR', 500)),
   Match.exhaustive,
 )