@lota-sdk/core 0.4.10 → 0.4.12

package/src/runtime/live-turn-trace.ts

@@ -0,0 +1,344 @@
+import type { AgentActivityData, ThinkingStepData } from '@lota-sdk/shared'
+import type { UIMessage, UIMessageStreamWriter } from 'ai'
+
+type StreamChunk<TMessage extends UIMessage> = Parameters<UIMessageStreamWriter<TMessage>['write']>[0]
+
+interface ReasoningBlockState {
+  pendingChunk: string
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return typeof value === 'object' && value !== null ? (value as Record<string, unknown>) : null
+}
+
+function readString(value: unknown): string | null {
+  return typeof value === 'string' && value.length > 0 ? value : null
+}
+
+function normalizeWhitespace(value: string): string {
+  return value.replace(/\s+/g, ' ').trim()
+}
+
+function clipThinkingTitle(value: string): string {
+  if (value.length <= 120) return value
+  return `${value.slice(0, 117).trimEnd()}...`
+}
+
+function normalizeThinkingTitle(value: string): string {
+  return clipThinkingTitle(normalizeWhitespace(value))
+}
+
+function sanitizeReasoningText(value: string): string {
+  return value.replace(/\[REDACTED\]/gi, '').replace(/\r\n/g, '\n')
+}
+
+function stripMarkdownTitleDecorators(line: string): string {
+  let value = line.trim()
+  value = value.replace(/^#{1,6}\s+/, '')
+  value = value.replace(/^\*\*(.+?)\*\*[:.]?$/, '$1')
+  value = value.replace(/^__(.+?)__[:.]?$/, '$1')
+  value = value.replace(/^`(.+?)`[:.]?$/, '$1')
+  value = value.replace(/[:\s]+$/, '')
+  return value.trim()
+}
+
+function readHeadingTitle(line: string): string | null {
+  const trimmed = line.trim()
+  if (/^#{1,6}\s+/.test(trimmed)) {
+    return stripMarkdownTitleDecorators(trimmed)
+  }
+  if (/^\*\*.+\*\*[:.]?$/.test(trimmed) || /^__.+__[:.]?$/.test(trimmed) || /^`.+`[:.]?$/.test(trimmed)) {
+    return stripMarkdownTitleDecorators(trimmed)
+  }
+  if (trimmed.length <= 90 && /^[A-Z0-9].*:\s*$/.test(trimmed)) {
+    return stripMarkdownTitleDecorators(trimmed)
+  }
+  return null
+}
+
+function readLeadLineTitle(line: string): string | null {
+  const trimmed = stripMarkdownTitleDecorators(line)
+  if (!trimmed) return null
+  if (trimmed.length > 90) return null
+  if (/[.!?]$/.test(trimmed)) return null
+  return trimmed
+}
+
+function readFirstCompleteSentence(chunk: string): string | null {
+  const compact = normalizeWhitespace(chunk)
+  if (!compact) return null
+  const sentenceMatch = compact.match(/^(.+?[.!?])(?:\s|$)/)
+  if (sentenceMatch?.[1]) {
+    return sentenceMatch[1]
+  }
+  return null
+}
+
+function isStableReasoningChunk(chunk: string, isLastChunk: boolean, isFinal: boolean): boolean {
+  if (!isLastChunk || isFinal) return true
+  if (chunk.includes('\n')) return true
+  return /[.!?:]\s*$/.test(chunk.trim())
+}
+
+export function extractThinkingTitlesFromReasoning(params: { text: string; isFinal?: boolean }): string[] {
+  const cleaned = sanitizeReasoningText(params.text).trim()
+  if (cleaned.length === 0) return []
+
+  const chunks = cleaned
+    .split(/\n{2,}/)
+    .map((chunk) => chunk.trim())
+    .filter((chunk) => chunk.length > 0)
+
+  const titles: string[] = []
+
+  for (const [index, chunk] of chunks.entries()) {
+    const isLastChunk = index === chunks.length - 1
+    if (!isStableReasoningChunk(chunk, isLastChunk, params.isFinal === true)) {
+      continue
+    }
+
+    const lines = chunk
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0)
+    if (lines.length === 0) continue
+
+    const headingTitle = readHeadingTitle(lines[0])
+    if (headingTitle) {
+      titles.push(normalizeThinkingTitle(headingTitle))
+      continue
+    }
+
+    if (lines.length > 1 || params.isFinal === true) {
+      const leadLineTitle = readLeadLineTitle(lines[0])
+      if (leadLineTitle) {
+        titles.push(normalizeThinkingTitle(leadLineTitle))
+        continue
+      }
+    }
+
+    const sentenceTitle = readFirstCompleteSentence(chunk)
+    if (sentenceTitle) {
+      titles.push(normalizeThinkingTitle(sentenceTitle))
+    }
+  }
+
+  return titles.filter((title) => title.length > 0)
+}
+
+function splitReasoningChunks(text: string, isFinal: boolean): { completedChunks: string[]; pendingChunk: string } {
+  const parts = text.split(/\n{2,}/)
+  if (isFinal) {
+    return { completedChunks: parts.map((part) => part.trim()).filter((part) => part.length > 0), pendingChunk: '' }
+  }
+
+  const completedChunks = parts
+    .slice(0, -1)
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0)
+  const pendingChunk = parts.at(-1)?.trimStart() ?? ''
+  return { completedChunks, pendingChunk }
+}
+
+function readChunkType<TMessage extends UIMessage>(chunk: StreamChunk<TMessage>): string | null {
+  return readString(asRecord(chunk)?.type)
+}
+
+function readChunkToolCallId<TMessage extends UIMessage>(chunk: StreamChunk<TMessage>): string | null {
+  const record = asRecord(chunk)
+  return readString(record?.toolCallId) ?? readString(record?.id)
+}
+
+function readChunkToolName<TMessage extends UIMessage>(chunk: StreamChunk<TMessage>): string | null {
+  return readString(asRecord(chunk)?.toolName)
+}
+
+function readChunkReasoningId<TMessage extends UIMessage>(chunk: StreamChunk<TMessage>): string | null {
+  return readString(asRecord(chunk)?.id)
+}
+
+function readChunkReasoningDelta<TMessage extends UIMessage>(chunk: StreamChunk<TMessage>): string | null {
+  return readString(asRecord(chunk)?.delta)
+}
+
+function readChunkErrorText<TMessage extends UIMessage>(chunk: StreamChunk<TMessage>): string | null {
+  const record = asRecord(chunk)
+  return readString(record?.errorText) ?? readString(record?.error)
+}
+
+export function createLiveTurnTraceStreamObserver<TMessage extends UIMessage>(params: {
+  traceId: string
+  writer: UIMessageStreamWriter<TMessage>
+  agentId?: string
+  agentName?: string
+}) {
+  const toolNamesByCallId = new Map<string, string>()
+  const startedToolIds = new Set<string>()
+  const completedToolIds = new Set<string>()
+  const reasoningBlocks = new Map<string, ReasoningBlockState>()
+  const emittedThinkingTitles = new Set<string>()
+  let activeThinkingStep: ThinkingStepData | null = null
+  let nextThinkingStepIndex = 0
+
+  const writeActivity = (data: AgentActivityData) => {
+    const chunk = {
+      type: 'data-agent-activity',
+      id: `agent-activity:${data.activityId}`,
+      data,
+      transient: true,
+    } as unknown as StreamChunk<TMessage>
+    params.writer.write(chunk)
+  }
+
+  const writeThinkingStep = (data: ThinkingStepData) => {
+    const chunk = {
+      type: 'data-thinking-step',
+      id: `thinking-step:${data.stepId}`,
+      data,
+      transient: true,
+    } as unknown as StreamChunk<TMessage>
+    params.writer.write(chunk)
+  }
+
+  const markThinkingStepDone = () => {
+    if (!activeThinkingStep) return
+    if (activeThinkingStep.status === 'done') return
+    activeThinkingStep = { ...activeThinkingStep, status: 'done' }
+    writeThinkingStep(activeThinkingStep)
+  }
+
+  const emitThinkingTitles = (titles: string[]) => {
+    for (const title of titles) {
+      const normalizedTitle = title.toLocaleLowerCase()
+      if (emittedThinkingTitles.has(normalizedTitle)) continue
+
+      markThinkingStepDone()
+
+      const nextStep: ThinkingStepData = {
+        traceId: params.traceId,
+        stepId: `${params.traceId}:thinking:${nextThinkingStepIndex}`,
+        index: nextThinkingStepIndex,
+        title,
+        status: 'streaming',
+      }
+      nextThinkingStepIndex += 1
+      emittedThinkingTitles.add(normalizedTitle)
+      activeThinkingStep = nextStep
+      writeThinkingStep(nextStep)
+    }
+  }
+
+  const emitToolPhase = (
+    phase: AgentActivityData['phase'],
+    toolCallId: string,
+    toolName: string,
+    errorText?: string,
+  ) => {
+    writeActivity({
+      traceId: params.traceId,
+      activityId: toolCallId,
+      kind: 'tool',
+      toolName,
+      toolCallId,
+      ...(params.agentId ? { agentId: params.agentId } : {}),
+      ...(params.agentName ? { agentName: params.agentName } : {}),
+      phase,
+      ...(errorText ? { errorText } : {}),
+    })
+  }
+
+  const startTool = (toolCallId: string, toolName: string) => {
+    if (!toolNamesByCallId.has(toolCallId)) {
+      toolNamesByCallId.set(toolCallId, toolName)
+    }
+    if (startedToolIds.has(toolCallId) || completedToolIds.has(toolCallId)) return
+    startedToolIds.add(toolCallId)
+    emitToolPhase('started', toolCallId, toolName)
+  }
+
+  const completeTool = (toolCallId: string, phase: 'completed' | 'failed', errorText?: string) => {
+    const toolName = toolNamesByCallId.get(toolCallId)
+    if (!toolName || completedToolIds.has(toolCallId)) return
+    completedToolIds.add(toolCallId)
+    emitToolPhase(phase, toolCallId, toolName, errorText)
+  }
+
+  const processReasoningText = (reasoningId: string, delta: string, isFinal: boolean) => {
+    const state = reasoningBlocks.get(reasoningId) ?? { pendingChunk: '' }
+    const nextBuffer = state.pendingChunk + sanitizeReasoningText(delta)
+    const { completedChunks, pendingChunk } = splitReasoningChunks(nextBuffer, isFinal)
+
+    for (const completedChunk of completedChunks) {
+      emitThinkingTitles(extractThinkingTitlesFromReasoning({ text: completedChunk, isFinal: true }))
+    }
+
+    if (!isFinal && pendingChunk.length > 0) {
+      emitThinkingTitles(extractThinkingTitlesFromReasoning({ text: pendingChunk, isFinal: false }))
+    }
+
+    if (isFinal) {
+      reasoningBlocks.delete(reasoningId)
+      return
+    }
+
+    reasoningBlocks.set(reasoningId, { pendingChunk })
+  }
+
+  return {
+    observeChunk(chunk: StreamChunk<TMessage>): void {
+      const chunkType = readChunkType(chunk)
+      if (!chunkType) return
+
+      switch (chunkType) {
+        case 'reasoning-delta': {
+          const reasoningId = readChunkReasoningId(chunk)
+          const delta = readChunkReasoningDelta(chunk)
+          if (!reasoningId || delta === null) return
+
+          processReasoningText(reasoningId, delta, false)
+          return
+        }
+
+        case 'reasoning-end': {
+          const reasoningId = readChunkReasoningId(chunk)
+          if (!reasoningId) return
+          processReasoningText(reasoningId, '', true)
+          markThinkingStepDone()
+          return
+        }
+
+        case 'tool-input-start':
+        case 'tool-input-available':
+        case 'tool-call': {
+          const toolCallId = readChunkToolCallId(chunk)
+          const toolName = readChunkToolName(chunk)
+          if (!toolCallId || !toolName) return
+          startTool(toolCallId, toolName)
+          return
+        }
+
+        case 'tool-output-available': {
+          const toolCallId = readChunkToolCallId(chunk)
+          if (!toolCallId) return
+          completeTool(toolCallId, 'completed')
+          return
+        }
+
+        case 'tool-output-error':
+        case 'tool-error': {
+          const toolCallId = readChunkToolCallId(chunk)
+          if (!toolCallId) return
+          completeTool(toolCallId, 'failed', readChunkErrorText(chunk) ?? undefined)
+          return
+        }
+
+        default:
+          return
+      }
+    },
+
+    finish(): void {
+      markThinkingStepDone()
+    },
+  }
+}

