@lota-sdk/core 0.4.13 → 0.4.15

package/src/queues/plan-agent-heartbeat.queue.ts

@@ -1,23 +1,23 @@
-import type { Job } from 'bullmq'
+import type { Job, JobsOptions } from 'bullmq'
 import { Effect, Schema } from 'effect'
 import type { Context } from 'effect'
 import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
 import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
+import type { makePlanAgentHeartbeatService } from '../services/plan/plan-agent-heartbeat.service'
 import { QueueJobServiceTag } from '../services/queue-job.service'
 import type { QueueJobService, WorkerHandle } from '../workers/worker-utils'
 import { DEFAULT_JOB_RETENTION, LONG_JOB_LOCK_DURATION_MS } from '../workers/worker-utils'
 import { createQueueFactoryWithDeps } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
-// Minimal service shape used by the worker processor. Declared structurally to
-// avoid importing the service tag — which would form a dependency cycle since
-// PlanAgentHeartbeatServiceLive depends on LotaQueuesServiceTag.
-interface PlanAgentHeartbeatWorkerServiceShape {
-  wakeNode(params: PlanAgentHeartbeatWakeJob): Effect.Effect<unknown, unknown, unknown>
-  sweep(params: { organizationId?: string }): Effect.Effect<void, unknown, unknown>
-}
+type PlanAgentHeartbeatWorkerServiceMethods = Pick<
+  ReturnType<typeof makePlanAgentHeartbeatService>,
+  'wakeNode' | 'sweep'
+>
+
+type PlanAgentHeartbeatWorkerServiceShape = PlanAgentHeartbeatWorkerServiceMethods
 
 class PlanAgentHeartbeatQueueError extends Schema.TaggedErrorClass<PlanAgentHeartbeatQueueError>()(
   '@lota-sdk/core/PlanAgentHeartbeatQueueError',
@@ -44,6 +44,7 @@ export type PlanAgentHeartbeatJob = PlanAgentHeartbeatWakeJob | PlanAgentHeartbe
 export const PLAN_AGENT_HEARTBEAT_QUEUE = 'plan-agent-heartbeat'
 const PLAN_AGENT_HEARTBEAT_SWEEP_INTERVAL_MS = 30_000
 const PLAN_AGENT_HEARTBEAT_SWEEP_JOB_ID = 'plan-agent-heartbeat-sweep'
+const REUSABLE_HEARTBEAT_JOB_STATES = new Set(['completed', 'failed'])
 
 export interface PlanAgentHeartbeatWorkerDeps {
   databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
@@ -84,35 +85,50 @@ export function makePlanAgentHeartbeatQueueRuntime(
 ): PlanAgentHeartbeatQueueRuntime {
   const { connectionProvider, queueJobService } = params
 
+  const enqueueReusableHeartbeatJob = async (job: PlanAgentHeartbeatJob, options: JobsOptions): Promise<void> => {
+    const jobId = typeof options.jobId === 'string' ? options.jobId : null
+    if (jobId) {
+      const existing = await queue.getQueue().getJob(jobId)
+      if (existing) {
+        const state = await existing.getState()
+        if (REUSABLE_HEARTBEAT_JOB_STATES.has(state)) {
+          await existing.remove()
+          serverLogger.info`Removed terminal Plan agent heartbeat job before re-enqueue (${jobId}, state=${state})`
+        }
+      }
+    }
+
+    await queue.enqueue(job, options)
+  }
+
   const enqueueDelayedSweep = (delayMs = PLAN_AGENT_HEARTBEAT_SWEEP_INTERVAL_MS): Promise<void> =>
-    queue.enqueue({ type: 'sweep' }, { delay: delayMs, jobId: PLAN_AGENT_HEARTBEAT_SWEEP_JOB_ID })
+    enqueueReusableHeartbeatJob({ type: 'sweep' }, { delay: delayMs, jobId: PLAN_AGENT_HEARTBEAT_SWEEP_JOB_ID })
 
   const processPlanAgentHeartbeatJob = (
     deps: PlanAgentHeartbeatWorkerDeps,
     job: Job<PlanAgentHeartbeatJob>,
   ): Promise<void> => {
     const { planAgentHeartbeatService: service } = deps
-    return Effect.runPromise(
-      Effect.gen(function* () {
-        if (job.data.type === 'wake-node') {
-          const wakeJob = job.data
-          yield* service.wakeNode(wakeJob)
-          return
-        }
-
-        yield* service.sweep({ organizationId: job.data.organizationId })
-        if (!job.data.organizationId) {
-          yield* Effect.tryPromise({
-            try: () => enqueueDelayedSweep(),
-            catch: (cause) =>
-              new PlanAgentHeartbeatQueueError({
-                message: 'Failed to enqueue delayed plan-agent heartbeat sweep.',
-                cause,
-              }),
-          })
-        }
-      }) as Effect.Effect<void, never, never>,
-    )
+    const program: Effect.Effect<void, unknown, never> = Effect.gen(function* () {
+      if (job.data.type === 'wake-node') {
+        const wakeJob: PlanAgentHeartbeatWakeJob = job.data
+        yield* service.wakeNode(wakeJob)
+        return
+      }
+
+      yield* service.sweep({ organizationId: job.data.organizationId })
+      if (!job.data.organizationId) {
+        yield* Effect.tryPromise({
+          try: () => enqueueDelayedSweep(),
+          catch: (cause) =>
+            new PlanAgentHeartbeatQueueError({
+              message: 'Failed to enqueue delayed plan-agent heartbeat sweep.',
+              cause,
+            }),
+        })
+      }
+    })
+    return Effect.runPromise(program)
   }
 
   const queue = createQueueFactoryWithDeps<PlanAgentHeartbeatJob, PlanAgentHeartbeatWorkerDeps>({
@@ -130,7 +146,7 @@ export function makePlanAgentHeartbeatQueueRuntime(
 
   return {
     enqueuePlanAgentHeartbeatWake: (wakeParams) =>
-      queue.enqueue({ type: 'wake-node', ...wakeParams }, { jobId: buildWakeJobId(wakeParams) }),
+      enqueueReusableHeartbeatJob({ type: 'wake-node', ...wakeParams }, { jobId: buildWakeJobId(wakeParams) }),
     startWorker: (options) => {
       const handle = queue.startWorker({
         deps: options.deps,
@@ -148,6 +164,7 @@ export function makePlanAgentHeartbeatQueueRuntime(
 }
 
 runStandaloneQueueWorker((runtime) => {
+  // @effect-diagnostics-next-line asyncFunction:off -- BullMQ standalone worker bootstrap.
   void (async () => {
     const { PlanAgentHeartbeatServiceTag } = await import('../services/plan/plan-agent-heartbeat.service')
     const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))

package/src/queues/plan-scheduler.queue.ts

@@ -4,10 +4,15 @@ import type { Context } from 'effect'
 import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
+import { ERROR_TAGS } from '../effect/errors'
 import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
+import type { makePlanCycleService } from '../services/plan/plan-cycle.service'
 import { PlanCycleServiceTag } from '../services/plan/plan-cycle.service'
+import type { makePlanDeadlineService } from '../services/plan/plan-deadline.service'
 import { PlanDeadlineServiceTag } from '../services/plan/plan-deadline.service'
+import type { makePlanExecutorService } from '../services/plan/plan-executor.service'
 import { PlanExecutorServiceTag } from '../services/plan/plan-executor.service'
+import type { makePlanSchedulerService } from '../services/plan/plan-scheduler.service'
 import { PlanSchedulerServiceTag } from '../services/plan/plan-scheduler.service'
 import { QueueJobServiceTag } from '../services/queue-job.service'
 import { nowEpochMillis } from '../utils/date-time'
@@ -15,6 +20,20 @@ import type { QueueJobService, WorkerHandle } from '../workers/worker-utils'
 import { createQueueFactoryWithDeps } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
+type PlanSchedulerWorkerServiceMethods = Pick<
+  ReturnType<typeof makePlanSchedulerService>,
+  'fireScheduleById' | 'recoverActiveSchedules'
+>
+
+type PlanDeadlineWorkerServiceMethods = Pick<
+  ReturnType<typeof makePlanDeadlineService>,
+  'checkDeadlines' | 'recoverDeadlineChecks'
+>
+
+type PlanExecutorWorkerServiceMethods = Pick<ReturnType<typeof makePlanExecutorService>, 'promoteDelayedNode'>
+
+type PlanCycleWorkerServiceMethods = Pick<ReturnType<typeof makePlanCycleService>, 'advanceCycle'>
+
 export interface PlanSchedulerFireJob {
   type: 'fire-schedule'
   scheduleId: string
@@ -31,17 +50,21 @@ export const PLAN_SCHEDULER_QUEUE = 'plan-scheduler'
 
 export interface PlanSchedulerWorkerDeps {
   databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
-  planSchedulerService: Context.Service.Shape<typeof PlanSchedulerServiceTag>
-  planDeadlineService: Context.Service.Shape<typeof PlanDeadlineServiceTag>
-  planExecutorService: Context.Service.Shape<typeof PlanExecutorServiceTag>
-  planCycleService: Context.Service.Shape<typeof PlanCycleServiceTag>
+  runPromise: <A, E, R>(effect: Effect.Effect<A, E, R>) => Promise<A>
+  planSchedulerService: PlanSchedulerWorkerServiceMethods
+  planDeadlineService: PlanDeadlineWorkerServiceMethods
+  planExecutorService: PlanExecutorWorkerServiceMethods
+  planCycleService: PlanCycleWorkerServiceMethods
 }
 
-class PlanSchedulerQueueError extends Schema.TaggedErrorClass<PlanSchedulerQueueError>()('PlanSchedulerQueueError', {
-  stage: Schema.Literals(['remove-schedule-fire-job', 'recover-active-schedules', 'recover-deadline-checks']),
-  message: Schema.String,
-  cause: Schema.Defect,
-}) {}
+class PlanSchedulerQueueError extends Schema.TaggedErrorClass<PlanSchedulerQueueError>()(
+  ERROR_TAGS.PlanSchedulerQueueError,
+  {
+    stage: Schema.Literals(['remove-schedule-fire-job', 'recover-active-schedules', 'recover-deadline-checks']),
+    message: Schema.String,
+    cause: Schema.Defect,
+  },
+) {}
 
 function toPlanSchedulerQueueError(stage: PlanSchedulerQueueError['stage'], cause: unknown): PlanSchedulerQueueError {
   return new PlanSchedulerQueueError({ stage, message: cause instanceof Error ? cause.message : String(cause), cause })
@@ -49,10 +72,8 @@ function toPlanSchedulerQueueError(stage: PlanSchedulerQueueError['stage'], caus
 
 function processPlanSchedulerJob(deps: PlanSchedulerWorkerDeps, job: Job<PlanSchedulerJob>): Promise<void> {
   const { planSchedulerService, planDeadlineService, planExecutorService, planCycleService } = deps
-  const runWithResolvedContext = <A, E>(effect: Effect.Effect<A, E, unknown>): Promise<void> =>
-    // Service Effects carry their provided context through the managed runtime
-    // that resolved these service tags, so residual R collapses at runtime.
-    Effect.runPromise(Effect.asVoid(effect as Effect.Effect<A, E, never>))
+  const runWithResolvedContext = <A, E, R>(effect: Effect.Effect<A, E, R>): Promise<void> =>
+    deps.runPromise(Effect.asVoid(effect))
 
   switch (job.data.type) {
     case 'fire-schedule':
@@ -132,7 +153,7 @@ export function makePlanSchedulerQueueRuntime(params: MakePlanSchedulerQueueRunt
     void Effect.runFork(
       deps.planSchedulerService.recoverActiveSchedules().pipe(
         Effect.mapError((cause) => toPlanSchedulerQueueError('recover-active-schedules', cause)),
-        Effect.catchTag('PlanSchedulerQueueError', (error) =>
+        Effect.catchTag(ERROR_TAGS.PlanSchedulerQueueError, (error) =>
           Effect.sync(() => {
             serverLogger.error`Plan scheduler startup recovery failed: ${error.message}`
           }),
@@ -144,7 +165,7 @@ export function makePlanSchedulerQueueRuntime(params: MakePlanSchedulerQueueRunt
     void Effect.runFork(
       deps.planDeadlineService.recoverDeadlineChecks().pipe(
         Effect.mapError((cause) => toPlanSchedulerQueueError('recover-deadline-checks', cause)),
-        Effect.catchTag('PlanSchedulerQueueError', (error) =>
+        Effect.catchTag(ERROR_TAGS.PlanSchedulerQueueError, (error) =>
           Effect.sync(() => {
             serverLogger.error`Plan deadline recovery failed: ${error.message}`
           }),
@@ -168,6 +189,7 @@ runStandaloneQueueWorker((runtime) => {
   planSchedulerQueue.startWorker({
     deps: {
       databaseService: resolve(DatabaseServiceTag),
+      runPromise: (effect) => runtime.runPromise(effect),
       planSchedulerService: resolve(PlanSchedulerServiceTag),
       planDeadlineService: resolve(PlanDeadlineServiceTag),
       planExecutorService: resolve(PlanExecutorServiceTag),

package/src/queues/queue-factory.ts

@@ -5,6 +5,7 @@ import type IORedis from 'ioredis'
 
 import type { LotaLogger } from '../config/logger'
 import { serverLogger } from '../config/logger'
+import { ERROR_TAGS } from '../effect/errors'
 import type { TrackedBullJobLike } from '../services/queue-job.service'
 import {
   attachWorkerEvents,
@@ -15,7 +16,7 @@ import {
 } from '../workers/worker-utils'
 import type { QueueJobService, WorkerHandle } from '../workers/worker-utils'
 
-class QueueFactoryError extends Schema.TaggedErrorClass<QueueFactoryError>()('@lota-sdk/core/QueueFactoryError', {
+class QueueFactoryError extends Schema.TaggedErrorClass<QueueFactoryError>()(ERROR_TAGS.QueueFactoryError, {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect),
 }) {}
@@ -148,7 +149,7 @@ function createQueueFactoryRuntime<TJob>(config: QueueFactoryConfigBase): {
           return Reflect.get(target, property, receiver) as unknown
         }
 
-        const value = (target as unknown as Record<string, unknown>)[property]
+        const value = Reflect.get(target, property, receiver) as unknown
         if (typeof value !== 'function' || !queueMethodsThatWaitForClose.has(property as QueueMethod)) {
           return value
         }
@@ -229,46 +230,69 @@ function createQueueFactoryRuntime<TJob>(config: QueueFactoryConfigBase): {
       ...(config.maxStalledCount !== undefined ? { maxStalledCount: config.maxStalledCount } : {}),
     }
 
-    const worker = workerConfig.processorPath
-      ? new Worker(config.name, workerConfig.processorPath, workerOptions)
-      : new Worker(
-          config.name,
-          createTracedWorkerProcessor(
+    let worker: Worker
+    try {
+      worker = workerConfig.processorPath
+        ? new Worker(config.name, workerConfig.processorPath, workerOptions)
+        : new Worker(
             config.name,
-            (job) =>
-              Effect.runPromise(
-                Effect.gen(function* () {
-                  const inlineWorkerConfig = workerConfig as QueueWorkerConfigInline<TJob>
-                  const typedJob = job as Job<TJob>
-                  const prepare = inlineWorkerConfig.prepare
-                  if (prepare) {
-                    yield* Effect.tryPromise({
-                      try: () => prepare(typedJob),
+            createTracedWorkerProcessor(
+              config.name,
+              (job) =>
+                Effect.runPromise(
+                  Effect.gen(function* () {
+                    const inlineWorkerConfig = workerConfig as QueueWorkerConfigInline<TJob>
+                    const typedJob = job as Job<TJob>
+                    const prepare = inlineWorkerConfig.prepare
+                    if (prepare) {
+                      yield* Effect.tryPromise({
+                        try: () => prepare(typedJob),
+                        catch: (cause) =>
+                          new QueueFactoryError({
+                            message: `Worker prepare failed for queue "${config.name}".`,
+                            cause,
+                          }),
+                      })
+                    }
+                    return yield* Effect.tryPromise({
+                      try: () => inlineWorkerConfig.processor(typedJob),
                       catch: (cause) =>
-                        new QueueFactoryError({ message: `Worker prepare failed for queue "${config.name}".`, cause }),
+                        new QueueFactoryError({
+                          message: `Worker processor failed for queue "${config.name}".`,
+                          cause,
+                        }),
                     })
-                  }
-                  return yield* Effect.tryPromise({
-                    try: () => inlineWorkerConfig.processor(typedJob),
-                    catch: (cause) =>
-                      new QueueFactoryError({ message: `Worker processor failed for queue "${config.name}".`, cause }),
-                  })
-                }),
-              ),
-            config.queueJobService,
-          ),
-          workerOptions,
-        )
+                  }),
+                ),
+              config.queueJobService,
+            ),
+            workerOptions,
+          )
+    } catch (error) {
+      // Construction threw — nothing to clean up since the Worker is created
+      // atomically by BullMQ; just rethrow so the caller can fail loudly.
+      logger.error`Failed to construct BullMQ worker "${config.displayName}": ${error}`
+      throw error
+    }
 
-    attachWorkerEvents(worker, config.displayName, logger)
+    // Acquire-style setup — if ANY step below throws, best-effort close the
+    // already-constructed worker before bubbling the error so no connection
+    // leaks.
+    try {
+      attachWorkerEvents(worker, config.displayName, logger)
+      const shutdown = createWorkerShutdown(worker, config.displayName, logger)
 
-    const shutdown = createWorkerShutdown(worker, config.displayName, logger)
+      if (registerSignals) {
+        registerShutdownSignals({ name: config.displayName, shutdown, logger })
+      }
 
-    if (registerSignals) {
-      registerShutdownSignals({ name: config.displayName, shutdown, logger })
+      return { worker, shutdown }
+    } catch (error) {
+      void worker.close().catch((closeError: unknown) => {
+        logger.warn`Failed to close BullMQ worker "${config.displayName}" after setup error: ${closeError}`
+      })
+      throw error
     }
-
-    return { worker, shutdown }
   }
 
   return { getQueue, enqueue, startWorker }

package/src/queues/standalone-worker.ts

@@ -2,10 +2,11 @@ import type { ManagedRuntime } from 'effect'
 import { Schema, Effect } from 'effect'
 
 import { serverLogger } from '../config/logger'
+import { ERROR_TAGS } from '../effect/errors'
 import { initializeSandboxedWorkerRuntime } from '../workers/bootstrap'
 
 class StandaloneQueueWorkerError extends Schema.TaggedErrorClass<StandaloneQueueWorkerError>()(
-  'StandaloneQueueWorkerError',
+  ERROR_TAGS.StandaloneQueueWorkerError,
   { message: Schema.String, cause: Schema.Defect },
 ) {}
 
@@ -28,7 +29,7 @@ export function runStandaloneQueueWorker(start: (runtime: ManagedRuntime.Managed
 
       yield* Effect.sync(() => start(runtime))
     }).pipe(
-      Effect.catchTag('StandaloneQueueWorkerError', (error) =>
+      Effect.catchTag(ERROR_TAGS.StandaloneQueueWorkerError, (error) =>
         Effect.sync(() => {
           serverLogger.error`Standalone queue worker failed: ${error.message}`
           process.exit(1)

package/src/redis/connection.ts

@@ -3,7 +3,6 @@ import IORedis from 'ioredis'
 import type { RedisOptions } from 'ioredis'
 
 import { RedisError } from '../effect/errors'
-import { effectTryServicePromise } from '../effect/helpers'
 import { getErrorMessage } from '../utils/errors'
 
 export interface RedisConnectionLogger {
@@ -147,7 +146,10 @@ function acquireRedisClient(
 
         if (client.status !== 'end') {
           const quitExit = yield* Effect.exit(
-            effectTryServicePromise(() => client.quit(), 'Failed to close Redis connection manager'),
+            Effect.tryPromise({
+              try: () => client.quit(),
+              catch: (cause) => new RedisError({ message: 'Failed to close Redis connection manager', cause }),
+            }),
           )
           if (Exit.isFailure(quitExit)) {
             log(options.logger, 'warn', `Redis quit failed, forcing disconnect: ${getErrorMessage(quitExit.cause)}`)
@@ -190,7 +192,12 @@ function startHealthCheckFiber(
       isHealthCheckRunning = true
       try {
         if (client.status === 'ready') {
-          const pingExit = yield* Effect.exit(effectTryServicePromise(() => client.ping(), 'Redis health check failed'))
+          const pingExit = yield* Effect.exit(
+            Effect.tryPromise({
+              try: () => client.ping(),
+              catch: (cause) => new RedisError({ message: 'Redis health check failed', cause }),
+            }),
+          )
           if (Exit.isFailure(pingExit)) {
             log(logger, 'warn', `Redis health check failed: ${getErrorMessage(pingExit.cause)}`)
             state.isHealthy = false

package/src/redis/org-memory-lock.ts

@@ -16,7 +16,7 @@ const ORG_MEMORY_LOCK_WAIT_LOG_INTERVAL_MS = 30_000
 const ORG_MEMORY_LOCK_MAX_WAIT_MS = 15 * 60 * 1000
 
 class OrgMemoryLockCallbackError extends Schema.TaggedErrorClass<OrgMemoryLockCallbackError>()(
-  'OrgMemoryLockCallbackError',
+  '@lota-sdk/core/OrgMemoryLockCallbackError',
   { message: Schema.String, cause: Schema.Defect },
 ) {}
 

package/src/redis/redis-lease-lock.ts

@@ -1,7 +1,7 @@
 import { Clock, Deferred, Duration, Effect, Random, Schedule } from 'effect'
 import type IORedis from 'ioredis'
 
-import { LockAcquisitionError, LockLostError, RedisError } from '../effect/errors'
+import { ERROR_TAGS, LockAcquisitionError, LockLostError, RedisError } from '../effect/errors'
 import { RedisServiceTag } from '../effect/services'
 import { getErrorMessage } from '../utils/errors'
 
@@ -119,7 +119,7 @@ function acquireLock(
       schedule: Schedule.fixed(Duration.millis(options.retryDelayMs)),
     }).pipe(
       Effect.asVoid,
-      Effect.catchTag('LockAcquisitionError', () =>
+      Effect.catchTag(ERROR_TAGS.LockAcquisitionError, () =>
         Effect.fail(new LockAcquisitionError({ lockKey: options.lockKey, maxWaitMs: options.maxWaitMs })),
       ),
     )
@@ -170,7 +170,7 @@ function startRefreshFiber(
       Effect.andThen(
         Effect.sync(() => {
           const message =
-            error._tag === 'LockLostError'
+            error._tag === ERROR_TAGS.LockLostError
               ? `${options.label} refresh was rejected for key ${options.lockKey}`
               : error.message
 
@@ -188,8 +188,8 @@ function startRefreshFiber(
       yield* Effect.sleep(Duration.millis(options.refreshIntervalMs))
 
       yield* refreshLock(redis, options, lockValue).pipe(
-        Effect.catchTag('LockLostError', handleLockLoss),
-        Effect.catchTag('RedisError', handleLockLoss),
+        Effect.catchTag(ERROR_TAGS.LockLostError, handleLockLoss),
+        Effect.catchTag(ERROR_TAGS.RedisError, handleLockLoss),
       )
     }
   })

package/src/redis/stream-context.ts

@@ -22,7 +22,7 @@ function toPublisher(client: Redis): Publisher {
 type SharedSubscriberEvent = { readonly channel: string; readonly message: string }
 
 class SharedSubscriberCloseError extends Schema.TaggedErrorClass<SharedSubscriberCloseError>()(
-  'SharedSubscriberCloseError',
+  '@lota-sdk/core/SharedSubscriberCloseError',
   { message: Schema.String, cause: Schema.optional(Schema.Defect) },
 ) {}
 

package/src/runtime/chat-message.ts

@@ -1,4 +1,15 @@
-import type { MessagePartLike } from './chat-types'
+import { chatLogger } from '../config/logger'
+import type { ChatMessageLike, MessagePartLike } from './chat-types'
+
+const AI_SDK_SUPPORTED_MESSAGE_PART_TYPES = new Set([
+  'text',
+  'reasoning',
+  'source-url',
+  'source-document',
+  'file',
+  'step-start',
+  'dynamic-tool',
+])
 
 export function hasMessageContent(parts: readonly MessagePartLike[]): boolean {
   for (const part of parts) {
@@ -8,3 +19,55 @@ export function hasMessageContent(parts: readonly MessagePartLike[]): boolean {
 
   return false
 }
+
+function isAiSdkSupportedMessagePart(part: MessagePartLike): boolean {
+  if (typeof part.type !== 'string') {
+    return false
+  }
+
+  return (
+    AI_SDK_SUPPORTED_MESSAGE_PART_TYPES.has(part.type) || part.type.startsWith('data-') || part.type.startsWith('tool-')
+  )
+}
+
+function isSubstantiveAssistantMessagePart(part: MessagePartLike): boolean {
+  return isAiSdkSupportedMessagePart(part) && part.type !== 'step-start'
+}
+
+function sanitizeAssistantMessageParts<TPart extends MessagePartLike>(parts: readonly TPart[]): TPart[] {
+  return parts.filter((part): part is TPart => isSubstantiveAssistantMessagePart(part))
+}
+
+export function sanitizePersistedMessages<TMessage extends ChatMessageLike>(messages: readonly TMessage[]): TMessage[] {
+  const sanitizedMessages: TMessage[] = []
+
+  for (const message of messages) {
+    const rawMessageId = (message as Record<string, unknown>).id
+    const messageId = typeof rawMessageId === 'string' && rawMessageId.trim() ? rawMessageId : 'unknown'
+
+    if (message.parts.length === 0) {
+      chatLogger.warn`Dropping persisted thread message with empty parts during history sanitization (role=${message.role}, id=${messageId})`
+      continue
+    }
+
+    if (message.role !== 'assistant') {
+      sanitizedMessages.push(message)
+      continue
+    }
+
+    const sanitizedParts = sanitizeAssistantMessageParts(message.parts)
+    if (sanitizedParts.length === 0) {
+      chatLogger.warn`Dropping persisted assistant thread message without substantive parts during history sanitization (id=${messageId})`
+      continue
+    }
+
+    if (sanitizedParts.length === message.parts.length) {
+      sanitizedMessages.push(message)
+      continue
+    }
+
+    sanitizedMessages.push({ ...message, parts: sanitizedParts } as TMessage)
+  }
+
+  return sanitizedMessages
+}

package/src/runtime/chat-run-orchestration.ts

@@ -1,17 +1,20 @@
 import { Cause, Context, Schema, Duration, Effect, Latch, Layer } from 'effect'
 
-import { effectTryPromise } from '../effect/helpers'
+import { ERROR_TAGS } from '../effect/errors'
 import { nowEpochMillis } from '../utils/date-time'
 
 const COMPACTION_WAIT_REFRESH_MS = 1_000
 const COMPACTION_MAX_WAIT_MS = 120_000
 
-class WaitForCompactionError extends Schema.TaggedErrorClass<WaitForCompactionError>()('WaitForCompactionError', {
-  entityId: Schema.String,
-  entityLabel: Schema.String,
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect),
-}) {}
+class WaitForCompactionError extends Schema.TaggedErrorClass<WaitForCompactionError>()(
+  ERROR_TAGS.WaitForCompactionError,
+  {
+    entityId: Schema.String,
+    entityLabel: Schema.String,
+    message: Schema.String,
+    cause: Schema.optional(Schema.Defect),
+  },
+) {}
 
 function toWaitForCompactionError(params: {
   entityId: string
@@ -28,12 +31,12 @@ function toWaitForCompactionError(params: {
 
 interface CompactionCoordination {
   readonly signal: (entityId: string, compacting: boolean) => Effect.Effect<void>
-  readonly waitIfNeeded: <TEntity>(params: {
+  readonly waitIfNeeded: <TEntity, TError, TRequirements>(params: {
     entityId: string
     entityLabel: string
-    loadEntity: () => PromiseLike<TEntity> | Effect.Effect<TEntity, unknown>
+    loadEntity: () => Effect.Effect<TEntity, TError, TRequirements>
     isCompacting: (entity: TEntity) => boolean
-  }) => Effect.Effect<TEntity, WaitForCompactionError>
+  }) => Effect.Effect<TEntity, WaitForCompactionError, TRequirements>
 }
 
 export class CompactionCoordinationTag extends Context.Service<CompactionCoordinationTag, CompactionCoordination>()(
@@ -65,18 +68,25 @@ export const CompactionCoordinationLive = Layer.effect(
           }
         }),
 
-      waitIfNeeded: Effect.fn('CompactionCoordination.waitIfNeeded')(function* <TEntity>(params: {
+      waitIfNeeded: Effect.fn('CompactionCoordination.waitIfNeeded')(function* <
+        TEntity,
+        TError,
+        TRequirements,
+      >(params: {
         entityId: string
         entityLabel: string
-        loadEntity: () => PromiseLike<TEntity> | Effect.Effect<TEntity, unknown>
+        loadEntity: () => Effect.Effect<TEntity, TError, TRequirements>
         isCompacting: (entity: TEntity) => boolean
       }) {
         const deadline = nowEpochMillis() + COMPACTION_MAX_WAIT_MS
         const latch = getLatch(params.entityId)
-        let entity = yield* effectTryPromise(
-          () => params.loadEntity(),
-          (cause) => toWaitForCompactionError({ entityId: params.entityId, entityLabel: params.entityLabel, cause }),
-        )
+        let entity = yield* params
+          .loadEntity()
+          .pipe(
+            Effect.mapError((cause) =>
+              toWaitForCompactionError({ entityId: params.entityId, entityLabel: params.entityLabel, cause }),
+            ),
+          )
 
         while (params.isCompacting(entity)) {
           Latch.closeUnsafe(latch)
@@ -94,10 +104,13 @@ export const CompactionCoordinationLive = Layer.effect(
             Effect.timeout(Duration.millis(refreshWindowMs)),
             Effect.catchIf(Cause.isTimeoutError, () => Effect.void),
           )
-          entity = yield* effectTryPromise(
-            () => params.loadEntity(),
-            (cause) => toWaitForCompactionError({ entityId: params.entityId, entityLabel: params.entityLabel, cause }),
-          )
+          entity = yield* params
+            .loadEntity()
+            .pipe(
+              Effect.mapError((cause) =>
+                toWaitForCompactionError({ entityId: params.entityId, entityLabel: params.entityLabel, cause }),
+              ),
+            )
         }
 
         Latch.openUnsafe(latch)