@lota-sdk/core 0.4.7 → 0.4.9

package/src/redis/stream-context.ts

@@ -1,28 +1,10 @@
+import { Context, Schema, Effect, Fiber, Layer, PubSub, Stream } from 'effect'
 import type { Redis } from 'ioredis'
 import type { Publisher, Subscriber } from 'resumable-stream/ioredis'
 import { createResumableStreamContext } from 'resumable-stream/ioredis'
 
-import { getRedisConnection } from './connection-accessor'
-
-function toSubscriber(client: Redis): Subscriber {
-  const handlers = new Map<string, (message: string) => void>()
-  const messageListener = (channel: string, message: string) => {
-    handlers.get(channel)?.(message)
-  }
-  return {
-    connect: () => Promise.resolve(),
-    subscribe: async (channel, callback) => {
-      if (handlers.size === 0) client.on('message', messageListener)
-      handlers.set(channel, callback)
-      await client.subscribe(channel)
-    },
-    unsubscribe: async (channel) => {
-      handlers.delete(channel)
-      if (handlers.size === 0) client.removeListener('message', messageListener)
-      return client.unsubscribe(channel)
-    },
-  }
-}
+import { RedisServiceTag } from '../effect/services'
+import type { RedisConnectionManager } from './connection'
 
 function toPublisher(client: Redis): Publisher {
   return {
@@ -34,35 +16,91 @@ function toPublisher(client: Redis): Publisher {
   }
 }
 
-let sharedSubscriber: { client: Redis; subscriber: Subscriber } | undefined
+type SharedSubscriberEvent = { readonly channel: string; readonly message: string }
+
+class SharedSubscriberCloseError extends Schema.TaggedErrorClass<SharedSubscriberCloseError>()(
+  'SharedSubscriberCloseError',
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
 
-function getSharedSubscriber(): Subscriber {
-  if (!sharedSubscriber) {
+export class SharedThreadStreamSubscriberTag extends Context.Service<
+  SharedThreadStreamSubscriberTag,
+  { readonly subscriber: Subscriber }
+>()('SharedThreadStreamSubscriber') {}
+
+export const SharedThreadStreamSubscriberLive = Layer.effect(
+  SharedThreadStreamSubscriberTag,
+  Effect.gen(function* () {
+    const redisManager = yield* RedisServiceTag
     // Disable enableReadyCheck — the ready check sends INFO which is rejected
     // on connections in subscribe mode, causing unhandled ioredis error events.
-    const client = getRedisConnection().duplicate({ enableReadyCheck: false })
+    const client = redisManager.getConnection().duplicate({ enableReadyCheck: false })
     client.on('error', () => {}) // prevent [ioredis] Unhandled error event logs
-    sharedSubscriber = { client, subscriber: toSubscriber(client) }
-  }
-  return sharedSubscriber.subscriber
-}
 
-export async function closeSharedSubscriber(): Promise<void> {
-  if (!sharedSubscriber) return
-  const { client } = sharedSubscriber
-  sharedSubscriber = undefined
-  try {
-    await client.quit()
-  } catch {
-    client.disconnect()
-  }
-}
+    const events = yield* PubSub.unbounded<SharedSubscriberEvent>()
+    const handlers = new Map<string, (message: string) => void>()
+
+    const dispatchFiber = yield* Effect.forkScoped(
+      Stream.fromPubSub(events).pipe(
+        Stream.runForEach((event) =>
+          Effect.sync(() => {
+            handlers.get(event.channel)?.(event.message)
+          }),
+        ),
+      ),
+    )
+
+    const currentContext = yield* Effect.context()
+    const runFork = Effect.runForkWith(currentContext)
+    const messageListener = (channel: string, message: string) => {
+      void runFork(PubSub.publish(events, { channel, message }).pipe(Effect.asVoid))
+    }
+    client.on('message', messageListener)
+
+    const subscribe = (channel: string, callback: (message: string) => void): Promise<void> => {
+      handlers.set(channel, callback)
+      return client.subscribe(channel).then(() => undefined)
+    }
+
+    const unsubscribe = (channel: string): Promise<void> => {
+      handlers.delete(channel)
+      return client.unsubscribe(channel).then(() => undefined)
+    }
+
+    const subscriber: Subscriber = {
+      connect: () => Promise.resolve(),
+      subscribe: (channel, callback) => subscribe(channel, callback),
+      unsubscribe: (channel) => unsubscribe(channel),
+    }
+
+    yield* Effect.addFinalizer(() =>
+      Effect.gen(function* () {
+        handlers.clear()
+        client.removeListener('message', messageListener)
+        yield* Fiber.interrupt(dispatchFiber)
+        yield* PubSub.shutdown(events)
+        yield* Effect.tryPromise({
+          try: () => client.quit(),
+          catch: (cause) =>
+            new SharedSubscriberCloseError({ message: 'Failed to quit shared stream subscriber.', cause }),
+        }).pipe(
+          Effect.catch(() =>
+            Effect.sync(() => {
+              client.disconnect()
+            }),
+          ),
+        )
+      }),
+    )
+
+    return { subscriber }
+  }),
+)
 
-export function createThreadResumableContext() {
-  const redis = getRedisConnection()
-  return createResumableStreamContext({
-    waitUntil: null,
-    subscriber: getSharedSubscriber(),
-    publisher: toPublisher(redis),
-  })
+export function createThreadResumableContext(
+  redisManager: Pick<RedisConnectionManager, 'getConnection'>,
+  subscriber: Subscriber,
+) {
+  const redis = redisManager.getConnection()
+  return createResumableStreamContext({ waitUntil: null, subscriber, publisher: toPublisher(redis) })
 }

package/src/runtime/agent-identity-overrides.ts

@@ -1,4 +1,4 @@
-import { agentDisplayNames } from '../config/agent-defaults'
+import { getAgentDisplayNames } from '../config/agent-defaults'
 import { asRecord, readOptionalString } from './thread-chat-helpers'
 
 interface RuntimeAgentIdentityOverrides {
@@ -58,5 +58,5 @@ export function resolveRuntimeAgentDisplayName(overrides: RuntimeAgentIdentityOv
     return override
   }
 
-  return agentDisplayNames[agentId] ?? agentId
+  return getAgentDisplayNames()[agentId] ?? agentId
 }

package/src/runtime/agent-runtime-policy.ts

@@ -162,10 +162,13 @@ export function buildThreadAgentToolPolicy<TAgent extends string, TSkill extends
   linearInstalled: boolean
   githubInstalled: boolean
   provideRepoTool: boolean
+  leadAgentId?: TAgent
+  onboardingOwnerAgentId?: TAgent
   getAgentSkills: (agentId: TAgent, mode: ChatMode) => TSkill[]
 }): AgentToolPolicy<TSkill> {
   const resolvedMode = params.mode ?? toChatMode(params.threadType)
-  const onboardingOwnerAgentId = resolveOnboardingOwnerAgentId(getLeadAgentId()) as TAgent
+  const leadAgentId = params.leadAgentId ?? (getLeadAgentId() as TAgent)
+  const onboardingOwnerAgentId = params.onboardingOwnerAgentId ?? (resolveOnboardingOwnerAgentId(leadAgentId) as TAgent)
   const skills = resolveActiveAgentSkills({
     agentId: params.agentId,
     threadType: params.threadType,

package/src/runtime/agent-stream-helpers.ts

@@ -1,7 +1,9 @@
 import type { ChatMessage } from '@lota-sdk/shared'
 import type { LanguageModelUsage, UIMessageStreamOptions } from 'ai'
+import { Duration, Effect, Fiber } from 'effect'
 
-import { agentDisplayNames, getLeadAgentDisplayName } from '../config/agent-defaults'
+import { getAgentDisplayNames, getLeadAgentDisplayName } from '../config/agent-defaults'
+import { nowEpochMillis } from '../utils/date-time'
 import { readRecord as _readRecord } from '../utils/string'
 
 export function readFiniteNumber(value: unknown): number | undefined {
@@ -32,7 +34,7 @@ export function createAgentMessageMetadata(params: {
 }): NonNullable<UIMessageStreamOptions<ChatMessage>['messageMetadata']> {
   return ({ part }) => {
     if (part.type === 'start') {
-      return { agentId: params.agentId, agentName: params.agentName, createdAt: Date.now() }
+      return { agentId: params.agentId, agentName: params.agentName, createdAt: nowEpochMillis() }
     }
 
     if (part.type === 'finish') {
@@ -100,13 +102,21 @@ export function createServerRunAbortController(externalAbortSignal?: AbortSignal
 export function createTimedAbortSignal(parentSignal: AbortSignal, timeoutMs: number) {
   const controller = new AbortController()
   let didTimeout = false
+  let disposed = false
   const abortFromParent = () => {
     controller.abort((parentSignal as AbortSignal & { reason?: unknown }).reason)
   }
-  const timeoutId = setTimeout(() => {
-    didTimeout = true
-    controller.abort(new Error(`Timed out after ${timeoutMs}ms`))
-  }, timeoutMs)
+  const timeoutFiber = Effect.runFork(
+    Effect.sleep(Duration.millis(timeoutMs)).pipe(
+      Effect.tap(() =>
+        Effect.sync(() => {
+          if (disposed || controller.signal.aborted) return
+          didTimeout = true
+          controller.abort(new Error(`Timed out after ${timeoutMs}ms`))
+        }),
+      ),
+    ),
+  )
 
   if (parentSignal.aborted) {
     abortFromParent()
@@ -118,14 +128,15 @@ export function createTimedAbortSignal(parentSignal: AbortSignal, timeoutMs: num
     signal: controller.signal,
     didTimeout: () => didTimeout,
     dispose: () => {
-      clearTimeout(timeoutId)
+      disposed = true
       parentSignal.removeEventListener('abort', abortFromParent)
+      void Effect.runFork(Fiber.interrupt(timeoutFiber))
     },
   }
 }
 
 export function buildSpecialistTaskMessage(params: { agentId: string; task: string }): ChatMessage {
-  const displayName = agentDisplayNames[params.agentId] ?? params.agentId
+  const displayName = getAgentDisplayNames()[params.agentId] ?? params.agentId
   const leadAgentDisplayName = getLeadAgentDisplayName()
   return {
     id: Bun.randomUUIDv7(),
@@ -133,6 +144,6 @@ export function buildSpecialistTaskMessage(params: { agentId: string; task: stri
     parts: [
       { type: 'text', text: [`${leadAgentDisplayName} request for ${displayName}:`, params.task.trim()].join('\n') },
     ],
-    metadata: { createdAt: Date.now() },
+    metadata: { createdAt: nowEpochMillis() },
   }
 }

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

@@ -1,25 +1,108 @@
-const COMPACTION_POLL_INTERVAL_MS = 200
+import { Cause, Context, Schema, Duration, Effect, Latch, Layer } from 'effect'
+
+import { effectTryPromise } from '../effect/helpers'
+import { nowEpochMillis } from '../utils/date-time'
+
+const COMPACTION_WAIT_REFRESH_MS = 1_000
 const COMPACTION_MAX_WAIT_MS = 120_000
 
-export async function waitForCompactionIfNeeded<TEntity>(params: {
+class WaitForCompactionError extends Schema.TaggedErrorClass<WaitForCompactionError>()('WaitForCompactionError', {
+  entityId: Schema.String,
+  entityLabel: Schema.String,
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+function toWaitForCompactionError(params: {
   entityId: string
   entityLabel: string
-  loadEntity: () => Promise<TEntity>
-  isCompacting: (entity: TEntity) => boolean
-}): Promise<TEntity> {
-  let entity = await params.loadEntity()
-  if (!params.isCompacting(entity)) return entity
-
-  const deadline = Date.now() + COMPACTION_MAX_WAIT_MS
-  while (params.isCompacting(entity)) {
-    if (Date.now() > deadline) {
-      throw new Error(
-        `${params.entityLabel} ${params.entityId} compaction did not complete within ${COMPACTION_MAX_WAIT_MS}ms`,
-      )
-    }
-    await Bun.sleep(COMPACTION_POLL_INTERVAL_MS)
-    entity = await params.loadEntity()
-  }
+  cause: unknown
+}): WaitForCompactionError {
+  return new WaitForCompactionError({
+    entityId: params.entityId,
+    entityLabel: params.entityLabel,
+    message: params.cause instanceof Error ? params.cause.message : String(params.cause),
+    cause: params.cause,
+  })
+}
 
-  return entity
+interface CompactionCoordination {
+  readonly signal: (entityId: string, compacting: boolean) => Effect.Effect<void>
+  readonly waitIfNeeded: <TEntity>(params: {
+    entityId: string
+    entityLabel: string
+    loadEntity: () => PromiseLike<TEntity> | Effect.Effect<TEntity, unknown>
+    isCompacting: (entity: TEntity) => boolean
+  }) => Effect.Effect<TEntity, WaitForCompactionError>
 }
+
+export class CompactionCoordinationTag extends Context.Service<CompactionCoordinationTag, CompactionCoordination>()(
+  'CompactionCoordination',
+) {}
+
+export const CompactionCoordinationLive = Layer.effect(
+  CompactionCoordinationTag,
+  Effect.sync((): CompactionCoordination => {
+    const latches = new Map<string, Latch.Latch>()
+
+    function getLatch(entityId: string): Latch.Latch {
+      let latch = latches.get(entityId)
+      if (!latch) {
+        latch = Latch.makeUnsafe(true)
+        latches.set(entityId, latch)
+      }
+      return latch
+    }
+
+    return {
+      signal: (entityId, compacting) =>
+        Effect.sync(() => {
+          const latch = getLatch(entityId)
+          if (compacting) {
+            Latch.closeUnsafe(latch)
+          } else {
+            Latch.openUnsafe(latch)
+          }
+        }),
+
+      waitIfNeeded: Effect.fn('CompactionCoordination.waitIfNeeded')(function* <TEntity>(params: {
+        entityId: string
+        entityLabel: string
+        loadEntity: () => PromiseLike<TEntity> | Effect.Effect<TEntity, unknown>
+        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 }),
+        )
+
+        while (params.isCompacting(entity)) {
+          Latch.closeUnsafe(latch)
+          if (nowEpochMillis() > deadline) {
+            return yield* new WaitForCompactionError({
+              entityId: params.entityId,
+              entityLabel: params.entityLabel,
+              message: `${params.entityLabel} ${params.entityId} compaction did not complete within ${COMPACTION_MAX_WAIT_MS}ms`,
+            })
+          }
+
+          const remainingMs = Math.max(0, deadline - nowEpochMillis())
+          const refreshWindowMs = Math.min(COMPACTION_WAIT_REFRESH_MS, remainingMs)
+          yield* latch.await.pipe(
+            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 }),
+          )
+        }
+
+        Latch.openUnsafe(latch)
+        return entity
+      }),
+    }
+  }),
+)

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

@@ -1,5 +1,9 @@
+import { Effect, Fiber, FiberMap } from 'effect'
+
 export class ChatRunRegistry {
-  private controllers = new Map<string, AbortController>()
+  private readonly controllers = new Map<string, AbortController>()
+
+  constructor(private readonly trackedRuns: FiberMap.FiberMap<string>) {}
 
   has(runId: string): boolean {
     return this.controllers.has(runId)
@@ -16,9 +20,39 @@ export class ChatRunRegistry {
   stop(runId: string, reason?: unknown): boolean {
     const controller = this.controllers.get(runId)
     if (!controller) return false
-
     this.controllers.delete(runId)
     controller.abort(reason)
+    void Effect.runFork(FiberMap.remove(this.trackedRuns, runId))
     return true
   }
+
+  trackRunEffect<A, E, R>(
+    runId: string,
+    controller: AbortController,
+    effect: Effect.Effect<A, E, R>,
+  ): Effect.Effect<A, E, R> {
+    return Effect.gen(
+      function* (this: ChatRunRegistry) {
+        this.controllers.set(runId, controller)
+        const fiber = yield* FiberMap.run(
+          this.trackedRuns,
+          runId,
+          effect.pipe(
+            Effect.ensuring(
+              Effect.sync(() => {
+                if (this.controllers.get(runId) === controller) {
+                  this.controllers.delete(runId)
+                }
+              }),
+            ),
+          ),
+        )
+        return yield* Fiber.join(fiber)
+      }.bind(this),
+    )
+  }
+
+  stopEffect(runId: string, reason?: unknown): Effect.Effect<boolean> {
+    return Effect.sync(() => this.stop(runId, reason))
+  }
 }

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

@@ -0,0 +1,107 @@
+import { Schema, Effect } from 'effect'
+
+import { createContextCompactionAgent } from '../../system-agents/context-compaction.agent'
+import type { GenerateHelperStructuredParams, GenerateHelperTextParams } from '../helper-model'
+import {
+  buildContextCompactionPrompt,
+  buildMemoryBlockCompactionPrompt,
+  ContextCompactionOutputSchema,
+  createContextCompactionRuntime,
+  parseCompactionOutput,
+} from './context-compaction'
+import type { ContextCompactionRunnerParams } from './context-compaction'
+import {
+  COMPACTION_CHUNK_MAX_CHARS,
+  CONTEXT_COMPACTION_INCLUDED_TOOL_NAMES,
+  CONTEXT_COMPACTION_INCLUDED_TOOL_PREFIXES,
+  CONTEXT_COMPACTION_THRESHOLD_RATIO,
+  CONTEXT_OUTPUT_RESERVE_TOKENS,
+  CONTEXT_SAFETY_MARGIN_TOKENS,
+  SUMMARY_ROLLUP_MAX_TOKENS,
+} from './context-compaction-constants'
+
+const CONTEXT_COMPACTION_MAX_OUTPUT_TOKENS = 512
+
+interface HelperModelRuntime {
+  generateHelperStructured<T>(params: GenerateHelperStructuredParams<T>): Promise<T>
+  generateHelperText(params: GenerateHelperTextParams): Promise<string>
+}
+
+interface CreateContextCompactionRuntimeDeps {
+  helperModelRuntime: HelperModelRuntime
+  now?: () => number
+  randomId?: () => string
+}
+
+class ContextCompactionRuntimeError extends Schema.TaggedErrorClass<ContextCompactionRuntimeError>()(
+  'ContextCompactionRuntimeError',
+  { message: Schema.String, cause: Schema.Defect },
+) {}
+
+function tryContextCompactionPromise<A>(
+  message: string,
+  thunk: () => PromiseLike<A>,
+): Effect.Effect<A, ContextCompactionRuntimeError> {
+  return Effect.tryPromise({
+    try: () => Promise.resolve(thunk()),
+    catch: (cause) => new ContextCompactionRuntimeError({ message, cause }),
+  })
+}
+
+function runContextCompacter(helperModelRuntime: HelperModelRuntime, params: ContextCompactionRunnerParams) {
+  return Effect.runPromise(
+    tryContextCompactionPromise('Failed to compact runtime context.', () =>
+      helperModelRuntime.generateHelperStructured({
+        tag: 'context-compaction',
+        createAgent: createContextCompactionAgent,
+        messages: [
+          {
+            role: 'user',
+            content: buildContextCompactionPrompt({
+              previousSummary: params.previousSummary,
+              transcript: params.transcript,
+            }),
+          },
+        ],
+        schema: ContextCompactionOutputSchema,
+        maxOutputTokens: 8_000,
+      }),
+    ).pipe(Effect.map(parseCompactionOutput)),
+  )
+}
+
+export function createWiredContextCompactionRuntime(deps: CreateContextCompactionRuntimeDeps) {
+  const { helperModelRuntime } = deps
+
+  const runtime = createContextCompactionRuntime({
+    runCompacter: (params) => runContextCompacter(helperModelRuntime, params),
+    now: deps.now,
+    randomId: deps.randomId,
+    thresholdRatio: CONTEXT_COMPACTION_THRESHOLD_RATIO,
+    outputReserveTokens: CONTEXT_OUTPUT_RESERVE_TOKENS,
+    safetyMarginTokens: CONTEXT_SAFETY_MARGIN_TOKENS,
+    compactionChunkMaxChars: COMPACTION_CHUNK_MAX_CHARS,
+    summaryRollupMaxTokens: SUMMARY_ROLLUP_MAX_TOKENS,
+    includedToolNames: CONTEXT_COMPACTION_INCLUDED_TOOL_NAMES,
+    includedToolPrefixes: CONTEXT_COMPACTION_INCLUDED_TOOL_PREFIXES,
+  })
+
+  function compactMemoryBlockSummary(params: { previousSummary: string; newEntriesText: string }): Promise<string> {
+    const previousSummary = params.previousSummary.trim()
+    const newEntriesText = params.newEntriesText.trim()
+    if (!previousSummary && !newEntriesText) return Promise.resolve('')
+
+    return Effect.runPromise(
+      tryContextCompactionPromise('Failed to compact memory block summary.', () =>
+        helperModelRuntime.generateHelperText({
+          tag: 'memory-block-compaction',
+          createAgent: createContextCompactionAgent,
+          messages: [{ role: 'user', content: buildMemoryBlockCompactionPrompt({ previousSummary, newEntriesText }) }],
+          maxOutputTokens: CONTEXT_COMPACTION_MAX_OUTPUT_TOKENS,
+        }),
+      ),
+    )
+  }
+
+  return { ...runtime, compactMemoryBlockSummary }
+}