@lota-sdk/core 0.1.23 → 0.1.25

package/src/services/memory-assessment.service.ts

@@ -1,44 +0,0 @@
-import type { z } from 'zod'
-
-import { MemoryImportanceAssessmentSchema } from '../db/memory-types'
-import { createHelperModelRuntime } from '../runtime/helper-model'
-import { createOrgMemoryAgent } from '../system-agents/memory.agent'
-import { clampImportance } from '../utils/string'
-
-type MemoryImportanceAssessment = z.infer<typeof MemoryImportanceAssessmentSchema>
-const MEMORY_IMPORTANCE_ASSESSMENT_TIMEOUT_MS = 10 * 60 * 1000
-const helperModelRuntime = createHelperModelRuntime()
-
-export function clampMemoryImportance(value: number): number {
-  return clampImportance(Math.max(0.2, Math.min(0.95, value)))
-}
-
-export async function assessMemoryImportance(params: {
-  content: string
-  targetScope: 'agent' | 'global'
-  tag?: string
-}): Promise<MemoryImportanceAssessment> {
-  const prompt = [
-    'Assess whether this memory should be persisted in long-term memory.',
-    `targetScope: ${params.targetScope}`,
-    `memory: ${params.content}`,
-    '',
-    'Rules:',
-    '- importance: number between 0 and 1 for long-term usefulness.',
-    '- durability: core|standard|ephemeral.',
-    '- classification: durable|transient|uncertain.',
-    '- rationale: short and concrete.',
-    '',
-    'The caller enforces a structured output schema.',
-    'Return only schema fields.',
-  ].join('\n')
-
-  return helperModelRuntime.generateHelperStructured({
-    tag: params.tag ?? 'memory-importance-assessment',
-    createAgent: createOrgMemoryAgent,
-    systemPrompt: 'You are a strict long-term memory quality assessor for an AI agent.',
-    messages: [{ role: 'user', content: prompt }],
-    schema: MemoryImportanceAssessmentSchema,
-    timeoutMs: MEMORY_IMPORTANCE_ASSESSMENT_TIMEOUT_MS,
-  })
-}

package/src/services/playbook-registry.service.ts

@@ -1,67 +0,0 @@
-import type { PlanTemplateRecord } from '@lota-sdk/shared'
-
-import type { RecordIdInput } from '../db/record-id'
-import type { PlaybookContribution } from '../runtime/plugin-types'
-import { getRuntimeConfig } from '../runtime/runtime-config'
-import { planTemplateService } from './plan-template.service'
-
-class PlaybookRegistryService {
-  collectPlaybooks(): PlaybookContribution[] {
-    const plugins = getRuntimeConfig().pluginRuntime ?? {}
-    const playbooks: PlaybookContribution[] = []
-    for (const plugin of Object.values(plugins)) {
-      if (plugin.playbookContributor?.playbooks) {
-        playbooks.push(...plugin.playbookContributor.playbooks)
-      }
-    }
-    return playbooks
-  }
-
-  async syncPlaybookTemplates(organizationId: RecordIdInput): Promise<PlanTemplateRecord[]> {
-    const playbooks = this.collectPlaybooks()
-    const templates: PlanTemplateRecord[] = []
-    const existing = await planTemplateService.listTemplates(organizationId, { source: 'playbook' })
-
-    for (const pb of playbooks) {
-      const match = existing.find((t) => t.sourceRef === pb.name)
-      if (match) {
-        const updated = await planTemplateService.updateTemplate(match.id, { draft: pb.draft, tags: pb.tags })
-        templates.push(updated)
-      } else {
-        const created = await planTemplateService.createTemplate({
-          organizationId,
-          name: pb.name,
-          description: pb.description,
-          draft: pb.draft,
-          tags: pb.tags,
-          source: 'playbook',
-          sourceRef: pb.name,
-        })
-        templates.push(created)
-      }
-    }
-
-    return templates
-  }
-
-  async instantiatePlaybook(params: {
-    name: string
-    organizationId: RecordIdInput
-    workstreamId: RecordIdInput
-    leadAgentId: string
-  }): Promise<unknown> {
-    const templates = await planTemplateService.listTemplates(params.organizationId, { source: 'playbook' })
-    const template = templates.find((t) => t.sourceRef === params.name)
-    if (!template) {
-      throw new Error(`Playbook "${params.name}" not found.`)
-    }
-    return planTemplateService.instantiate({
-      templateId: template.id,
-      organizationId: params.organizationId,
-      workstreamId: params.workstreamId,
-      leadAgentId: params.leadAgentId,
-    })
-  }
-}
-
-export const playbookRegistryService = new PlaybookRegistryService()

package/src/workers/regular-chat-memory-digest.worker.ts

@@ -1,22 +0,0 @@
-import type { SandboxedJob } from 'bullmq'
-
-import { serverLogger } from '../config/logger'
-import type { RegularChatMemoryDigestJob } from '../queues/regular-chat-memory-digest.queue'
-import { initializeSandboxedWorkerRuntime } from './bootstrap'
-import { runRegularChatMemoryDigest } from './regular-chat-memory-digest.runner'
-import { toSandboxedWorkerError } from './utils/sandbox-error'
-import { createTracedWorkerProcessor } from './worker-utils'
-
-await initializeSandboxedWorkerRuntime()
-
-const handler = async (job: SandboxedJob<RegularChatMemoryDigestJob>) => {
-  try {
-    await runRegularChatMemoryDigest(job.data)
-  } catch (error) {
-    const serialized = toSandboxedWorkerError(error, 'Regular chat memory digest failed')
-    serverLogger.error`${serialized.message}`
-    throw serialized
-  }
-}
-
-export default createTracedWorkerProcessor('regular-chat-memory-digest', handler)

package/src/workers/skill-extraction.worker.ts

@@ -1,22 +0,0 @@
-import type { SandboxedJob } from 'bullmq'
-
-import { serverLogger } from '../config/logger'
-import type { SkillExtractionJob } from '../queues/skill-extraction.queue'
-import { initializeSandboxedWorkerRuntime } from './bootstrap'
-import { runSkillExtraction } from './skill-extraction.runner'
-import { toSandboxedWorkerError } from './utils/sandbox-error'
-import { createTracedWorkerProcessor } from './worker-utils'
-
-await initializeSandboxedWorkerRuntime()
-
-const handler = async (job: SandboxedJob<SkillExtractionJob>) => {
-  try {
-    await runSkillExtraction(job.data)
-  } catch (error) {
-    const serialized = toSandboxedWorkerError(error, 'Skill extraction failed')
-    serverLogger.error`${serialized.message}`
-    throw serialized
-  }
-}
-
-export default createTracedWorkerProcessor('skill-extraction', handler)