@lota-sdk/core 0.4.9 → 0.4.10

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

@@ -1,7 +1,8 @@
 import type { ChatMessage } from '@lota-sdk/shared'
-import { Schema, Effect } from 'effect'
+import { Duration, Effect, Schedule, Schema } from 'effect'
 import { z } from 'zod'
 
+import { iterateEffect } from '../../effect/helpers'
 import { nowEpochMillis } from '../../utils/date-time'
 import {
   CHARS_PER_TOKEN_ESTIMATE,
@@ -64,6 +65,13 @@ class CompactionError extends Schema.TaggedErrorClass<CompactionError>()('Compac
   cause: Schema.optional(Schema.Defect),
 }) {}
 
+class CompactionParseError extends Schema.TaggedErrorClass<CompactionParseError>()('CompactionParseError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+const COMPACTION_RUNNER_RETRY_OPTIONS = { times: 2, schedule: Schedule.exponential(Duration.millis(500), 2) } as const
+
 export interface ContextCompactionPromptParams {
   previousSummary: string
   transcript: string
@@ -325,22 +333,32 @@ export function createContextCompactionRuntime(
     return { estimatedTokens, threshold, shouldCompact: estimatedTokens >= threshold }
   }
 
-  const compactContextMessagesEffect = (params: { previousSummary: string; newMessages: ContextMessage[] }) =>
-    Effect.gen(function* () {
-      const chunks = splitByCharBudget(params.newMessages, compactionChunkMaxChars)
-      let summary = normalizeSummary(params.previousSummary)
-
-      for (const chunk of chunks) {
-        const transcript = toCompactionTranscript(chunk)
-        const output = yield* Effect.tryPromise({
-          try: () => options.runCompacter({ previousSummary: summary, chunk, transcript }),
-          catch: (error: unknown) => new CompactionError({ message: String(error), cause: error }),
-        })
-        summary = normalizeSummary(output.summary)
-      }
-
-      return { summary }
-    })
+  const compactContextMessagesEffect = Effect.fn('ContextCompaction.compactContextMessages')(function* (params: {
+    previousSummary: string
+    newMessages: ContextMessage[]
+  }) {
+    const chunks = splitByCharBudget(params.newMessages, compactionChunkMaxChars)
+    const initialSummary = normalizeSummary(params.previousSummary)
+
+    const finalSummary = yield* iterateEffect<{ summary: string; index: number }, CompactionError, never>(
+      { summary: initialSummary, index: 0 },
+      {
+        while: (state) => state.index < chunks.length,
+        body: (state) =>
+          Effect.gen(function* () {
+            const chunk = chunks[state.index]
+            const transcript = toCompactionTranscript(chunk)
+            const output = yield* Effect.tryPromise({
+              try: () => options.runCompacter({ previousSummary: state.summary, chunk, transcript }),
+              catch: (error: unknown) => new CompactionError({ message: String(error), cause: error }),
+            }).pipe(Effect.retry(COMPACTION_RUNNER_RETRY_OPTIONS))
+            return { summary: normalizeSummary(output.summary), index: state.index + 1 }
+          }),
+      },
+    )
+
+    return { summary: finalSummary.summary }
+  })
 
   const rollupSummaryIfOversizedEffect = (summary: string) =>
     Effect.gen(function* () {
@@ -356,81 +374,104 @@ export function createContextCompactionRuntime(
       return normalizeSummary(output.summary)
     })
 
+  type CompactionLoopState = {
+    summaryText: string
+    remainingMessages: ChatMessage[]
+    compactedMessages: ChatMessage[]
+    lastCompactedMessageId: string | undefined
+    estimatedTokens: number
+    done: boolean
+  }
+
   const compactHistoryEffect = (params: CompactHistoryParams) =>
     Effect.gen(function* () {
-      let summaryText = normalizeSummary(params.summaryText)
-      let remainingMessages = [...params.liveMessages]
-      let compactedMessages: ChatMessage[] = []
-      let lastCompactedMessageId: string | undefined
-      const summaryPayload = buildSyntheticSummaryPayload(summaryText)
-      const initialPayload = stringifyUnknown([...(summaryPayload ? [summaryPayload] : []), ...remainingMessages]) ?? ''
+      const initialSummaryText = normalizeSummary(params.summaryText)
+      const initialRemaining = [...params.liveMessages]
+      const summaryPayload = buildSyntheticSummaryPayload(initialSummaryText)
+      const initialPayload = stringifyUnknown([...(summaryPayload ? [summaryPayload] : []), ...initialRemaining]) ?? ''
       const inputChars = initialPayload.length
 
-      const buildEarlyExitResult = (estimatedTokens: number): CompactHistoryResult => {
-        const exitSummaryPayload = buildSyntheticSummaryPayload(summaryText)
+      const buildExitResult = (state: CompactionLoopState): CompactHistoryResult => {
+        const exitSummaryPayload = buildSyntheticSummaryPayload(state.summaryText)
         const outputPayload =
-          stringifyUnknown([...(exitSummaryPayload ? [exitSummaryPayload] : []), ...remainingMessages]) ?? ''
+          stringifyUnknown([...(exitSummaryPayload ? [exitSummaryPayload] : []), ...state.remainingMessages]) ?? ''
         return {
-          compacted: compactedMessages.length > 0,
-          summaryText,
-          ...(lastCompactedMessageId ? { lastCompactedMessageId } : {}),
-          compactedMessages,
-          compactedMessageCount: compactedMessages.length,
-          remainingMessageCount: remainingMessages.length,
-          estimatedTokens,
+          compacted: state.compactedMessages.length > 0,
+          summaryText: state.summaryText,
+          ...(state.lastCompactedMessageId ? { lastCompactedMessageId: state.lastCompactedMessageId } : {}),
+          compactedMessages: state.compactedMessages,
+          compactedMessageCount: state.compactedMessages.length,
+          remainingMessageCount: state.remainingMessages.length,
+          estimatedTokens: state.estimatedTokens,
           inputChars,
           outputChars: outputPayload.length,
         }
       }
 
-      for (;;) {
-        const assessment = shouldCompactHistory({
-          summaryText,
-          liveMessages: remainingMessages,
-          contextSize: params.contextSize,
-        })
-
-        if (!assessment.shouldCompact) {
-          return buildEarlyExitResult(assessment.estimatedTokens)
-        }
-
-        const boundary = Math.max(0, remainingMessages.length - params.tailMessageCount)
-        if (boundary <= 0) {
-          return buildEarlyExitResult(assessment.estimatedTokens)
-        }
-
-        const candidatePrefix = remainingMessages.slice(0, boundary)
-        const messagesToCompact = candidatePrefix.filter((message) => !readIsCompacted(message))
-        const contextMessages = messagesToCompact
-          .map(toContextMessageFromChatMessage)
-          .filter((message) => compactWhitespace(message.text).length > 0)
-        const sourceText = toCompactionTranscript(contextMessages)
-
-        if (!compactWhitespace(sourceText)) {
-          return buildEarlyExitResult(assessment.estimatedTokens)
-        }
-
-        let nextSummary = normalizeSummary(
-          (yield* compactContextMessagesEffect({ previousSummary: summaryText, newMessages: contextMessages })).summary,
-        )
-        nextSummary = yield* rollupSummaryIfOversizedEffect(nextSummary)
-
-        if (nextSummary.length >= sourceText.length) {
-          return yield* new CompactionError({ message: 'Compaction summary is not shorter than compacted source' })
-        }
+      const initialState: CompactionLoopState = {
+        summaryText: initialSummaryText,
+        remainingMessages: initialRemaining,
+        compactedMessages: [],
+        lastCompactedMessageId: undefined,
+        estimatedTokens: 0,
+        done: false,
+      }
 
-        summaryText = nextSummary
-        compactedMessages = [
-          ...compactedMessages,
-          ...candidatePrefix.map((message) => markMessageCompacted(message, now)),
-        ]
-        lastCompactedMessageId = candidatePrefix.at(-1)?.id ?? lastCompactedMessageId
-        remainingMessages = remainingMessages.slice(boundary)
+      const finalState = yield* iterateEffect<CompactionLoopState, CompactionError, never>(initialState, {
+        while: (state) => !state.done,
+        body: (state) =>
+          Effect.gen(function* () {
+            const assessment = shouldCompactHistory({
+              summaryText: state.summaryText,
+              liveMessages: state.remainingMessages,
+              contextSize: params.contextSize,
+            })
+
+            if (!assessment.shouldCompact) {
+              return { ...state, estimatedTokens: assessment.estimatedTokens, done: true }
+            }
+
+            const boundary = Math.max(0, state.remainingMessages.length - params.tailMessageCount)
+            if (boundary <= 0) {
+              return { ...state, estimatedTokens: assessment.estimatedTokens, done: true }
+            }
+
+            const candidatePrefix = state.remainingMessages.slice(0, boundary)
+            const messagesToCompact = candidatePrefix.filter((message) => !readIsCompacted(message))
+            const contextMessages = messagesToCompact
+              .map(toContextMessageFromChatMessage)
+              .filter((message) => compactWhitespace(message.text).length > 0)
+            const sourceText = toCompactionTranscript(contextMessages)
+
+            if (!compactWhitespace(sourceText)) {
+              return { ...state, estimatedTokens: assessment.estimatedTokens, done: true }
+            }
+
+            const compacted = yield* compactContextMessagesEffect({
+              previousSummary: state.summaryText,
+              newMessages: contextMessages,
+            })
+            const rolledSummary = yield* rollupSummaryIfOversizedEffect(normalizeSummary(compacted.summary))
+
+            if (rolledSummary.length >= sourceText.length) {
+              return yield* new CompactionError({ message: 'Compaction summary is not shorter than compacted source' })
+            }
+
+            return {
+              summaryText: rolledSummary,
+              remainingMessages: state.remainingMessages.slice(boundary),
+              compactedMessages: [
+                ...state.compactedMessages,
+                ...candidatePrefix.map((message) => markMessageCompacted(message, now)),
+              ],
+              lastCompactedMessageId: candidatePrefix.at(-1)?.id ?? state.lastCompactedMessageId,
+              estimatedTokens: assessment.estimatedTokens,
+              done: false,
+            }
+          }),
+      })
 
-        if (remainingMessages.length <= params.tailMessageCount) {
-          continue
-        }
-      }
+      return buildExitResult(finalState)
     })
 
   return {
@@ -442,7 +483,10 @@ export function createContextCompactionRuntime(
   }
 }
 
-export function parseCompactionOutput(value: unknown): CompactionOutput {
-  const parsed = ContextCompactionOutputSchema.parse(value)
-  return { summary: parsed.summary }
+export function parseCompactionOutput(value: unknown): Effect.Effect<CompactionOutput, CompactionParseError> {
+  const parsed = ContextCompactionOutputSchema.safeParse(value)
+  if (!parsed.success) {
+    return Effect.fail(new CompactionParseError({ message: 'Failed to parse compaction output', cause: parsed.error }))
+  }
+  return Effect.succeed({ summary: parsed.data.summary })
 }

package/src/runtime/domain-layer.ts

@@ -0,0 +1,192 @@
+/**
+ * Builds the domain-service Layer tree for `createLotaRuntime`.
+ *
+ * The services form a 9-tier dependency graph on top of the infrastructure
+ * layer (config, logging, database, redis, agents, threads, extensions).
+ * Each tier is provided with the accumulated context of earlier tiers so
+ * every service resolves cleanly when the ManagedRuntime eagerly loads them.
+ */
+
+import type { Layer as LayerType } from 'effect'
+import { Layer } from 'effect'
+
+import { AiGatewayLive } from '../ai-gateway/ai-gateway'
+import { EmbeddingCacheLive } from '../ai/embedding-cache'
+import type { buildInfrastructureLayer } from '../effect/layers'
+import { SharedThreadStreamSubscriberLive } from '../redis/stream-context'
+import { AgentActivityServiceLive } from '../services/agent-activity.service'
+import { AgentExecutorServiceLive } from '../services/agent-executor.service'
+import { ArtifactServiceLive } from '../services/artifact.service'
+import { AttachmentServiceLive } from '../services/attachment.service'
+import { AutonomousJobServiceLive } from '../services/autonomous-job.service'
+import { BackgroundWorkServiceLive } from '../services/background-work.service'
+import { ChatRunRegistryLive } from '../services/chat-run-registry.service'
+import { ContextCompactionServiceLive } from '../services/context-compaction.service'
+import { DocumentChunkServiceLive } from '../services/document-chunk.service'
+import { ExecutionPlanServiceLive } from '../services/execution-plan/execution-plan.service'
+import { FeedbackLoopServiceLive } from '../services/feedback-loop.service'
+import { GlobalOrchestratorServiceLive } from '../services/global-orchestrator.service'
+import { InstitutionalMemoryServiceLive } from '../services/institutional-memory.service'
+import { LearnedSkillServiceLive } from '../services/learned-skill.service'
+import { MemoryServiceLive } from '../services/memory/memory.service'
+import { RerankServiceLive } from '../services/memory/rerank.service'
+import { MonitoringWindowServiceLive } from '../services/monitoring-window.service'
+import { MutatingApprovalServiceLive } from '../services/mutating-approval.service'
+import { NodeWorkspaceServiceLive } from '../services/node-workspace.service'
+import { NotificationServiceLive } from '../services/notification.service'
+import { OrganizationMemberServiceLive } from '../services/organization-member.service'
+import { OrganizationServiceLive } from '../services/organization.service'
+import { OwnershipDispatcherServiceLive } from '../services/ownership-dispatcher.service'
+import { PlanAgentHeartbeatServiceLive } from '../services/plan/plan-agent-heartbeat.service'
+import { PlanAgentQueryServiceLive } from '../services/plan/plan-agent-query.service'
+import { PlanApprovalServiceLive } from '../services/plan/plan-approval.service'
+import { PlanArtifactServiceLive } from '../services/plan/plan-artifact.service'
+import { PlanBuilderServiceLive } from '../services/plan/plan-builder.service'
+import { PlanCheckpointServiceLive } from '../services/plan/plan-checkpoint.service'
+import { PlanCompilerServiceLive } from '../services/plan/plan-compiler.service'
+import { PlanCoordinationServiceLive } from '../services/plan/plan-coordination.service'
+import { PlanCycleServiceLive } from '../services/plan/plan-cycle.service'
+import { PlanDeadlineServiceLive } from '../services/plan/plan-deadline.service'
+import { PlanEventDeliveryServiceLive } from '../services/plan/plan-event-delivery.service'
+import { PlanExecutorServiceLive } from '../services/plan/plan-executor.service'
+import { PlanRunServiceLive } from '../services/plan/plan-run.service'
+import { PlanSchedulerServiceLive } from '../services/plan/plan-scheduler.service'
+import { PlanTemplateServiceLive } from '../services/plan/plan-template.service'
+import { PlanValidatorServiceLive } from '../services/plan/plan-validator.service'
+import { PlanWorkspaceServiceLive } from '../services/plan/plan-workspace.service'
+import { PluginExecutorServiceLive } from '../services/plugin-executor.service'
+import { QualityMetricsServiceLive } from '../services/quality-metrics.service'
+import { QueueJobServiceLive } from '../services/queue-job.service'
+import { RecentActivityTitleServiceLive } from '../services/recent-activity-title.service'
+import { RecentActivityServiceLive } from '../services/recent-activity.service'
+import { SkillResolverServiceLive } from '../services/skill-resolver.service'
+import { SocialChatHistoryServiceLive } from '../services/social-chat-history.service'
+import { SystemExecutorServiceLive } from '../services/system-executor.service'
+import { ThreadMessageServiceLive } from '../services/thread/thread-message.service'
+import { ThreadTitleServiceLive } from '../services/thread/thread-title.service'
+import { ThreadTurnServiceLive } from '../services/thread/thread-turn'
+import { ThreadTurnPreparationServiceLive } from '../services/thread/thread-turn-preparation.service'
+import { ThreadServiceLive } from '../services/thread/thread.service'
+import { UserServiceLive } from '../services/user.service'
+import { WriteIntentValidatorServiceLive } from '../services/write-intent-validator.service'
+import { AttachmentStorageServiceLive } from '../storage/attachment-storage.service'
+import { GeneratedDocumentStorageServiceLive } from '../storage/generated-document-storage.service'
+import { FirecrawlLive } from '../tools/firecrawl-client'
+import { CompactionCoordinationLive } from './chat-run-orchestration'
+import { HelperModelLive } from './helper-model'
+
+function provide<A, E, R extends RCtx, RCtx, E2>(
+  layer: LayerType.Layer<A, E, R>,
+  ctx: LayerType.Layer<RCtx, E2, never>,
+): LayerType.Layer<A, E | E2, never> {
+  return Layer.provideMerge(ctx)(layer)
+}
+
+type InfrastructureLayer = ReturnType<typeof buildInfrastructureLayer>
+
+/**
+ * Compose the domain service layer tree on top of the supplied infrastructure
+ * layer. The returned layer has no remaining requirements and can be fed
+ * straight into `ManagedRuntime.make`.
+ */
+export function buildDomainServiceLayer(infrastructureLayer: InfrastructureLayer) {
+  const tier0 = provide(
+    Layer.mergeAll(
+      BackgroundWorkServiceLive,
+      ChatRunRegistryLive,
+      CompactionCoordinationLive,
+      DocumentChunkServiceLive,
+      NodeWorkspaceServiceLive,
+      NotificationServiceLive,
+      PlanArtifactServiceLive,
+      PlanBuilderServiceLive,
+      WriteIntentValidatorServiceLive,
+    ),
+    infrastructureLayer,
+  )
+  const ctx0 = Layer.mergeAll(
+    infrastructureLayer,
+    provide(Layer.mergeAll(AiGatewayLive, EmbeddingCacheLive, FirecrawlLive, HelperModelLive), infrastructureLayer),
+    tier0,
+  )
+
+  const tier1 = provide(
+    Layer.mergeAll(
+      SharedThreadStreamSubscriberLive,
+      AgentExecutorServiceLive,
+      AttachmentStorageServiceLive,
+      GeneratedDocumentStorageServiceLive,
+      LearnedSkillServiceLive,
+      OrganizationServiceLive,
+      OrganizationMemberServiceLive,
+      PlanApprovalServiceLive,
+      PlanRunServiceLive,
+      PlanSchedulerServiceLive,
+      PlanWorkspaceServiceLive,
+      PluginExecutorServiceLive,
+      QualityMetricsServiceLive,
+      QueueJobServiceLive,
+      RecentActivityServiceLive,
+      RerankServiceLive,
+      SocialChatHistoryServiceLive,
+      SystemExecutorServiceLive,
+      ThreadMessageServiceLive,
+      UserServiceLive,
+    ),
+    ctx0,
+  )
+  const ctx1 = Layer.mergeAll(ctx0, tier1)
+
+  const tier2 = provide(
+    Layer.mergeAll(
+      ArtifactServiceLive,
+      AttachmentServiceLive,
+      ContextCompactionServiceLive,
+      FeedbackLoopServiceLive,
+      InstitutionalMemoryServiceLive,
+      MemoryServiceLive,
+      MonitoringWindowServiceLive,
+      MutatingApprovalServiceLive,
+      PlanAgentQueryServiceLive,
+      PlanCheckpointServiceLive,
+      PlanCoordinationServiceLive,
+      PlanEventDeliveryServiceLive,
+      SkillResolverServiceLive,
+      RecentActivityTitleServiceLive,
+    ),
+    ctx1,
+  )
+  const ctx2 = Layer.mergeAll(ctx1, tier2)
+
+  const tier3 = provide(Layer.mergeAll(PlanValidatorServiceLive, ThreadServiceLive), ctx2)
+  const ctx3 = Layer.mergeAll(ctx2, tier3)
+
+  const tier4 = provide(Layer.mergeAll(PlanCompilerServiceLive, ThreadTitleServiceLive), ctx3)
+  const ctx4 = Layer.mergeAll(ctx3, tier4)
+
+  const tier5 = provide(PlanExecutorServiceLive, ctx4)
+  const ctx5 = Layer.mergeAll(ctx4, tier5)
+
+  const tier6 = provide(
+    Layer.mergeAll(OwnershipDispatcherServiceLive, PlanAgentHeartbeatServiceLive, PlanDeadlineServiceLive),
+    ctx5,
+  )
+  const ctx6 = Layer.mergeAll(ctx5, tier6)
+
+  const tier7 = provide(Layer.mergeAll(ExecutionPlanServiceLive, GlobalOrchestratorServiceLive), ctx6)
+  const ctx7 = Layer.mergeAll(ctx6, tier7)
+
+  const tier8 = provide(
+    Layer.mergeAll(
+      PlanTemplateServiceLive,
+      AutonomousJobServiceLive,
+      AgentActivityServiceLive,
+      ThreadTurnPreparationServiceLive,
+    ),
+    ctx7,
+  )
+  const ctx8 = Layer.mergeAll(ctx7, tier8)
+
+  const tier9 = provide(Layer.mergeAll(PlanCycleServiceLive, ThreadTurnServiceLive), ctx8)
+  return Layer.mergeAll(ctx8, tier9)
+}

package/src/runtime/graph-designer.ts

@@ -1,19 +1,27 @@
 import type { GraphDesignRequest, GraphDesignResponse } from '@lota-sdk/shared'
-import { Effect } from 'effect'
 
-import { getOptionalCurrentRuntime } from '../effect/runtime-ref'
+import { resolveOptionalLotaService } from '../effect/runtime'
 import { RuntimeConfigServiceTag } from '../effect/services'
 
 export interface GraphDesigner {
   designGraph(request: GraphDesignRequest): Promise<GraphDesignResponse>
 }
 
+let currentGraphDesigner: GraphDesigner | null = null
+
+export function configureGraphDesigner(graphDesigner: GraphDesigner | null | undefined): void {
+  currentGraphDesigner = graphDesigner ?? null
+}
+
+export function clearGraphDesigner(): void {
+  currentGraphDesigner = null
+}
+
 export function getGraphDesigner(): GraphDesigner | null {
-  const runtime = getOptionalCurrentRuntime()
-  if (!runtime) {
-    return null
+  if (currentGraphDesigner) {
+    return currentGraphDesigner
   }
 
-  const runtimeConfig = runtime.runSync(Effect.service(RuntimeConfigServiceTag))
-  return runtimeConfig.graphDesigner ?? null
+  const runtimeConfig = resolveOptionalLotaService(RuntimeConfigServiceTag)
+  return runtimeConfig?.graphDesigner ?? null
 }

package/src/runtime/helper-model.ts

@@ -253,7 +253,7 @@ export function createHelperModelRuntime() {
   }
 
   function generateHelperText(params: GenerateHelperTextParams): Promise<string> {
-    return Effect.runPromise(generateHelperTextEffect(params))
+    return Effect.runPromise(generateHelperTextEffect(params).pipe(Effect.withSpan('HelperModel.generateHelperText')))
   }
 
   function generateHelperStructuredEffect<T>(
@@ -300,7 +300,9 @@ export function createHelperModelRuntime() {
   }
 
   function generateHelperStructured<T>(params: GenerateHelperStructuredParams<T>): Promise<T> {
-    return Effect.runPromise(generateHelperStructuredEffect(params))
+    return Effect.runPromise(
+      generateHelperStructuredEffect(params).pipe(Effect.withSpan('HelperModel.generateHelperStructured')),
+    )
   }
 
   return { generateHelperTextEffect, generateHelperText, generateHelperStructuredEffect, generateHelperStructured }
@@ -308,6 +310,8 @@ export function createHelperModelRuntime() {
 
 export type HelperModelRuntime = ReturnType<typeof createHelperModelRuntime>
 
-export class HelperModelTag extends Context.Service<HelperModelTag, HelperModelRuntime>()('HelperModel') {}
+export class HelperModelTag extends Context.Service<HelperModelTag, HelperModelRuntime>()(
+  '@lota-sdk/core/HelperModel',
+) {}
 
-export const HelperModelLive = Layer.succeed(HelperModelTag, createHelperModelRuntime())
+export const HelperModelLive = Layer.sync(HelperModelTag, () => createHelperModelRuntime())

package/src/runtime/index.ts

@@ -1,7 +1,6 @@
 export * from './approval-continuation'
 export * from './agent-runtime-policy'
 export * from './agent-stream-helpers'
-export * from './agent-types'
 export * from './chat-request-routing'
 export * from './chat-run-registry'
 export * from './context-compaction/context-compaction'

package/src/runtime/memory/memory-block.ts

@@ -1,10 +1,14 @@
-import type { Cause } from 'effect'
-import { DateTime, Effect } from 'effect'
+import { Effect, Schema } from 'effect'
 import { z } from 'zod'
 
-import { effectTryPromise } from '../../effect/helpers'
+import { nowDate } from '../../utils/date-time'
 import { compactWhitespace } from '../../utils/string'
 
+export class MemoryBlockCompactError extends Schema.TaggedErrorClass<MemoryBlockCompactError>()(
+  'MemoryBlockCompactError',
+  { message: Schema.String, cause: Schema.Defect },
+) {}
+
 function escapeRegex(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
@@ -61,7 +65,7 @@ export interface CompactMemoryBlockEntriesParams {
   compact: (params: {
     previousSummary: string
     newEntriesText: string
-  }) => PromiseLike<string> | Effect.Effect<string, unknown>
+  }) => PromiseLike<string> | Effect.Effect<string, MemoryBlockCompactError>
 }
 
 export interface CompactMemoryBlockEntriesResult {
@@ -106,7 +110,7 @@ function toMemoryBlockEntriesSource(entries: Array<{ role: string; content: stri
 
 export function compactMemoryBlockEntries(
   params: CompactMemoryBlockEntriesParams,
-): Effect.Effect<CompactMemoryBlockEntriesResult, Cause.UnknownError> {
+): Effect.Effect<CompactMemoryBlockEntriesResult, MemoryBlockCompactError> {
   return Effect.gen(function* () {
     let summary = typeof params.previousSummary === 'string' ? params.previousSummary.trim() : ''
     let entries = [...params.entries]
@@ -114,9 +118,15 @@ export function compactMemoryBlockEntries(
 
     while (entries.length >= params.triggerEntries) {
       const chunk = entries.slice(0, params.chunkEntries)
-      const nextSummary = (yield* effectTryPromise(() =>
-        params.compact({ previousSummary: summary, newEntriesText: toMemoryBlockEntriesSource(chunk) }),
-      )).trim()
+      const compactParams = { previousSummary: summary, newEntriesText: toMemoryBlockEntriesSource(chunk) }
+      const value = params.compact(compactParams)
+      const raw = yield* Effect.isEffect(value)
+        ? value
+        : Effect.tryPromise({
+            try: () => Promise.resolve(value),
+            catch: (cause) => new MemoryBlockCompactError({ message: 'compact callback failed', cause }),
+          })
+      const nextSummary = raw.trim()
 
       if (!nextSummary) {
         break
@@ -162,7 +172,7 @@ export interface CreateMemoryBlockRuntimeOptions {
 export function createMemoryBlockRuntime(options: CreateMemoryBlockRuntimeOptions = {}): MemoryBlockRuntime {
   const labelPrefixRegex = createLabelPrefixRegex(options.labelRoles ?? [])
   const memoryBlockMaxChars = options.maxChars ?? 400
-  const now = options.now ?? (() => Effect.runSync(DateTime.nowAsDate))
+  const now = options.now ?? nowDate
 
   const normalizeMemoryBlockEntry = (entry: string): string => {
     const normalizedLines = entry