685 lines
20 KiB
TypeScript
685 lines
20 KiB
TypeScript
"use client"
|
|
|
|
import {
|
|
createContext,
|
|
useCallback,
|
|
useContext,
|
|
useMemo,
|
|
useReducer,
|
|
type ReactNode,
|
|
} from "react"
|
|
import type { LiveMessage } from "@/contexts/acp-connections-context"
|
|
import type { DbConversationDetail, MessageTurn } from "@/lib/types"
|
|
import { inferLiveToolName } from "@/lib/tool-call-normalization"
|
|
|
|
export type ConversationSyncState =
|
|
| "idle"
|
|
| "awaiting_persist"
|
|
| "reconciling"
|
|
| "failed"
|
|
|
|
export type ConversationTimelinePhase = "persisted" | "optimistic" | "streaming"
|
|
|
|
export interface ConversationTimelineTurn {
|
|
key: string
|
|
turn: MessageTurn
|
|
phase: ConversationTimelinePhase
|
|
}
|
|
|
|
export interface ConversationRuntimeSession {
|
|
conversationId: number
|
|
externalId: string | null
|
|
persistedTurns: MessageTurn[]
|
|
optimisticTurns: MessageTurn[]
|
|
liveMessage: LiveMessage | null
|
|
syncState: ConversationSyncState
|
|
activeTurnToken: string | null
|
|
lastHydratedAt: number | null
|
|
lastPersistedAt: number | null
|
|
persistedUpdatedAt: string | null
|
|
persistedMessageCount: number
|
|
}
|
|
|
|
interface ConversationRuntimeState {
|
|
byConversationId: Map<number, ConversationRuntimeSession>
|
|
conversationIdByExternalId: Map<string, number>
|
|
}
|
|
|
|
const initialState: ConversationRuntimeState = {
|
|
byConversationId: new Map(),
|
|
conversationIdByExternalId: new Map(),
|
|
}
|
|
|
|
type Action =
|
|
| { type: "HYDRATE_FROM_DETAIL"; detail: DbConversationDetail }
|
|
| {
|
|
type: "APPEND_OPTIMISTIC_TURN"
|
|
conversationId: number
|
|
turn: MessageTurn
|
|
turnToken: string
|
|
}
|
|
| {
|
|
type: "SET_LIVE_MESSAGE"
|
|
conversationId: number
|
|
liveMessage: LiveMessage | null
|
|
}
|
|
| {
|
|
type: "ACK_PERSISTED_DETAIL"
|
|
conversationId: number
|
|
detail: DbConversationDetail
|
|
turnToken?: string | null
|
|
}
|
|
| {
|
|
type: "SET_EXTERNAL_ID"
|
|
conversationId: number
|
|
externalId: string | null
|
|
}
|
|
| {
|
|
type: "SET_SYNC_STATE"
|
|
conversationId: number
|
|
syncState: ConversationSyncState
|
|
}
|
|
| {
|
|
type: "MIGRATE_CONVERSATION"
|
|
fromConversationId: number
|
|
toConversationId: number
|
|
}
|
|
| { type: "REMOVE_CONVERSATION"; conversationId: number }
|
|
| { type: "RESET" }
|
|
|
|
function createEmptySession(
|
|
conversationId: number
|
|
): ConversationRuntimeSession {
|
|
return {
|
|
conversationId,
|
|
externalId: null,
|
|
persistedTurns: [],
|
|
optimisticTurns: [],
|
|
liveMessage: null,
|
|
syncState: "idle",
|
|
activeTurnToken: null,
|
|
lastHydratedAt: null,
|
|
lastPersistedAt: null,
|
|
persistedUpdatedAt: null,
|
|
persistedMessageCount: 0,
|
|
}
|
|
}
|
|
|
|
function formatLivePlanEntries(
|
|
entries: Array<{ content: string; priority: string; status: string }>
|
|
): string {
|
|
if (entries.length === 0) {
|
|
return "Plan updated."
|
|
}
|
|
const lines = entries.map(
|
|
(entry) => `- [${entry.status}] ${entry.content} (${entry.priority})`
|
|
)
|
|
return `Plan updated:\n${lines.join("\n")}`
|
|
}
|
|
|
|
function buildStreamingTurnFromLiveMessage(
|
|
conversationId: number,
|
|
liveMessage: LiveMessage
|
|
): MessageTurn | null {
|
|
const blocks: MessageTurn["blocks"] = []
|
|
|
|
for (const block of liveMessage.content) {
|
|
switch (block.type) {
|
|
case "text":
|
|
if (block.text.length > 0) {
|
|
blocks.push({ type: "text", text: block.text })
|
|
}
|
|
break
|
|
case "thinking":
|
|
if (block.text.length > 0) {
|
|
blocks.push({ type: "thinking", text: block.text })
|
|
}
|
|
break
|
|
case "plan": {
|
|
blocks.push({
|
|
type: "thinking",
|
|
text: formatLivePlanEntries(block.entries),
|
|
})
|
|
break
|
|
}
|
|
case "tool_call": {
|
|
const toolName = inferLiveToolName({
|
|
title: block.info.title,
|
|
kind: block.info.kind,
|
|
rawInput: block.info.raw_input,
|
|
})
|
|
blocks.push({
|
|
type: "tool_use",
|
|
tool_use_id: block.info.tool_call_id,
|
|
tool_name: toolName,
|
|
input_preview: block.info.raw_input,
|
|
})
|
|
const isFinalState =
|
|
block.info.status === "completed" || block.info.status === "failed"
|
|
if (isFinalState) {
|
|
blocks.push({
|
|
type: "tool_result",
|
|
tool_use_id: block.info.tool_call_id,
|
|
output_preview: block.info.raw_output ?? block.info.content,
|
|
is_error: block.info.status === "failed",
|
|
})
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if (blocks.length === 0) return null
|
|
|
|
return {
|
|
id: `live-${conversationId}-${liveMessage.id}`,
|
|
role: "assistant",
|
|
blocks,
|
|
timestamp: new Date(liveMessage.startedAt).toISOString(),
|
|
}
|
|
}
|
|
|
|
function shouldAcceptPersistedSnapshot(
|
|
current: ConversationRuntimeSession | undefined,
|
|
detail: DbConversationDetail
|
|
): boolean {
|
|
if (!current) return true
|
|
|
|
const nextUpdatedAt = detail.summary.updated_at ?? null
|
|
const nextMessageCount = detail.summary.message_count
|
|
const nextTurnCount = detail.turns.length
|
|
|
|
if (nextMessageCount < current.persistedMessageCount) return false
|
|
if (nextTurnCount < current.persistedTurns.length) return false
|
|
if (!current.persistedUpdatedAt || !nextUpdatedAt) return true
|
|
if (nextUpdatedAt < current.persistedUpdatedAt) return false
|
|
|
|
return true
|
|
}
|
|
|
|
function upsertExternalIdIndex(
|
|
index: Map<string, number>,
|
|
previousExternalId: string | null,
|
|
nextExternalId: string | null,
|
|
conversationId: number
|
|
): Map<string, number> {
|
|
const next = new Map(index)
|
|
if (previousExternalId) {
|
|
next.delete(previousExternalId)
|
|
}
|
|
if (nextExternalId) {
|
|
next.set(nextExternalId, conversationId)
|
|
}
|
|
return next
|
|
}
|
|
|
|
function reduceHydrateDetail(
|
|
state: ConversationRuntimeState,
|
|
conversationId: number,
|
|
detail: DbConversationDetail
|
|
): ConversationRuntimeState {
|
|
const current = state.byConversationId.get(conversationId)
|
|
const nextExternalId = detail.summary.external_id ?? null
|
|
const acceptSnapshot = shouldAcceptPersistedSnapshot(current, detail)
|
|
const prevPersistedTurnCount = current?.persistedTurns.length ?? 0
|
|
const prevPersistedMessageCount = current?.persistedMessageCount ?? 0
|
|
const optimisticTurns = current?.optimisticTurns ?? []
|
|
const persistedTurns = acceptSnapshot
|
|
? detail.turns
|
|
: (current?.persistedTurns ?? [])
|
|
const nextPersistedUpdatedAt = acceptSnapshot
|
|
? (detail.summary.updated_at ?? null)
|
|
: (current?.persistedUpdatedAt ?? null)
|
|
const nextPersistedMessageCount = acceptSnapshot
|
|
? detail.summary.message_count
|
|
: (current?.persistedMessageCount ?? 0)
|
|
const shouldDropOptimistic =
|
|
optimisticTurns.length > 0 &&
|
|
persistedTurns.length >= (current?.persistedTurns.length ?? 0) + 1
|
|
// Content advance: actual turns or messages grew — safe to clear
|
|
// liveMessage because persisted data now covers the streamed content.
|
|
const hasContentAdvance =
|
|
acceptSnapshot &&
|
|
(detail.turns.length > prevPersistedTurnCount ||
|
|
detail.summary.message_count > prevPersistedMessageCount)
|
|
// Note: updated_at changes (e.g. status update bumping the timestamp)
|
|
// are NOT treated as content advance. Only actual turns / message_count
|
|
// growth should clear liveMessage, because a metadata-only bump could
|
|
// arrive before the session file is flushed to disk.
|
|
|
|
const nextSession: ConversationRuntimeSession = {
|
|
...(current ?? createEmptySession(conversationId)),
|
|
externalId: nextExternalId,
|
|
persistedTurns,
|
|
liveMessage:
|
|
hasContentAdvance && current?.syncState !== "awaiting_persist"
|
|
? null
|
|
: (current?.liveMessage ?? null),
|
|
optimisticTurns: shouldDropOptimistic ? [] : optimisticTurns,
|
|
syncState: shouldDropOptimistic ? "idle" : (current?.syncState ?? "idle"),
|
|
activeTurnToken: shouldDropOptimistic
|
|
? null
|
|
: (current?.activeTurnToken ?? null),
|
|
lastHydratedAt: Date.now(),
|
|
lastPersistedAt: acceptSnapshot
|
|
? Date.now()
|
|
: (current?.lastPersistedAt ?? null),
|
|
persistedUpdatedAt: nextPersistedUpdatedAt,
|
|
persistedMessageCount: nextPersistedMessageCount,
|
|
}
|
|
|
|
const nextByConversationId = new Map(state.byConversationId)
|
|
nextByConversationId.set(conversationId, nextSession)
|
|
const nextExternalIndex = upsertExternalIdIndex(
|
|
state.conversationIdByExternalId,
|
|
current?.externalId ?? null,
|
|
nextExternalId,
|
|
conversationId
|
|
)
|
|
|
|
return {
|
|
byConversationId: nextByConversationId,
|
|
conversationIdByExternalId: nextExternalIndex,
|
|
}
|
|
}
|
|
|
|
function reducer(
|
|
state: ConversationRuntimeState,
|
|
action: Action
|
|
): ConversationRuntimeState {
|
|
switch (action.type) {
|
|
case "HYDRATE_FROM_DETAIL":
|
|
return reduceHydrateDetail(state, action.detail.summary.id, action.detail)
|
|
|
|
case "APPEND_OPTIMISTIC_TURN": {
|
|
const current =
|
|
state.byConversationId.get(action.conversationId) ??
|
|
createEmptySession(action.conversationId)
|
|
const nextSession: ConversationRuntimeSession = {
|
|
...current,
|
|
optimisticTurns: [...current.optimisticTurns, action.turn],
|
|
syncState: "awaiting_persist",
|
|
activeTurnToken: action.turnToken,
|
|
}
|
|
const nextByConversationId = new Map(state.byConversationId)
|
|
nextByConversationId.set(action.conversationId, nextSession)
|
|
return { ...state, byConversationId: nextByConversationId }
|
|
}
|
|
|
|
case "SET_LIVE_MESSAGE": {
|
|
const current =
|
|
state.byConversationId.get(action.conversationId) ??
|
|
createEmptySession(action.conversationId)
|
|
|
|
// Guard: prevent stale liveMessage from ACP reconnects overriding
|
|
// persisted data. When a session has no active liveMessage and no
|
|
// pending interaction (idle or reconciling without a live turn),
|
|
// a SET_LIVE_MESSAGE from a reconnected ACP connection carries
|
|
// the completed response that is already in persistedTurns.
|
|
// Accepting it would cause duplicate assistant text in the timeline.
|
|
if (
|
|
action.liveMessage !== null &&
|
|
current.liveMessage === null &&
|
|
current.syncState !== "awaiting_persist" &&
|
|
current.persistedTurns.length > 0
|
|
) {
|
|
return state
|
|
}
|
|
|
|
const nextSession: ConversationRuntimeSession = {
|
|
...current,
|
|
liveMessage: action.liveMessage,
|
|
}
|
|
const nextByConversationId = new Map(state.byConversationId)
|
|
nextByConversationId.set(action.conversationId, nextSession)
|
|
return { ...state, byConversationId: nextByConversationId }
|
|
}
|
|
|
|
case "ACK_PERSISTED_DETAIL": {
|
|
const nextState = reduceHydrateDetail(
|
|
state,
|
|
action.conversationId,
|
|
action.detail
|
|
)
|
|
const session = nextState.byConversationId.get(action.conversationId)
|
|
if (!session) return nextState
|
|
const nextSession: ConversationRuntimeSession = {
|
|
...session,
|
|
syncState: "idle",
|
|
activeTurnToken:
|
|
action.turnToken != null &&
|
|
action.turnToken === session.activeTurnToken
|
|
? null
|
|
: session.activeTurnToken,
|
|
}
|
|
const nextByConversationId = new Map(nextState.byConversationId)
|
|
nextByConversationId.set(action.conversationId, nextSession)
|
|
return { ...nextState, byConversationId: nextByConversationId }
|
|
}
|
|
|
|
case "SET_EXTERNAL_ID": {
|
|
const current =
|
|
state.byConversationId.get(action.conversationId) ??
|
|
createEmptySession(action.conversationId)
|
|
const nextSession: ConversationRuntimeSession = {
|
|
...current,
|
|
externalId: action.externalId,
|
|
}
|
|
const nextByConversationId = new Map(state.byConversationId)
|
|
nextByConversationId.set(action.conversationId, nextSession)
|
|
const nextExternalIndex = upsertExternalIdIndex(
|
|
state.conversationIdByExternalId,
|
|
current.externalId,
|
|
action.externalId,
|
|
action.conversationId
|
|
)
|
|
return {
|
|
byConversationId: nextByConversationId,
|
|
conversationIdByExternalId: nextExternalIndex,
|
|
}
|
|
}
|
|
|
|
case "SET_SYNC_STATE": {
|
|
const current =
|
|
state.byConversationId.get(action.conversationId) ??
|
|
createEmptySession(action.conversationId)
|
|
const nextSession: ConversationRuntimeSession = {
|
|
...current,
|
|
syncState: action.syncState,
|
|
}
|
|
const nextByConversationId = new Map(state.byConversationId)
|
|
nextByConversationId.set(action.conversationId, nextSession)
|
|
return { ...state, byConversationId: nextByConversationId }
|
|
}
|
|
|
|
case "MIGRATE_CONVERSATION": {
|
|
if (action.fromConversationId === action.toConversationId) return state
|
|
const from = state.byConversationId.get(action.fromConversationId)
|
|
if (!from) return state
|
|
const to =
|
|
state.byConversationId.get(action.toConversationId) ??
|
|
createEmptySession(action.toConversationId)
|
|
|
|
const preferFromSnapshot =
|
|
from.persistedTurns.length >= to.persistedTurns.length
|
|
const mergedLiveMessage = to.liveMessage ?? from.liveMessage
|
|
|
|
const merged: ConversationRuntimeSession = {
|
|
...to,
|
|
...from,
|
|
conversationId: action.toConversationId,
|
|
persistedTurns: preferFromSnapshot
|
|
? from.persistedTurns
|
|
: to.persistedTurns,
|
|
optimisticTurns: [...from.optimisticTurns, ...to.optimisticTurns],
|
|
liveMessage: mergedLiveMessage,
|
|
syncState: to.syncState !== "idle" ? to.syncState : from.syncState,
|
|
activeTurnToken: to.activeTurnToken ?? from.activeTurnToken,
|
|
lastHydratedAt:
|
|
Math.max(from.lastHydratedAt ?? 0, to.lastHydratedAt ?? 0) || null,
|
|
lastPersistedAt:
|
|
Math.max(from.lastPersistedAt ?? 0, to.lastPersistedAt ?? 0) || null,
|
|
persistedUpdatedAt:
|
|
(to.persistedUpdatedAt ?? "") > (from.persistedUpdatedAt ?? "")
|
|
? to.persistedUpdatedAt
|
|
: from.persistedUpdatedAt,
|
|
persistedMessageCount: Math.max(
|
|
from.persistedMessageCount,
|
|
to.persistedMessageCount
|
|
),
|
|
}
|
|
|
|
const nextByConversationId = new Map(state.byConversationId)
|
|
nextByConversationId.delete(action.fromConversationId)
|
|
nextByConversationId.set(action.toConversationId, merged)
|
|
|
|
const nextExternalIndex = new Map(state.conversationIdByExternalId)
|
|
for (const [externalId, conversationId] of nextExternalIndex.entries()) {
|
|
if (conversationId === action.fromConversationId) {
|
|
nextExternalIndex.set(externalId, action.toConversationId)
|
|
}
|
|
}
|
|
if (merged.externalId) {
|
|
nextExternalIndex.set(merged.externalId, action.toConversationId)
|
|
}
|
|
|
|
return {
|
|
byConversationId: nextByConversationId,
|
|
conversationIdByExternalId: nextExternalIndex,
|
|
}
|
|
}
|
|
|
|
case "REMOVE_CONVERSATION": {
|
|
const current = state.byConversationId.get(action.conversationId)
|
|
if (!current) return state
|
|
const nextByConversationId = new Map(state.byConversationId)
|
|
nextByConversationId.delete(action.conversationId)
|
|
const nextExternalIndex = new Map(state.conversationIdByExternalId)
|
|
if (current.externalId) {
|
|
nextExternalIndex.delete(current.externalId)
|
|
}
|
|
return {
|
|
byConversationId: nextByConversationId,
|
|
conversationIdByExternalId: nextExternalIndex,
|
|
}
|
|
}
|
|
|
|
case "RESET":
|
|
return initialState
|
|
}
|
|
}
|
|
|
|
interface ConversationRuntimeContextValue {
|
|
getSession: (conversationId: number) => ConversationRuntimeSession | null
|
|
getConversationIdByExternalId: (externalId: string) => number | null
|
|
getTimelineTurns: (conversationId: number) => ConversationTimelineTurn[]
|
|
hydrateFromDetail: (detail: DbConversationDetail) => void
|
|
appendOptimisticTurn: (
|
|
conversationId: number,
|
|
turn: MessageTurn,
|
|
turnToken: string
|
|
) => void
|
|
setLiveMessage: (
|
|
conversationId: number,
|
|
liveMessage: LiveMessage | null
|
|
) => void
|
|
acknowledgePersistedDetail: (
|
|
conversationId: number,
|
|
detail: DbConversationDetail,
|
|
turnToken?: string | null
|
|
) => void
|
|
setExternalId: (conversationId: number, externalId: string | null) => void
|
|
setSyncState: (
|
|
conversationId: number,
|
|
syncState: ConversationSyncState
|
|
) => void
|
|
migrateConversation: (
|
|
fromConversationId: number,
|
|
toConversationId: number
|
|
) => void
|
|
removeConversation: (conversationId: number) => void
|
|
reset: () => void
|
|
}
|
|
|
|
const ConversationRuntimeContext =
|
|
createContext<ConversationRuntimeContextValue | null>(null)
|
|
|
|
export function ConversationRuntimeProvider({
|
|
children,
|
|
}: {
|
|
children: ReactNode
|
|
}) {
|
|
const [state, dispatch] = useReducer(reducer, initialState)
|
|
|
|
const getSession = useCallback(
|
|
(conversationId: number) =>
|
|
state.byConversationId.get(conversationId) ?? null,
|
|
[state.byConversationId]
|
|
)
|
|
|
|
const getConversationIdByExternalId = useCallback(
|
|
(externalId: string) =>
|
|
state.conversationIdByExternalId.get(externalId) ?? null,
|
|
[state.conversationIdByExternalId]
|
|
)
|
|
|
|
const getTimelineTurns = useCallback(
|
|
(conversationId: number): ConversationTimelineTurn[] => {
|
|
const session = state.byConversationId.get(conversationId)
|
|
if (!session) return []
|
|
|
|
const persisted: ConversationTimelineTurn[] = session.persistedTurns.map(
|
|
(turn, index) => ({
|
|
key: `persisted-${conversationId}-${turn.id}-${index}`,
|
|
turn,
|
|
phase: "persisted",
|
|
})
|
|
)
|
|
const optimistic: ConversationTimelineTurn[] =
|
|
session.optimisticTurns.map((turn, index) => ({
|
|
key: `optimistic-${conversationId}-${turn.id}-${index}`,
|
|
turn,
|
|
phase: "optimistic",
|
|
}))
|
|
const streamingMessage = session.liveMessage
|
|
const streamingTurn = streamingMessage
|
|
? buildStreamingTurnFromLiveMessage(conversationId, streamingMessage)
|
|
: null
|
|
|
|
if (!streamingTurn) {
|
|
return [...persisted, ...optimistic]
|
|
}
|
|
|
|
return [
|
|
...persisted,
|
|
...optimistic,
|
|
{
|
|
key: `streaming-${conversationId}-${streamingMessage?.id ?? "unknown"}`,
|
|
turn: streamingTurn,
|
|
phase: "streaming",
|
|
},
|
|
]
|
|
},
|
|
[state.byConversationId]
|
|
)
|
|
|
|
const hydrateFromDetail = useCallback((detail: DbConversationDetail) => {
|
|
dispatch({ type: "HYDRATE_FROM_DETAIL", detail })
|
|
}, [])
|
|
|
|
const appendOptimisticTurn = useCallback(
|
|
(conversationId: number, turn: MessageTurn, turnToken: string) => {
|
|
dispatch({
|
|
type: "APPEND_OPTIMISTIC_TURN",
|
|
conversationId,
|
|
turn,
|
|
turnToken,
|
|
})
|
|
},
|
|
[]
|
|
)
|
|
|
|
const setLiveMessage = useCallback(
|
|
(conversationId: number, liveMessage: LiveMessage | null) => {
|
|
dispatch({ type: "SET_LIVE_MESSAGE", conversationId, liveMessage })
|
|
},
|
|
[]
|
|
)
|
|
|
|
const acknowledgePersistedDetail = useCallback(
|
|
(
|
|
conversationId: number,
|
|
detail: DbConversationDetail,
|
|
turnToken?: string | null
|
|
) => {
|
|
dispatch({
|
|
type: "ACK_PERSISTED_DETAIL",
|
|
conversationId,
|
|
detail,
|
|
turnToken,
|
|
})
|
|
},
|
|
[]
|
|
)
|
|
|
|
const setExternalId = useCallback(
|
|
(conversationId: number, externalId: string | null) => {
|
|
dispatch({ type: "SET_EXTERNAL_ID", conversationId, externalId })
|
|
},
|
|
[]
|
|
)
|
|
|
|
const setSyncState = useCallback(
|
|
(conversationId: number, syncState: ConversationSyncState) => {
|
|
dispatch({ type: "SET_SYNC_STATE", conversationId, syncState })
|
|
},
|
|
[]
|
|
)
|
|
|
|
const migrateConversation = useCallback(
|
|
(fromConversationId: number, toConversationId: number) => {
|
|
dispatch({
|
|
type: "MIGRATE_CONVERSATION",
|
|
fromConversationId,
|
|
toConversationId,
|
|
})
|
|
},
|
|
[]
|
|
)
|
|
|
|
const removeConversation = useCallback((conversationId: number) => {
|
|
dispatch({ type: "REMOVE_CONVERSATION", conversationId })
|
|
}, [])
|
|
|
|
const reset = useCallback(() => {
|
|
dispatch({ type: "RESET" })
|
|
}, [])
|
|
|
|
const value = useMemo<ConversationRuntimeContextValue>(
|
|
() => ({
|
|
getSession,
|
|
getConversationIdByExternalId,
|
|
getTimelineTurns,
|
|
hydrateFromDetail,
|
|
appendOptimisticTurn,
|
|
setLiveMessage,
|
|
acknowledgePersistedDetail,
|
|
setExternalId,
|
|
setSyncState,
|
|
migrateConversation,
|
|
removeConversation,
|
|
reset,
|
|
}),
|
|
[
|
|
getSession,
|
|
getConversationIdByExternalId,
|
|
getTimelineTurns,
|
|
hydrateFromDetail,
|
|
appendOptimisticTurn,
|
|
setLiveMessage,
|
|
acknowledgePersistedDetail,
|
|
setExternalId,
|
|
setSyncState,
|
|
migrateConversation,
|
|
removeConversation,
|
|
reset,
|
|
]
|
|
)
|
|
|
|
return (
|
|
<ConversationRuntimeContext.Provider value={value}>
|
|
{children}
|
|
</ConversationRuntimeContext.Provider>
|
|
)
|
|
}
|
|
|
|
export function useConversationRuntime() {
|
|
const ctx = useContext(ConversationRuntimeContext)
|
|
if (!ctx) {
|
|
throw new Error(
|
|
"useConversationRuntime must be used within ConversationRuntimeProvider"
|
|
)
|
|
}
|
|
return ctx
|
|
}
|