@lota-sdk/core 0.4.8 → 0.4.10

package/src/runtime/team-consultation-orchestrator.ts

@@ -1,272 +0,0 @@
-import { ConsultTeamArgsSchema, withMessageCreatedAt } from '@lota-sdk/shared'
-import type { ChatMessage, ConsultTeamResultData } from '@lota-sdk/shared'
-import { convertToModelMessages, tool as createTool } from 'ai'
-
-import { agentDisplayNames, teamConsultParticipants } from '../config/agent-defaults'
-import { createTimedAbortSignal } from './agent-stream-helpers'
-import { buildModelInputMessagesWithUploadMetadata, buildReadableUploadMetadataText } from './chat-attachments'
-import type { ReadableUploadMetadataLike } from './chat-attachments'
-import type { RepoSectionName } from './indexed-repositories-policy'
-import { buildTeamConsultationFailureMessage } from './team-consultation-prompts'
-import { extractMessageText } from './thread-chat-helpers'
-
-export type DefaultRepoSections = RepoSectionName[]
-const TEAM_CONSULTATION_TIMEOUT_MS = 90_000
-
-function buildSnapshot(responses: ConsultTeamResultData['responses']): ConsultTeamResultData {
-  return { responses: responses.map((response) => ({ ...response })) }
-}
-
-function getConsultTeamOutput(output: unknown): ConsultTeamResultData | undefined {
-  if (output && typeof output === 'object' && Array.isArray((output as { responses?: unknown }).responses)) {
-    return output as ConsultTeamResultData
-  }
-
-  if (Array.isArray(output)) {
-    for (let index = output.length - 1; index >= 0; index -= 1) {
-      const candidate = getConsultTeamOutput(output[index])
-      if (candidate) return candidate
-    }
-  }
-
-  return undefined
-}
-
-function findLastUserMessage(
-  messages: ChatMessage[],
-  predicate: (message: ChatMessage) => boolean,
-): ChatMessage | null {
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const message = messages[index]
-    if (predicate(message)) {
-      return message
-    }
-  }
-
-  return null
-}
-
-function selectTeamConsultationContextMessages(messages: ChatMessage[], latestUserMessageId: string): ChatMessage[] {
-  const latestUserMessage =
-    findLastUserMessage(messages, (message) => message.id === latestUserMessageId && message.role === 'user') ??
-    findLastUserMessage(messages, (message) => message.role === 'user')
-
-  return latestUserMessage ? [latestUserMessage] : []
-}
-
-interface ParticipantObserver {
-  run<T>(fn: () => T | Promise<T>): Promise<T>
-  recordError?: (error: unknown) => void
-  recordAbort?: (error: unknown) => void
-}
-
-export interface TeamConsultationParticipantRunner {
-  buildParticipantAgent(
-    agentId: string,
-    params: {
-      task: string
-      systemWorkspaceDetails?: string
-      preSeededMemoriesSection?: string
-      retrievedKnowledgeSection?: string
-    },
-  ): Promise<{
-    agent: {
-      generate(params: Record<string, unknown>): Promise<{ text: string }>
-      stream(
-        params: Record<string, unknown>,
-      ): Promise<{
-        consumeStream(): unknown
-        toUIMessageStream(options: Record<string, unknown>): ReadableStream<unknown>
-      }>
-    }
-    observer: ParticipantObserver
-  }>
-}
-
-export interface CreateConsultTeamToolParams {
-  historyMessages: ChatMessage[]
-  latestUserMessageId: string
-  availableUploads: ReadableUploadMetadataLike[]
-  defaultRepoSectionsByAgent: Record<string, DefaultRepoSections | undefined>
-  systemWorkspaceDetails?: string
-  getPreSeededMemoriesSection: (agentId: string) => Promise<string | undefined>
-  retrievedKnowledgeSection?: string
-  displayNamesById?: Partial<Record<string, string>>
-  abortSignal: AbortSignal
-  participantRunner: TeamConsultationParticipantRunner
-  onReadError?: (agentId: string, error: unknown) => void
-}
-
-export function createConsultTeamTool(params: CreateConsultTeamToolParams) {
-  const resolveDisplayName = (agentId: string) => {
-    if (params.displayNamesById && Object.hasOwn(params.displayNamesById, agentId)) {
-      const override = params.displayNamesById[agentId]
-      if (override !== undefined) {
-        return override
-      }
-    }
-
-    return agentDisplayNames[agentId] ?? agentId
-  }
-  const participantNames = teamConsultParticipants
-    .map((agentId) => resolveDisplayName(agentId))
-    .filter((value) => value.trim().length > 0)
-  const participantSummary =
-    participantNames.length > 0 ? participantNames.join(', ') : 'the configured specialist participants'
-
-  return createTool({
-    description: `Consult the specialist team in parallel before replying. Use this when the answer benefits from structured input across ${participantSummary}.`,
-    inputSchema: ConsultTeamArgsSchema,
-    execute: async function* ({ task }) {
-      const uploadMetadataText = buildReadableUploadMetadataText(params.availableUploads)
-      const responses: ConsultTeamResultData['responses'] = teamConsultParticipants.map((agentId) => ({
-        agentId,
-        agentName: resolveDisplayName(agentId),
-        status: 'running',
-      }))
-      const queue: ConsultTeamResultData[] = []
-      let wake: (() => void) | undefined
-      let completedWorkers = 0
-      let fatalError: unknown
-
-      const pushSnapshot = () => {
-        queue.push(buildSnapshot(responses))
-        wake?.()
-        wake = undefined
-      }
-
-      const workerPromises = teamConsultParticipants.map(async (agentId, index) => {
-        const agentName = resolveDisplayName(agentId)
-        const timedAbort = createTimedAbortSignal(params.abortSignal, TEAM_CONSULTATION_TIMEOUT_MS)
-        let latestMessage: ChatMessage | null = null
-
-        try {
-          const { agent, observer } = await params.participantRunner.buildParticipantAgent(agentId, {
-            task,
-            systemWorkspaceDetails: params.systemWorkspaceDetails,
-            preSeededMemoriesSection: await params.getPreSeededMemoriesSection(agentId),
-            retrievedKnowledgeSection: params.retrievedKnowledgeSection,
-          })
-          const modelMessages = await convertToModelMessages(
-            buildModelInputMessagesWithUploadMetadata({
-              messages: selectTeamConsultationContextMessages(params.historyMessages, params.latestUserMessageId),
-              latestUserMessageId: params.latestUserMessageId,
-              uploadMetadataText,
-            }),
-            { ignoreIncompleteToolCalls: true },
-          )
-
-          let result: Awaited<ReturnType<typeof agent.generate>>
-          try {
-            result = await observer.run(() =>
-              agent.generate({
-                messages: modelMessages,
-                abortSignal: timedAbort.signal,
-                timeout: TEAM_CONSULTATION_TIMEOUT_MS,
-              }),
-            )
-          } catch (error) {
-            if (params.abortSignal.aborted || timedAbort.signal.aborted) {
-              observer.recordAbort?.(error)
-            } else {
-              observer.recordError?.(error)
-            }
-            throw error
-          }
-
-          const responseText = result.text.trim()
-          if (!responseText) {
-            throw new Error(`Team participant ${agentId} did not produce a response.`)
-          }
-
-          latestMessage = withMessageCreatedAt(
-            {
-              id: Bun.randomUUIDv7(),
-              role: 'assistant',
-              parts: [{ type: 'text', text: responseText }],
-              metadata: { agentId, agentName },
-            } satisfies ChatMessage,
-            Date.now(),
-          )
-
-          responses[index] = {
-            agentId,
-            agentName,
-            status: 'complete',
-            summary: extractMessageText(latestMessage).trim() || undefined,
-            message: latestMessage,
-          }
-          pushSnapshot()
-        } catch (error) {
-          if (params.abortSignal.aborted) {
-            fatalError = error
-            wake?.()
-            wake = undefined
-            return
-          }
-
-          responses[index] = {
-            agentId,
-            agentName,
-            status: 'error',
-            summary: latestMessage ? extractMessageText(latestMessage).trim() || undefined : undefined,
-            error: buildTeamConsultationFailureMessage(
-              agentName,
-              TEAM_CONSULTATION_TIMEOUT_MS,
-              timedAbort.didTimeout(),
-              error,
-            ),
-            ...(latestMessage ? { message: latestMessage } : {}),
-          }
-          pushSnapshot()
-        } finally {
-          timedAbort.dispose()
-          completedWorkers += 1
-          wake?.()
-          wake = undefined
-        }
-      })
-
-      pushSnapshot()
-
-      while (queue.length > 0 || completedWorkers < teamConsultParticipants.length) {
-        if (fatalError) {
-          await Promise.allSettled(workerPromises)
-          throw fatalError
-        }
-
-        if (queue.length === 0) {
-          await new Promise<void>((resolve) => {
-            wake = resolve
-          })
-          continue
-        }
-
-        const snapshot = queue.shift()
-        if (snapshot) {
-          yield snapshot
-        }
-      }
-
-      await Promise.all(workerPromises)
-      return buildSnapshot(responses)
-    },
-    toModelOutput: ({ output }) => {
-      const result = getConsultTeamOutput(output)
-      const summaryLines =
-        result?.responses
-          .map((response) => {
-            const summary =
-              typeof response.error === 'string' && response.error.trim().length > 0
-                ? response.error.trim()
-                : typeof response.summary === 'string' && response.summary.trim().length > 0
-                  ? response.summary.trim()
-                  : 'No response.'
-            return `${response.agentName}: ${summary}`
-          })
-          .join('\n') ?? 'Team consultation completed.'
-
-      return { type: 'text', value: summaryLines }
-    },
-  })
-}

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

