@lota-sdk/core 0.4.8 → 0.4.10

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

@@ -0,0 +1,344 @@
+import { THREAD, sdkThreadStatusSchema } from '@lota-sdk/shared'
+import { Context, Effect, Layer } from 'effect'
+import { surql } from 'surrealdb'
+
+import { getCoreThreadProfile, isAgentName } from '../../config/agent-defaults'
+import { ensureRecordId, isRecordIdInput, recordIdToString } from '../../db/record-id'
+import type { RecordIdRef } from '../../db/record-id'
+import type { SurrealDBService } from '../../db/service'
+import { TABLES } from '../../db/tables'
+import { BadRequestError, ServiceError } from '../../effect/errors'
+import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
+import { DatabaseServiceTag, RedisServiceTag } from '../../effect/services'
+import type { RedisConnectionManager } from '../../redis/connection'
+import { CompactionCoordinationTag } from '../../runtime/chat-run-orchestration'
+import { toIsoDateTimeString } from '../../utils/date-time'
+import { BackgroundWorkService } from '../background-work.service'
+import { ChatRunRegistryTag } from '../chat-run-registry.service'
+import { ContextCompactionServiceTag } from '../context-compaction.service'
+import type { makeContextCompactionService } from '../context-compaction.service'
+import { createThreadActiveRunHelpers } from './thread-active-run'
+import { createThreadBootstrapHelpers } from './thread-bootstrap'
+import { createThreadListingHelpers } from './thread-listing'
+import { createThreadMemoryBlockHelpers, formatMemoryBlockForPrompt } from './thread-memory-block'
+import { ThreadMessageServiceTag } from './thread-message.service'
+import type { makeThreadMessageService } from './thread-message.service'
+import { createThreadRecordStore } from './thread-record-store'
+import { NormalizedThreadSchema, PublicThreadSchema } from './thread.types'
+import type { NormalizedThread, PublicThread, ThreadRecord } from './thread.types'
+
+export { ActiveThreadRunConflictError } from '../../effect/errors'
+
+function assertMutableThreadEffect(thread: ThreadRecord): Effect.Effect<void, BadRequestError> {
+  return thread.type === 'default'
+    ? Effect.fail(new BadRequestError({ message: 'Default threads cannot be modified.' }))
+    : Effect.void
+}
+
+function getDefaultTitle(thread: Pick<ThreadRecord, 'type' | 'threadType'>): string {
+  if (thread.type === 'thread' && typeof thread.threadType === 'string') {
+    return getCoreThreadProfile(thread.threadType).config.title
+  }
+
+  return THREAD.DEFAULT_TITLE
+}
+
+function normalizeRecordIdStringEffect(id: unknown, table: string): Effect.Effect<string, BadRequestError> {
+  return isRecordIdInput(id)
+    ? Effect.succeed(recordIdToString(ensureRecordId(id, table), table))
+    : Effect.fail(new BadRequestError({ message: `Invalid record id for table ${table}.` }))
+}
+
+function toPublicThread(thread: NormalizedThread): PublicThread {
+  const { organizationId: _organizationId, userId: _userId, memoryBlock: _memoryBlock, ...publicThread } = thread
+  return PublicThreadSchema.parse(publicThread)
+}
+
+type ThreadServiceError = ServiceError | BadRequestError
+
+const effectTryPromise = makeEffectTryPromiseWithMessage((message, cause) => new ServiceError({ message, cause }))
+
+type ChatRunRegistry = Context.Service.Shape<typeof ChatRunRegistryTag>
+
+type CompactionCoordination = Context.Service.Shape<typeof CompactionCoordinationTag>
+
+interface ThreadServiceDeps {
+  db: SurrealDBService
+  redis: RedisConnectionManager
+  chatRunRegistry: ChatRunRegistry
+  threadMessageService: ReturnType<typeof makeThreadMessageService>
+  contextCompactionService: ReturnType<typeof makeContextCompactionService>
+  compactionCoordination: CompactionCoordination
+  background: Context.Service.Shape<typeof BackgroundWorkService>
+}
+
+export function makeThreadService(deps: ThreadServiceDeps) {
+  const threadStore = createThreadRecordStore({ db: deps.db })
+  const activeRun = createThreadActiveRunHelpers({
+    db: deps.db,
+    threadStore,
+    redis: deps.redis,
+    chatRunRegistry: deps.chatRunRegistry,
+  })
+
+  function computeIsRunning(
+    thread: Pick<ThreadRecord, 'id' | 'activeRunId'>,
+    options: { checkLease: boolean },
+  ): Effect.Effect<boolean, ThreadServiceError> {
+    const activeRunId =
+      typeof thread.activeRunId === 'string' && thread.activeRunId.trim().length > 0 ? thread.activeRunId : null
+
+    if (activeRunId === null) {
+      return Effect.succeed(false)
+    }
+
+    if (deps.chatRunRegistry.has(activeRunId)) {
+      return Effect.succeed(true)
+    }
+
+    if (!options.checkLease) {
+      return Effect.succeed(true)
+    }
+
+    return effectTryPromise(
+      () => activeRun.hasActiveRunLease(ensureRecordId(thread.id, TABLES.THREAD)),
+      'Failed to check active thread run lease.',
+    )
+  }
+
+  function toNormalizedThread(
+    thread: ThreadRecord,
+    options: { checkLease?: boolean } = {},
+  ): Effect.Effect<NormalizedThread, ThreadServiceError> {
+    return Effect.gen(function* () {
+      const isRunning = yield* computeIsRunning(thread, { checkLease: options.checkLease ?? true })
+      const [id, userId, organizationId] = yield* Effect.all([
+        normalizeRecordIdStringEffect(thread.id, TABLES.THREAD),
+        normalizeRecordIdStringEffect(thread.userId, TABLES.USER),
+        normalizeRecordIdStringEffect(thread.organizationId, TABLES.ORGANIZATION),
+      ])
+      const candidate = {
+        id,
+        userId,
+        organizationId,
+        type: thread.type,
+        ...(thread.type === 'thread' && typeof thread.threadType === 'string' ? { threadType: thread.threadType } : {}),
+        nameGenerated: thread.nameGenerated,
+        isRunning,
+        isCompacting: thread.isCompacting === true,
+        ...(isAgentName(thread.agentId) ? { agentId: thread.agentId } : {}),
+        title: thread.title ?? getDefaultTitle(thread),
+        status: thread.status,
+        memoryBlock: formatMemoryBlockForPrompt(thread),
+        members: thread.members,
+        createdAt: toIsoDateTimeString(thread.createdAt),
+        updatedAt: toIsoDateTimeString(thread.updatedAt),
+      }
+      return yield* Effect.try({
+        try: () => NormalizedThreadSchema.parse(candidate),
+        catch: (cause) => new ServiceError({ message: 'Failed to parse normalized thread.', cause }),
+      })
+    })
+  }
+
+  function toNormalizedThreads(
+    threads: ThreadRecord[],
+    options: { checkLease?: boolean } = {},
+  ): Effect.Effect<NormalizedThread[], ThreadServiceError> {
+    return Effect.forEach(threads, (thread) => toNormalizedThread(thread, options))
+  }
+
+  const bootstrap = createThreadBootstrapHelpers({
+    threadStore,
+    threadMessageService: deps.threadMessageService,
+    redis: deps.redis,
+    normalizeThread: toNormalizedThread,
+  })
+
+  const listing = createThreadListingHelpers({ db: deps.db, normalizeThreads: toNormalizedThreads })
+
+  const memory = createThreadMemoryBlockHelpers({
+    threadStore,
+    contextCompactionService: { compactMemoryBlock: deps.contextCompactionService.compactMemoryBlock },
+    background: deps.background,
+  })
+
+  function getById(threadId: RecordIdRef) {
+    return effectTryPromise(() => threadStore.getById(threadId), 'Failed to load thread.')
+  }
+
+  function getThread(threadId: RecordIdRef) {
+    return Effect.gen(function* () {
+      const thread = yield* getById(threadId)
+      return yield* toNormalizedThread(thread)
+    })
+  }
+
+  function updateTitle(threadId: RecordIdRef, title: string) {
+    return Effect.gen(function* () {
+      const existing = yield* getById(threadId)
+      yield* assertMutableThreadEffect(existing)
+      const thread = yield* effectTryPromise(
+        () => threadStore.update(threadId, { title, nameGenerated: true }),
+        'Failed to update thread title.',
+      )
+      return yield* toNormalizedThread(thread)
+    })
+  }
+
+  function updateStatus(threadId: RecordIdRef, status: string) {
+    return Effect.gen(function* () {
+      const parsedStatus = sdkThreadStatusSchema.safeParse(status)
+      if (!parsedStatus.success) {
+        return yield* new BadRequestError({ message: `Invalid thread status: ${status}` })
+      }
+      const existing = yield* getById(threadId)
+      yield* assertMutableThreadEffect(existing)
+      const thread = yield* effectTryPromise(
+        () => threadStore.update(threadId, { status: parsedStatus.data }),
+        'Failed to update thread status.',
+      )
+      return yield* toNormalizedThread(thread)
+    })
+  }
+
+  function setCompacting(threadId: RecordIdRef, value: boolean) {
+    const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+    const threadIdString = recordIdToString(threadRef, TABLES.THREAD)
+    return Effect.asVoid(
+      effectTryPromise(
+        () => deps.db.query<unknown>(surql`UPDATE ONLY ${threadRef} SET isCompacting = ${value}`),
+        'Failed to update thread compaction flag.',
+      ).pipe(Effect.tap(() => deps.compactionCoordination.signal(threadIdString, value))),
+    )
+  }
+
+  function clearThread(threadId: RecordIdRef) {
+    return Effect.gen(function* () {
+      const existing = yield* getById(threadId)
+      yield* assertMutableThreadEffect(existing)
+      const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+      yield* effectTryPromise(
+        () => deps.db.deleteWhere(TABLES.THREAD_MESSAGE, { threadId: threadRef }),
+        'Failed to delete thread messages.',
+      )
+      yield* effectTryPromise(
+        () =>
+          deps.db.query<unknown>(surql`
+          UPDATE ONLY ${threadRef}
+          SET turnCount = 0,
+              compactionSummary = NONE,
+              lastCompactedMessageId = NONE,
+              activeRunId = NONE,
+              activeStreamId = NONE,
+              isCompacting = false
+        `),
+        'Failed to reset thread state.',
+      )
+    })
+  }
+
+  function deleteThread(threadId: RecordIdRef) {
+    return Effect.gen(function* () {
+      const existing = yield* getById(threadId)
+      yield* assertMutableThreadEffect(existing)
+      yield* effectTryPromise(() => threadStore.deleteById(threadId), 'Failed to delete thread.')
+    })
+  }
+
+  function incrementTurnCount(threadId: RecordIdRef) {
+    const threadRef = ensureRecordId(threadId, TABLES.THREAD)
+    return Effect.gen(function* () {
+      const result = yield* effectTryPromise(
+        () =>
+          deps.db.query<{ turnCount: number }>(
+            surql`
+        UPDATE ONLY ${threadRef}
+        SET turnCount += 1
+        RETURN turnCount
+      `,
+          ),
+        'Failed to increment thread turn count.',
+      )
+      return result[0].turnCount
+    })
+  }
+
+  return {
+    findById: (...args: Parameters<typeof threadStore.findById>) =>
+      effectTryPromise(() => threadStore.findById(...args), 'Failed to find thread.'),
+    getById,
+    findAll: (...args: Parameters<typeof threadStore.findAll>) =>
+      effectTryPromise(() => threadStore.findAll(...args), 'Failed to find all threads.'),
+    create: (...args: Parameters<typeof threadStore.create>) =>
+      effectTryPromise(() => threadStore.create(...args), 'Failed to create thread.'),
+    update: (...args: Parameters<typeof threadStore.update>) =>
+      effectTryPromise(() => threadStore.update(...args), 'Failed to update thread.'),
+    delete: (...args: Parameters<typeof threadStore.deleteById>) =>
+      effectTryPromise(() => threadStore.deleteById(...args), 'Failed to delete thread.'),
+    getOrCreateDefault: (...args: Parameters<typeof bootstrap.getOrCreateDefault>) =>
+      effectTryPromise(() => bootstrap.getOrCreateDefault(...args), 'Failed to get or create default thread.'),
+    getOrCreateThread: (...args: Parameters<typeof bootstrap.getOrCreateThread>) =>
+      effectTryPromise(() => bootstrap.getOrCreateThread(...args), 'Failed to get or create thread.'),
+    createThread: (...args: Parameters<typeof bootstrap.createThread>) =>
+      effectTryPromise(() => bootstrap.createThread(...args), 'Failed to create thread.'),
+    ensureBootstrapThreads: (...args: Parameters<typeof bootstrap.ensureBootstrapThreads>) =>
+      effectTryPromise(() => bootstrap.ensureBootstrapThreads(...args), 'Failed to ensure bootstrap threads.'),
+    listThreads: (...args: Parameters<typeof listing.listThreads>) =>
+      effectTryPromise(() => listing.listThreads(...args), 'Failed to list threads.'),
+    listOrganizationThreads: (...args: Parameters<typeof listing.listOrganizationThreads>) =>
+      effectTryPromise(() => listing.listOrganizationThreads(...args), 'Failed to list organization threads.'),
+    getThread,
+    updateTitle,
+    updateStatus,
+    setActiveTurn: activeRun.setActiveTurn,
+    getActiveTurn: (...args: Parameters<typeof activeRun.getActiveTurn>) =>
+      effectTryPromise(() => activeRun.getActiveTurn(...args), 'Failed to get active turn.'),
+    getActiveRunId: activeRun.getActiveRunId,
+    hasActiveRunLease: activeRun.hasActiveRunLease,
+    withActiveRunLease: activeRun.withActiveRunLease,
+    getActiveStreamId: activeRun.getActiveStreamId,
+    clearActiveTurn: activeRun.clearActiveTurn,
+    clearStaleActiveRunIfMissingFromRegistry: activeRun.clearStaleActiveRunIfMissingFromRegistry,
+    stopActiveRun: (...args: Parameters<typeof activeRun.stopActiveRun>) =>
+      effectTryPromise(() => activeRun.stopActiveRun(...args), 'Failed to stop active run.'),
+    setCompacting,
+    appendMemoryBlock: (...args: Parameters<typeof memory.appendMemoryBlock>) =>
+      effectTryPromise(() => memory.appendMemoryBlock(...args), 'Failed to append memory block.'),
+    compactMemoryBlock: (...args: Parameters<typeof memory.compactMemoryBlock>) =>
+      effectTryPromise(() => memory.compactMemoryBlock(...args), 'Failed to compact memory block.'),
+    clearThread,
+    deleteThread,
+    listRecentThreads: (...args: Parameters<typeof listing.listRecentThreads>) =>
+      effectTryPromise(() => listing.listRecentThreads(...args), 'Failed to list recent threads.'),
+    formatMemoryBlockForPrompt,
+    toPublicThread,
+    incrementTurnCount,
+  }
+}
+
+export class ThreadServiceTag extends Context.Service<ThreadServiceTag, ReturnType<typeof makeThreadService>>()(
+  '@lota-sdk/core/ThreadService',
+) {}
+
+export const ThreadServiceLive = Layer.effect(
+  ThreadServiceTag,
+  Effect.gen(function* () {
+    const db = yield* DatabaseServiceTag
+    const redis = yield* RedisServiceTag
+    const chatRunRegistry = yield* ChatRunRegistryTag
+    const threadMessageService = yield* ThreadMessageServiceTag
+    const contextCompactionService = yield* ContextCompactionServiceTag
+    const compactionCoordination = yield* CompactionCoordinationTag
+    const background = yield* BackgroundWorkService
+    return makeThreadService({
+      db,
+      redis,
+      chatRunRegistry,
+      threadMessageService,
+      contextCompactionService,
+      compactionCoordination,
+      background,
+    })
+  }),
+)

