Enterprise agent platform for building, deploying, and operating AI teammates.
import { unwrapFinalAnswerContent } from "@/lib/final-answer"
type ResultMessageLike = {
id: string
role: string
isResult?: boolean
}
type TraceEventLike = {
event_id?: string
}
type WebSocketEventLike = {
type?: unknown
event_type?: unknown
data?: unknown
}
export type FinalAnswerStreamEventType =
| "final_answer_start"
| "final_answer_delta"
| "final_answer_end"
| "final_answer_error"
export type FinalAnswerStreamActionPayload = {
messageId: string
delta?: string
content?: string
status: "running" | "completed" | "failed" | "interrupted"
timestamp: string
executionSequence?: number
}
export const isStreamingFinalAnswerMessage = (message: ResultMessageLike): boolean => {
return (
message.role === "assistant" &&
message.isResult === true &&
message.id.startsWith("final_answer_")
)
}
export const isFinalAnswerStreamEventType = (
value: unknown,
): value is FinalAnswerStreamEventType => {
return (
value === "final_answer_start" ||
value === "final_answer_delta" ||
value === "final_answer_end" ||
value === "final_answer_error"
)
}
export const getWebSocketEventType = (
message: WebSocketEventLike,
): string | undefined => {
if (typeof message.type !== "string") {
return undefined
}
if (message.type !== "trace_event") {
return message.type
}
if (typeof message.event_type === "string") {
return message.event_type
}
const data =
message.data && typeof message.data === "object"
? (message.data as Record<string, unknown>)
: {}
return typeof data.event_type === "string" ? data.event_type : message.type
}
export const shouldBufferMessageForHistoricalReplay = ({
isReplaying,
isHistoryLoading,
message,
}: {
isReplaying: boolean
isHistoryLoading: boolean
message: WebSocketEventLike
}): boolean => {
if (!isReplaying) {
return false
}
const eventType = getWebSocketEventType(message)
if (isFinalAnswerStreamEventType(eventType)) {
return false
}
return isHistoryLoading || eventType === "historical_data_complete"
}
export const getFinalAnswerStreamMessageId = (
value: unknown,
): string | undefined => {
const data =
value && typeof value === "object"
? (value as Record<string, unknown>)
: {}
const result =
data.result && typeof data.result === "object"
? (data.result as Record<string, unknown>)
: {}
const candidates = [
data.stream_message_id,
data.streamMessageId,
result.stream_message_id,
result.streamMessageId,
]
for (const candidate of candidates) {
if (typeof candidate === "string" && candidate) {
return candidate
}
}
return undefined
}
export const mergeTraceEventsById = <T extends TraceEventLike>(
...eventGroups: Array<readonly T[] | undefined>
): T[] => {
const merged: T[] = []
const seenIds = new Set<string>()
for (const events of eventGroups) {
for (const event of events || []) {
const eventId = typeof event.event_id === "string" ? event.event_id : ""
if (eventId) {
if (seenIds.has(eventId)) {
continue
}
seenIds.add(eventId)
}
merged.push(event)
}
}
return merged
}
export const getFinalAnswerStreamActionPayload = ({
eventType,
eventData,
eventId,
timestamp,
fallbackMessageId,
executionSequence,
}: {
eventType: FinalAnswerStreamEventType
eventData: unknown
eventId?: unknown
timestamp?: unknown
fallbackMessageId?: string
executionSequence?: number
}): FinalAnswerStreamActionPayload | null => {
const data =
eventData && typeof eventData === "object"
? (eventData as Record<string, unknown>)
: {}
const nestedData =
data.data && typeof data.data === "object"
? (data.data as Record<string, unknown>)
: {}
const streamData = { ...nestedData, ...data }
const messageId = String(
streamData.message_id || eventId || fallbackMessageId || "",
)
if (!messageId) {
return null
}
const normalizedTimestamp = String(timestamp || new Date().toISOString())
if (eventType === "final_answer_start") {
return {
messageId,
executionSequence,
timestamp: normalizedTimestamp,
status: streamData.status === "interrupted" ? "interrupted" : "running",
}
}
if (eventType === "final_answer_delta") {
const delta = typeof streamData.delta === "string" ? streamData.delta : ""
if (!delta) {
return null
}
return {
messageId,
executionSequence,
delta,
timestamp: normalizedTimestamp,
status: "running",
}
}
if (eventType === "final_answer_error") {
const error = typeof streamData.error === "string" ? streamData.error : ""
return {
messageId,
executionSequence,
content: error,
timestamp: normalizedTimestamp,
status: "failed",
}
}
const content =
typeof streamData.content === "string"
? unwrapFinalAnswerContent(streamData.content)
: ""
return {
messageId,
executionSequence,
content,
timestamp: normalizedTimestamp,
status: "completed",
}
}