@@ -1,152 +0,0 @@
-import type { PlaybookVersion, Recommendation } from '@lota-sdk/shared'
-import { PlaybookSchema, PlaybookVersionSchema } from '@lota-sdk/shared'
-
-import { ensureRecordId, recordIdToString } from '../db/record-id'
-import { databaseService } from '../db/service'
-import { TABLES } from '../db/tables'
-
-class AdaptivePlaybookService {
-  async refineFromCycle(params: {
-    playbookId: string
-    runId: string
-    recommendations: Recommendation[]
-    organizationId: string
-  }): Promise<PlaybookVersion> {
-    const playbook = await databaseService.findOne(
-      TABLES.PLAYBOOK,
-      { id: ensureRecordId(params.playbookId, TABLES.PLAYBOOK) },
-      PlaybookSchema,
-    )
-    if (!playbook) {
-      throw new Error(`Playbook not found: ${params.playbookId}`)
-    }
-
-    const currentVersion = await databaseService.findOne(
-      TABLES.PLAYBOOK_VERSION,
-      {
-        id: ensureRecordId(
-          recordIdToString(playbook.currentVersionId, TABLES.PLAYBOOK_VERSION),
-          TABLES.PLAYBOOK_VERSION,
-        ),
-      },
-      PlaybookVersionSchema,
-    )
-
-    const nextVersionNumber = currentVersion ? currentVersion.version + 1 : 1
-    const now = new Date()
-
-    const newVersion = await databaseService.create(
-      TABLES.PLAYBOOK_VERSION,
-      {
-        playbookId: ensureRecordId(params.playbookId, TABLES.PLAYBOOK),
-        version: nextVersionNumber,
-        parentVersionId: playbook.currentVersionId,
-        appliedRecommendations: params.recommendations.map((r) => r.description),
-        status: 'testing',
-        createdAt: now,
-      },
-      PlaybookVersionSchema,
-    )
-
-    await databaseService.update(
-      TABLES.PLAYBOOK,
-      ensureRecordId(params.playbookId, TABLES.PLAYBOOK),
-      {
-        currentVersionId: newVersion.id,
-        previousVersionId: playbook.currentVersionId,
-        cycleCount: playbook.cycleCount + 1,
-      },
-      PlaybookSchema,
-    )
-
-    return newVersion
-  }
-
-  evaluateRegression(params: { currentScore: number; previousScore: number; threshold?: number }): {
-    shouldRollback: boolean
-  } {
-    const threshold = params.threshold ?? 0.9
-    if (params.previousScore === 0) return { shouldRollback: false }
-    return { shouldRollback: params.currentScore < params.previousScore * threshold }
-  }
-
-  async rollback(params: {
-    playbookId: string
-    organizationId: string
-    maxLevels?: number
-  }): Promise<PlaybookVersion | null> {
-    const maxLevels = params.maxLevels ?? 3
-    return this.rollbackRecursive(params.playbookId, params.organizationId, maxLevels)
-  }
-
-  private async rollbackRecursive(
-    playbookId: string,
-    organizationId: string,
-    remainingLevels: number,
-  ): Promise<PlaybookVersion | null> {
-    if (remainingLevels <= 0) return null
-
-    const playbook = await databaseService.findOne(
-      TABLES.PLAYBOOK,
-      { id: ensureRecordId(playbookId, TABLES.PLAYBOOK) },
-      PlaybookSchema,
-    )
-    if (!playbook) return null
-
-    const currentVersion = await databaseService.findOne(
-      TABLES.PLAYBOOK_VERSION,
-      {
-        id: ensureRecordId(
-          recordIdToString(playbook.currentVersionId, TABLES.PLAYBOOK_VERSION),
-          TABLES.PLAYBOOK_VERSION,
-        ),
-      },
-      PlaybookVersionSchema,
-    )
-    if (!currentVersion?.parentVersionId) return null
-
-    // Mark current version as rolled-back
-    await databaseService.update(
-      TABLES.PLAYBOOK_VERSION,
-      ensureRecordId(recordIdToString(currentVersion.id, TABLES.PLAYBOOK_VERSION), TABLES.PLAYBOOK_VERSION),
-      { status: 'rolled-back' },
-      PlaybookVersionSchema,
-    )
-
-    // Restore parent version as active
-    const parentVersion = await databaseService.findOne(
-      TABLES.PLAYBOOK_VERSION,
-      {
-        id: ensureRecordId(
-          recordIdToString(currentVersion.parentVersionId, TABLES.PLAYBOOK_VERSION),
-          TABLES.PLAYBOOK_VERSION,
-        ),
-      },
-      PlaybookVersionSchema,
-    )
-    if (!parentVersion) return null
-
-    await databaseService.update(
-      TABLES.PLAYBOOK_VERSION,
-      ensureRecordId(recordIdToString(parentVersion.id, TABLES.PLAYBOOK_VERSION), TABLES.PLAYBOOK_VERSION),
-      { status: 'active' },
-      PlaybookVersionSchema,
-    )
-
-    await databaseService.update(
-      TABLES.PLAYBOOK,
-      ensureRecordId(playbookId, TABLES.PLAYBOOK),
-      { currentVersionId: parentVersion.id, previousVersionId: parentVersion.parentVersionId },
-      PlaybookSchema,
-    )
-
-    // Check if parent version is also regressed (caller can evaluate and re-invoke)
-    if (parentVersion.qualityScore !== undefined && parentVersion.qualityScore < 0.5) {
-      return this.rollbackRecursive(playbookId, organizationId, remainingLevels - 1)
-    }
-
-    return parentVersion
-  }
-}
-
-export const adaptivePlaybookService = new AdaptivePlaybookService()

