@lota-sdk/core 0.4.9 → 0.4.11

package/src/services/agent-executor.service.ts

@@ -12,13 +12,19 @@ import { stepCountIs, tool } from 'ai'
 import type { ToolSet } from 'ai'
 import { Context, Schema, Effect, Layer } from 'effect'
 
-import { getAgentRoster, getAgentRuntimeConfig, getResolvedAgentFactoryConfig } from '../config/agent-defaults'
+import type { ResolvedAgentConfig, ResolvedAgentFactoryConfig } from '../config/agent-defaults'
 import { ensureRecordId } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
 import { BadRequestError, NotFoundError } from '../effect/errors'
-import { runPromise } from '../effect/runtime'
-import { DatabaseServiceTag } from '../effect/services'
+import { makeEffectTryPromiseWithOperation } from '../effect/helpers'
+import {
+  AgentConfigServiceTag,
+  AgentFactoryServiceTag,
+  DatabaseServiceTag,
+  RuntimeAdaptersServiceTag,
+  TurnHooksServiceTag,
+} from '../effect/services'
 import { toValidationError } from '../effect/zod'
 import {
   OWNERSHIP_DISPATCH_BLOCKED_TOOL_NAMES,
@@ -32,7 +38,6 @@ import {
   getGithubInstallationForOrganization,
   getLinearInstallationByOrgId,
 } from '../runtime/plugin-resolution'
-import { getTurnHooks } from '../runtime/runtime-extensions'
 import { readInstructionSections, readOptionalString } from '../runtime/thread-chat-helpers'
 import { nowDate } from '../utils/date-time'
 import type { makeNodeWorkspaceService } from './node-workspace.service'
@@ -90,8 +95,8 @@ export function buildWriteIntentDispatchPrompt(nodeSpec: PlanNodeSpec): string {
 
 const MAX_SELF_CORRECTION_RETRIES = 3
 
-function validateOwner(agentId: string, nodeId: string): PlanValidationIssueInput[] {
-  if (!getAgentRoster().includes(agentId)) {
+function validateOwner(agentConfig: ResolvedAgentConfig, agentId: string, nodeId: string): PlanValidationIssueInput[] {
+  if (!agentConfig.roster.includes(agentId)) {
     return [
       {
         severity: 'blocking',
@@ -112,27 +117,15 @@ class AgentExecutorError extends Schema.TaggedErrorClass<AgentExecutorError>()('
   cause: Schema.Defect,
 }) {}
 
-function tryAgentExecutorPromise<A>(
+const tryAgentExecutorPromise = makeEffectTryPromiseWithOperation(
+  (operation, message, cause) => new AgentExecutorError({ operation, message, cause }),
+)
+const tryAgentExecutorTask = <A>(
   operation: string,
   message: string,
-  thunk: () => PromiseLike<A> | A | Effect.Effect<A, unknown, never>,
-): Effect.Effect<A, AgentExecutorError> {
-  return Effect.suspend(() => {
-    try {
-      const value = thunk()
-      if (Effect.isEffect(value)) {
-        return value.pipe(Effect.mapError((cause) => new AgentExecutorError({ operation, message, cause })))
-      }
-
-      return Effect.tryPromise({
-        try: () => Promise.resolve(value),
-        catch: (cause) => new AgentExecutorError({ operation, message, cause }),
-      })
-    } catch (cause) {
-      return Effect.fail(new AgentExecutorError({ operation, message, cause }))
-    }
-  })
-}
+  task: () => PromiseLike<A>,
+): Effect.Effect<A, AgentExecutorError> =>
+  Effect.tryPromise({ try: task, catch: (cause) => new AgentExecutorError({ operation, message, cause }) })
 
 function isAgentExecutorOwner(
   owner: PlanNodeSpec['owner'],
@@ -151,7 +144,7 @@ function buildWriteIntentTool(params: {
       'Write a validated artifact or structured output field. Call this for each deliverable. If validation fails, correct your payload and try again.',
     inputSchema: WriteIntentSchema,
     execute: (intent: WriteIntent) =>
-      runPromise(
+      Effect.runPromise(
         Effect.gen(function* () {
           const correctionCount = params.workspace.sys.correctionCounts.get(intent.targetPath) ?? 0
 
@@ -190,7 +183,7 @@ function buildWriteIntentTool(params: {
 }
 
 function createExecuteNode(deps: AgentExecutorDeps) {
-  return function executeNode(params: {
+  return Effect.fn('AgentExecutor.executeNode')(function* (params: {
     nodeSpec: PlanNodeSpec
     resolvedInput: Record<string, unknown>
     inputArtifacts: PlanArtifactSubmission[]
@@ -198,70 +191,72 @@ function createExecuteNode(deps: AgentExecutorDeps) {
     executionMode?: ExecutionMode
     schemaRegistry?: PlanSchemaRegistry
   }) {
-    return Effect.gen(function* () {
-      const owner = params.nodeSpec.owner
-      if (!isAgentExecutorOwner(owner)) {
-        return yield* new BadRequestError({
-          message: `AgentExecutor cannot execute owner type "${owner.executorType}".`,
-        })
-      }
+    const owner = params.nodeSpec.owner
+    if (!isAgentExecutorOwner(owner)) {
+      return yield* new BadRequestError({ message: `AgentExecutor cannot execute owner type "${owner.executorType}".` })
+    }
 
-      const agentId = owner.ref
-      if (!getAgentRoster().includes(agentId)) {
-        return yield* new BadRequestError({ message: `Agent executor "${agentId}" is not registered.` })
-      }
+    const agentId = owner.ref
+    if (!deps.agentConfig.roster.includes(agentId)) {
+      return yield* new BadRequestError({ message: `Agent executor "${agentId}" is not registered.` })
+    }
 
-      const thread = yield* tryAgentExecutorPromise('load-thread', 'Failed to load dispatched thread.', () =>
-        deps.db.findOne(TABLES.THREAD, { id: ensureRecordId(params.context.threadId, TABLES.THREAD) }, ThreadSchema),
-      )
-      if (!thread) {
-        return yield* new NotFoundError({
-          resource: TABLES.THREAD,
-          message: `Thread ${params.context.threadId} not found for dispatched execution.`,
-        })
-      }
+    const thread = yield* tryAgentExecutorPromise('load-thread', 'Failed to load dispatched thread.', () =>
+      deps.db.findOne(TABLES.THREAD, { id: ensureRecordId(params.context.threadId, TABLES.THREAD) }, ThreadSchema),
+    ).pipe(Effect.withSpan('AgentExecutor.loadThread'))
+    if (!thread) {
+      return yield* new NotFoundError({
+        resource: TABLES.THREAD,
+        message: `Thread ${params.context.threadId} not found for dispatched execution.`,
+      })
+    }
 
-      const organizationRef = ensureRecordId(params.context.organizationId, TABLES.ORGANIZATION)
-      const threadRef = ensureRecordId(params.context.threadId, TABLES.THREAD)
-      const userRefSource = params.context.userId ?? thread.userId
-      if (!userRefSource) {
-        return yield* new BadRequestError({
-          message: `Thread ${params.context.threadId} is missing a user context for dispatched execution.`,
-        })
-      }
-      const userRef = ensureRecordId(userRefSource, TABLES.USER)
-      const userName = params.context.userName ?? 'User'
-      const [linearInstallation, githubInstallation, indexedRepoContext] = yield* Effect.all([
-        tryAgentExecutorPromise(
-          'get-linear-installation',
-          `Failed to load Linear installation for org ${params.context.organizationId}.`,
-          () => getLinearInstallationByOrgId(organizationRef),
-        ),
-        tryAgentExecutorPromise(
-          'get-github-installation',
-          `Failed to load GitHub installation for org ${params.context.organizationId}.`,
-          () => getGithubInstallationForOrganization(params.context.organizationId),
-        ),
-        tryAgentExecutorPromise(
-          'build-indexed-repositories-context',
-          `Failed to build indexed repository context for org ${params.context.organizationId}.`,
-          () => buildIndexedRepositoriesContext(params.context.organizationId),
-        ),
-      ])
-
-      const mode = params.executionMode ?? 'linear'
-      const dispatchMode = thread.type === 'group' ? 'fixedThreadMode' : 'direct'
-      const dispatchInstructionSections = [
-        buildOwnershipDispatchContextSection({
-          node: params.nodeSpec,
-          resolvedInput: params.resolvedInput,
-          inputArtifacts: params.inputArtifacts,
-          upstreamHandoffs: params.context.upstreamHandoffs,
-        }),
-      ]
+    const organizationRef = ensureRecordId(params.context.organizationId, TABLES.ORGANIZATION)
+    const threadRef = ensureRecordId(params.context.threadId, TABLES.THREAD)
+    const userRefSource = params.context.userId ?? thread.userId
+    if (!userRefSource) {
+      return yield* new BadRequestError({
+        message: `Thread ${params.context.threadId} is missing a user context for dispatched execution.`,
+      })
+    }
+    const userRef = ensureRecordId(userRefSource, TABLES.USER)
+    const userName = params.context.userName ?? 'User'
+    const runtimeAdapters = yield* RuntimeAdaptersServiceTag
+    const { linearInstallation, githubInstallation, indexedRepoContext } = yield* Effect.all({
+      linearInstallation: tryAgentExecutorTask(
+        'get-linear-installation',
+        `Failed to load Linear installation for org ${params.context.organizationId}.`,
+        () => getLinearInstallationByOrgId(deps.agentFactoryConfig.pluginRuntime, organizationRef),
+      ),
+      githubInstallation: tryAgentExecutorTask(
+        'get-github-installation',
+        `Failed to load GitHub installation for org ${params.context.organizationId}.`,
+        () =>
+          getGithubInstallationForOrganization(deps.agentFactoryConfig.pluginRuntime, params.context.organizationId),
+      ),
+      indexedRepoContext: tryAgentExecutorTask(
+        'build-indexed-repositories-context',
+        `Failed to build indexed repository context for org ${params.context.organizationId}.`,
+        () => buildIndexedRepositoriesContext(runtimeAdapters, params.context.organizationId),
+      ),
+    }).pipe(Effect.withSpan('AgentExecutor.loadInstallations'))
 
-      const turnHooks = getTurnHooks()
-      const agentResolutionValue = yield* Effect.tryPromise(() =>
+    const mode = params.executionMode ?? 'linear'
+    const dispatchMode = thread.type === 'group' ? 'fixedThreadMode' : 'direct'
+    const dispatchInstructionSections = [
+      buildOwnershipDispatchContextSection({
+        node: params.nodeSpec,
+        resolvedInput: params.resolvedInput,
+        inputArtifacts: params.inputArtifacts,
+        upstreamHandoffs: params.context.upstreamHandoffs,
+      }),
+    ]
+
+    const turnHooks = yield* TurnHooksServiceTag
+    const agentResolutionValue = yield* tryAgentExecutorPromise(
+      'resolve-agent',
+      `Failed to resolve agent "${agentId}" for dispatched execution.`,
+      () =>
         Promise.resolve(
           turnHooks.resolveAgent?.({
             agentId,
@@ -278,156 +273,172 @@ function createExecuteNode(deps: AgentExecutorDeps) {
             context: null,
           }),
         ),
-      )
-      const agentResolution = isRecord(agentResolutionValue) ? agentResolutionValue : null
-      const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? agentId
-      const runtimeConfig = getAgentRuntimeConfig({
-        agentId: resolvedAgentId,
-        threadType: thread.type,
-        mode: dispatchMode,
-        onboardingActive: false,
-        linearInstalled: Boolean(linearInstallation),
-        additionalInstructionSections: mergeInstructionSections(
-          dispatchInstructionSections,
-          readInstructionSections(agentResolution?.additionalInstructionSections),
-        ),
-        responseGuardSection: buildOwnershipDispatchResponseGuard({ node: params.nodeSpec, executionMode: mode }),
-      })
-
-      const agentFactoryConfig = getResolvedAgentFactoryConfig()
-      const rawTools = yield* tryAgentExecutorPromise(
-        'build-agent-tools',
-        `Failed to build agent tools for "${resolvedAgentId}".`,
-        () =>
-          Promise.resolve(
-            agentFactoryConfig.buildAgentTools({
-              agentId: resolvedAgentId,
-              orgId: organizationRef,
-              userId: userRef,
-              userName,
-              threadId: threadRef,
-              orgIdString: params.context.organizationId,
-              threadType: thread.type,
-              mode: dispatchMode,
-              linearInstalled: Boolean(linearInstallation),
-              onboardingActive: false,
-              githubInstalled: Boolean(githubInstallation),
-              provideRepoTool: indexedRepoContext.provideRepoTool,
-              defaultRepoSections: indexedRepoContext.defaultSectionsByAgent[resolvedAgentId],
-              memoryBlock: '',
-              onAppendMemoryBlock: () => undefined,
-              availableUploads: [],
-              includeExecutionPlanTools: false,
-            }),
-          ),
-      )
-      const tools = applyToolPolicy(rawTools, params.nodeSpec)
+    )
+    const agentResolution = isRecord(agentResolutionValue) ? agentResolutionValue : null
+    const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? agentId
+    const runtimeConfig = deps.agentFactoryConfig.getAgentRuntimeConfig({
+      agentId: resolvedAgentId,
+      threadType: thread.type,
+      mode: dispatchMode,
+      onboardingActive: false,
+      linearInstalled: Boolean(linearInstallation),
+      additionalInstructionSections: mergeInstructionSections(
+        dispatchInstructionSections,
+        readInstructionSections(agentResolution?.additionalInstructionSections),
+      ),
+      responseGuardSection: buildOwnershipDispatchResponseGuard({ node: params.nodeSpec, executionMode: mode }),
+    })
 
-      const agentFactory = agentFactoryConfig.createAgent[resolvedAgentId]
-      if (!agentFactory) {
-        return yield* new BadRequestError({ message: `Agent factory "${resolvedAgentId}" is not registered.` })
-      }
+    const agentFactoryConfig = deps.agentFactoryConfig
+    const rawTools = yield* tryAgentExecutorPromise(
+      'build-agent-tools',
+      `Failed to build agent tools for "${resolvedAgentId}".`,
+      () =>
+        Promise.resolve(
+          agentFactoryConfig.buildAgentTools({
+            agentId: resolvedAgentId,
+            orgId: organizationRef,
+            userId: userRef,
+            userName,
+            threadId: threadRef,
+            orgIdString: params.context.organizationId,
+            threadType: thread.type,
+            mode: dispatchMode,
+            linearInstalled: Boolean(linearInstallation),
+            onboardingActive: false,
+            githubInstalled: Boolean(githubInstallation),
+            provideRepoTool: indexedRepoContext.provideRepoTool,
+            defaultRepoSections: indexedRepoContext.defaultSectionsByAgent[resolvedAgentId],
+            memoryBlock: '',
+            onAppendMemoryBlock: () => undefined,
+            availableUploads: [],
+            includeExecutionPlanTools: false,
+          }),
+        ),
+    )
+    const tools = applyToolPolicy(rawTools, params.nodeSpec)
 
-      const maxSteps = typeof runtimeConfig.maxSteps === 'number' ? runtimeConfig.maxSteps : 8
-
-      if (mode === 'linear') {
-        const agent = agentFactory({
-          mode: dispatchMode,
-          tools,
-          extraInstructions:
-            typeof runtimeConfig.extraInstructions === 'string' ? runtimeConfig.extraInstructions : undefined,
-          maxRetries: 1,
-          stopWhen: [stepCountIs(maxSteps)],
-        })
-
-        const result = yield* tryAgentExecutorPromise(
-          'generate-agent-dispatch',
-          `Agent "${resolvedAgentId}" failed to generate a dispatch result.`,
-          () => agent.generate({ prompt: buildDispatchPrompt(params.nodeSpec) }),
-        )
-        const outputCandidate = PlanNodeResultSubmissionSchema.safeParse(result.output)
-        if (outputCandidate.success) {
-          return outputCandidate.data
-        }
-
-        return yield* toValidationError(
-          outputCandidate.error,
-          `Agent executor "${agentId}" returned an invalid node result`,
-        )
-      }
+    const agentFactory = agentFactoryConfig.createAgent[resolvedAgentId]
+    if (!agentFactory) {
+      return yield* new BadRequestError({ message: `Agent factory "${resolvedAgentId}" is not registered.` })
+    }
 
-      const workspace = deps.nodeWorkspaceService.initialize({
-        nodeSpec: params.nodeSpec,
-        resolvedInput: params.resolvedInput,
-        inputArtifacts: params.inputArtifacts,
-        schemaRegistry: params.schemaRegistry ?? {},
-      })
+    const maxSteps = typeof runtimeConfig.maxSteps === 'number' ? runtimeConfig.maxSteps : 8
 
-      const graphTools = {
-        ...tools,
-        writeIntent: buildWriteIntentTool({
-          nodeSpec: params.nodeSpec,
-          workspace,
-          writeIntentValidatorService: deps.writeIntentValidatorService,
-          stageWrite: (intent) => deps.nodeWorkspaceService.stageWrite(workspace, intent, 'validated'),
-        }),
-      }
+    if (mode === 'linear') {
       const agent = agentFactory({
         mode: dispatchMode,
-        tools: graphTools,
+        tools,
         extraInstructions:
           typeof runtimeConfig.extraInstructions === 'string' ? runtimeConfig.extraInstructions : undefined,
         maxRetries: 1,
         stopWhen: [stepCountIs(maxSteps)],
       })
 
-      yield* Effect.tryPromise(() => agent.generate({ prompt: buildWriteIntentDispatchPrompt(params.nodeSpec) }))
+      const result = yield* tryAgentExecutorPromise(
+        'generate-agent-dispatch',
+        `Agent "${resolvedAgentId}" failed to generate a dispatch result.`,
+        () => agent.generate({ prompt: buildDispatchPrompt(params.nodeSpec) }),
+      ).pipe(Effect.withSpan('AgentExecutor.generateLinearDispatch'))
+      const outputCandidate = PlanNodeResultSubmissionSchema.safeParse(result.output)
+      if (outputCandidate.success) {
+        return outputCandidate.data
+      }
 
-      const finalResult = yield* deps.nodeWorkspaceService.finalize(workspace)
+      return yield* toValidationError(
+        outputCandidate.error,
+        `Agent executor "${agentId}" returned an invalid node result`,
+      )
+    }
 
-      if (!finalResult.isComplete) {
-        const result: PlanNodeResult = {
-          structuredOutput: finalResult.structuredOutput,
-          artifacts: finalResult.artifacts,
-          notes: 'Execution incomplete: missing required deliverables or validation failures.',
-        }
-        deps.nodeWorkspaceService.cleanup(workspace)
-        return result
-      }
+    const workspace = deps.nodeWorkspaceService.initialize({
+      nodeSpec: params.nodeSpec,
+      resolvedInput: params.resolvedInput,
+      inputArtifacts: params.inputArtifacts,
+      schemaRegistry: params.schemaRegistry ?? {},
+    })
+
+    const graphTools = {
+      ...tools,
+      writeIntent: buildWriteIntentTool({
+        nodeSpec: params.nodeSpec,
+        workspace,
+        writeIntentValidatorService: deps.writeIntentValidatorService,
+        stageWrite: (intent) => deps.nodeWorkspaceService.stageWrite(workspace, intent, 'validated'),
+      }),
+    }
+    const agent = agentFactory({
+      mode: dispatchMode,
+      tools: graphTools,
+      extraInstructions:
+        typeof runtimeConfig.extraInstructions === 'string' ? runtimeConfig.extraInstructions : undefined,
+      maxRetries: 1,
+      stopWhen: [stepCountIs(maxSteps)],
+    })
+
+    yield* tryAgentExecutorPromise(
+      'generate-write-intent-dispatch',
+      `Agent "${resolvedAgentId}" failed to generate a write-intent dispatch result.`,
+      () => agent.generate({ prompt: buildWriteIntentDispatchPrompt(params.nodeSpec) }),
+    ).pipe(Effect.withSpan('AgentExecutor.generateWriteIntentDispatch'))
 
+    const finalResult = yield* deps.nodeWorkspaceService.finalize(workspace)
+
+    if (!finalResult.isComplete) {
       const result: PlanNodeResult = {
         structuredOutput: finalResult.structuredOutput,
         artifacts: finalResult.artifacts,
-        notes: finalResult.notes,
+        notes: 'Execution incomplete: missing required deliverables or validation failures.',
       }
-
       deps.nodeWorkspaceService.cleanup(workspace)
       return result
-    })
-  }
+    }
+
+    const result: PlanNodeResult = {
+      structuredOutput: finalResult.structuredOutput,
+      artifacts: finalResult.artifacts,
+      notes: finalResult.notes,
+    }
+
+    deps.nodeWorkspaceService.cleanup(workspace)
+    return result
+  })
 }
 
 interface AgentExecutorDeps {
+  agentConfig: ResolvedAgentConfig
+  agentFactoryConfig: ResolvedAgentFactoryConfig
   db: SurrealDBService
   nodeWorkspaceService: ReturnType<typeof makeNodeWorkspaceService>
   writeIntentValidatorService: ReturnType<typeof makeWriteIntentValidatorService>
 }
 
 export function makeAgentExecutorService(deps: AgentExecutorDeps) {
-  return { validateOwner, executeNode: createExecuteNode(deps) }
+  return {
+    validateOwner: (agentId: string, nodeId: string) => validateOwner(deps.agentConfig, agentId, nodeId),
+    executeNode: createExecuteNode(deps),
+  }
 }
 
 export class AgentExecutorServiceTag extends Context.Service<
   AgentExecutorServiceTag,
   ReturnType<typeof makeAgentExecutorService>
->()('AgentExecutorService') {}
+>()('@lota-sdk/core/AgentExecutorService') {}
 
 export const AgentExecutorServiceLive = Layer.effect(
   AgentExecutorServiceTag,
   Effect.gen(function* () {
+    const agentConfig = yield* AgentConfigServiceTag
+    const agentFactoryConfig = yield* AgentFactoryServiceTag
     const db = yield* DatabaseServiceTag
     const nodeWorkspaceService = yield* NodeWorkspaceServiceTag
     const writeIntentValidatorService = yield* WriteIntentValidatorServiceTag
-    return makeAgentExecutorService({ db, nodeWorkspaceService, writeIntentValidatorService })
+    return makeAgentExecutorService({
+      agentConfig,
+      agentFactoryConfig,
+      db,
+      nodeWorkspaceService,
+      writeIntentValidatorService,
+    })
   }),
 )

package/src/services/artifact.service.ts

@@ -15,7 +15,7 @@ import type { SurrealDBService, DatabaseTransaction } from '../db/service'
 import { TABLES } from '../db/tables'
 import { ConfigurationError, DatabaseError, NotFoundError } from '../effect/errors'
 import { DatabaseServiceTag } from '../effect/services'
-import { toValidationError } from '../effect/zod'
+import { toValidationError, zodParse } from '../effect/zod'
 import type { makeGeneratedDocumentStorageService } from '../storage/generated-document-storage.service'
 import { GeneratedDocumentStorageServiceTag } from '../storage/generated-document-storage.service'
 import { sha256Hex } from '../utils/crypto'
@@ -180,7 +180,7 @@ export function makeArtifactService(deps: ArtifactServiceDeps) {
         },
       })
 
-      return ArtifactRecordSchema.array().parse(records)
+      return yield* zodParse(ArtifactRecordSchema.array(), records)
     })
 
   const publishArtifactInTransactionEffect = (
@@ -247,7 +247,7 @@ export function makeArtifactService(deps: ArtifactServiceDeps) {
         })
       }
 
-      const created = ArtifactRecordSchema.parse(createdRecord)
+      const created = yield* zodParse(ArtifactRecordSchema, createdRecord)
 
       const previousActive = existing.find((record) => record.status === 'active')
       if (previousActive) {
@@ -392,7 +392,12 @@ export function makeArtifactService(deps: ArtifactServiceDeps) {
         listBacklinksEffect(artifact),
       ])
 
-      return GetArtifactResultSchema.parse({ artifact, content, versions: versions.map(toVersionSummary), backlinks })
+      return yield* zodParse(GetArtifactResultSchema, {
+        artifact,
+        content,
+        versions: versions.map(toVersionSummary),
+        backlinks,
+      })
     })
 
   const listBacklinksEffect = (artifact: Pick<ArtifactRecord, 'id' | 'organizationId'>) =>
@@ -439,7 +444,7 @@ export function makeArtifactService(deps: ArtifactServiceDeps) {
 }
 
 export class ArtifactServiceTag extends Context.Service<ArtifactServiceTag, ReturnType<typeof makeArtifactService>>()(
-  'ArtifactService',
+  '@lota-sdk/core/ArtifactService',
 ) {}
 
 export const ArtifactServiceLive = Layer.effect(

package/src/services/attachment.service.ts

@@ -3,11 +3,7 @@ import { Context, Effect, Layer } from 'effect'
 import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
-import { runPromise } from '../effect/runtime'
-import type {
-  makeAttachmentStorageService,
-  UploadedThreadAttachment as SdkUploadedThreadAttachment,
-} from '../storage/attachment-storage.service'
+import type { makeAttachmentStorageService } from '../storage/attachment-storage.service'
 import { AttachmentStorageServiceTag } from '../storage/attachment-storage.service'
 import type { MessagePartLike, ReadableUploadMetadata as SdkReadableUploadMetadata } from '../storage/attachment-types'
 
@@ -55,28 +51,12 @@ export function makeAttachmentService(attachmentStorage: ReturnType<typeof makeA
       })
     },
 
-    extractStoredAttachmentText({
-      storageKey,
-      name,
-      contentType,
-    }: {
-      storageKey: string
-      name: string
-      contentType: string
-    }): Promise<string> {
-      return runPromise(attachmentStorage.extractStoredAttachmentText({ storageKey, name, contentType }))
+    extractStoredAttachmentText(params: { storageKey: string; name: string; contentType: string }) {
+      return attachmentStorage.extractStoredAttachmentText(params)
     },
 
-    extractStoredAttachmentPages({
-      storageKey,
-      name,
-      contentType,
-    }: {
-      storageKey: string
-      name: string
-      contentType: string
-    }): Promise<{ pageMode: 'logical' | 'pdf'; pages: string[] }> {
-      return runPromise(attachmentStorage.extractStoredAttachmentPages({ storageKey, name, contentType }))
+    extractStoredAttachmentPages(params: { storageKey: string; name: string; contentType: string }) {
+      return attachmentStorage.extractStoredAttachmentPages(params)
     },
 
     readFilePartsFromUpload({
@@ -117,16 +97,14 @@ export function makeAttachmentService(attachmentStorage: ReturnType<typeof makeA
       relativePath: string
       content: string
       contentType: string
-    }): Promise<{ storageKey: string; sizeBytes: number }> {
-      return runPromise(
-        attachmentStorage.writeOrganizationDocument({
-          orgId: toOrgId(orgId),
-          namespace,
-          relativePath,
-          content,
-          contentType,
-        }),
-      )
+    }) {
+      return attachmentStorage.writeOrganizationDocument({
+        orgId: toOrgId(orgId),
+        namespace,
+        relativePath,
+        content,
+        contentType,
+      })
     },
 
     uploadOrganizationDocument({
@@ -143,18 +121,8 @@ export function makeAttachmentService(attachmentStorage: ReturnType<typeof makeA
       return attachmentStorage.uploadOrganizationDocument({ file, orgId: toOrgId(orgId), namespace, relativePath })
     },
 
-    uploadThreadAttachment({
-      file,
-      orgId,
-      userId,
-    }: {
-      file: File
-      orgId: RecordIdRef
-      userId: RecordIdRef
-    }): Promise<SdkUploadedThreadAttachment> {
-      return runPromise(
-        attachmentStorage.uploadThreadAttachment({ file, orgId: toOrgId(orgId), userId: toUserId(userId) }),
-      )
+    uploadThreadAttachment({ file, orgId, userId }: { file: File; orgId: RecordIdRef; userId: RecordIdRef }) {
+      return attachmentStorage.uploadThreadAttachment({ file, orgId: toOrgId(orgId), userId: toUserId(userId) })
     },
   }
 }
@@ -162,7 +130,7 @@ export function makeAttachmentService(attachmentStorage: ReturnType<typeof makeA
 export class AttachmentServiceTag extends Context.Service<
   AttachmentServiceTag,
   ReturnType<typeof makeAttachmentService>
->()('AttachmentService') {}
+>()('@lota-sdk/core/AttachmentService') {}
 
 export const AttachmentServiceLive = Layer.effect(
   AttachmentServiceTag,