@lota-sdk/core 0.4.29 → 0.4.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.4.29",
+  "version": "0.4.31",
   "files": [
     "src",
     "infrastructure/schema"
@@ -32,7 +32,7 @@
     "@ai-sdk/provider": "^3.0.9",
     "@chat-adapter/slack": "^4.26.0",
     "@chat-adapter/state-ioredis": "^4.26.0",
-    "@lota-sdk/shared": "0.4.29",
+    "@lota-sdk/shared": "0.4.31",
     "@mendable/firecrawl-js": "^4.20.0",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.170",

package/src/ai-gateway/ai-gateway.ts

@@ -992,10 +992,47 @@ function removeJsonSchemaFormatKeywords(value: unknown): void {
   }
 }
 
-function cloneAiGatewayJsonSchema(schema: JSONSchema7): JSONSchema7 {
+function requireAllJsonSchemaObjectProperties(value: unknown): void {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      requireAllJsonSchemaObjectProperties(item)
+    }
+    return
+  }
+
+  if (!isRecord(value)) {
+    return
+  }
+
+  if (isRecord(value.properties)) {
+    const propertyNames = Object.keys(value.properties)
+    if (propertyNames.length > 0) {
+      const currentRequired = Array.isArray(value.required)
+        ? value.required.filter((item): item is string => typeof item === 'string')
+        : []
+      value.required = [...new Set([...currentRequired, ...propertyNames])]
+    }
+  }
+
+  for (const [key, child] of Object.entries(value)) {
+    if (JSON_SCHEMA_PROPERTY_MAP_KEYS.has(key) && isRecord(child)) {
+      for (const propertySchema of Object.values(child)) {
+        requireAllJsonSchemaObjectProperties(propertySchema)
+      }
+      continue
+    }
+
+    requireAllJsonSchemaObjectProperties(child)
+  }
+}
+
+function cloneAiGatewayJsonSchema(schema: JSONSchema7, options?: { requireAllProperties?: boolean }): JSONSchema7 {
   // eslint-disable-next-line typescript-eslint/no-unsafe-assignment -- structuredClone preserves the imported JSONSchema7 shape.
   const nextSchema: JSONSchema7 = structuredClone(schema)
   removeJsonSchemaFormatKeywords(nextSchema)
+  if (options?.requireAllProperties) {
+    requireAllJsonSchemaObjectProperties(nextSchema)
+  }
   return nextSchema
 }
 
