@nextclaw/ui 0.6.10 → 0.6.11

package/src/components/chat/stores/chat-session-list.store.ts

@@ -0,0 +1,34 @@
+import { create } from 'zustand';
+import type { SessionEntryView } from '@/api/types';
+
+export type ChatSessionListSnapshot = {
+  sessions: SessionEntryView[];
+  selectedSessionKey: string | null;
+  selectedAgentId: string;
+  query: string;
+  isLoading: boolean;
+};
+
+type ChatSessionListStore = {
+  snapshot: ChatSessionListSnapshot;
+  setSnapshot: (patch: Partial<ChatSessionListSnapshot>) => void;
+};
+
+const initialSnapshot: ChatSessionListSnapshot = {
+  sessions: [],
+  selectedSessionKey: null,
+  selectedAgentId: 'main',
+  query: '',
+  isLoading: false
+};
+
+export const useChatSessionListStore = create<ChatSessionListStore>((set) => ({
+  snapshot: initialSnapshot,
+  setSnapshot: (patch) =>
+    set((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        ...patch
+      }
+    }))
+}));

package/src/components/chat/stores/chat-thread.store.ts

@@ -0,0 +1,52 @@
+import { create } from 'zustand';
+import type { MutableRefObject } from 'react';
+import type { UiMessage } from '@nextclaw/agent-chat';
+import type { ChatModelOption } from '@/components/chat/chat-input.types';
+
+export type ChatThreadSnapshot = {
+  isProviderStateResolved: boolean;
+  modelOptions: ChatModelOption[];
+  sessionTypeUnavailable: boolean;
+  sessionTypeUnavailableMessage?: string | null;
+  selectedSessionKey: string | null;
+  sessionDisplayName?: string;
+  canDeleteSession: boolean;
+  isDeletePending: boolean;
+  threadRef: MutableRefObject<HTMLDivElement | null> | null;
+  isHistoryLoading: boolean;
+  uiMessages: UiMessage[];
+  isSending: boolean;
+  isAwaitingAssistantOutput: boolean;
+};
+
+type ChatThreadStore = {
+  snapshot: ChatThreadSnapshot;
+  setSnapshot: (patch: Partial<ChatThreadSnapshot>) => void;
+};
+
+const initialSnapshot: ChatThreadSnapshot = {
+  isProviderStateResolved: false,
+  modelOptions: [],
+  sessionTypeUnavailable: false,
+  sessionTypeUnavailableMessage: null,
+  selectedSessionKey: null,
+  sessionDisplayName: undefined,
+  canDeleteSession: false,
+  isDeletePending: false,
+  threadRef: null,
+  isHistoryLoading: false,
+  uiMessages: [],
+  isSending: false,
+  isAwaitingAssistantOutput: false
+};
+
+export const useChatThreadStore = create<ChatThreadStore>((set) => ({
+  snapshot: initialSnapshot,
+  setSnapshot: (patch) =>
+    set((state) => ({
+      snapshot: {
+        ...state.snapshot,
+        ...patch
+      }
+    }))
+}));

package/src/components/chat/useChatRuntimeController.ts

