@lota-sdk/core 0.4.36 → 0.4.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.4.36",
+  "version": "0.4.37",
   "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.36",
+    "@lota-sdk/shared": "0.4.37",
     "@mendable/firecrawl-js": "^4.20.0",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.170",

package/src/services/plan/plan-agent-heartbeat.service.ts

@@ -1,3 +1,4 @@
+import type { PlanFailureClass } from '@lota-sdk/shared'
 import { Context, Schema, Effect, Layer } from 'effect'
 
 import type { ResolvedAgentConfig } from '../../config/agent-defaults'
@@ -39,6 +40,18 @@ function buildWakeDedupeKey(params: {
   return `${params.organizationId}:${params.threadId}:${params.runId}:${params.nodeId}:${params.agentId}`
 }
 
+function classifyPlanTurnDispatchFailure(error: unknown): PlanFailureClass {
+  const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase()
+  if (message.includes('timeout')) {
+    return 'timeout_exceeded'
+  }
+  return 'non_recoverable_logic_error'
+}
+
+function formatPlanTurnDispatchError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
 class PlanAgentHeartbeatError extends Schema.TaggedErrorClass<PlanAgentHeartbeatError>()(
   ERROR_TAGS.PlanAgentHeartbeatError,
   { operation: Schema.String, cause: Schema.Defect },
@@ -151,9 +164,27 @@ export function makePlanAgentHeartbeatService(deps: PlanAgentHeartbeatDeps) {
               )
             }
 
-            yield* heartbeatServiceEffect(
-              'trigger-plan-node-turn',
-              threadTurnService.triggerPlanNodeTurn({ runId: params.runId, nodeId: params.nodeId }),
+            yield* threadTurnService.triggerPlanNodeTurn({ runId: params.runId, nodeId: params.nodeId }).pipe(
+              Effect.catch((cause) =>
+                heartbeatServiceEffect(
+                  'block-node-on-plan-turn-failure',
+                  planExecutorService.blockNodeOnDispatchFailure({
+                    threadId: threadRef,
+                    runId: params.runId,
+                    nodeId: params.nodeId,
+                    emittedBy: 'plan-agent-heartbeat',
+                    message: formatPlanTurnDispatchError(cause),
+                    failureClass: classifyPlanTurnDispatchFailure(cause),
+                  }),
+                ).pipe(
+                  Effect.tap(() =>
+                    Effect.sync(() => {
+                      serverLogger.warn`Plan agent heartbeat blocked ${params.runId}/${params.nodeId} after plan-turn failure: ${formatPlanTurnDispatchError(cause)}`
+                    }),
+                  ),
+                  Effect.asVoid,
+                ),
+              ),
             )
             return true
           }),

package/src/workers/bootstrap.ts

@@ -8,14 +8,13 @@ import {
   makeAiGatewayService,
 } from '../ai-gateway/ai-gateway'
 import type { AiGatewayModels, RuntimeBridge } from '../ai-gateway/ai-gateway'
-import { EmbeddingCacheLive } from '../ai/embedding-cache'
 import { serverLogger } from '../config/logger'
 import { connectWithStartupRetry, waitForDatabaseBootstrap } from '../db/startup'
 import { buildWorkerInfrastructureLayer } from '../effect'
 import { ERROR_TAGS } from '../effect/errors'
 import { DatabaseServiceTag, RuntimeAdaptersServiceTag } from '../effect/services'
+import { buildDomainServiceLayer } from '../runtime/domain-layer'
 import { lotaRuntimeEnvConfig, parseLotaRuntimeConfig, parseWorkerBootstrapEnv } from '../runtime/runtime-config'
-import { FirecrawlLive } from '../tools/firecrawl-client'
 import { getErrorMessage } from '../utils/errors'
 
 class SandboxedWorkerBootstrapError extends Schema.TaggedErrorClass<SandboxedWorkerBootstrapError>()(
@@ -103,11 +102,7 @@ function ensureSandboxedWorkerRuntimeConfigured(): Promise<WorkerManagedRuntime>
         Layer.effect(AiGatewayModelsTag, Deferred.await(aiGatewayModelsDeferred)),
         Layer.effect(RuntimeBridgeTag, Deferred.await(runtimeBridgeDeferred)),
       )
-      const layerWithBridge = Layer.mergeAll(infrastructureLayer, bridgeLayer)
-      const fullLayer = Layer.mergeAll(
-        layerWithBridge,
-        Layer.provide(Layer.mergeAll(EmbeddingCacheLive, FirecrawlLive), layerWithBridge),
-      )
+      const fullLayer = buildDomainServiceLayer(infrastructureLayer, bridgeLayer)
 
       const managedRuntime = ManagedRuntime.make(fullLayer)
       const runtimeBridge: RuntimeBridge = {

package/src/workers/organization-learning.worker.ts

@@ -7,11 +7,12 @@ import { serverLogger } from '../config/logger'
 import {
   AgentConfigServiceTag,
   DatabaseServiceTag,
+  RedisServiceTag,
   RuntimeAdaptersServiceTag,
   RuntimeConfigServiceTag,
 } from '../effect/services'
+import { makeOrganizationLearningQueueRuntime } from '../queues/organization-learning.queue'
 import type { OrganizationLearningJob } from '../queues/organization-learning.queue'
-import { LotaQueuesServiceTag } from '../queues/queues.service'
 import { LearnedSkillServiceTag } from '../services/learned-skill.service'
 import { MemoryServiceTag } from '../services/memory/memory.service'
 import { QueueJobServiceTag } from '../services/queue-job.service'
@@ -28,7 +29,12 @@ const runtime = await initializeSandboxedWorkerRuntime()
 const resolve = <I, T>(tag: Context.Key<I, T>): Promise<T> => runtime.runPromise(Effect.service(tag))
 const agentConfig = await resolve(AgentConfigServiceTag)
 const aiGatewayModels = await resolve(AiGatewayModelsTag)
-const queues = await resolve(LotaQueuesServiceTag)
+const redis = await resolve(RedisServiceTag)
+const organizationLearningQueueJobService = await resolve(QueueJobServiceTag)
+const organizationLearningQueue = makeOrganizationLearningQueueRuntime({
+  connectionProvider: () => redis.getConnectionForBullMQ(),
+  queueJobService: organizationLearningQueueJobService,
+})
 const regularChatDigestServices: RegularChatDigestServices = {
   agentConfig,
   aiGatewayModels,
@@ -36,7 +42,7 @@ const regularChatDigestServices: RegularChatDigestServices = {
   memoryService: await resolve(MemoryServiceTag),
   socialChatHistoryService: await resolve(SocialChatHistoryServiceTag),
   runtimeAdapters: await resolve(RuntimeAdaptersServiceTag),
-  organizationLearningQueue: queues.organizationLearning,
+  organizationLearningQueue,
 }
 const workerRuntimeConfig = await resolve(RuntimeConfigServiceTag)
 const skillExtractionServices: SkillExtractionServices = {
@@ -49,7 +55,6 @@ const skillExtractionServices: SkillExtractionServices = {
   embeddingModel: workerRuntimeConfig.aiGateway.embeddingModel,
   runPromise: (effect) => runtime.runPromise(effect),
 }
-const organizationLearningQueueJobService = await resolve(QueueJobServiceTag)
 
 // One sandboxed worker handles both organization-learning branches so the
 // queue can dispatch digest and skill jobs without separate worker images.