package/src/services/artifact-provenance.service.ts

@@ -1,172 +0,0 @@
-import type { ImpactAnalysis, PlanNodeRunRecord, ProvenanceChain, ProvenanceNode } from '@lota-sdk/shared'
-
-import { recordIdToString } from '../db/record-id'
-
-class ArtifactProvenanceService {
-  /**
-   * Backward: trace which upstream nodes/artifacts produced the inputs for this artifact's node.
-   * From nodeId, follow edges upstream. At each upstream node, collect its artifacts.
-   * Continue until maxDepth or no more upstreams.
-   */
-  async traceBackward(params: { runId: string; nodeId: string; maxDepth?: number }): Promise<ProvenanceChain> {
-    const { planRunService } = await import('./plan-run.service')
-
-    const run = await planRunService.getRunById(params.runId)
-    const spec = await planRunService.getPlanSpecById(run.planSpecId)
-    const nodeSpecs = await planRunService.listNodeSpecs(spec.id)
-    const artifacts = await planRunService.listArtifacts(run.id)
-
-    const nodeSpecsByNodeId = new Map(nodeSpecs.map((n) => [n.nodeId, n]))
-    const artifactsByNodeId = new Map<string, typeof artifacts>()
-    for (const artifact of artifacts) {
-      const list = artifactsByNodeId.get(artifact.nodeId) ?? []
-      list.push(artifact)
-      artifactsByNodeId.set(artifact.nodeId, list)
-    }
-
-    const maxDepth = params.maxDepth ?? 10
-    const chain: ProvenanceNode[] = []
-    const visited = new Set<string>()
-    const queue: Array<{ nodeId: string; depth: number }> = [{ nodeId: params.nodeId, depth: 0 }]
-
-    while (queue.length > 0) {
-      const entry = queue.shift()
-      if (!entry || visited.has(entry.nodeId) || entry.depth > maxDepth) continue
-      visited.add(entry.nodeId)
-
-      const nodeSpec = nodeSpecsByNodeId.get(entry.nodeId)
-      if (!nodeSpec) continue
-
-      const nodeArtifacts = (artifactsByNodeId.get(entry.nodeId) ?? []).map((a) => ({
-        name: a.name,
-        kind: a.kind,
-        id: recordIdToString(a.id),
-      }))
-
-      chain.push({ nodeId: entry.nodeId, label: nodeSpec.label, artifacts: nodeArtifacts })
-
-      // Walk upstream
-      for (const upstreamId of nodeSpec.upstreamNodeIds) {
-        if (!visited.has(upstreamId)) {
-          queue.push({ nodeId: upstreamId, depth: entry.depth + 1 })
-        }
-      }
-    }
-
-    return { root: { nodeId: params.nodeId }, chain, depth: Math.max(0, chain.length - 1) }
-  }
-
-  /**
-   * Forward: trace which downstream nodes consume this artifact's node output.
-   * Same as backward but follow edges downstream.
-   */
-  async traceForward(params: { runId: string; nodeId: string; maxDepth?: number }): Promise<ProvenanceChain> {
-    const { planRunService } = await import('./plan-run.service')
-
-    const run = await planRunService.getRunById(params.runId)
-    const spec = await planRunService.getPlanSpecById(run.planSpecId)
-    const nodeSpecs = await planRunService.listNodeSpecs(spec.id)
-    const artifacts = await planRunService.listArtifacts(run.id)
-
-    const nodeSpecsByNodeId = new Map(nodeSpecs.map((n) => [n.nodeId, n]))
-    const artifactsByNodeId = new Map<string, typeof artifacts>()
-    for (const artifact of artifacts) {
-      const list = artifactsByNodeId.get(artifact.nodeId) ?? []
-      list.push(artifact)
-      artifactsByNodeId.set(artifact.nodeId, list)
-    }
-
-    const maxDepth = params.maxDepth ?? 10
-    const chain: ProvenanceNode[] = []
-    const visited = new Set<string>()
-    const queue: Array<{ nodeId: string; depth: number }> = [{ nodeId: params.nodeId, depth: 0 }]
-
-    while (queue.length > 0) {
-      const entry = queue.shift()
-      if (!entry || visited.has(entry.nodeId) || entry.depth > maxDepth) continue
-      visited.add(entry.nodeId)
-
-      const nodeSpec = nodeSpecsByNodeId.get(entry.nodeId)
-      if (!nodeSpec) continue
-
-      const nodeArtifacts = (artifactsByNodeId.get(entry.nodeId) ?? []).map((a) => ({
-        name: a.name,
-        kind: a.kind,
-        id: recordIdToString(a.id),
-      }))
-
-      chain.push({ nodeId: entry.nodeId, label: nodeSpec.label, artifacts: nodeArtifacts })
-
-      // Walk downstream
-      for (const downstreamId of nodeSpec.downstreamNodeIds) {
-        if (!visited.has(downstreamId)) {
-          queue.push({ nodeId: downstreamId, depth: entry.depth + 1 })
-        }
-      }
-    }
-
-    return { root: { nodeId: params.nodeId }, chain, depth: Math.max(0, chain.length - 1) }
-  }
-
-  /**
-   * Impact: which downstream nodes/artifacts would be affected.
-   * Forward traversal collecting all affected nodes and their artifacts.
-   * Includes non-completed nodes.
-   */
-  async analyzeImpact(params: { runId: string; nodeId: string }): Promise<ImpactAnalysis> {
-    const { planRunService } = await import('./plan-run.service')
-
-    const run = await planRunService.getRunById(params.runId)
-    const spec = await planRunService.getPlanSpecById(run.planSpecId)
-    const nodeSpecs = await planRunService.listNodeSpecs(spec.id)
-    const nodeRuns = await planRunService.listNodeRuns(run.id)
-    const artifacts = await planRunService.listArtifacts(run.id)
-
-    const nodeSpecsByNodeId = new Map(nodeSpecs.map((n) => [n.nodeId, n]))
-    const nodeRunsByNodeId = new Map(nodeRuns.map((n: PlanNodeRunRecord) => [n.nodeId, n]))
-
-    const affectedNodes: Array<{ nodeId: string; label: string; status: PlanNodeRunRecord['status'] }> = []
-    const affectedArtifacts: Array<{ name: string; nodeId: string }> = []
-
-    const visited = new Set<string>()
-    const queue: string[] = []
-
-    // Seed: downstream neighbors of the source node
-    const sourceSpec = nodeSpecsByNodeId.get(params.nodeId)
-    if (sourceSpec) {
-      for (const downstreamId of sourceSpec.downstreamNodeIds) {
-        queue.push(downstreamId)
-      }
-    }
-
-    while (queue.length > 0) {
-      const nodeId = queue.shift()
-      if (!nodeId || visited.has(nodeId)) continue
-      visited.add(nodeId)
-
-      const nodeSpec = nodeSpecsByNodeId.get(nodeId)
-      if (!nodeSpec) continue
-
-      const nodeRun = nodeRunsByNodeId.get(nodeId)
-      affectedNodes.push({ nodeId, label: nodeSpec.label, status: nodeRun?.status ?? 'pending' })
-
-      // Collect artifacts for this node
-      for (const artifact of artifacts.filter((a) => a.nodeId === nodeId)) {
-        affectedArtifacts.push({ name: artifact.name, nodeId })
-      }
-
-      // Continue downstream
-      for (const downstreamId of nodeSpec.downstreamNodeIds) {
-        if (!visited.has(downstreamId)) queue.push(downstreamId)
-      }
-    }
-
-    return {
-      sourceNodeId: params.nodeId,
-      affectedNodes: affectedNodes as ImpactAnalysis['affectedNodes'],
-      affectedArtifacts,
-    }
-  }
-}
-
-export const artifactProvenanceService = new ArtifactProvenanceService()