@@ -0,0 +1,134 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { type AgentChatController, getStopDisabledReason } from '@nextclaw/agent-chat';
+import type { ChatRunView, SessionMessageView } from '@/api/types';
+import type { SendMessageParams, UseChatStreamControllerParams } from '@/components/chat/chat-stream/types';
+import { buildResumeMetadata, buildSendMetadata } from '@/components/chat/chat-stream/nextbot-parsers';
+import { buildUiMessagesFromHistoryMessages, normalizeRequestedSkills } from '@/lib/chat-runtime-utils';
+import { useValueFromBehaviorSubject, useValueFromObservable } from '@/hooks/useObservable';
+
+export function useChatRuntimeController(
+  params: UseChatStreamControllerParams,
+  controller: AgentChatController
+) {
+  const paramsRef = useRef(params);
+  useEffect(() => {
+    paramsRef.current = params;
+  });
+
+  const activeHistorySessionKeyRef = useRef<string | null>(null);
+
+  // Bind callbacks to controller
+  useEffect(() => {
+    controller.setCallbacks({
+      onRunSettled: async ({ sourceSessionId, resultSessionId }) => {
+        const bindings = paramsRef.current;
+        await bindings.refetchSessions();
+        const activeSessionKey = bindings.selectedSessionKeyRef.current;
+        if (!activeSessionKey || activeSessionKey === sourceSessionId || (resultSessionId && activeSessionKey === resultSessionId)) {
+          await bindings.refetchHistory();
+        }
+      },
+      onRunError: ({ sourceMessage, restoreDraft }) => {
+        if (restoreDraft) {
+          paramsRef.current.setDraft((prev) => (prev.trim().length === 0 && sourceMessage ? sourceMessage : prev));
+        }
+      },
+      onSessionChanged: (sessionId) => {
+        paramsRef.current.setSelectedSessionKey((prev) => (prev === sessionId ? prev : sessionId));
+      }
+    });
+  }, [controller]);
+
+  // Reactive state from controller observables
+  const uiMessages = useValueFromObservable(controller.messages$, controller.getMessages());
+  const isSending = useValueFromBehaviorSubject(controller.isAgentResponding$);
+  const isAwaitingAssistantOutput = useValueFromBehaviorSubject(controller.isAwaitingResponse$);
+  const activeRun = useValueFromBehaviorSubject(controller.activeRun$);
+  const lastSendError = useValueFromBehaviorSubject(controller.lastError$);
+
+  // Derived state
+  const activeBackendRunId = activeRun?.remoteRunId ?? null;
+  const stopDisabledReason = getStopDisabledReason(activeRun);
+  const canStopCurrentRun = Boolean(
+    activeRun && (stopDisabledReason === null || (activeRun.remoteStopCapable && !activeBackendRunId))
+  );
+
+  const sendMessage = useCallback(async (payload: SendMessageParams) => {
+    const requestedSkills = normalizeRequestedSkills(payload.requestedSkills);
+    const metadata = buildSendMetadata(payload, requestedSkills);
+    await controller.send({
+      message: payload.message,
+      sessionId: payload.sessionKey,
+      agentId: payload.agentId,
+      metadata,
+      restoreDraftOnError: payload.restoreDraftOnError,
+      stopCapable: payload.stopSupported,
+      stopReason: payload.stopReason
+    });
+  }, [controller]);
+
+  const resumeRun = useCallback(async (run: ChatRunView) => {
+    const backendRunId = run.runId?.trim();
+    const sessionKey = run.sessionKey?.trim();
+    if (!backendRunId || !sessionKey) {
+      return;
+    }
+    const metadata = buildResumeMetadata(run);
+    await controller.resume({
+      remoteRunId: backendRunId,
+      sessionId: sessionKey,
+      agentId: run.agentId,
+      metadata,
+      stopCapable: run.stopSupported,
+      stopReason: run.stopReason
+    });
+  }, [controller]);
+
+  const stopCurrentRun = useCallback(async () => {
+    await controller.stop();
+  }, [controller]);
+
+  const resetStreamState = useCallback(() => {
+    activeHistorySessionKeyRef.current = null;
+    controller.reset();
+  }, [controller]);
+
+  const applyHistoryMessages = useCallback((messages: SessionMessageView[], options?: { isLoading?: boolean }) => {
+    const isRunActive = Boolean(controller.activeRun$.getValue() || controller.isAgentResponding$.getValue());
+    if (isRunActive) {
+      return;
+    }
+    const selectedSessionKey = paramsRef.current.selectedSessionKeyRef.current;
+    if (selectedSessionKey !== activeHistorySessionKeyRef.current) {
+      activeHistorySessionKeyRef.current = selectedSessionKey;
+      if (controller.getMessages().length > 0) {
+        controller.setMessages([]);
+      }
+    }
+    if (!selectedSessionKey) {
+      if (controller.getMessages().length > 0) {
+        controller.setMessages([]);
+      }
+      return;
+    }
+    if (options?.isLoading && messages.length === 0) {
+      return;
+    }
+    controller.setMessages(buildUiMessagesFromHistoryMessages(messages));
+  }, [controller]);
+
+  return {
+    uiMessages,
+    isSending,
+    isAwaitingAssistantOutput,
+    canStopCurrentRun,
+    stopDisabledReason,
+    lastSendError,
+    activeBackendRunId,
+    sendMessage,
+    stopCurrentRun,
+    resumeRun,
+    resetStreamState,
+    applyHistoryMessages
+  };
+}

