@lota-sdk/core 0.1.15 → 0.1.17

package/src/services/memory.service.ts

@@ -26,8 +26,7 @@ import {
 import { getRuntimeConfig } from '../runtime/runtime-config'
 import { createMemoryRerankerAgent, MEMORY_RERANKER_PROMPT } from '../system-agents/memory-reranker.agent'
 import { createOrgMemoryAgent, ORG_MEMORY_PROMPT } from '../system-agents/memory.agent'
-import { toError } from '../utils/errors'
-import { compactWhitespace } from '../utils/string'
+import { compactWhitespace, truncateText } from '../utils/string'
 import { assessMemoryImportance, clampMemoryImportance } from './memory-assessment.service'
 import { formatMemoryResults, formatRerankedResults, getCandidateLimit } from './memory-utils'
 
@@ -44,6 +43,7 @@ const MAX_CONVERSATION_MEMORY_BLOCK_CHARS = 2_000
 const MAX_CONVERSATION_ATTACHMENT_CONTEXT_CHARS = 6_000
 const MAX_CONVERSATION_ASSESSMENT_CHARS = 7_000
 const ONBOARDING_MEMORY_MAX_FACTS = 16
+const MAX_ORG_MEMORY_CLIENTS = 128
 const ONBOARDING_MEMORY_EXTRACTION_PROMPT =
   'Onboarding mode is active. Extract multiple concrete startup facts from user-provided context: company mission, product capabilities, customer segments, pricing, traction, go-to-market plans, roadmap, team composition, technical stack, risks, and referenced URLs. Prefer one fact per concrete claim.'
 
@@ -65,17 +65,29 @@ const MemoryRerankOutputSchema = z.object({
 
 export type MemoryRerankOutput = z.infer<typeof MemoryRerankOutputSchema>
 
-const isRoutableAgentName = (value?: string): boolean => Boolean(value && agentRoster.includes(value))
+const isRoutableAgentName = (value?: string): value is string => Boolean(value && agentRoster.includes(value))
 
 class MemoryService {
   private orgMemoryCache = new Map<string, Memory>()
 
   private getOrCreateMemory(cacheKey: string, cache: Map<string, Memory>): Memory {
     const cached = cache.get(cacheKey)
-    if (cached) return cached
+    if (cached) {
+      cache.delete(cacheKey)
+      cache.set(cacheKey, cached)
+      return cached
+    }
 
     const memory = new Memory({ createAgent: createOrgMemoryAgent }, { customPrompt: ORG_MEMORY_PROMPT })
 
+    if (cache.size >= MAX_ORG_MEMORY_CLIENTS) {
+      const oldestKey = cache.keys().next().value
+      if (typeof oldestKey === 'string') {
+        cache.delete(oldestKey)
+        aiLogger.debug`Evicted cached org memory client for ${oldestKey}`
+      }
+    }
+
     cache.set(cacheKey, memory)
     aiLogger.debug`Memory client created and cached for ${cacheKey}`
     return memory
@@ -87,9 +99,7 @@ class MemoryService {
   }
 
   private truncateCandidateText(value: string): string {
-    const normalized = compactWhitespace(value)
-    if (normalized.length <= RERANK_CANDIDATE_MAX_CHARS) return normalized
-    return `${normalized.slice(0, RERANK_CANDIDATE_MAX_CHARS)}...`
+    return truncateText(compactWhitespace(value), RERANK_CANDIDATE_MAX_CHARS)
   }
 
   private readNumericMetadata(metadata: Record<string, unknown>, key: string): number {
@@ -129,8 +139,7 @@ class MemoryService {
   private normalizeConversationText(value: string, maxChars: number): string {
     const normalized = compactWhitespace(value)
     if (!normalized) return ''
-    if (normalized.length <= maxChars) return normalized
-    return `${normalized.slice(0, maxChars - 3)}...`
+    return truncateText(normalized, maxChars)
   }
 
   private resolveAgentScopeNames(agentName?: string, agentNames: string[] = []): string[] {
@@ -148,9 +157,7 @@ class MemoryService {
   }
 
   private normalizePreSeededMemoryText(value: string): string {
-    const normalized = compactWhitespace(value)
-    if (normalized.length <= PRESEEDED_MEMORY_MAX_CHARS) return normalized
-    return `${normalized.slice(0, PRESEEDED_MEMORY_MAX_CHARS - 3)}...`
+    return truncateText(compactWhitespace(value), PRESEEDED_MEMORY_MAX_CHARS)
   }
 
   private formatPreSeededMemoriesSection(memories: MemoryRecord[]): string | undefined {
@@ -331,15 +338,9 @@ class MemoryService {
     aiLogger.debug`Organization memory search requested (orgId: ${orgId}, scopeId: ${orgScopeId}, queryLength: ${query.length})`
     const memory = this.getOrgMemory(orgId)
 
-    try {
-      const results = await this.searchMemories({ query, memory, scopeId: orgScopeId, memoryType: ORG_MEMORY_TYPE })
-      aiLogger.debug`Organization memory search completed (resultLength: ${results.length}, preview: ${results.slice(0, 100)})`
-      return results
-    } catch (error: unknown) {
-      const normalizedError = toError(error)
-      aiLogger.error`Organization memory search failed: ${normalizedError}`
-      throw normalizedError
-    }
+    const results = await this.searchMemories({ query, memory, scopeId: orgScopeId, memoryType: ORG_MEMORY_TYPE })
+    aiLogger.debug`Organization memory search completed (resultLength: ${results.length}, preview: ${results.slice(0, 100)})`
+    return results
   }
 
   async getStaleMemories(orgId: string): Promise<string> {
@@ -368,21 +369,15 @@ class MemoryService {
     const searchK = getRuntimeConfig().memory.searchK
     const limit = options?.limit ?? (fastMode ? Math.min(searchK, 4) : searchK)
 
-    try {
-      const candidates = await memory.searchCandidates(query, {
-        scopeId: orgScopeId,
-        limit,
-        memoryType: ORG_MEMORY_TYPE,
-        fastMode,
-        includeNeighborContext: !fastMode,
-      })
-      aiLogger.debug`Organization memory search (raw) completed (candidates: ${candidates.length})`
-      return formatMemoryResults(candidates)
-    } catch (error: unknown) {
-      const normalizedError = toError(error)
-      aiLogger.error`Organization memory search (raw) failed: ${normalizedError}`
-      throw normalizedError
-    }
+    const candidates = await memory.searchCandidates(query, {
+      scopeId: orgScopeId,
+      limit,
+      memoryType: ORG_MEMORY_TYPE,
+      fastMode,
+      includeNeighborContext: !fastMode,
+    })
+    aiLogger.debug`Organization memory search (raw) completed (candidates: ${candidates.length})`
+    return formatMemoryResults(candidates)
   }
 
   async searchAgentMemories(orgId: string, agentName: string, query: string): Promise<string> {
@@ -395,20 +390,14 @@ class MemoryService {
     aiLogger.debug`Agent memory search requested (orgId: ${orgId}, agentName: ${agentName}, scopeId: ${scoped}, queryLength: ${query.length})`
     const memory = this.getOrgMemory(orgId)
 
-    try {
-      const results = await this.searchMemories({ query, memory, scopeId: scoped, memoryType: ORG_MEMORY_TYPE })
-      aiLogger.debug`Agent memory search completed (agentName: ${agentName}, resultLength: ${results.length}, preview: ${results.slice(0, 100)})`
-      return results
-    } catch (error: unknown) {
-      const normalizedError = toError(error)
-      aiLogger.error`Agent memory search failed: ${normalizedError}`
-      throw normalizedError
-    }
+    const results = await this.searchMemories({ query, memory, scopeId: scoped, memoryType: ORG_MEMORY_TYPE })
+    aiLogger.debug`Agent memory search completed (agentName: ${agentName}, resultLength: ${results.length}, preview: ${results.slice(0, 100)})`
+    return results
   }
 
   async searchOrgMemoriesForAgent(orgId: string, agentName: string, query: string): Promise<string> {
     if (!isRoutableAgentName(agentName)) {
-      return await this.searchOrganizationMemories(orgId, query)
+      return this.searchOrganizationMemories(orgId, query)
     }
 
     const [agentResult, orgResult] = await Promise.all([
@@ -429,7 +418,7 @@ class MemoryService {
   }): Promise<MemoryRecord[]> {
     const { orgId, ...listOptions } = params
     const orgMemory = this.getOrgMemory(orgId)
-    return await orgMemory.list({ scopeId: scopeId(ORG_SCOPE_PREFIX, orgId), ...listOptions })
+    return orgMemory.list({ scopeId: scopeId(ORG_SCOPE_PREFIX, orgId), ...listOptions })
   }
 
   async getTopMemories(params: { orgId: string; agentName?: string; limit?: number }): Promise<string | undefined> {
@@ -513,7 +502,7 @@ class MemoryService {
     ]
 
     if (isRoutableAgentName(agentName)) {
-      const agentScoped = agentScopeId(orgId, agentName as string)
+      const agentScoped = agentScopeId(orgId, agentName)
       retrievalTasks.push({
         scopeTag: `agent:${agentName}`,
         retrieve: async () =>
@@ -649,7 +638,7 @@ class MemoryService {
     importance?: number
   }): Promise<string> {
     if (!isRoutableAgentName(agentName)) {
-      throw new Error(`Invalid agentName for agent memory: ${agentName}`)
+      throw new Error(`Invalid agentName for agent memory: ${agentName as string}`)
     }
 
     const memory = this.getOrgMemory(orgId)
@@ -733,6 +722,8 @@ class MemoryService {
     input,
     output,
     sourceId,
+    source = 'chat',
+    sourceMetadata,
     onboardStatus,
     agentName,
     historyMessages = [],
@@ -744,6 +735,8 @@ class MemoryService {
     input: string
     output: string
     sourceId?: string
+    source?: string
+    sourceMetadata?: Record<string, unknown>
     onboardStatus?: string
     agentName?: string
     historyMessages?: Array<{ role: 'user' | 'agent'; content: string; agentName?: string }>
@@ -800,7 +793,7 @@ class MemoryService {
         scopeId: orgScopeId,
         memoryType: ORG_MEMORY_TYPE,
         ...(typeof assessedImportance === 'number' ? { importance: assessedImportance } : {}),
-        metadata: { orgId, source: 'chat', ...(sourceId ? { sourceId } : {}), ...assessmentMetadata },
+        metadata: { orgId, source, ...(sourceId ? { sourceId } : {}), ...sourceMetadata, ...assessmentMetadata },
       },
     ]
 
@@ -814,8 +807,9 @@ class MemoryService {
           orgId,
           agentName: scopedAgentName,
           memoryScope: 'agent',
-          source: 'chat',
+          source,
           ...(sourceId ? { sourceId } : {}),
+          ...sourceMetadata,
           ...assessmentMetadata,
         },
       })
@@ -830,16 +824,10 @@ class MemoryService {
     const preparedUpdates = await orgMemory.prepareFactsToScopes(extractedFacts, scopes)
     if (preparedUpdates.length === 0) return
 
-    try {
-      await withOrgMemoryLock(orgId, async () => {
-        await orgMemory.applyPreparedScopeUpdates(preparedUpdates)
-      })
-      aiLogger.debug`Conversation memories added to ${scopes.length} scope(s) from ${messages.length} message(s)`
-    } catch (error: unknown) {
-      const normalizedError = toError(error)
-      aiLogger.error`Memory write failed: ${normalizedError}`
-      throw normalizedError
-    }
+    await withOrgMemoryLock(orgId, async () => {
+      await orgMemory.applyPreparedScopeUpdates(preparedUpdates)
+    })
+    aiLogger.debug`Conversation memories added to ${scopes.length} scope(s) from ${messages.length} message(s)`
   }
 }
 

package/src/services/monitoring-window.service.ts

@@ -0,0 +1,86 @@
+import type { MonitoringWindowConfig } from '@lota-sdk/shared'
+
+import { planSchedulerService } from './plan-scheduler.service'
+
+class MonitoringWindowService {
+  computeCheckTimes(config: MonitoringWindowConfig): { offsetMs: number; intervalMs: number }[] {
+    const times: { offsetMs: number; intervalMs: number }[] = []
+    let currentInterval = config.initialIntervalMs
+    let elapsed = 0
+    while (elapsed < config.durationMs) {
+      times.push({ offsetMs: elapsed, intervalMs: currentInterval })
+      elapsed += currentInterval
+      currentInterval = Math.min(currentInterval / config.decayFactor, config.maxIntervalMs)
+    }
+    return times
+  }
+
+  async startMonitoringWindow(params: {
+    runId: string
+    nodeId: string
+    config: MonitoringWindowConfig
+    organizationId: string
+    workstreamId: string
+  }): Promise<void> {
+    await planSchedulerService.createSchedule({
+      organizationId: params.organizationId,
+      workstreamId: params.workstreamId,
+      runId: params.runId,
+      nodeId: params.nodeId,
+      scheduleSpec: {
+        type: 'monitoring',
+        intervalMs: params.config.initialIntervalMs,
+        maxFires: this.computeCheckTimes(params.config).length,
+        missedPolicy: 'skip',
+      },
+    })
+  }
+
+  evaluateTermination(params: { samples: unknown[]; config: MonitoringWindowConfig }): boolean {
+    if (!params.config.earlyTermination) return false
+    if (params.samples.length < params.config.earlyTermination.minSamples) return false
+
+    const { condition, minSamples } = params.config.earlyTermination
+    const numericSamples = params.samples
+      .map((s) =>
+        typeof s === 'number'
+          ? s
+          : typeof s === 'object' && s !== null && 'value' in s
+            ? Number((s as Record<string, unknown>).value)
+            : NaN,
+      )
+      .filter((n) => !isNaN(n))
+
+    // No numeric data to evaluate against — don't terminate
+    if (numericSamples.length === 0) return false
+
+    if (condition === 'stable') {
+      const recent = numericSamples.slice(-minSamples)
+      if (recent.length < 2) return false
+      const mean = recent.reduce((a, b) => a + b, 0) / recent.length
+      const variance = recent.reduce((a, b) => a + (b - mean) ** 2, 0) / recent.length
+      const cv = mean !== 0 ? Math.sqrt(variance) / Math.abs(mean) : 0
+      return cv < 0.1
+    }
+
+    const thresholdMatch = condition.match(/^threshold:(\d+(?:\.\d+)?)$/)
+    if (thresholdMatch?.[1]) {
+      const threshold = parseFloat(thresholdMatch[1])
+      return numericSamples.some((v) => v >= threshold)
+    }
+
+    if (condition === 'trend:declining') {
+      const recent = numericSamples.slice(-minSamples)
+      return recent.length >= 2 && recent.every((v, i) => i === 0 || v <= (recent[i - 1] ?? v))
+    }
+
+    if (condition === 'trend:increasing') {
+      const recent = numericSamples.slice(-minSamples)
+      return recent.length >= 2 && recent.every((v, i) => i === 0 || v >= (recent[i - 1] ?? v))
+    }
+
+    throw new Error(`Unknown monitoring termination condition: ${condition}`)
+  }
+}
+
+export const monitoringWindowService = new MonitoringWindowService()

package/src/services/mutating-approval.service.ts

@@ -106,5 +106,5 @@ async function verifyMutatingApprovalForWorkstream(
 }
 
 export const verifyMutatingApproval: VerifyMutatingApproval = async (params) => {
-  return await verifyMutatingApprovalForWorkstream(ensureRecordId(params.workstreamId, TABLES.WORKSTREAM), params)
+  return verifyMutatingApprovalForWorkstream(ensureRecordId(params.workstreamId, TABLES.WORKSTREAM), params)
 }

package/src/services/node-workspace.service.ts

@@ -0,0 +1,155 @@
+import type {
+  NodeResultQuality,
+  PlanArtifactSubmission,
+  PlanNodeResult,
+  PlanNodeSpec,
+  PlanSchemaRegistry,
+  WriteIntent,
+  WriteIntentAction,
+} from '@lota-sdk/shared'
+
+import { serverLogger } from '../config/logger'
+
+export type WorkspaceEntryValidation = 'validated' | 'unvalidated'
+
+export interface WorkspaceEntry {
+  targetPath: string
+  action: WriteIntentAction
+  payload: unknown
+  validation: WorkspaceEntryValidation
+  stagedAt: Date
+}
+
+export interface NodeWorkspace {
+  nodeId: string
+  ctx: Readonly<{
+    resolvedInput: Record<string, unknown>
+    inputArtifacts: PlanArtifactSubmission[]
+    schemaRegistry: PlanSchemaRegistry
+    nodeSpec: PlanNodeSpec
+  }>
+  work: Map<string, unknown>
+  sys: {
+    startedAt: Date
+    correctionCounts: Map<string, number>
+    writeLog: Array<{ targetPath: string; action: WriteIntentAction; timestamp: Date; result: 'accepted' | 'rejected' }>
+  }
+  deliverables: Map<string, WorkspaceEntry>
+}
+
+class NodeWorkspaceService {
+  initialize(params: {
+    nodeSpec: PlanNodeSpec
+    resolvedInput: Record<string, unknown>
+    inputArtifacts: PlanArtifactSubmission[]
+    schemaRegistry: PlanSchemaRegistry
+  }): NodeWorkspace {
+    const ctx = Object.freeze({
+      resolvedInput: params.resolvedInput,
+      inputArtifacts: params.inputArtifacts,
+      schemaRegistry: params.schemaRegistry,
+      nodeSpec: params.nodeSpec,
+    })
+
+    return {
+      nodeId: params.nodeSpec.id,
+      ctx,
+      work: new Map(),
+      sys: { startedAt: new Date(), correctionCounts: new Map(), writeLog: [] },
+      deliverables: new Map(),
+    }
+  }
+
+  stageWrite(workspace: NodeWorkspace, intent: WriteIntent, validation: WorkspaceEntryValidation): void {
+    const existing = workspace.deliverables.get(intent.targetPath)
+
+    if (intent.action === 'append' && existing && Array.isArray(existing.payload) && Array.isArray(intent.payload)) {
+      existing.payload = [...(existing.payload as unknown[]), ...intent.payload]
+      existing.action = intent.action
+      existing.validation = validation
+      existing.stagedAt = new Date()
+    } else {
+      workspace.deliverables.set(intent.targetPath, {
+        targetPath: intent.targetPath,
+        action: intent.action,
+        payload: intent.payload,
+        validation,
+        stagedAt: new Date(),
+      })
+    }
+
+    workspace.sys.writeLog.push({
+      targetPath: intent.targetPath,
+      action: intent.action,
+      timestamp: new Date(),
+      result: 'accepted',
+    })
+  }
+
+  finalize(workspace: NodeWorkspace): PlanNodeResult & { isComplete: boolean; quality: NodeResultQuality } {
+    const artifacts: PlanArtifactSubmission[] = []
+    let structuredOutput: Record<string, unknown> | undefined
+    let allValidated = true
+    const requiredNames = new Set(workspace.ctx.nodeSpec.deliverables.filter((d) => d.required).map((d) => d.name))
+    const presentRequired = new Set<string>()
+
+    for (const [targetPath, entry] of workspace.deliverables) {
+      if (entry.validation === 'unvalidated') {
+        allValidated = false
+      }
+
+      if (targetPath.startsWith('structuredOutput')) {
+        if (!structuredOutput) structuredOutput = {}
+        const subPath = targetPath.replace(/^structuredOutput\.?/, '')
+        if (subPath) {
+          structuredOutput[subPath] = entry.payload
+        } else {
+          structuredOutput =
+            typeof entry.payload === 'object' && entry.payload !== null && !Array.isArray(entry.payload)
+              ? (entry.payload as Record<string, unknown>)
+              : structuredOutput
+        }
+        continue
+      }
+
+      const spec = workspace.ctx.nodeSpec.deliverables.find((d) => d.name === targetPath)
+      if (!spec) {
+        serverLogger.warn`Write to unknown deliverable path "${targetPath}" in node ${workspace.nodeId} — skipping`
+        continue
+      }
+
+      if (requiredNames.has(targetPath)) {
+        presentRequired.add(targetPath)
+      }
+
+      artifacts.push({
+        name: spec.name,
+        kind: spec.kind,
+        pointer: `workspace://${workspace.nodeId}/${targetPath}`,
+        schemaRef: spec.schemaRef,
+        description: spec.description,
+        payload:
+          typeof entry.payload === 'string'
+            ? { content: entry.payload }
+            : typeof entry.payload === 'object' && entry.payload !== null
+              ? (entry.payload as Record<string, unknown> | unknown[])
+              : undefined,
+      })
+    }
+
+    const allRequiredPresent = requiredNames.size === presentRequired.size
+    const quality: NodeResultQuality = allRequiredPresent && allValidated ? 'full' : 'partial'
+    const isComplete = quality === 'full'
+
+    return { structuredOutput, artifacts, quality, isComplete }
+  }
+
+  cleanup(workspace: NodeWorkspace): void {
+    workspace.work.clear()
+    workspace.deliverables.clear()
+    workspace.sys.writeLog.length = 0
+    workspace.sys.correctionCounts.clear()
+  }
+}
+
+export const nodeWorkspaceService = new NodeWorkspaceService()

package/src/services/notification.service.ts

@@ -0,0 +1,39 @@
+import type { NotificationSeverity } from '@lota-sdk/shared'
+
+export interface NotificationPayload {
+  organizationId: string
+  workstreamId: string
+  runId?: string
+  nodeId?: string
+  severity: NotificationSeverity
+  title: string
+  body: string
+  dedupeKey?: string
+  metadata?: Record<string, unknown>
+}
+
+export interface NotificationService {
+  notify(payload: NotificationPayload): Promise<void>
+  remind(payload: NotificationPayload): Promise<void>
+  escalate(payload: NotificationPayload): Promise<void>
+}
+
+export class NoOpNotificationService implements NotificationService {
+  async notify(_payload: NotificationPayload): Promise<void> {}
+  async remind(_payload: NotificationPayload): Promise<void> {}
+  async escalate(_payload: NotificationPayload): Promise<void> {}
+}
+
+let _notificationService: NotificationService | null = null
+
+export function configureNotificationService(service: NotificationService | null): void {
+  _notificationService = service
+}
+
+export function getNotificationService(): NotificationService {
+  if (_notificationService === null) {
+    throw new Error('Notification service is not configured.')
+  }
+
+  return _notificationService
+}

package/src/services/organization-member.service.ts

@@ -1,4 +1,4 @@
-import { recordIdStringSchema } from '@lota-sdk/shared'
+import { recordIdSchema, recordIdStringSchema } from '@lota-sdk/shared'
 import { z } from 'zod'
 
 import { BaseService } from '../db/base.service'
@@ -8,9 +8,9 @@ import { TABLES } from '../db/tables'
 import { toIsoDateTimeString } from '../utils/date-time'
 
 const organizationMemberRecordSchema = z.object({
-  id: z.unknown(),
-  in: z.unknown(),
-  out: z.unknown(),
+  id: recordIdSchema,
+  in: recordIdSchema,
+  out: recordIdSchema,
   role: z.string(),
   createdAt: z.coerce.date(),
 })
@@ -91,6 +91,13 @@ class OrganizationMemberService extends BaseService<typeof organizationMemberRec
     )
   }
 
+  async getMembership(userId: RecordIdInput, organizationId: RecordIdInput): Promise<SdkOrganizationMember | null> {
+    const userRef = ensureRecordId(userId, TABLES.USER)
+    const organizationRef = ensureRecordId(organizationId, TABLES.ORGANIZATION)
+    const record = (await this.findAll({ in: userRef, out: organizationRef }, { limit: 1 })).at(0)
+    return record ? this.toPublic(record) : null
+  }
+
   async isMember(userId: RecordIdInput, organizationId: RecordIdInput): Promise<boolean> {
     const userRef = ensureRecordId(userId, TABLES.USER)
     const organizationRef = ensureRecordId(organizationId, TABLES.ORGANIZATION)

package/src/services/organization.service.ts

@@ -1,4 +1,4 @@
-import { recordIdStringSchema } from '@lota-sdk/shared'
+import { recordIdSchema, recordIdStringSchema } from '@lota-sdk/shared'
 import { z } from 'zod'
 
 import { BaseService } from '../db/base.service'
@@ -9,12 +9,12 @@ import { TABLES } from '../db/tables'
 import { toIsoDateTimeString, toOptionalIsoDateTimeString } from '../utils/date-time'
 
 const organizationRecordSchema = z.object({
-  id: z.unknown(),
+  id: recordIdSchema,
   name: z.string(),
-  regularChatDigestLastWorkstreamCursorCreatedAt: z.union([z.date(), z.string(), z.number()]).optional(),
+  regularChatDigestLastWorkstreamCursorCreatedAt: z.coerce.date().optional(),
   regularChatDigestLastWorkstreamCursorId: z.string().optional(),
   skillExtractionLastCursorId: z.string().optional(),
-  skillExtractionLastCursorCreatedAt: z.union([z.date(), z.string(), z.number()]).optional(),
+  skillExtractionLastCursorCreatedAt: z.coerce.date().optional(),
   createdAt: z.coerce.date(),
   updatedAt: z.coerce.date(),
 })
@@ -86,7 +86,7 @@ class OrganizationService extends BaseService<typeof organizationRecordSchema> {
   }
 
   async getOrganizationRecord(organizationId: RecordIdRef): Promise<SdkOrganizationRecord> {
-    return await this.getById(ensureRecordId(organizationId, TABLES.ORGANIZATION))
+    return this.getById(ensureRecordId(organizationId, TABLES.ORGANIZATION))
   }
 
   async updateOrganization(organizationId: RecordIdInput, params: { name: string }): Promise<SdkOrganization> {