@lota-sdk/core 0.4.3 → 0.4.5

package/infrastructure/schema/02_execution_plan.surql

@@ -86,7 +86,9 @@ DEFINE TABLE IF NOT EXISTS planRun SCHEMAFULL;
 DEFINE FIELD IF NOT EXISTS planSpecId ON TABLE planRun TYPE record<planSpec> REFERENCE ON DELETE CASCADE;
 DEFINE FIELD IF NOT EXISTS organizationId ON TABLE planRun TYPE record<organization>;
 DEFINE FIELD IF NOT EXISTS threadId ON TABLE planRun TYPE record<thread> REFERENCE ON DELETE CASCADE;
+DEFINE FIELD IF NOT EXISTS sourceThreadId ON TABLE planRun TYPE option<record<thread>>;
 DEFINE FIELD IF NOT EXISTS leadAgentId ON TABLE planRun TYPE string;
+DEFINE FIELD IF NOT EXISTS createdByAgentId ON TABLE planRun TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS status ON TABLE planRun TYPE string;
 DEFINE FIELD IF NOT EXISTS currentNodeId ON TABLE planRun TYPE option<string>;
 DEFINE FIELD IF NOT EXISTS waitingNodeId ON TABLE planRun TYPE option<string>;
@@ -103,7 +105,9 @@ DEFINE FIELD IF NOT EXISTS completedAt ON TABLE planRun TYPE option<datetime>;
 
 DEFINE INDEX IF NOT EXISTS planRunOrgIdx ON TABLE planRun COLUMNS organizationId;
 DEFINE INDEX IF NOT EXISTS planRunThreadIdx ON TABLE planRun COLUMNS threadId;
+DEFINE INDEX IF NOT EXISTS planRunSourceThreadIdx ON TABLE planRun COLUMNS sourceThreadId;
 DEFINE INDEX IF NOT EXISTS planRunThreadStatusIdx ON TABLE planRun COLUMNS threadId, status;
+DEFINE INDEX IF NOT EXISTS planRunSourceThreadStatusIdx ON TABLE planRun COLUMNS sourceThreadId, status;
 DEFINE INDEX IF NOT EXISTS planRunSpecIdx ON TABLE planRun COLUMNS planSpecId;
 
 DEFINE TABLE IF NOT EXISTS planNodeRun SCHEMAFULL;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -32,7 +32,7 @@
     "@chat-adapter/slack": "^4.23.0",
     "@chat-adapter/state-ioredis": "^4.23.0",
     "@logtape/logtape": "^2.0.5",
-    "@lota-sdk/shared": "0.4.3",
+    "@lota-sdk/shared": "0.4.5",
     "@mendable/firecrawl-js": "^4.18.1",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.145",

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

@@ -305,17 +305,6 @@ export function injectAiGatewayExtraParamsRequestBody(
   return JSON.stringify({ ...parsed, extra_params: mergedExtraParams })
 }
 