package/src/components/chat/useChatSessionTypeState.ts

@@ -0,0 +1,148 @@
+import { useEffect, useMemo } from 'react';
+import type { Dispatch, SetStateAction } from 'react';
+import type { SessionEntryView } from '@/api/types';
+import { t } from '@/lib/i18n';
+
+export const DEFAULT_SESSION_TYPE = 'native';
+
+export type ChatSessionTypeOption = {
+  value: string;
+  label: string;
+};
+
+type UseChatSessionTypeStateParams = {
+  selectedSession: SessionEntryView | null;
+  selectedSessionKey: string | null;
+  pendingSessionType: string;
+  setPendingSessionType: Dispatch<SetStateAction<string>>;
+  sessionTypesData?: {
+    defaultType?: string;
+    options?: Array<{ value: string; label: string }>;
+  } | null;
+};
+
+export function normalizeSessionType(value: unknown): string {
+  if (typeof value !== 'string') {
+    return DEFAULT_SESSION_TYPE;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized || DEFAULT_SESSION_TYPE;
+}
+
+export function resolveSessionTypeLabel(sessionType: string, fallbackLabel?: string): string {
+  if (sessionType === 'native') {
+    return t('chatSessionTypeNative');
+  }
+  if (sessionType === 'codex-sdk') {
+    return t('chatSessionTypeCodex');
+  }
+  if (sessionType === 'claude-agent-sdk') {
+    return t('chatSessionTypeClaude');
+  }
+  return fallbackLabel?.trim() || sessionType;
+}
+
+function buildSessionTypeOptions(
+  options: Array<{ value: string; label: string }>
+): ChatSessionTypeOption[] {
+  const deduped = new Map<string, ChatSessionTypeOption>();
+  for (const option of options) {
+    const value = normalizeSessionType(option.value);
+    deduped.set(value, {
+      value,
+      label: option.label?.trim() || resolveSessionTypeLabel(value)
+    });
+  }
+  if (!deduped.has(DEFAULT_SESSION_TYPE)) {
+    deduped.set(DEFAULT_SESSION_TYPE, {
+      value: DEFAULT_SESSION_TYPE,
+      label: resolveSessionTypeLabel(DEFAULT_SESSION_TYPE)
+    });
+  }
+  return Array.from(deduped.values()).sort((left, right) => {
+    if (left.value === DEFAULT_SESSION_TYPE) {
+      return -1;
+    }
+    if (right.value === DEFAULT_SESSION_TYPE) {
+      return 1;
+    }
+    return left.value.localeCompare(right.value);
+  });
+}
+
+export function useChatSessionTypeState(params: UseChatSessionTypeStateParams): {
+  sessionTypeOptions: ChatSessionTypeOption[];
+  defaultSessionType: string;
+  selectedSessionType: string;
+  canEditSessionType: boolean;
+  sessionTypeUnavailable: boolean;
+  sessionTypeUnavailableMessage: string | null;
+} {
+  const {
+    selectedSession,
+    selectedSessionKey,
+    pendingSessionType,
+    setPendingSessionType,
+    sessionTypesData
+  } = params;
+
+  const runtimeSessionTypeOptions = useMemo(
+    () => buildSessionTypeOptions(sessionTypesData?.options ?? []),
+    [sessionTypesData?.options]
+  );
+  const sessionTypeOptions = useMemo(() => {
+    const options = [...runtimeSessionTypeOptions];
+    const currentSessionType = normalizeSessionType(selectedSession?.sessionType);
+    if (!options.some((option) => option.value === currentSessionType)) {
+      options.push({
+        value: currentSessionType,
+        label: resolveSessionTypeLabel(currentSessionType)
+      });
+    }
+    return options.sort((left, right) => {
+      if (left.value === DEFAULT_SESSION_TYPE) {
+        return -1;
+      }
+      if (right.value === DEFAULT_SESSION_TYPE) {
+        return 1;
+      }
+      return left.value.localeCompare(right.value);
+    });
+  }, [runtimeSessionTypeOptions, selectedSession?.sessionType]);
+  const defaultSessionType = useMemo(
+    () => normalizeSessionType(sessionTypesData?.defaultType ?? DEFAULT_SESSION_TYPE),
+    [sessionTypesData?.defaultType]
+  );
+  const selectedSessionType = useMemo(
+    () => normalizeSessionType(selectedSession?.sessionType ?? pendingSessionType ?? defaultSessionType),
+    [defaultSessionType, pendingSessionType, selectedSession?.sessionType]
+  );
+
+  useEffect(() => {
+    if (selectedSessionKey) {
+      return;
+    }
+    setPendingSessionType(defaultSessionType);
+  }, [defaultSessionType, selectedSessionKey, setPendingSessionType]);
+
+  const canEditSessionType = !selectedSessionKey || Boolean(selectedSession?.sessionTypeMutable);
+  const availableSessionTypeSet = useMemo(
+    () => new Set(runtimeSessionTypeOptions.map((option) => option.value)),
+    [runtimeSessionTypeOptions]
+  );
+  const sessionTypeUnavailable = Boolean(
+    selectedSession && !availableSessionTypeSet.has(normalizeSessionType(selectedSession.sessionType))
+  );
+  const sessionTypeUnavailableMessage = sessionTypeUnavailable
+    ? `${resolveSessionTypeLabel(selectedSessionType)} ${t('chatSessionTypeUnavailableSuffix')}`
+    : null;
+
+  return {
+    sessionTypeOptions,
+    defaultSessionType,
+    selectedSessionType,
+    canEditSessionType,
+    sessionTypeUnavailable,
+    sessionTypeUnavailableMessage
+  };
+}

package/src/components/common/MaskedInput.tsx

@@ -9,7 +9,7 @@ interface MaskedInputProps extends React.InputHTMLAttributes<HTMLInputElement> {
   isSet?: boolean;
 }
 
-export function MaskedInput({ maskedValue, isSet, className, value, onChange, placeholder, ...props }: MaskedInputProps) {
+export function MaskedInput({ isSet, className, value, onChange, placeholder, ...props }: MaskedInputProps) {
   const [showKey, setShowKey] = useState(false);
   const [isEditing, setIsEditing] = useState(false);
   const hasUserInput = typeof value === 'string' && value.length > 0;

package/src/hooks/useConfig.ts

@@ -24,6 +24,7 @@ import {
   fetchChatRun,
   fetchChatRuns,
   fetchChatCapabilities,
+  fetchChatSessionTypes,
   fetchCronJobs,
   deleteCronJob,
   setCronJobEnabled,
@@ -294,9 +295,26 @@ export function useChatCapabilities(params?: { sessionKey?: string | null; agent
   });
 }
 
-export function useChatRuns(params?: { sessionKey?: string | null; states?: Array<'queued' | 'running' | 'completed' | 'failed' | 'aborted'>; limit?: number }) {
+export function useChatSessionTypes() {
+  return useQuery({
+    queryKey: ['chat-session-types'],
+    queryFn: fetchChatSessionTypes,
+    staleTime: 10_000,
+    retry: false
+  });
+}
+
+export function useChatRuns(params?: {
+  sessionKey?: string | null;
+  states?: Array<'queued' | 'running' | 'completed' | 'failed' | 'aborted'>;
+  limit?: number;
+  syncActiveStates?: boolean;
+  isLocallyRunning?: boolean;
+}) {
   const sessionKey = params?.sessionKey?.trim() || undefined;
   const states = Array.isArray(params?.states) && params.states.length > 0 ? params.states : undefined;
+  const isActiveStatesQuery = Boolean(states?.some((state) => state === 'queued' || state === 'running'));
+  const shouldSyncActiveStates = Boolean(params?.syncActiveStates && isActiveStatesQuery);
   return useQuery({
     queryKey: ['chat-runs', sessionKey ?? null, states ?? null, params?.limit ?? null],
     queryFn: () => fetchChatRuns({
@@ -306,6 +324,18 @@ export function useChatRuns(params?: { sessionKey?: string | null; states?: Arra
     }),
     enabled: Boolean(sessionKey) || Boolean(states),
     staleTime: 5_000,
+    refetchInterval: (query) => {
+      if (!shouldSyncActiveStates) {
+        return false;
+      }
+      if (params?.isLocallyRunning) {
+        return 800;
+      }
+      const data = query.state.data;
+      const hasActiveRuns = Array.isArray(data?.runs) && data.runs.length > 0;
+      return hasActiveRuns ? 800 : false;
+    },
+    refetchIntervalInBackground: false,
     retry: false
   });
 }

package/src/hooks/useObservable.ts

@@ -0,0 +1,20 @@
+import { useEffect, useState } from 'react';
+import type { BehaviorSubject, Observable } from 'rxjs';
+
+export function useValueFromBehaviorSubject<T>(subject: BehaviorSubject<T>): T {
+  const [state, setState] = useState<T>(subject.getValue());
+  useEffect(() => {
+    const subscription = subject.subscribe(setState);
+    return () => subscription.unsubscribe();
+  }, [subject]);
+  return state;
+}
+
+export function useValueFromObservable<T>(observable: Observable<T>, defaultValue: T): T {
+  const [state, setState] = useState<T>(defaultValue);
+  useEffect(() => {
+    const subscription = observable.subscribe(setState);
+    return () => subscription.unsubscribe();
+  }, [observable]);
+  return state;
+}

package/src/lib/chat-message.ts

@@ -11,37 +11,6 @@ export type ToolCard = {
   hasResult?: boolean;
 };
 
-export type ChatTimelineMessageItem = {
-  kind: 'message';
-  key: string;
-  role: ChatRole;
-  timestamp: string;
-  message: SessionMessageView;
-};
-
-export type ChatTimelineAssistantTurnSegment =
-  | {
-      kind: 'assistant_message';
-      key: string;
-      text: string;
-      reasoning: string;
-    }
-  | {
-      kind: 'tool_card';
-      key: string;
-      card: ToolCard;
-    };
-
-export type ChatTimelineAssistantTurnItem = {
-  kind: 'assistant_turn';
-  key: string;
-  role: 'assistant';
-  timestamp: string;
-  segments: ChatTimelineAssistantTurnSegment[];
-};
-
-export type ChatTimelineItem = ChatTimelineMessageItem | ChatTimelineAssistantTurnItem;
-
 const TOOL_DETAIL_FIELDS = ['cmd', 'command', 'query', 'q', 'path', 'url', 'to', 'channel', 'agentId', 'sessionKey'];
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -55,7 +24,7 @@ function truncateText(value: string, maxChars = 2400): string {
   return `${value.slice(0, maxChars)}\n…`;
 }
 
-function stringifyUnknown(value: unknown): string {
+export function stringifyUnknown(value: unknown): string {
   if (typeof value === 'string') {
     return value;
   }
@@ -91,7 +60,7 @@ function parseArgsObject(value: unknown): Record<string, unknown> | null {
   }
 }
 
-function summarizeToolArgs(args: unknown): string | undefined {
+export function summarizeToolArgs(args: unknown): string | undefined {
   const parsed = parseArgsObject(args);
   if (!parsed) {
     const text = stringifyUnknown(args).trim();
@@ -212,20 +181,6 @@ export function extractToolCards(message: SessionMessageView): ToolCard[] {
   return cards;
 }
 
-function normalizeEvent(event: SessionEventView, index: number): SessionEventView & { _idx: number; _seq: number } {
-  const seq = Number.isFinite(event.seq) && event.seq > 0 ? Math.trunc(event.seq) : index + 1;
-  const timestamp =
-    typeof event.timestamp === 'string' && event.timestamp
-      ? event.timestamp
-      : event.message?.timestamp ?? new Date().toISOString();
-  return {
-    ...event,
-    timestamp,
-    _idx: index,
-    _seq: seq
-  };
-}
-
 function inferEventTypeFromMessage(message: SessionMessageView): string {
   const role = normalizeChatRole(message);
   if (role === 'assistant' && hasToolCalls(message)) {
@@ -245,158 +200,3 @@ export function buildFallbackEventsFromMessages(messages: SessionMessageView[]):
     message
   }));
 }
-
-function appendText(base: string, next: string): string {
-  if (!next) {
-    return base;
-  }
-  if (!base) {
-    return next;
-  }
-  return `${base}\n\n${next}`;
-}
-
-export function buildChatTimeline(events: SessionEventView[]): ChatTimelineItem[] {
-  const normalized = events
-    .map((event, index) => normalizeEvent(event, index))
-    .sort((left, right) => {
-      if (left._seq !== right._seq) {
-        return left._seq - right._seq;
-      }
-      const leftTs = Date.parse(left.timestamp);
-      const rightTs = Date.parse(right.timestamp);
-      if (Number.isFinite(leftTs) && Number.isFinite(rightTs) && leftTs !== rightTs) {
-        return leftTs - rightTs;
-      }
-      return left._idx - right._idx;
-    });
-
-  const timeline: ChatTimelineItem[] = [];
-  let activeTurn:
-    | {
-        item: ChatTimelineAssistantTurnItem;
-        cardByCallId: Map<string, ToolCard>;
-      }
-    | null = null;
-
-  const closeActiveTurn = () => {
-    activeTurn = null;
-  };
-
-  const ensureActiveTurn = (eventKey: string, timestamp: string) => {
-    if (activeTurn) {
-      activeTurn.item.timestamp = timestamp;
-      return activeTurn;
-    }
-    const item: ChatTimelineAssistantTurnItem = {
-      kind: 'assistant_turn',
-      key: `turn-${eventKey}`,
-      role: 'assistant',
-      timestamp,
-      segments: []
-    };
-    timeline.push(item);
-    activeTurn = {
-      item,
-      cardByCallId: new Map<string, ToolCard>()
-    };
-    return activeTurn;
-  };
-
-  const pushAssistantMessageSegment = (
-    target: { item: ChatTimelineAssistantTurnItem },
-    eventKey: string,
-    message: SessionMessageView
-  ) => {
-    const text = extractMessageText(message.content).trim();
-    const reasoning =
-      typeof message.reasoning_content === 'string' ? message.reasoning_content.trim() : '';
-    if (!text && !reasoning) {
-      return;
-    }
-    target.item.segments.push({
-      kind: 'assistant_message',
-      key: `assistant-${eventKey}-${target.item.segments.length}`,
-      text,
-      reasoning
-    });
-  };
-
-  for (const event of normalized) {
-    const message = event.message;
-    if (!message) {
-      continue;
-    }
-
-    const role = normalizeChatRole(message);
-    const timestamp =
-      typeof message.timestamp === 'string' && message.timestamp
-        ? message.timestamp
-        : event.timestamp;
-    const eventKey = `${event._seq}-${event._idx}`;
-
-    if (role === 'assistant') {
-      const turn = ensureActiveTurn(eventKey, timestamp);
-      pushAssistantMessageSegment(turn, eventKey, message);
-      if (!hasToolCalls(message)) {
-        continue;
-      }
-
-      const toolCards = buildToolCallCards(message);
-      for (const card of toolCards) {
-        turn.item.segments.push({
-          kind: 'tool_card',
-          key: `tool-call-${eventKey}-${turn.item.segments.length}`,
-          card
-        });
-        if (typeof card.callId === 'string' && card.callId.trim()) {
-          turn.cardByCallId.set(card.callId, card);
-        }
-      }
-      continue;
-    }
-
-    if (role === 'tool') {
-      const turn = ensureActiveTurn(eventKey, timestamp);
-      const callId =
-        typeof message.tool_call_id === 'string' && message.tool_call_id.trim()
-          ? message.tool_call_id.trim()
-          : undefined;
-      if (callId && turn.cardByCallId.has(callId)) {
-        const card = turn.cardByCallId.get(callId)!;
-        const resultText = extractMessageText(message.content).trim();
-        card.text = appendText(card.text ?? '', resultText);
-        card.hasResult = true;
-        if (typeof message.name === 'string' && message.name.trim()) {
-          card.name = message.name.trim();
-        }
-        turn.item.timestamp = timestamp;
-        continue;
-      }
-
-      turn.item.segments.push({
-        kind: 'tool_card',
-        key: `tool-result-${eventKey}-${turn.item.segments.length}`,
-        card: {
-          kind: 'result',
-          name: toToolName(message.name),
-          text: extractMessageText(message.content).trim(),
-          callId,
-          hasResult: true
-        }
-      });
-      continue;
-    }
-
-    timeline.push({
-      kind: 'message',
-      key: `message-${event._seq}-${event._idx}`,
-      role,
-      timestamp,
-      message
-    });
-    closeActiveTurn();
-  }
-
-  return timeline;
-}