@lota-sdk/core 0.4.31 → 0.4.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.4.31",
+  "version": "0.4.33",
   "files": [
     "src",
     "infrastructure/schema"
@@ -32,7 +32,7 @@
     "@ai-sdk/provider": "^3.0.9",
     "@chat-adapter/slack": "^4.26.0",
     "@chat-adapter/state-ioredis": "^4.26.0",
-    "@lota-sdk/shared": "0.4.31",
+    "@lota-sdk/shared": "0.4.33",
     "@mendable/firecrawl-js": "^4.20.0",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.170",

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

@@ -99,12 +99,15 @@ export function createWiredContextCompactionRuntime(deps: CreateContextCompactio
     if (!previousSummary && !newEntriesText) return Effect.succeed('')
 
     return tryContextCompactionPromise('Failed to compact memory block summary.', () =>
-      helperModelRuntime.generateHelperText({
-        tag: 'memory-block-compaction',
-        createAgent,
-        messages: [{ role: 'user', content: buildMemoryBlockCompactionPrompt({ previousSummary, newEntriesText }) }],
-        maxOutputTokens: CONTEXT_COMPACTION_MAX_OUTPUT_TOKENS,
-      }),
+      helperModelRuntime
+        .generateHelperStructured({
+          tag: 'memory-block-compaction',
+          createAgent,
+          messages: [{ role: 'user', content: buildMemoryBlockCompactionPrompt({ previousSummary, newEntriesText }) }],
+          schema: ContextCompactionOutputSchema,
+          maxOutputTokens: CONTEXT_COMPACTION_MAX_OUTPUT_TOKENS,
+        })
+        .then((result) => result.summary),
     ).pipe(
       Effect.retry({
         times: MEMORY_BLOCK_COMPACTION_RETRY_ATTEMPTS,

package/src/services/thread/thread-memory-block.ts

@@ -1,11 +1,14 @@
 import type { Context } from 'effect'
-import { Schema, Effect } from 'effect'
+import { Duration, Schema, Effect, Schedule } from 'effect'
 
 import { serverLogger } from '../../config/logger'
 import type { RecordIdRef } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import { TABLES } from '../../db/tables'
+import { isRetriableTransactionConflict } from '../../db/transaction-conflict'
 import { ERROR_TAGS } from '../../effect/errors'
+import type { RedisConnectionManager } from '../../redis/connection'
+import { withLeaseLock } from '../../redis/redis-lease-lock'
 import {
   appendToMemoryBlock,
   compactMemoryBlockEntries,
@@ -24,6 +27,12 @@ type ContextCompactionServiceLike = Pick<ReturnType<typeof makeContextCompaction
 
 type BackgroundWorker = Context.Service.Shape<typeof BackgroundWorkServiceTag>
 
+const MEMORY_BLOCK_COMPACTION_RETRY_ATTEMPTS = 4
+const MEMORY_BLOCK_COMPACTION_RETRY_BASE_DELAY_MS = 50
+const MEMORY_BLOCK_COMPACTION_LOCK_TTL_MS = 120_000
+const MEMORY_BLOCK_COMPACTION_LOCK_MAX_WAIT_MS = 250
+const MEMORY_BLOCK_COMPACTION_LOCK_RETRY_DELAY_MS = 125
+
 class ThreadMemoryBlockError extends Schema.TaggedErrorClass<ThreadMemoryBlockError>()(
   ERROR_TAGS.ThreadMemoryBlockError,
   { message: Schema.String, cause: Schema.optional(Schema.Defect) },
@@ -40,7 +49,38 @@ export function createThreadMemoryBlockHelpers(deps: {
   threadStore: ThreadRecordStore
   contextCompactionService: ContextCompactionServiceLike
   background: BackgroundWorker
+  redis?: RedisConnectionManager
 }) {
+  function withCompactionLock(
+    threadIdString: string,
+    effect: Effect.Effect<boolean, ThreadMemoryBlockError>,
+  ): Effect.Effect<boolean, ThreadMemoryBlockError> {
+    if (!deps.redis) return effect
+
+    return withLeaseLock(
+      {
+        redis: deps.redis.getConnection(),
+        lockKey: `thread-memory-block:compact:${threadIdString}`,
+        lockTtlMs: MEMORY_BLOCK_COMPACTION_LOCK_TTL_MS,
+        maxWaitMs: MEMORY_BLOCK_COMPACTION_LOCK_MAX_WAIT_MS,
+        retryDelayMs: MEMORY_BLOCK_COMPACTION_LOCK_RETRY_DELAY_MS,
+        label: 'thread memory block compaction',
+        logger: serverLogger,
+      },
+      () => effect,
+    ).pipe(
+      Effect.catchTag(ERROR_TAGS.LockAcquisitionError, () => Effect.succeed(false)),
+      Effect.mapError((cause) =>
+        cause._tag === ERROR_TAGS.ThreadMemoryBlockError
+          ? cause
+          : new ThreadMemoryBlockError({
+              message: `Failed to coordinate memory block compaction for thread ${threadIdString}`,
+              cause,
+            }),
+      ),
+    )
+  }
+
   function appendMemoryBlock(threadId: RecordIdRef, entry: string): Effect.Effect<string, ThreadMemoryBlockError> {
     return Effect.gen(function* () {
       const threadRef = ensureRecordId(threadId, TABLES.THREAD)
@@ -94,7 +134,7 @@ export function createThreadMemoryBlockHelpers(deps: {
     })
   }
 
-  function compactMemoryBlock(threadId: RecordIdRef): Effect.Effect<boolean, ThreadMemoryBlockError> {
+  function compactMemoryBlockOnce(threadId: RecordIdRef): Effect.Effect<boolean, ThreadMemoryBlockError> {
     return Effect.gen(function* () {
       const threadRef = ensureRecordId(threadId, TABLES.THREAD)
       const threadIdString = recordIdToString(threadRef, TABLES.THREAD)
@@ -151,5 +191,21 @@ export function createThreadMemoryBlockHelpers(deps: {
     })
   }
 
+  function compactMemoryBlock(threadId: RecordIdRef): Effect.Effect<boolean, ThreadMemoryBlockError> {
+    const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+    const threadIdString = recordIdToString(threadRef, TABLES.THREAD)
+    const compact = compactMemoryBlockOnce(threadRef).pipe(
+      Effect.retry({
+        times: MEMORY_BLOCK_COMPACTION_RETRY_ATTEMPTS - 1,
+        schedule: Schedule.jittered(
+          Schedule.exponential(Duration.millis(MEMORY_BLOCK_COMPACTION_RETRY_BASE_DELAY_MS), 2),
+        ),
+        while: isRetriableTransactionConflict,
+      }),
+    )
+
+    return withCompactionLock(threadIdString, compact)
+  }
+
   return { appendMemoryBlock, compactMemoryBlock }
 }

package/src/services/thread/thread.service.ts

@@ -170,6 +170,7 @@ export function makeThreadService(deps: ThreadServiceDeps) {
     threadStore,
     contextCompactionService: { compactMemoryBlock: deps.contextCompactionService.compactMemoryBlock },
     background: deps.background,
+    redis: deps.redis,
   })
 
   const getById = Effect.fn('ThreadService.getById')(function* (threadId: RecordIdRef) {

package/src/system-agents/context-compaction.agent.ts

@@ -3,10 +3,7 @@ import { ToolLoopAgent } from 'ai'
 
 import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
-import {
-  OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
-  OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
-} from '../config/model-constants'
+import { OPENROUTER_STRUCTURED_HELPER_MODEL_ID } from '../config/model-constants'
 import { resolveHelperAgentOptions } from './helper-agent-options'
 
 const CONTEXT_COMPACTION_PROMPT = `<agent-instructions>
@@ -37,7 +34,6 @@ export function makeContextCompactionAgentFactory(models: AiGatewayModels) {
       id: 'context-compaction',
       model: models.chatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
       headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
-      providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
       ...resolveHelperAgentOptions(options, { instructions: CONTEXT_COMPACTION_PROMPT }),
     })
 }