-export function injectAiGatewayOpenAIPromptCacheRetentionRequestBody(
-  body: BodyInit | null | undefined,
-): BodyInit | null | undefined {
-  const parsed = parseAiGatewayJsonRequestBody(body)
-  if (!parsed) return body
-  if (!readString(parsed.model)?.startsWith('openai/')) return body
-  if (readString(parsed.prompt_cache_retention) !== null) return body
-
-  return JSON.stringify({ ...parsed, prompt_cache_retention: OPENAI_PROMPT_CACHE_RETENTION })
-}
-
 function createAiGatewayFetch(extraParams?: AiGatewayExtraParams): typeof fetch {
   const fetchWithMutations = (input: RequestInfo | URL, init?: RequestInit | BunFetchRequestInit) => {
     const parsedBody = parseAiGatewayJsonRequestBody(init?.body)

package/src/config/background-processing.ts

@@ -14,15 +14,6 @@ const DEFAULT_CONFIG: BackgroundProcessingConfig = {
 
 let resolvedConfig: BackgroundProcessingConfig = { ...DEFAULT_CONFIG }
 
-export function configureBackgroundProcessing(config?: Partial<BackgroundProcessingConfig>): void {
-  resolvedConfig = {
-    memoryExtractionFrequency: config?.memoryExtractionFrequency ?? DEFAULT_CONFIG.memoryExtractionFrequency,
-    skillExtractionFrequency: config?.skillExtractionFrequency ?? DEFAULT_CONFIG.skillExtractionFrequency,
-    memoryDigestFrequency: config?.memoryDigestFrequency ?? DEFAULT_CONFIG.memoryDigestFrequency,
-    memoryConsolidationFrequency: config?.memoryConsolidationFrequency ?? DEFAULT_CONFIG.memoryConsolidationFrequency,
-  }
-}
-
 export function getBackgroundProcessingConfig(): BackgroundProcessingConfig {
   return resolvedConfig
 }

package/src/config/model-constants.ts

@@ -8,7 +8,6 @@ export {
   OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS,
   OPENROUTER_MEDIUM_REASONING_PROVIDER_OPTIONS,
   OPENROUTER_MINIMAL_REASONING_PROVIDER_OPTIONS,
-  OPENROUTER_STRUCTURED_REASONING_MODEL_ID,
   OPENROUTER_TEAM_AGENT_MODEL_ID,
   OPENROUTER_WEB_RESEARCH_MODEL_ID,
   OPENROUTER_XHIGH_REASONING_PROVIDER_OPTIONS,

package/src/create-runtime.ts

@@ -2,7 +2,6 @@ import type { ChatMessage } from '@lota-sdk/shared'
 
 import { configureEmbeddingCache } from './ai/embedding-cache'
 import { configureAgentFactory, configureAgents } from './config/agent-defaults'
-import { configureBackgroundProcessing } from './config/background-processing'
 import { configureLotaLogger } from './config/logger'
 import { configureThreads } from './config/thread-defaults'
 import { ensureRecordId } from './db/record-id'
@@ -251,7 +250,6 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
     const redisManager = createRedisConnectionManager({ url: runtimeConfig.redis.url })
     setRedisConnectionManager(redisManager)
     configureEmbeddingCache(redisManager.getConnection(), runtimeConfig.memory.embeddingCacheTtlSeconds)
-    configureBackgroundProcessing()
     configureSocialChatHistory({ keyPrefix: runtimeConfig.socialChat?.historyRedisKeyPrefix })
 
     const socialChatAgentId = runtimeConfig.socialChat?.agentId?.trim() || 'socialChat'

package/src/db/service.ts

@@ -44,8 +44,6 @@ export interface SurrealDatabaseLogger {
   error?: (message: string) => void
 }
 
-export type BoundQueryLike = { query: string; bindings?: Record<string, unknown> }
-
 interface FindManyOptions {
   limit?: number
   offset?: number
@@ -91,18 +89,6 @@ function configureMutation(
   return builder.merge(data)
 }
 
-function isBoundQueryLike(value: unknown): value is BoundQueryLike {
-  if (!isRecord(value)) {
-    return false
-  }
-
-  if (typeof value.query !== 'string') {
-    return false
-  }
-
-  return value.bindings === undefined || isRecord(value.bindings)
-}
-
 const CONNECT_MAX_ATTEMPTS = 5
 const CONNECT_RETRY_BASE_DELAY_MS = 100
 const CONNECT_RETRY_JITTER_MS = 50
@@ -396,11 +382,7 @@ export class SurrealDBService {
     return { clause: clauses.join(' AND '), bindings }
   }
 
-  private normalizeBoundQuery(query: BoundQuery | BoundQueryLike): BoundQuery {
-    if (!(query instanceof BoundQuery) && !isBoundQueryLike(query)) {
-      throw new SurrealDBError('Invalid query object: expected a BoundQuery-like value')
-    }
-
+  private normalizeBoundQuery(query: BoundQuery): BoundQuery {
     return new BoundQuery(query.query, this.normalizeBindings(query.bindings))
   }
 
@@ -533,7 +515,7 @@ export class SurrealDBService {
   private wrapTransaction(tx: SurrealTransaction): DatabaseTransaction {
     return {
       query: async (query: unknown) => {
-        const boundQuery = this.normalizeBoundQuery(query as BoundQuery | BoundQueryLike)
+        const boundQuery = this.normalizeBoundQuery(query as BoundQuery)
         const queryText = this.resolveQueryText(boundQuery)
 
         try {
@@ -578,16 +560,16 @@ export class SurrealDBService {
     }
   }
 
-  private resolveQueryText(query: BoundQuery | BoundQueryLike): string {
+  private resolveQueryText(query: BoundQuery): string {
     return query.query
   }
 
-  async query<T>(query: BoundQuery | BoundQueryLike): Promise<T[]> {
+  async query<T>(query: BoundQuery): Promise<T[]> {
     const statements = await this.queryAll<T>(query)
     return statements.at(0) ?? []
   }
 
-  async queryAll<T>(query: BoundQuery | BoundQueryLike, schema?: z.ZodTypeAny): Promise<T[][]> {
+  async queryAll<T>(query: BoundQuery, schema?: z.ZodTypeAny): Promise<T[][]> {
     const client = await this.ensureConnected()
     const boundQuery = this.normalizeBoundQuery(query)
     const queryText = this.resolveQueryText(boundQuery)
@@ -607,13 +589,13 @@ export class SurrealDBService {
     }
   }
 
-  async queryOne<T extends z.ZodTypeAny>(query: BoundQuery | BoundQueryLike, schema: T): Promise<z.infer<T> | null> {
+  async queryOne<T extends z.ZodTypeAny>(query: BoundQuery, schema: T): Promise<z.infer<T> | null> {
     const results = await this.query<unknown>(query)
     const first = results.at(0)
     return first ? this.parseSchema(schema, first) : null
   }
 
-  async queryMany<T extends z.ZodTypeAny>(query: BoundQuery | BoundQueryLike, schema: T): Promise<z.infer<T>[]> {
+  async queryMany<T extends z.ZodTypeAny>(query: BoundQuery, schema: T): Promise<z.infer<T>[]> {
     const results = await this.query<unknown>(query)
     return results.map((row) => this.parseSchema(schema, row))
   }

package/src/queues/autonomous-job.queue.ts

@@ -129,10 +129,6 @@ export function startAutonomousJobWorker(options: AutonomousJobWorkerOptions = {
   return handle
 }
 
-export function getAutonomousJobQueueHandle(): WorkerHandle {
-  return startAutonomousJobWorker()
-}
-
 if (import.meta.main) {
   startAutonomousJobWorker()
 }

package/src/runtime/execution-plan.ts

@@ -16,9 +16,7 @@ function toExecutionPlanPromptSummaries(plans: SerializableExecutionPlan[]): Exe
   return plans.map(({ runId, title }) => ({ runId, title }))
 }
 
-function formatExecutionPlansForPrompt(plans: SerializableExecutionPlan[]): string | undefined {
-  if (plans.length === 0) return undefined
-
+function formatExecutionPlansForPrompt(plans: SerializableExecutionPlan[]): string {
   const payload = { activePlans: toExecutionPlanPromptSummaries(plans), planCount: plans.length }
 
   return ['<execution-plan-state>', JSON.stringify(payload, null, 2), '</execution-plan-state>'].join('\n')
@@ -26,10 +24,7 @@ function formatExecutionPlansForPrompt(plans: SerializableExecutionPlan[]): stri
 
 export function buildExecutionPlanInstructionSections(plans: SerializableExecutionPlan[] | null | undefined): string[] {
   const normalized = plans ?? []
-  const sections = [EXECUTION_PLAN_AGENT_PROTOCOL_PROMPT]
-  const stateSection = formatExecutionPlansForPrompt(normalized)
-  if (stateSection) sections.push(stateSection)
-  return sections
+  return [EXECUTION_PLAN_AGENT_PROTOCOL_PROMPT, formatExecutionPlansForPrompt(normalized)]
 }
 
 export function createExecutionPlanInstructionSectionCache(params: {

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

@@ -41,6 +41,14 @@ type AgentActivityDeps = {
   threadService: Pick<typeof threadService, 'listThreads'>
 }
 
+function isPendingPlanApproval(plan: SerializableExecutionPlan): boolean {
+  return plan.status === 'pending-approval'
+}
+
+function countPendingPlanApprovals(activePlans: ActivePlanEntry[]): number {
+  return activePlans.filter(({ plan }) => isPendingPlanApproval(plan)).length
+}
+
 function normalizeCardStatus(status: string): BoardColumnStatus {
   if (status === 'pending' || status === 'scheduled') return 'ready'
   if (status === 'partial') return 'completed'
@@ -145,9 +153,9 @@ export class AgentActivityService {
 
   async getBoard(userRef: string, orgRef: string): Promise<PlanBoardResponse> {
     const activePlans = await this.getAllActivePlans(userRef, orgRef)
-    const cards = activePlans.flatMap(({ plan, thread }) =>
-      plan.nodes.map((node) => planNodeToCard(node, plan, thread.id, thread.title)),
-    )
+    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,
@@ -161,7 +169,7 @@ export class AgentActivityService {
         totalNodes: cards.length,
         completedNodes: cards.filter((card) => card.status === 'completed').length,
         activePlanCount: activePlans.length,
-        pendingApprovalCount: cards.filter((card) => card.hasApproval).length,
+        pendingApprovalCount: countPendingPlanApprovals(activePlans) + cards.filter((card) => card.hasApproval).length,
       },
     }
   }
@@ -187,8 +195,13 @@ export class AgentActivityService {
   async getMyTasks(userRef: string, orgRef: string): Promise<MyTasksResponse> {
     const activePlans = await this.getAllActivePlans(userRef, orgRef)
     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'
@@ -198,7 +211,7 @@ export class AgentActivityService {
       }
     }
 
-    return { tasks, pendingApprovalCount: tasks.filter((task) => task.hasApproval).length }
+    return { tasks, pendingApprovalCount: pendingPlanApprovalCount + tasks.filter((task) => task.hasApproval).length }
   }
 
   async getAgentActivity(userRef: string, orgRef: string): Promise<AgentActivityResponse> {
@@ -210,6 +223,23 @@ export class AgentActivityService {
     }
 
     for (const { plan, thread } of activePlans) {
+      if (isPendingPlanApproval(plan)) {
+        if (plan.leadAgentId.trim()) {
+          const leadEntry = this.ensureEntry(activityByAgent, plan.leadAgentId)
+          leadEntry.isLeadingActivePlan = true
+          this.ensureProjectEntry(leadEntry.projects, {
+            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
+      }
+
       const involvedAgents = new Set<string>()
 
       for (const node of plan.nodes) {

package/src/services/artifact.service.ts

@@ -7,6 +7,7 @@ import type {
   GetArtifactResult,
   PublishArtifactArgs,
 } from '@lota-sdk/shared'
+import { BoundQuery } from 'surrealdb'
 
 import type { RecordIdInput } from '../db/record-id'
 import { ensureRecordId, recordIdToString } from '../db/record-id'
@@ -270,25 +271,25 @@ class ArtifactService {
 
     let lastError: unknown = null
     for (let attempt = 1; attempt <= ARTIFACT_PUBLISH_MAX_ATTEMPTS; attempt += 1) {
-      let pendingStorageKey: string | null = null
+      const publishAttemptState: { pendingStorageKey?: string } = {}
       try {
         return await databaseService.withTransaction(
           async (tx) =>
             await this.publishArtifactInTransaction(params, tx, {
               onStorageWrite: (storageKey) => {
-                pendingStorageKey = storageKey
+                publishAttemptState.pendingStorageKey = storageKey
               },
               onStorageCleanup: (storageKey) => {
-                if (pendingStorageKey === storageKey) {
-                  pendingStorageKey = null
+                if (publishAttemptState.pendingStorageKey === storageKey) {
+                  publishAttemptState.pendingStorageKey = undefined
                 }
               },
             }),
         )
       } catch (error) {
-        const storageKeyToCleanup = pendingStorageKey
-        pendingStorageKey = null
-        if (storageKeyToCleanup !== null) {
+        const storageKeyToCleanup = publishAttemptState.pendingStorageKey
+        publishAttemptState.pendingStorageKey = undefined
+        if (typeof storageKeyToCleanup === 'string') {
           await generatedDocumentStorageService.deleteTextArtifact(storageKeyToCleanup).catch(() => undefined)
         }
         lastError = error
@@ -361,13 +362,10 @@ class ArtifactService {
   async listBacklinks(artifact: Pick<ArtifactRecord, 'id' | 'organizationId'>): Promise<ArtifactRecord[]> {
     const artifactId = recordIdToString(artifact.id, TABLES.ARTIFACT)
     const records = await databaseService.queryMany(
-      {
-        query: `SELECT * FROM ${TABLES.ARTIFACT} WHERE organizationId = $organizationId AND references[*].targetId CONTAINS $targetId`,
-        bindings: {
-          organizationId: ensureRecordId(artifact.organizationId, TABLES.ORGANIZATION),
-          targetId: artifactId,
-        },
-      },
+      new BoundQuery(
+        `SELECT * FROM ${TABLES.ARTIFACT} WHERE organizationId = $organizationId AND references[*].targetId CONTAINS $targetId`,
+        { organizationId: ensureRecordId(artifact.organizationId, TABLES.ORGANIZATION), targetId: artifactId },
+      ),
       ArtifactRecordSchema,
     )
     return records

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

@@ -22,7 +22,7 @@ import type {
 } from '@lota-sdk/shared'
 import type { Job } from 'bullmq'
 import { CronExpressionParser } from 'cron-parser'
-import { RecordId } from 'surrealdb'
+import { BoundQuery, RecordId } from 'surrealdb'
 import { z } from 'zod'
 
 import { ensureRecordId, recordIdToString } from '../db/record-id'
@@ -262,17 +262,14 @@ class AutonomousJobService {
 
   private async findRecoverableRunRow(autonomousJobId: RecordIdInput): Promise<AutonomousJobRunRow | null> {
     const rows = await databaseService.queryMany(
-      {
-        query: `SELECT * FROM ${TABLES.AUTONOMOUS_JOB_RUN}
+      new BoundQuery(
+        `SELECT * FROM ${TABLES.AUTONOMOUS_JOB_RUN}
           WHERE autonomousJobId = $autonomousJobId
             AND status IN $statuses
           ORDER BY createdAt DESC
           LIMIT 1`,
-        bindings: {
-          autonomousJobId: ensureRecordId(autonomousJobId, TABLES.AUTONOMOUS_JOB),
-          statuses: ['queued', 'running'],
-        },
-      },
+        { autonomousJobId: ensureRecordId(autonomousJobId, TABLES.AUTONOMOUS_JOB), statuses: ['queued', 'running'] },
+      ),
       AutonomousJobRunRowSchema,
     )
 
@@ -371,10 +368,9 @@ class AutonomousJobService {
   async recoverActiveJobs(now = new Date()): Promise<void> {
     await databaseService.connect()
     const activeRows = await databaseService.queryMany(
-      {
-        query: `SELECT * FROM ${TABLES.AUTONOMOUS_JOB} WHERE status = $status ORDER BY createdAt ASC`,
-        bindings: { status: 'active' },
-      },
+      new BoundQuery(`SELECT * FROM ${TABLES.AUTONOMOUS_JOB} WHERE status = $status ORDER BY createdAt ASC`, {
+        status: 'active',
+      }),
       AutonomousJobRowSchema,
     )