package/src/services/user.service.ts

@@ -1,56 +1,106 @@
 import type { SdkUser, SdkUserRecord } from '@lota-sdk/shared'
 import { sdkUserRecordSchema, sdkUserSchema } from '@lota-sdk/shared'
+import { Context, Schema, Effect, Layer } from 'effect'
 
-import { BaseService } from '../db/base.service'
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdInput } from '../db/record-id'
-import { databaseService } from '../db/service'
+import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
+import { NotFoundError } from '../effect/errors'
+import { DatabaseServiceTag } from '../effect/services'
 import { toIsoDateTimeString } from '../utils/date-time'
 
-class UserService extends BaseService<typeof sdkUserRecordSchema> {
-  constructor() {
-    super(TABLES.USER, sdkUserRecordSchema)
-  }
+function toPublic(record: SdkUserRecord): SdkUser {
+  return sdkUserSchema.parse({
+    id: recordIdToString(ensureRecordId(record.id as RecordIdInput, TABLES.USER), TABLES.USER),
+    name: record.name,
+    email: record.email,
+    createdAt: toIsoDateTimeString(record.createdAt),
+    updatedAt: toIsoDateTimeString(record.updatedAt),
+  })
+}
 
-  toPublic(record: SdkUserRecord): SdkUser {
-    return sdkUserSchema.parse({
-      id: recordIdToString(ensureRecordId(record.id as RecordIdInput, TABLES.USER), TABLES.USER),
-      name: record.name,
-      email: record.email,
-      createdAt: toIsoDateTimeString(record.createdAt),
-      updatedAt: toIsoDateTimeString(record.updatedAt),
-    })
-  }
+function userNotFoundError(userId: RecordIdInput): NotFoundError {
+  return new NotFoundError({
+    resource: TABLES.USER,
+    id: recordIdToString(userId, TABLES.USER),
+    message: `Record not found in ${TABLES.USER}: ${recordIdToString(userId, TABLES.USER)}`,
+  })
+}
+
+class UserServiceError extends Schema.TaggedErrorClass<UserServiceError>()('UserServiceError', {
+  operation: Schema.String,
+  cause: Schema.Defect,
+}) {}
+
+function toUserServiceError(operation: string, cause: unknown): UserServiceError {
+  return new UserServiceError({ operation, cause })
+}
 
-  async upsertUser(params: { id: RecordIdInput; name: string; email: string }): Promise<SdkUser> {
+export function makeUserService(db: SurrealDBService) {
+  function upsertUserEffect(params: { id: RecordIdInput; name: string; email: string }) {
     const userRef = ensureRecordId(params.id, TABLES.USER)
-    const record = await databaseService.upsert(
-      TABLES.USER,
-      userRef,
-      { name: params.name, email: params.email },
-      sdkUserRecordSchema,
+    return db.upsert(TABLES.USER, userRef, { name: params.name, email: params.email }, sdkUserRecordSchema).pipe(
+      Effect.mapError((cause) => toUserServiceError('upsertUser', cause)),
+      Effect.map(toPublic),
     )
-    return this.toPublic(record)
   }
 
-  async getUser(userId: RecordIdInput): Promise<SdkUser> {
-    return this.toPublic(await this.getById(ensureRecordId(userId, TABLES.USER)))
+  function getUserEffect(userId: RecordIdInput) {
+    return db.findOne(TABLES.USER, { id: ensureRecordId(userId, TABLES.USER) }, sdkUserRecordSchema).pipe(
+      Effect.mapError((cause) => toUserServiceError('getUser', cause)),
+      Effect.flatMap((record) => (record ? Effect.succeed(record) : Effect.fail(userNotFoundError(userId)))),
+      Effect.map(toPublic),
+    )
   }
 
-  async listUsers(): Promise<SdkUser[]> {
-    return (await this.findAll({}, { orderBy: 'createdAt', orderDir: 'ASC' })).map((record) => this.toPublic(record))
+  function listUsersEffect() {
+    return db.findMany(TABLES.USER, {}, sdkUserRecordSchema, { orderBy: 'createdAt', orderDir: 'ASC' }).pipe(
+      Effect.mapError((cause) => toUserServiceError('listUsers', cause)),
+      Effect.map((records) => records.map(toPublic)),
+    )
   }
 
-  async updateUser(userId: RecordIdInput, params: { name?: string; email?: string }): Promise<SdkUser> {
-    return this.toPublic(await this.update(ensureRecordId(userId, TABLES.USER), params))
+  function updateUserEffect(userId: RecordIdInput, params: { name?: string; email?: string }) {
+    return db.update(TABLES.USER, ensureRecordId(userId, TABLES.USER), params, sdkUserRecordSchema).pipe(
+      Effect.mapError((cause) => toUserServiceError('updateUser', cause)),
+      Effect.flatMap((updated) => (updated ? Effect.succeed(updated) : Effect.fail(userNotFoundError(userId)))),
+      Effect.map(toPublic),
+    )
   }
 
-  async deleteUser(userId: RecordIdInput): Promise<void> {
+  function deleteUserEffect(userId: RecordIdInput) {
     const userRef = ensureRecordId(userId, TABLES.USER)
-    await databaseService.deleteWhere(TABLES.ORGANIZATION_MEMBER, { in: userRef })
-    await this.delete(userRef)
+    return Effect.gen(function* () {
+      yield* db
+        .deleteWhere(TABLES.ORGANIZATION_MEMBER, { in: userRef })
+        .pipe(Effect.mapError((cause) => toUserServiceError('deleteUser.deleteMemberships', cause)))
+      const deleted = yield* db
+        .deleteById(TABLES.USER, userRef)
+        .pipe(Effect.mapError((cause) => toUserServiceError('deleteUser.deleteUser', cause)))
+      if (!deleted) {
+        return yield* userNotFoundError(userId)
+      }
+    })
+  }
+
+  return {
+    upsertUser: upsertUserEffect,
+    getUser: getUserEffect,
+    listUsers: listUsersEffect,
+    updateUser: updateUserEffect,
+    deleteUser: deleteUserEffect,
   }
 }
 
-export const userService = new UserService()
+export class UserServiceTag extends Context.Service<UserServiceTag, ReturnType<typeof makeUserService>>()(
+  '@lota-sdk/core/UserService',
+) {}
+
+export const UserServiceLive = Layer.effect(
+  UserServiceTag,
+  Effect.gen(function* () {
+    const db = yield* DatabaseServiceTag
+    return makeUserService(db)
+  }),
+)

package/src/services/write-intent-validator.service.ts

@@ -1,6 +1,8 @@
 import type { PlanDataSchema, PlanNodeSpec, PlanSchemaRegistry, WriteIntent } from '@lota-sdk/shared'
+import { Context, Layer } from 'effect'
 
-import { validateSchemaValue } from './plan-validator.service'
+import { nowIsoDateTimeString } from '../utils/date-time'
+import { validateSchemaValue } from './plan/plan-validator.service'
 
 export interface WriteValidationIssue {
   code: string
@@ -15,19 +17,51 @@ export interface WriteValidationResult {
   validatedAt: string
 }
 
-class WriteIntentValidatorService {
-  validate(params: {
-    intent: WriteIntent
-    nodeSpec: PlanNodeSpec
-    schemaRegistry: PlanSchemaRegistry
-    existingDeliverables: Map<string, unknown>
-  }): WriteValidationResult {
-    const issues: WriteValidationIssue[] = []
-    const { intent, nodeSpec, schemaRegistry, existingDeliverables } = params
+function buildWriteValidationResult(issues: WriteValidationIssue[]): WriteValidationResult {
+  const hasFailed = issues.length > 0
+  return {
+    status: hasFailed ? 'fail' : 'pass',
+    issues,
+    ...(hasFailed ? { suggestion: issues.map((i) => i.message).join('; ') } : {}),
+    validatedAt: nowIsoDateTimeString(),
+  }
+}
+
+export function makeWriteIntentValidatorService() {
+  return {
+    validate(params: {
+      intent: WriteIntent
+      nodeSpec: PlanNodeSpec
+      schemaRegistry: PlanSchemaRegistry
+      existingDeliverables: Map<string, unknown>
+    }): WriteValidationResult {
+      const issues: WriteValidationIssue[] = []
+      const { intent, nodeSpec, schemaRegistry, existingDeliverables } = params
+
+      if (intent.targetPath.startsWith('structuredOutput')) {
+        if (nodeSpec.outputSchemaRef) {
+          const schema = schemaRegistry[nodeSpec.outputSchemaRef] as PlanDataSchema | undefined
+          if (schema) {
+            const schemaIssues = validateSchemaValue({ schema, value: intent.payload, path: intent.targetPath })
+            for (const message of schemaIssues) {
+              issues.push({ code: 'schema_validation_failed', message })
+            }
+          }
+        }
+        return buildWriteValidationResult(issues)
+      }
 
-    if (intent.targetPath.startsWith('structuredOutput')) {
-      if (nodeSpec.outputSchemaRef) {
-        const schema = schemaRegistry[nodeSpec.outputSchemaRef] as PlanDataSchema | undefined
+      const deliverable = nodeSpec.deliverables.find((d) => d.name === intent.targetPath)
+      if (!deliverable) {
+        issues.push({
+          code: 'unknown_deliverable',
+          message: `"${intent.targetPath}" does not match any declared deliverable.`,
+        })
+        return buildWriteValidationResult(issues)
+      }
+
+      if (deliverable.schemaRef) {
+        const schema = schemaRegistry[deliverable.schemaRef] as PlanDataSchema | undefined
         if (schema) {
           const schemaIssues = validateSchemaValue({ schema, value: intent.payload, path: intent.targetPath })
           for (const message of schemaIssues) {
@@ -35,47 +69,25 @@ class WriteIntentValidatorService {
           }
         }
       }
-      return this.buildResult(issues)
-    }
-
-    const deliverable = nodeSpec.deliverables.find((d) => d.name === intent.targetPath)
-    if (!deliverable) {
-      issues.push({
-        code: 'unknown_deliverable',
-        message: `"${intent.targetPath}" does not match any declared deliverable.`,
-      })
-      return this.buildResult(issues)
-    }
 
-    if (deliverable.schemaRef) {
-      const schema = schemaRegistry[deliverable.schemaRef] as PlanDataSchema | undefined
-      if (schema) {
-        const schemaIssues = validateSchemaValue({ schema, value: intent.payload, path: intent.targetPath })
-        for (const message of schemaIssues) {
-          issues.push({ code: 'schema_validation_failed', message })
-        }
+      if (intent.action === 'update' && !existingDeliverables.has(intent.targetPath)) {
+        issues.push({
+          code: 'update_target_not_found',
+          message: `Cannot update "${intent.targetPath}" — no prior write exists.`,
+        })
       }
-    }
-
-    if (intent.action === 'update' && !existingDeliverables.has(intent.targetPath)) {
-      issues.push({
-        code: 'update_target_not_found',
-        message: `Cannot update "${intent.targetPath}" — no prior write exists.`,
-      })
-    }
 
-    return this.buildResult(issues)
-  }
-
-  private buildResult(issues: WriteValidationIssue[]): WriteValidationResult {
-    const hasFailed = issues.length > 0
-    return {
-      status: hasFailed ? 'fail' : 'pass',
-      issues,
-      ...(hasFailed ? { suggestion: issues.map((i) => i.message).join('; ') } : {}),
-      validatedAt: new Date().toISOString(),
-    }
+      return buildWriteValidationResult(issues)
+    },
   }
 }
 
-export const writeIntentValidatorService = new WriteIntentValidatorService()
+export class WriteIntentValidatorServiceTag extends Context.Service<
+  WriteIntentValidatorServiceTag,
+  ReturnType<typeof makeWriteIntentValidatorService>
+>()('@lota-sdk/core/WriteIntentValidatorService') {}
+
+export const WriteIntentValidatorServiceLive = Layer.succeed(
+  WriteIntentValidatorServiceTag,
+  makeWriteIntentValidatorService(),
+)