@@ -1010,7 +1047,9 @@ export function normalizeAiGatewayJsonSchemas(params: AiGatewayCallOptions): AiG
 
   if (params.responseFormat?.type === 'json' && params.responseFormat.schema) {
     // eslint-disable-next-line typescript-eslint/no-unsafe-assignment -- cloneAiGatewayJsonSchema returns the same JSONSchema7 type.
-    const responseSchema: JSONSchema7 = cloneAiGatewayJsonSchema(params.responseFormat.schema)
+    const responseSchema: JSONSchema7 = cloneAiGatewayJsonSchema(params.responseFormat.schema, {
+      requireAllProperties: true,
+    })
     nextParams = {
       ...nextParams,
       // eslint-disable-next-line typescript-eslint/no-unsafe-assignment -- responseSchema is JSONSchema7 for responseFormat.schema.

package/src/db/memory-store.helpers.ts

@@ -6,9 +6,32 @@ import { recordIdToString } from './record-id'
 import { TABLES } from './tables'
 
 export function isUniqueIndexConflict(error: unknown, indexName: string): boolean {
-  if (!(error instanceof Error)) return false
-  const message = error.message
-  return message.includes(indexName) && message.includes('already contains')
+  const visited = new Set<unknown>()
+  const stack: unknown[] = [error]
+
+  while (stack.length > 0) {
+    const current = stack.pop()
+    if (current === null || current === undefined || visited.has(current)) continue
+    visited.add(current)
+
+    if (typeof current === 'string') {
+      if (current.includes(indexName) && current.includes('already contains')) return true
+      continue
+    }
+
+    if (current instanceof Error) {
+      if (current.message.includes(indexName) && current.message.includes('already contains')) return true
+      stack.push(current.cause)
+      continue
+    }
+
+    if (typeof current === 'object') {
+      const record = current as Record<string, unknown>
+      stack.push(record.message, record.cause)
+    }
+  }
+
+  return false
 }
 
 const coerceDate = (value: unknown): Date => {

package/src/db/startup.ts

@@ -9,11 +9,17 @@ import { getErrorMessage } from '../utils/errors'
 import type { SurrealDBService, SurrealDatabaseLogger } from './service'
 import type { SurrealDBError } from './service-normalization'
 import { TABLES } from './tables'
+import { isRetriableTransactionConflict } from './transaction-conflict'
 
 const DATABASE_BOOTSTRAP_KEY = 'database-schema-ready'
 const DEFAULT_RETRY_DELAY_MS = 1_000
 const DEFAULT_MAX_WAIT_MS = 3 * 60 * 1_000
 const RETRY_LOG_INTERVAL = 5
+const BOOTSTRAP_PUBLISH_RETRY_OPTIONS = {
+  times: 8,
+  schedule: Schedule.jittered(Schedule.exponential(Duration.millis(50), 2)),
+  while: isRetriableTransactionConflict,
+} as const
 
 const RuntimeBootstrapRecordSchema = z.object({
   id: recordIdSchema,
@@ -212,21 +218,22 @@ export function publishDatabaseBootstrapEffect(params: {
   schemaFingerprint: string
 }): Effect.Effect<void, DatabaseError> {
   return Effect.asVoid(
-    params.databaseService
-      .upsert(
+    Effect.suspend(() =>
+      params.databaseService.upsert(
         TABLES.RUNTIME_BOOTSTRAP,
         new RecordId(TABLES.RUNTIME_BOOTSTRAP, DATABASE_BOOTSTRAP_KEY),
         { key: DATABASE_BOOTSTRAP_KEY, schemaFingerprint: params.schemaFingerprint, readyAt: nowDate() },
         RuntimeBootstrapRecordSchema,
-      )
-      .pipe(
-        Effect.mapError(
-          (error) =>
-            new DatabaseError({
-              message: `Failed to publish database bootstrap: ${getErrorMessage(error)}`,
-              cause: error,
-            }),
-        ),
       ),
+    ).pipe(
+      Effect.retry(BOOTSTRAP_PUBLISH_RETRY_OPTIONS),
+      Effect.mapError(
+        (error) =>
+          new DatabaseError({
+            message: `Failed to publish database bootstrap: ${getErrorMessage(error)}`,
+            cause: error,
+          }),
+      ),
+    ),
   )
 }

package/src/db/transaction-conflict.ts

@@ -1,15 +1,41 @@
-export function isRetriableTransactionConflict(error: unknown): boolean {
-  if (!(error instanceof Error)) {
+function readErrorMessage(error: unknown): string | undefined {
+  if (error instanceof Error) {
+    return error.message
+  }
+
+  if (typeof error === 'object' && error !== null && typeof (error as { message?: unknown }).message === 'string') {
+    return (error as { message: string }).message
+  }
+
+  return undefined
+}
+
+function readErrorCause(error: unknown): unknown {
+  if (typeof error !== 'object' || error === null || !('cause' in error)) {
+    return undefined
+  }
+
+  return (error as { cause?: unknown }).cause
+}
+
+export function isRetriableTransactionConflict(error: unknown, seen = new Set<unknown>()): boolean {
+  if (seen.has(error)) {
     return false
   }
+  seen.add(error)
+
+  const message = readErrorMessage(error)?.toLowerCase()
+  if (
+    message?.includes('transaction conflict') ||
+    message?.includes('transaction read conflict') ||
+    message?.includes('read or write conflict') ||
+    message?.includes('write conflict') ||
+    message?.includes('resource busy') ||
+    message?.includes('this transaction can be retried')
+  ) {
+    return true
+  }
 
-  const message = error.message.toLowerCase()
-  return (
-    message.includes('transaction conflict') ||
-    message.includes('transaction read conflict') ||
-    message.includes('read or write conflict') ||
-    message.includes('write conflict') ||
-    message.includes('resource busy') ||
-    message.includes('this transaction can be retried')
-  )
+  const cause = readErrorCause(error)
+  return cause !== undefined && isRetriableTransactionConflict(cause, seen)
 }

package/src/queues/queue-factory.ts

@@ -42,6 +42,7 @@ interface QueueFactoryConfigBase {
   lockDuration?: number
   stalledInterval?: number
   maxStalledCount?: number
+  shutdownTimeoutMs?: number
   defaultJobOptions?: JobsOptions
   recycleSandboxChildren?: boolean
   connectionProvider: () => IORedis
@@ -285,7 +286,7 @@ function createQueueFactoryRuntime<TJob>(config: QueueFactoryConfigBase): {
       if ((config.recycleSandboxChildren ?? true) && workerConfig.processorPath) {
         attachSandboxChildRecycling(worker, config.displayName, logger)
       }
-      const shutdown = createWorkerShutdown(worker, config.displayName, logger)
+      const shutdown = createWorkerShutdown(worker, config.displayName, logger, config.shutdownTimeoutMs)
 
       if (registerSignals) {
         registerShutdownSignals({ name: config.displayName, shutdown, logger })

package/src/runtime/context-compaction/context-compaction-runtime.ts

@@ -1,4 +1,4 @@
-import { Schema, Effect } from 'effect'
+import { Duration, Schema, Effect, Schedule } from 'effect'
 
 import type { AiGatewayModels } from '../../ai-gateway/ai-gateway'
 import { makeContextCompactionAgentFactory } from '../../system-agents/context-compaction.agent'
@@ -22,6 +22,8 @@ import {
 } from './context-compaction-constants'
 
 const CONTEXT_COMPACTION_MAX_OUTPUT_TOKENS = 512
+const MEMORY_BLOCK_COMPACTION_RETRY_ATTEMPTS = 2
+const MEMORY_BLOCK_COMPACTION_RETRY_BASE_DELAY_MS = 100
 
 interface HelperModelRuntime {
   generateHelperStructured<T>(params: GenerateHelperStructuredParams<T>): Promise<T>
@@ -103,6 +105,13 @@ export function createWiredContextCompactionRuntime(deps: CreateContextCompactio
         messages: [{ role: 'user', content: buildMemoryBlockCompactionPrompt({ previousSummary, newEntriesText }) }],
         maxOutputTokens: CONTEXT_COMPACTION_MAX_OUTPUT_TOKENS,
       }),
+    ).pipe(
+      Effect.retry({
+        times: MEMORY_BLOCK_COMPACTION_RETRY_ATTEMPTS,
+        schedule: Schedule.jittered(
+          Schedule.exponential(Duration.millis(MEMORY_BLOCK_COMPACTION_RETRY_BASE_DELAY_MS), 2),
+        ),
+      }),
     )
   }
 

package/src/runtime/helper-model.ts

@@ -29,6 +29,7 @@ export interface HelperMessage {
 
 interface HelperAgentGenerateParams {
   messages: Array<{ role: 'user' | 'assistant'; content: string }>
+  abortSignal?: AbortSignal
   timeout?: TimeoutConfiguration
   onStepFinish?: ToolLoopAgentOnStepFinishCallback<ToolSet>
   onFinish?: ToolLoopAgentOnFinishCallback<ToolSet>
@@ -49,6 +50,7 @@ export interface GenerateHelperTextParams {
   temperature?: number
   maxOutputTokens?: number
   timeoutMs?: number
+  abortSignal?: AbortSignal
 }
 
 export interface GenerateHelperStructuredParams<T> extends Omit<GenerateHelperTextParams, 'tag'> {
@@ -149,12 +151,13 @@ function createHelperAgent(params: {
 function generateWithHelperAgent(
   tag: string,
   agent: HelperAgent,
-  params: { messages: HelperMessage[]; timeoutMs?: number },
+  params: { messages: HelperMessage[]; timeoutMs?: number; abortSignal?: AbortSignal },
 ): Effect.Effect<{ text?: unknown; output?: unknown }, AiGenerationError> {
   return Effect.tryPromise({
     try: () =>
       agent.generate({
         messages: toModelMessages(params.messages),
+        ...(params.abortSignal ? { abortSignal: params.abortSignal } : {}),
         ...(typeof params.timeoutMs === 'number' ? { timeout: params.timeoutMs } : {}),
       }),
     catch: (error) => formatGenerationError(tag, error),

package/src/services/queue-job.service.ts

@@ -56,8 +56,8 @@ const QueueJobAttemptRowSchema = z.object({
   updatedAt: z.coerce.date(),
 })
 
-const PERSISTENCE_MAX_ATTEMPTS = 4
-const PERSISTENCE_RETRY_BASE_DELAY_MS = 25
+const PERSISTENCE_MAX_ATTEMPTS = 8
+const PERSISTENCE_RETRY_BASE_DELAY_MS = 50
 
 export interface TrackedBullJobLike {
   queueName: string

package/src/workers/worker-utils.ts

@@ -108,13 +108,18 @@ export const attachWorkerEvents = (worker: Worker, name: string, logger: typeof
   })
 }
 
-export const createWorkerShutdown = (worker: Worker, name: string, logger: typeof chatLogger = chatLogger) => {
+export const createWorkerShutdown = (
+  worker: Worker,
+  name: string,
+  logger: typeof chatLogger = chatLogger,
+  timeoutMs = DEFAULT_SHUTDOWN_TIMEOUT_MS,
+) => {
   return () => {
     logger.info`Shutting down ${name} worker`
     return Effect.runPromise(
       Effect.asVoid(
         Effect.tryPromise({
-          try: () => closeWorkerWithTimeout(worker, name, logger),
+          try: () => closeWorkerWithTimeout(worker, name, logger, timeoutMs),
           catch: (cause) => new QueueWorkerError({ phase: 'close', cause }),
         }),
       ),