package/src/services/chat-attachments.service.ts

@@ -1,17 +0,0 @@
-import type { ChatMessage } from '@lota-sdk/shared'
-
-import type { RecordIdRef } from '../db/record-id'
-import { attachmentService } from './attachment.service'
-import type { ReadableUploadMetadata } from './attachment.service'
-
-export function listReadableUploadsFromChatMessages(params: {
-  messages: ChatMessage[]
-  orgId: RecordIdRef
-  userId: RecordIdRef
-}): ReadableUploadMetadata[] {
-  return attachmentService.listReadableUploadsFromMessages({
-    messages: params.messages.map((message) => ({ parts: message.parts as Array<Record<string, unknown>> })),
-    orgId: params.orgId,
-    userId: params.userId,
-  })
-}

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

@@ -1,13 +0,0 @@
-import { createWiredContextCompactionRuntime } from '../runtime/context-compaction-runtime'
-import { createHelperModelRuntime } from '../runtime/helper-model'
-
-const helperModelRuntime = createHelperModelRuntime()
-
-const wiredRuntime = createWiredContextCompactionRuntime({
-  helperModelRuntime,
-  now: () => Date.now(),
-  randomId: () => Bun.randomUUIDv7(),
-})
-
-export const contextCompactionRuntime = wiredRuntime
-export const compactMemoryBlockSummary = wiredRuntime.compactMemoryBlockSummary