@lota-sdk/ui 0.4.10 → 0.4.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/ui",
-  "version": "0.4.10",
+  "version": "0.4.12",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -25,8 +25,8 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@lota-sdk/shared": "0.4.10",
-    "ai": "^6.0.167"
+    "@lota-sdk/shared": "0.4.12",
+    "ai": "^6.0.168"
   },
   "peerDependencies": {
     "@ai-sdk/react": "^3.0.118",
@@ -34,8 +34,8 @@
     "react": "^19.2.0"
   },
   "devDependencies": {
-    "@ai-sdk/react": "^3.0.169",
-    "@tanstack/react-query": "^5.99.0",
+    "@ai-sdk/react": "^3.0.170",
+    "@tanstack/react-query": "^5.99.1",
     "@types/react": "^19.2.14",
     "react": "^19.2.5"
   }

package/src/runtime/index.ts

@@ -1,4 +1,5 @@
 export * from './active-thread-helpers'
+export * from './live-turn-trace'
 export * from './session-common'
 export * from './use-active-thread-session'
 export * from './use-session-messages'

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

@@ -0,0 +1,146 @@
+import { agentActivityDataSchema, multiAgentEventDataSchema, thinkingStepDataSchema } from '@lota-sdk/shared'
+import type { AgentActivityData } from '@lota-sdk/shared'
+
+export interface LiveTurnRoutingState {
+  phase: 'routing' | 'waiting-for-agent' | 'agent-message-persisted'
+  agentId?: string
+  agentName?: string
+  note?: string
+}
+
+export interface LiveTurnActivity {
+  id: string
+  traceId: string
+  kind: 'tool'
+  toolName: string
+  toolCallId?: string
+  agentId?: string
+  agentName?: string
+  status: 'running' | 'done' | 'error'
+  errorText?: string
+}
+
+export interface LiveTurnThinkingStep {
+  id: string
+  traceId: string
+  index: number
+  title: string
+  status: 'streaming' | 'done'
+}
+
+export interface LiveTurnTrace {
+  routing: LiveTurnRoutingState | null
+  activities: LiveTurnActivity[]
+  thinkingSteps: LiveTurnThinkingStep[]
+}
+
+export interface LiveTurnTraceDataPartLike {
+  type?: unknown
+  data?: unknown
+}
+
+export function createEmptyLiveTurnTrace(): LiveTurnTrace {
+  return { routing: null, activities: [], thinkingSteps: [] }
+}
+
+function toActivityStatus(phase: AgentActivityData['phase']): LiveTurnActivity['status'] {
+  if (phase === 'failed') return 'error'
+  if (phase === 'completed') return 'done'
+  return 'running'
+}
+
+function upsertActivity(current: LiveTurnActivity[], nextActivity: LiveTurnActivity): LiveTurnActivity[] {
+  const index = current.findIndex((activity) => activity.id === nextActivity.id)
+  if (index === -1) {
+    return [...current, nextActivity]
+  }
+
+  const updated = [...current]
+  updated[index] = { ...updated[index], ...nextActivity }
+  return updated
+}
+
+function upsertThinkingStep(current: LiveTurnThinkingStep[], nextStep: LiveTurnThinkingStep): LiveTurnThinkingStep[] {
+  const index = current.findIndex((step) => step.id === nextStep.id)
+  if (index === -1) {
+    return [...current, nextStep].sort((left, right) => left.index - right.index)
+  }
+
+  const updated = [...current]
+  updated[index] = { ...updated[index], ...nextStep }
+  return updated.sort((left, right) => left.index - right.index)
+}
+
+export function hasLiveTurnTrace(trace: LiveTurnTrace): boolean {
+  return trace.routing !== null || trace.activities.length > 0 || trace.thinkingSteps.length > 0
+}
+
+export function reduceLiveTurnTraceDataPart(
+  current: LiveTurnTrace,
+  dataPart: LiveTurnTraceDataPartLike,
+): LiveTurnTrace {
+  const partType = typeof dataPart.type === 'string' ? dataPart.type : ''
+  if (!partType.startsWith('data-')) {
+    return current
+  }
+
+  switch (partType) {
+    case 'data-multi-agent-event': {
+      const parsed = multiAgentEventDataSchema.safeParse(dataPart.data)
+      if (!parsed.success) return current
+
+      if (parsed.data.phase === 'complete') {
+        return createEmptyLiveTurnTrace()
+      }
+
+      return {
+        ...current,
+        routing: {
+          phase: parsed.data.phase,
+          ...(parsed.data.agentId ? { agentId: parsed.data.agentId } : {}),
+          ...(parsed.data.agentName ? { agentName: parsed.data.agentName } : {}),
+          ...(parsed.data.note ? { note: parsed.data.note } : {}),
+        },
+      }
+    }
+
+    case 'data-agent-activity': {
+      const parsed = agentActivityDataSchema.safeParse(dataPart.data)
+      if (!parsed.success) return current
+
+      return {
+        ...current,
+        activities: upsertActivity(current.activities, {
+          id: parsed.data.activityId,
+          traceId: parsed.data.traceId,
+          kind: parsed.data.kind,
+          toolName: parsed.data.toolName,
+          ...(parsed.data.toolCallId ? { toolCallId: parsed.data.toolCallId } : {}),
+          ...(parsed.data.agentId ? { agentId: parsed.data.agentId } : {}),
+          ...(parsed.data.agentName ? { agentName: parsed.data.agentName } : {}),
+          status: toActivityStatus(parsed.data.phase),
+          ...(parsed.data.errorText ? { errorText: parsed.data.errorText } : {}),
+        }),
+      }
+    }
+
+    case 'data-thinking-step': {
+      const parsed = thinkingStepDataSchema.safeParse(dataPart.data)
+      if (!parsed.success) return current
+
+      return {
+        ...current,
+        thinkingSteps: upsertThinkingStep(current.thinkingSteps, {
+          id: parsed.data.stepId,
+          traceId: parsed.data.traceId,
+          index: parsed.data.index,
+          title: parsed.data.title,
+          status: parsed.data.status,
+        }),
+      }
+    }
+
+    default:
+      return current
+  }
+}