@lota-sdk/core 0.4.10 → 0.4.12

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

@@ -9,9 +9,9 @@ import type {
 } from '@lota-sdk/shared'
 import { Context, Schema, Effect, Layer } from 'effect'
 
-import { getAgentRoster } from '../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { serverLogger } from '../config/logger'
-import { toAwaitableEffect } from '../effect/awaitable-effect'
+import { AgentConfigServiceTag } from '../effect/services'
 import { unsafeDateFrom } from '../utils/date-time'
 import type { makeExecutionPlanService } from './execution-plan/execution-plan.service'
 import { ExecutionPlanServiceTag } from './execution-plan/execution-plan.service'
@@ -37,6 +37,7 @@ type ActivePlanEntry = {
 }
 
 type AgentActivityDeps = {
+  agentConfig: ResolvedAgentConfig
   executionPlanService: Pick<ReturnType<typeof makeExecutionPlanService>, 'getActivePlansForThread'>
   threadService: Pick<ReturnType<typeof makeThreadService>, 'listThreads'>
 }
@@ -154,158 +155,97 @@ function buildPlanViewNode(
 }
 
 export function getBoard(userRef: string, orgRef: string, deps: AgentActivityDeps) {
-  return toAwaitableEffect(
-    Effect.gen(function* () {
-      const activePlans = yield* getAllActivePlans(userRef, orgRef, deps)
-      const cards = activePlans
-        .filter(({ plan }) => !isPendingPlanApproval(plan))
-        .flatMap(({ plan, thread }) => plan.nodes.map((node) => planNodeToCard(node, plan, thread.id, thread.title)))
-
-      const columns: PlanBoardColumn[] = BOARD_COLUMN_ORDER.map((status) => ({
-        status,
-        label: COLUMN_LABELS[status],
-        nodes: cards.filter((card) => card.status === status),
-      }))
-
-      return {
-        columns,
-        summary: {
-          totalNodes: cards.length,
-          completedNodes: cards.filter((card) => card.status === 'completed').length,
-          activePlanCount: activePlans.length,
-          pendingApprovalCount:
-            countPendingPlanApprovals(activePlans) + cards.filter((card) => card.hasApproval).length,
-        },
-      }
-    }),
-  )
+  return Effect.gen(function* () {
+    const activePlans = yield* getAllActivePlans(userRef, orgRef, deps)
+    const cards = activePlans
+      .filter(({ plan }) => !isPendingPlanApproval(plan))
+      .flatMap(({ plan, thread }) => plan.nodes.map((node) => planNodeToCard(node, plan, thread.id, thread.title)))
+
+    const columns: PlanBoardColumn[] = BOARD_COLUMN_ORDER.map((status) => ({
+      status,
+      label: COLUMN_LABELS[status],
+      nodes: cards.filter((card) => card.status === status),
+    }))
+
+    return {
+      columns,
+      summary: {
+        totalNodes: cards.length,
+        completedNodes: cards.filter((card) => card.status === 'completed').length,
+        activePlanCount: activePlans.length,
+        pendingApprovalCount: countPendingPlanApprovals(activePlans) + cards.filter((card) => card.hasApproval).length,
+      },
+    }
+  })
 }
 
 export function getPlanView(orgRef: string, planRunId: string, userRef: string, deps: AgentActivityDeps) {
-  return toAwaitableEffect(
-    Effect.gen(function* () {
-      const activePlans = yield* getAllActivePlans(userRef, orgRef, deps)
-      const match = activePlans.find(({ plan }) => plan.runId === planRunId)
-      if (!match) return null
-
-      const { plan, thread } = match
-      return {
-        planRunId: plan.runId,
-        title: plan.title,
-        objective: plan.objective,
-        status: plan.status,
-        leadAgentId: plan.leadAgentId,
-        progress: { completed: plan.progress.completed + plan.progress.partial, total: plan.progress.total },
-        nodes: plan.nodes.map((node) => buildPlanViewNode(node, plan, thread.id, thread.title)),
-        edges: plan.edges.map((edge) => ({ from: edge.source, to: edge.target })),
-      }
-    }),
-  )
+  return Effect.gen(function* () {
+    const activePlans = yield* getAllActivePlans(userRef, orgRef, deps)
+    const match = activePlans.find(({ plan }) => plan.runId === planRunId)
+    if (!match) return null
+
+    const { plan, thread } = match
+    return {
+      planRunId: plan.runId,
+      title: plan.title,
+      objective: plan.objective,
+      status: plan.status,
+      leadAgentId: plan.leadAgentId,
+      progress: { completed: plan.progress.completed + plan.progress.partial, total: plan.progress.total },
+      nodes: plan.nodes.map((node) => buildPlanViewNode(node, plan, thread.id, thread.title)),
+      edges: plan.edges.map((edge) => ({ from: edge.source, to: edge.target })),
+    }
+  })
 }
 
 export function getMyTasks(userRef: string, orgRef: string, deps: AgentActivityDeps) {
-  return toAwaitableEffect(
-    Effect.gen(function* () {
-      const activePlans = yield* getAllActivePlans(userRef, orgRef, deps)
-      const tasks: PlanNodeCard[] = []
-      const pendingPlanApprovalCount = countPendingPlanApprovals(activePlans)
-
-      for (const { plan, thread } of activePlans) {
-        if (isPendingPlanApproval(plan)) {
-          continue
-        }
-
-        for (const node of plan.nodes) {
-          const humanOwned = node.owner.executorType === 'user'
-          const awaitingHuman = node.status === 'awaiting-human'
-          if (!humanOwned && !awaitingHuman) continue
+  return Effect.gen(function* () {
+    const activePlans = yield* getAllActivePlans(userRef, orgRef, deps)
+    const tasks: PlanNodeCard[] = []
+    const pendingPlanApprovalCount = countPendingPlanApprovals(activePlans)
 
-          tasks.push(planNodeToCard(node, plan, thread.id, thread.title))
-        }
+    for (const { plan, thread } of activePlans) {
+      if (isPendingPlanApproval(plan)) {
+        continue
       }
 
-      return { tasks, pendingApprovalCount: pendingPlanApprovalCount + tasks.filter((task) => task.hasApproval).length }
-    }),
-  )
-}
+      for (const node of plan.nodes) {
+        const humanOwned = node.owner.executorType === 'user'
+        const awaitingHuman = node.status === 'awaiting-human'
+        if (!humanOwned && !awaitingHuman) continue
 
-export function getAgentActivity(userRef: string, orgRef: string, deps: AgentActivityDeps) {
-  return toAwaitableEffect(
-    Effect.gen(function* () {
-      const [activePlans, userTasks] = yield* Effect.all([
-        getAllActivePlans(userRef, orgRef, deps),
-        getMyTasks(userRef, orgRef, deps),
-      ])
-      const activityByAgent = new Map<string, AgentActivityEntry>()
-
-      const agentRoster = getAgentRoster()
-      for (const agentId of agentRoster) {
-        activityByAgent.set(agentId, {
-          agentId,
-          counts: createEmptyCounts(),
-          tasks: [],
-          projects: [],
-          isLeadingActivePlan: false,
-          isRunning: false,
-          lastActiveAt: null,
-        })
+        tasks.push(planNodeToCard(node, plan, thread.id, thread.title))
       }
+    }
 
-      for (const { plan, thread } of activePlans) {
-        if (isPendingPlanApproval(plan)) {
-          if (plan.leadAgentId.trim()) {
-            const leadEntry = activityByAgent.get(plan.leadAgentId) ?? {
-              agentId: plan.leadAgentId,
-              counts: createEmptyCounts(),
-              tasks: [],
-              projects: [],
-              isLeadingActivePlan: false,
-              isRunning: false,
-              lastActiveAt: null,
-            }
-            activityByAgent.set(plan.leadAgentId, leadEntry)
-            leadEntry.isLeadingActivePlan = true
-            if (!leadEntry.projects.some((project) => project.planRunId === plan.runId)) {
-              leadEntry.projects.push({
-                threadId: thread.id,
-                threadTitle: thread.title,
-                planRunId: plan.runId,
-                planTitle: plan.title,
-                status: plan.status,
-              })
-            }
-            leadEntry.isRunning = leadEntry.isRunning || thread.isRunning
-            leadEntry.lastActiveAt = maxIsoDate(leadEntry.lastActiveAt, thread.updatedAt)
-          }
-          continue
-        }
+    return { tasks, pendingApprovalCount: pendingPlanApprovalCount + tasks.filter((task) => task.hasApproval).length }
+  })
+}
 
-        const involvedAgents = new Set<string>()
-
-        for (const node of plan.nodes) {
-          if (node.owner.executorType !== 'agent') continue
-
-          const agentId = node.owner.ref
-          const entry =
-            activityByAgent.get(agentId) ??
-            ({
-              agentId,
-              counts: createEmptyCounts(),
-              tasks: [],
-              projects: [],
-              isLeadingActivePlan: false,
-              isRunning: false,
-              lastActiveAt: null,
-            } as AgentActivityEntry)
-          activityByAgent.set(agentId, entry)
-          involvedAgents.add(agentId)
-          incrementCounts(entry.counts, node.status)
-
-          if (!isCompletedStatus(node.status)) {
-            entry.tasks.push(planNodeToCard(node, plan, thread.id, thread.title))
-          }
-        }
+export function getAgentActivity(userRef: string, orgRef: string, deps: AgentActivityDeps) {
+  return Effect.gen(function* () {
+    const [activePlans, userTasks] = yield* Effect.all([
+      getAllActivePlans(userRef, orgRef, deps),
+      getMyTasks(userRef, orgRef, deps),
+    ])
+    const activityByAgent = new Map<string, AgentActivityEntry>()
+
+    const agentRoster = deps.agentConfig.roster
+    for (const agentId of agentRoster) {
+      activityByAgent.set(agentId, {
+        agentId,
+        counts: createEmptyCounts(),
+        tasks: [],
+        projects: [],
+        isLeadingActivePlan: false,
+        isRunning: false,
+        lastActiveAt: null,
+      })
+    }
 
+    for (const { plan, thread } of activePlans) {
+      if (isPendingPlanApproval(plan)) {
         if (plan.leadAgentId.trim()) {
           const leadEntry = activityByAgent.get(plan.leadAgentId) ?? {
             agentId: plan.leadAgentId,
@@ -318,15 +258,8 @@ export function getAgentActivity(userRef: string, orgRef: string, deps: AgentAct
           }
           activityByAgent.set(plan.leadAgentId, leadEntry)
           leadEntry.isLeadingActivePlan = true
-          involvedAgents.add(plan.leadAgentId)
-        }
-
-        for (const agentId of involvedAgents) {
-          const entry = activityByAgent.get(agentId)
-          if (!entry) continue
-
-          if (!entry.projects.some((project) => project.planRunId === plan.runId)) {
-            entry.projects.push({
+          if (!leadEntry.projects.some((project) => project.planRunId === plan.runId)) {
+            leadEntry.projects.push({
               threadId: thread.id,
               threadTitle: thread.title,
               planRunId: plan.runId,
@@ -334,38 +267,97 @@ export function getAgentActivity(userRef: string, orgRef: string, deps: AgentAct
               status: plan.status,
             })
           }
+          leadEntry.isRunning = leadEntry.isRunning || thread.isRunning
+          leadEntry.lastActiveAt = maxIsoDate(leadEntry.lastActiveAt, thread.updatedAt)
+        }
+        continue
+      }
+
+      const involvedAgents = new Set<string>()
+
+      for (const node of plan.nodes) {
+        if (node.owner.executorType !== 'agent') continue
+
+        const agentId = node.owner.ref
+        const entry =
+          activityByAgent.get(agentId) ??
+          ({
+            agentId,
+            counts: createEmptyCounts(),
+            tasks: [],
+            projects: [],
+            isLeadingActivePlan: false,
+            isRunning: false,
+            lastActiveAt: null,
+          } as AgentActivityEntry)
+        activityByAgent.set(agentId, entry)
+        involvedAgents.add(agentId)
+        incrementCounts(entry.counts, node.status)
 
-          entry.isRunning = entry.isRunning || thread.isRunning
-          entry.lastActiveAt = maxIsoDate(entry.lastActiveAt, thread.updatedAt)
+        if (!isCompletedStatus(node.status)) {
+          entry.tasks.push(planNodeToCard(node, plan, thread.id, thread.title))
         }
       }
 
-      const agents = [...activityByAgent.values()].sort((left, right) => {
-        const leftIndex = agentRoster.indexOf(left.agentId)
-        const rightIndex = agentRoster.indexOf(right.agentId)
-        if (leftIndex !== -1 || rightIndex !== -1) {
-          if (leftIndex === -1) return 1
-          if (rightIndex === -1) return -1
-          return leftIndex - rightIndex
+      if (plan.leadAgentId.trim()) {
+        const leadEntry = activityByAgent.get(plan.leadAgentId) ?? {
+          agentId: plan.leadAgentId,
+          counts: createEmptyCounts(),
+          tasks: [],
+          projects: [],
+          isLeadingActivePlan: false,
+          isRunning: false,
+          lastActiveAt: null,
         }
-        return left.agentId.localeCompare(right.agentId)
-      })
+        activityByAgent.set(plan.leadAgentId, leadEntry)
+        leadEntry.isLeadingActivePlan = true
+        involvedAgents.add(plan.leadAgentId)
+      }
 
-      return {
-        agents,
-        userActivity: {
-          taskCount: userTasks.tasks.length,
-          pendingApprovalCount: userTasks.pendingApprovalCount,
-          awaitingHumanCount: userTasks.tasks.filter((task) => task.status === 'awaiting-human').length,
-          lastActiveAt: activePlans.reduce<string | null>(
-            (latest, entry) => maxIsoDate(latest, entry.thread.updatedAt),
-            null,
-          ),
-        },
-        totalActivePlans: activePlans.length,
+      for (const agentId of involvedAgents) {
+        const entry = activityByAgent.get(agentId)
+        if (!entry) continue
+
+        if (!entry.projects.some((project) => project.planRunId === plan.runId)) {
+          entry.projects.push({
+            threadId: thread.id,
+            threadTitle: thread.title,
+            planRunId: plan.runId,
+            planTitle: plan.title,
+            status: plan.status,
+          })
+        }
+
+        entry.isRunning = entry.isRunning || thread.isRunning
+        entry.lastActiveAt = maxIsoDate(entry.lastActiveAt, thread.updatedAt)
+      }
+    }
+
+    const agents = [...activityByAgent.values()].sort((left, right) => {
+      const leftIndex = agentRoster.indexOf(left.agentId)
+      const rightIndex = agentRoster.indexOf(right.agentId)
+      if (leftIndex !== -1 || rightIndex !== -1) {
+        if (leftIndex === -1) return 1
+        if (rightIndex === -1) return -1
+        return leftIndex - rightIndex
       }
-    }),
-  )
+      return left.agentId.localeCompare(right.agentId)
+    })
+
+    return {
+      agents,
+      userActivity: {
+        taskCount: userTasks.tasks.length,
+        pendingApprovalCount: userTasks.pendingApprovalCount,
+        awaitingHumanCount: userTasks.tasks.filter((task) => task.status === 'awaiting-human').length,
+        lastActiveAt: activePlans.reduce<string | null>(
+          (latest, entry) => maxIsoDate(latest, entry.thread.updatedAt),
+          null,
+        ),
+      },
+      totalActivePlans: activePlans.length,
+    }
+  })
 }
 
 export function getAllActivePlans(userRef: string, orgRef: string, deps: AgentActivityDeps) {
@@ -452,8 +444,9 @@ export class AgentActivityServiceTag extends Context.Service<AgentActivityServic
 export const AgentActivityServiceLive = Layer.effect(
   AgentActivityServiceTag,
   Effect.gen(function* () {
+    const agentConfig = yield* AgentConfigServiceTag
     const executionPlanService = yield* ExecutionPlanServiceTag
     const threadService = yield* ThreadServiceTag
-    return createAgentActivityService({ executionPlanService, threadService })
+    return createAgentActivityService({ agentConfig, executionPlanService, threadService })
   }),
 )

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

@@ -12,14 +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 { makeEffectTryPromiseWithOperation } from '../effect/helpers'
-import { runPromise } from '../effect/runtime'
-import { DatabaseServiceTag } from '../effect/services'
+import {
+  AgentConfigServiceTag,
+  AgentFactoryServiceTag,
+  DatabaseServiceTag,
+  RuntimeAdaptersServiceTag,
+  TurnHooksServiceTag,
+} from '../effect/services'
 import { toValidationError } from '../effect/zod'
 import {
   OWNERSHIP_DISPATCH_BLOCKED_TOOL_NAMES,
@@ -33,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'
@@ -91,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',
@@ -140,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
 
@@ -193,7 +197,7 @@ function createExecuteNode(deps: AgentExecutorDeps) {
     }
 
     const agentId = owner.ref
-    if (!getAgentRoster().includes(agentId)) {
+    if (!deps.agentConfig.roster.includes(agentId)) {
       return yield* new BadRequestError({ message: `Agent executor "${agentId}" is not registered.` })
     }
 
@@ -217,21 +221,23 @@ function createExecuteNode(deps: AgentExecutorDeps) {
     }
     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(organizationRef),
+        () => getLinearInstallationByOrgId(deps.agentFactoryConfig.pluginRuntime, organizationRef),
       ),
       githubInstallation: tryAgentExecutorTask(
         'get-github-installation',
         `Failed to load GitHub installation for org ${params.context.organizationId}.`,
-        () => getGithubInstallationForOrganization(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(params.context.organizationId),
+        () => buildIndexedRepositoriesContext(runtimeAdapters, params.context.organizationId),
       ),
     }).pipe(Effect.withSpan('AgentExecutor.loadInstallations'))
 
@@ -246,7 +252,7 @@ function createExecuteNode(deps: AgentExecutorDeps) {
       }),
     ]
 
-    const turnHooks = getTurnHooks()
+    const turnHooks = yield* TurnHooksServiceTag
     const agentResolutionValue = yield* tryAgentExecutorPromise(
       'resolve-agent',
       `Failed to resolve agent "${agentId}" for dispatched execution.`,
@@ -270,7 +276,7 @@ function createExecuteNode(deps: AgentExecutorDeps) {
     )
     const agentResolution = isRecord(agentResolutionValue) ? agentResolutionValue : null
     const resolvedAgentId = readOptionalString(agentResolution?.agentId) ?? agentId
-    const runtimeConfig = getAgentRuntimeConfig({
+    const runtimeConfig = deps.agentFactoryConfig.getAgentRuntimeConfig({
       agentId: resolvedAgentId,
       threadType: thread.type,
       mode: dispatchMode,
@@ -283,7 +289,7 @@ function createExecuteNode(deps: AgentExecutorDeps) {
       responseGuardSection: buildOwnershipDispatchResponseGuard({ node: params.nodeSpec, executionMode: mode }),
     })
 
-    const agentFactoryConfig = getResolvedAgentFactoryConfig()
+    const agentFactoryConfig = deps.agentFactoryConfig
     const rawTools = yield* tryAgentExecutorPromise(
       'build-agent-tools',
       `Failed to build agent tools for "${resolvedAgentId}".`,
@@ -400,13 +406,18 @@ function createExecuteNode(deps: AgentExecutorDeps) {
 }
 
 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<
@@ -417,9 +428,17 @@ export class AgentExecutorServiceTag extends Context.Service<
 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/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,35 +51,11 @@ 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 }))
-    },
-
-    extractStoredAttachmentTextEffect(params: { storageKey: string; name: string; contentType: string }) {
+    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 }))
-    },
-
-    extractStoredAttachmentPagesEffect(params: { storageKey: string; name: string; contentType: string }) {
+    extractStoredAttachmentPages(params: { storageKey: string; name: string; contentType: string }) {
       return attachmentStorage.extractStoredAttachmentPages(params)
     },
 
@@ -125,30 +97,6 @@ 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,
-        }),
-      )
-    },
-
-    writeOrganizationDocumentEffect({
-      orgId,
-      namespace,
-      relativePath,
-      content,
-      contentType,
-    }: {
-      orgId: RecordIdRef
-      namespace: string
-      relativePath: string
-      content: string
-      contentType: string
     }) {
       return attachmentStorage.writeOrganizationDocument({
         orgId: toOrgId(orgId),
@@ -173,21 +121,7 @@ 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) }),
-      )
-    },
-
-    uploadThreadAttachmentEffect({ file, orgId, userId }: { file: File; orgId: RecordIdRef; userId: RecordIdRef }) {
+    uploadThreadAttachment({ file, orgId, userId }: { file: File; orgId: RecordIdRef; userId: RecordIdRef }) {
       return attachmentStorage.uploadThreadAttachment({ file, orgId: toOrgId(orgId), userId: toUserId(userId) })
     },
   }