@lota-sdk/core 0.4.12 → 0.4.14

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)

package/src/runtime/context-compaction/context-compaction-runtime.ts

@@ -1,6 +1,7 @@
 import { Schema, Effect } from 'effect'
 
-import { createContextCompactionAgent } from '../../system-agents/context-compaction.agent'
+import type { AiGatewayModels } from '../../ai-gateway/ai-gateway'
+import { makeContextCompactionAgentFactory } from '../../system-agents/context-compaction.agent'
 import type { GenerateHelperStructuredParams, GenerateHelperTextParams } from '../helper-model'
 import {
   buildContextCompactionPrompt,
@@ -29,12 +30,13 @@ interface HelperModelRuntime {
 
 interface CreateContextCompactionRuntimeDeps {
   helperModelRuntime: HelperModelRuntime
+  aiGatewayModels: AiGatewayModels
   now?: () => number
   randomId?: () => string
 }
 
 class ContextCompactionRuntimeError extends Schema.TaggedErrorClass<ContextCompactionRuntimeError>()(
-  'ContextCompactionRuntimeError',
+  '@lota-sdk/core/ContextCompactionRuntimeError',
   { message: Schema.String, cause: Schema.Defect },
 ) {}
 
@@ -48,11 +50,15 @@ function tryContextCompactionPromise<A>(
   })
 }
 
-function runContextCompacterEffect(helperModelRuntime: HelperModelRuntime, params: ContextCompactionRunnerParams) {
+function runContextCompacterEffect(
+  helperModelRuntime: HelperModelRuntime,
+  aiGatewayModels: AiGatewayModels,
+  params: ContextCompactionRunnerParams,
+) {
   return tryContextCompactionPromise('Failed to compact runtime context.', () =>
     helperModelRuntime.generateHelperStructured({
       tag: 'context-compaction',
-      createAgent: createContextCompactionAgent,
+      createAgent: makeContextCompactionAgentFactory(aiGatewayModels),
       messages: [
         {
           role: 'user',
@@ -69,10 +75,11 @@ function runContextCompacterEffect(helperModelRuntime: HelperModelRuntime, param
 }
 
 export function createWiredContextCompactionRuntime(deps: CreateContextCompactionRuntimeDeps) {
-  const { helperModelRuntime } = deps
+  const { helperModelRuntime, aiGatewayModels } = deps
+  const createAgent = makeContextCompactionAgentFactory(aiGatewayModels)
 
   const runtime = createContextCompactionRuntime({
-    runCompacter: (params) => runContextCompacterEffect(helperModelRuntime, params),
+    runCompacter: (params) => runContextCompacterEffect(helperModelRuntime, aiGatewayModels, params),
     now: deps.now,
     randomId: deps.randomId,
     thresholdRatio: CONTEXT_COMPACTION_THRESHOLD_RATIO,
@@ -92,7 +99,7 @@ export function createWiredContextCompactionRuntime(deps: CreateContextCompactio
     return tryContextCompactionPromise('Failed to compact memory block summary.', () =>
       helperModelRuntime.generateHelperText({
         tag: 'memory-block-compaction',
-        createAgent: createContextCompactionAgent,
+        createAgent,
         messages: [{ role: 'user', content: buildMemoryBlockCompactionPrompt({ previousSummary, newEntriesText }) }],
         maxOutputTokens: CONTEXT_COMPACTION_MAX_OUTPUT_TOKENS,
       }),