package/src/runtime/plugin-resolution.ts

@@ -1,9 +1,7 @@
 import { Schema, Effect } from 'effect'
 
-import { getPluginRuntime } from '../config/agent-defaults'
 import type { RecordIdRef } from '../db/record-id'
-import type { LotaRuntimeIndexedRepositoriesContext } from './runtime-extensions'
-import { getRuntimeAdapters } from './runtime-extensions'
+import type { LotaRuntimeAdapters, LotaRuntimeIndexedRepositoriesContext } from './runtime-extensions'
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null
@@ -44,14 +42,15 @@ function requireRecord(value: unknown, message: string): Effect.Effect<Record<st
 }
 
 function resolvePluginServiceEffect(
+  pluginRuntime: Record<string, unknown> | undefined,
   pluginName: string,
   serviceName: string,
   methodName: string,
 ): Effect.Effect<(...args: unknown[]) => PromiseLike<unknown>, PluginResolutionError> {
-  return Effect.fromNullishOr(getPluginRuntime()).pipe(
+  return Effect.fromNullishOr(pluginRuntime).pipe(
     Effect.mapError(() => configError(`Plugin runtime is not configured. Missing "${pluginName}" integration.`)),
-    Effect.flatMap((pluginRuntime) =>
-      requireRecord(pluginRuntime[pluginName], `Plugin "${pluginName}" is not configured in the current runtime.`),
+    Effect.flatMap((runtime) =>
+      requireRecord(runtime[pluginName], `Plugin "${pluginName}" is not configured in the current runtime.`),
     ),
     Effect.flatMap((plugin) =>
       requireRecord(plugin.services, `Plugin "${pluginName}" does not expose a services registry.`),
@@ -76,17 +75,26 @@ function resolvePluginServiceEffect(
 }
 
 function tryResolvePluginServiceEffect(
+  pluginRuntime: Record<string, unknown> | undefined,
   pluginName: string,
   serviceName: string,
   methodName: string,
 ): Effect.Effect<((...args: unknown[]) => PromiseLike<unknown>) | void, never, never> {
-  return Effect.catch(resolvePluginServiceEffect(pluginName, serviceName, methodName), () => Effect.void)
+  return Effect.catch(resolvePluginServiceEffect(pluginRuntime, pluginName, serviceName, methodName), () => Effect.void)
 }
 
-export function getLinearInstallationByOrgId(organizationId: RecordIdRef): Promise<unknown> {
+export function getLinearInstallationByOrgId(
+  pluginRuntime: Record<string, unknown> | undefined,
+  organizationId: RecordIdRef,
+): Promise<unknown> {
   return Effect.runPromise(
     Effect.gen(function* () {
-      const fn = yield* tryResolvePluginServiceEffect('linear', 'linearService', 'getInstallationByOrgId')
+      const fn = yield* tryResolvePluginServiceEffect(
+        pluginRuntime,
+        'linear',
+        'linearService',
+        'getInstallationByOrgId',
+      )
       if (!fn) return null
       return yield* Effect.tryPromise({
         try: () => fn(organizationId),
@@ -96,10 +104,18 @@ export function getLinearInstallationByOrgId(organizationId: RecordIdRef): Promi
   )
 }
 
-export function getGithubInstallationForOrganization(organizationId: string): Promise<unknown> {
+export function getGithubInstallationForOrganization(
+  pluginRuntime: Record<string, unknown> | undefined,
+  organizationId: string,
+): Promise<unknown> {
   return Effect.runPromise(
     Effect.gen(function* () {
-      const fn = yield* tryResolvePluginServiceEffect('github', 'githubService', 'getInstallationForOrganization')
+      const fn = yield* tryResolvePluginServiceEffect(
+        pluginRuntime,
+        'github',
+        'githubService',
+        'getInstallationForOrganization',
+      )
       if (!fn) return null
       return yield* Effect.tryPromise({
         try: () => fn(organizationId),
@@ -116,9 +132,10 @@ const EMPTY_INDEXED_REPO_CONTEXT: LotaRuntimeIndexedRepositoriesContext = {
 }
 
 export function buildIndexedRepositoriesContext(
+  adapters: LotaRuntimeAdapters,
   organizationId: string,
 ): Promise<LotaRuntimeIndexedRepositoriesContext> {
-  const buildContext = getRuntimeAdapters().buildIndexedRepositoriesContext
+  const buildContext = adapters.buildIndexedRepositoriesContext
   if (!buildContext) return Promise.resolve(EMPTY_INDEXED_REPO_CONTEXT)
   return Effect.runPromise(
     Effect.tryPromise({