@nextclaw/ui 0.6.10 → 0.6.12

package/src/components/chat/chat-stream/nextbot-runtime-agent.ts

@@ -0,0 +1,413 @@
+import { EventType, type AgentEvent, type IAgent, type RunAgentInput } from '@nextclaw/agent-chat';
+import { Observable, type Subscribable } from 'rxjs';
+import {
+  buildDeltaEvents,
+  buildDeltaMessageId,
+  buildSessionEventEvents,
+  isAssistantSessionEvent,
+  shouldCloseDeltaOnSessionEvent
+} from './stream-event-adapter';
+import { openResumeRunStream, openSendTurnStream, requestStopRun } from './transport';
+import type {
+  ActiveRunState,
+  NextbotAgentRunMetadata,
+  StreamDeltaEvent,
+  StreamReadyEvent,
+  StreamSessionEvent
+} from './types';
+import { isAbortLikeError } from '@/lib/chat-runtime-utils';
+
+type SendRunMetadata = Extract<NextbotAgentRunMetadata, { mode: 'send' }>;
+type ResumeRunMetadata = Extract<NextbotAgentRunMetadata, { mode: 'resume' }>;
+type StreamResult = { sessionKey: string; reply: string };
+type EmitEvent = (event: AgentEvent) => void;
+type StreamRuntimeState = {
+  deltaMessageId: string;
+  deltaStarted: boolean;
+  deltaClosed: boolean;
+  hasAssistantSessionEvent: boolean;
+  hasAssistantOutput: boolean;
+};
+type RunObservableParams = {
+  metadata: NextbotAgentRunMetadata;
+  clientRunId: string;
+  abortController: AbortController;
+  runState: ActiveRunState;
+};
+
+function createBackendRunId(): string {
+  const now = Date.now().toString(36);
+  const rand = Math.random().toString(36).slice(2, 10);
+  return `run-${now}-${rand}`;
+}
+
+export type NextbotRunMetadataPayload =
+  | {
+      driver: 'nextbot-stream';
+      kind: 'ready';
+      sessionKey?: string;
+      backendRunId?: string;
+      stopSupported?: boolean;
+      stopReason?: string;
+      requestedAt?: string;
+    }
+  | {
+      driver: 'nextbot-stream';
+      kind: 'final';
+      sessionKey: string;
+      reply: string;
+      hasAssistantSessionEvent: boolean;
+    };
+
+function readRunMetadata(input: RunAgentInput): NextbotAgentRunMetadata | null {
+  const raw = input.metadata;
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    return null;
+  }
+  const record = raw as Record<string, unknown>;
+  if (record.driver !== 'nextbot-stream') {
+    return null;
+  }
+  const mode = record.mode;
+  if (mode === 'send') {
+    const payload = record.payload;
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+      return null;
+    }
+    const requestedSkills = Array.isArray(record.requestedSkills)
+      ? record.requestedSkills.filter((item): item is string => typeof item === 'string')
+      : [];
+    return {
+      driver: 'nextbot-stream',
+      mode: 'send',
+      payload: payload as SendRunMetadata['payload'],
+      requestedSkills
+    };
+  }
+  if (mode === 'resume') {
+    const runId = typeof record.runId === 'string' ? record.runId.trim() : '';
+    if (!runId) {
+      return null;
+    }
+    const fromEventIndex =
+      typeof record.fromEventIndex === 'number' && Number.isFinite(record.fromEventIndex)
+        ? Math.max(0, Math.trunc(record.fromEventIndex))
+        : undefined;
+    const sessionKey = typeof record.sessionKey === 'string' ? record.sessionKey.trim() : '';
+    const agentId = typeof record.agentId === 'string' ? record.agentId.trim() : '';
+    const stopSupported = typeof record.stopSupported === 'boolean' ? record.stopSupported : undefined;
+    const stopReason = typeof record.stopReason === 'string' ? record.stopReason.trim() : '';
+    return {
+      driver: 'nextbot-stream',
+      mode: 'resume',
+      runId,
+      ...(typeof fromEventIndex === 'number' ? { fromEventIndex } : {}),
+      ...(sessionKey ? { sessionKey } : {}),
+      ...(agentId ? { agentId } : {}),
+      ...(typeof stopSupported === 'boolean' ? { stopSupported } : {}),
+      ...(stopReason ? { stopReason } : {})
+    };
+  }
+  return null;
+}
+
+function buildInitialRunState(metadata: NextbotAgentRunMetadata): ActiveRunState {
+  if (metadata.mode === 'send') {
+    const backendRunId = metadata.payload.runId?.trim() || '';
+    return {
+      localRunId: 0,
+      sessionKey: metadata.payload.sessionKey,
+      ...(metadata.payload.agentId ? { agentId: metadata.payload.agentId } : {}),
+      ...(backendRunId ? { backendRunId } : {}),
+      backendStopSupported: Boolean(metadata.payload.stopSupported),
+      ...(metadata.payload.stopReason ? { backendStopReason: metadata.payload.stopReason } : {})
+    };
+  }
+  return {
+    localRunId: 0,
+    sessionKey: metadata.sessionKey ?? '',
+    ...(metadata.agentId ? { agentId: metadata.agentId } : {}),
+    backendRunId: metadata.runId,
+    backendStopSupported: Boolean(metadata.stopSupported),
+    ...(metadata.stopReason ? { backendStopReason: metadata.stopReason } : {})
+  };
+}
+
+function withEnsuredSendRunId(metadata: NextbotAgentRunMetadata): NextbotAgentRunMetadata {
+  if (metadata.mode !== 'send') {
+    return metadata;
+  }
+  const runId = metadata.payload.runId?.trim();
+  if (runId) {
+    return metadata;
+  }
+  return {
+    ...metadata,
+    payload: {
+      ...metadata.payload,
+      runId: createBackendRunId()
+    }
+  };
+}
+
+function updateRunStateFromReady(runState: ActiveRunState, event: {
+  sessionKey?: string;
+  runId?: string;
+  stopSupported?: boolean;
+  stopReason?: string;
+}) {
+  runState.backendRunId = event.runId?.trim() || runState.backendRunId;
+  runState.backendStopSupported =
+    typeof event.stopSupported === 'boolean' ? event.stopSupported : runState.backendStopSupported;
+  if (event.stopReason?.trim()) {
+    runState.backendStopReason = event.stopReason.trim();
+  }
+  if (event.sessionKey?.trim()) {
+    runState.sessionKey = event.sessionKey.trim();
+  }
+}
+
+function createStreamRuntimeState(): StreamRuntimeState {
+  return {
+    deltaMessageId: buildDeltaMessageId(),
+    deltaStarted: false,
+    deltaClosed: false,
+    hasAssistantSessionEvent: false,
+    hasAssistantOutput: false
+  };
+}
+
+function buildReadyMetadata(event: StreamReadyEvent): NextbotRunMetadataPayload {
+  return {
+    driver: 'nextbot-stream',
+    kind: 'ready',
+    ...(event.sessionKey?.trim() ? { sessionKey: event.sessionKey.trim() } : {}),
+    ...(event.runId?.trim() ? { backendRunId: event.runId.trim() } : {}),
+    ...(typeof event.stopSupported === 'boolean' ? { stopSupported: event.stopSupported } : {}),
+    ...(event.stopReason?.trim() ? { stopReason: event.stopReason.trim() } : {}),
+    ...(event.requestedAt ? { requestedAt: event.requestedAt } : {})
+  };
+}
+
+function buildFinalMetadata(result: StreamResult, hasAssistantSessionEvent: boolean): NextbotRunMetadataPayload {
+  return {
+    driver: 'nextbot-stream',
+    kind: 'final',
+    sessionKey: result.sessionKey,
+    reply: result.reply,
+    hasAssistantSessionEvent
+  };
+}
+
+function emitRunMetadata(emit: EmitEvent, clientRunId: string, metadata: NextbotRunMetadataPayload) {
+  emit({
+    type: EventType.RUN_METADATA,
+    runId: clientRunId,
+    metadata
+  });
+}
+
+function closeDelta(runtime: StreamRuntimeState, emit: EmitEvent) {
+  if (!runtime.deltaStarted || runtime.deltaClosed) {
+    return;
+  }
+  emit({ type: EventType.TEXT_END, messageId: runtime.deltaMessageId });
+  runtime.deltaClosed = true;
+}
+
+function handleDelta(runtime: StreamRuntimeState, emit: EmitEvent, event: StreamDeltaEvent) {
+  const events = buildDeltaEvents({
+    messageId: runtime.deltaMessageId,
+    delta: event.delta,
+    started: runtime.deltaStarted
+  });
+  if (events.length > 0) {
+    runtime.deltaStarted = true;
+    runtime.deltaClosed = false;
+    runtime.hasAssistantOutput = true;
+  }
+  for (const streamEvent of events) {
+    emit(streamEvent);
+  }
+}
+
+function handleSession(runtime: StreamRuntimeState, emit: EmitEvent, event: StreamSessionEvent) {
+  if (shouldCloseDeltaOnSessionEvent(event.data)) {
+    closeDelta(runtime, emit);
+    runtime.deltaMessageId = buildDeltaMessageId();
+    runtime.deltaStarted = false;
+    runtime.deltaClosed = false;
+  }
+  if (isAssistantSessionEvent(event.data)) {
+    runtime.hasAssistantSessionEvent = true;
+  }
+  for (const streamEvent of buildSessionEventEvents({
+    event: event.data,
+    messageId: runtime.deltaMessageId
+  })) {
+    emit(streamEvent);
+  }
+}
+
+function emitFallbackReplyIfNeeded(runtime: StreamRuntimeState, emit: EmitEvent, reply: string) {
+  const fallbackText = reply.trim();
+  if (runtime.hasAssistantOutput || !fallbackText) {
+    return;
+  }
+  const fallbackMessageId = buildDeltaMessageId();
+  emit({ type: EventType.TEXT_START, messageId: fallbackMessageId });
+  emit({ type: EventType.TEXT_DELTA, messageId: fallbackMessageId, delta: fallbackText });
+  emit({ type: EventType.TEXT_END, messageId: fallbackMessageId });
+}
+
+export class NextbotRuntimeAgent implements IAgent {
+  private activeAbortController: AbortController | null = null;
+  private activeRunState: ActiveRunState | null = null;
+
+  private buildMissingMetadataObservable = (clientRunId: string): Observable<AgentEvent> =>
+    new Observable<AgentEvent>((subscriber) => {
+      subscriber.next({
+        type: EventType.RUN_ERROR,
+        runId: clientRunId,
+        error: 'nextbot runtime metadata is required'
+      });
+      subscriber.complete();
+    });
+
+  private openRunStream = (params: {
+    metadata: NextbotAgentRunMetadata;
+    signal: AbortSignal;
+    onReady: (event: StreamReadyEvent) => void;
+    onDelta: (event: StreamDeltaEvent) => void;
+    onSessionEvent: (event: StreamSessionEvent) => void;
+  }): Promise<StreamResult> => {
+    const { metadata, signal, onReady, onDelta, onSessionEvent } = params;
+    if (metadata.mode === 'send') {
+      return openSendTurnStream({
+        item: metadata.payload,
+        requestedSkills: metadata.requestedSkills,
+        signal,
+        onReady,
+        onDelta,
+        onSessionEvent
+      });
+    }
+    return openResumeRunStream({
+      runId: (metadata as ResumeRunMetadata).runId,
+      fromEventIndex: (metadata as ResumeRunMetadata).fromEventIndex,
+      signal,
+      onReady,
+      onDelta,
+      onSessionEvent
+    });
+  };
+
+  private finalizeRunState = (abortController: AbortController, runState: ActiveRunState) => {
+    if (this.activeAbortController === abortController) {
+      this.activeAbortController = null;
+    }
+    if (this.activeRunState === runState) {
+      this.activeRunState = null;
+    }
+  };
+
+  private createRunObservable = ({
+    metadata,
+    clientRunId,
+    abortController,
+    runState
+  }: RunObservableParams): Observable<AgentEvent> =>
+    new Observable<AgentEvent>((subscriber) => {
+      const runtime = createStreamRuntimeState();
+      let disposed = false;
+      const emit: EmitEvent = (event) => {
+        if (!disposed) {
+          subscriber.next(event);
+        }
+      };
+
+      emit({ type: EventType.RUN_STARTED, runId: clientRunId });
+
+      const streamTask = this.openRunStream({
+        metadata,
+        signal: abortController.signal,
+        onReady: (event) => {
+          if (this.activeRunState) {
+            updateRunStateFromReady(this.activeRunState, event);
+          }
+          emitRunMetadata(emit, clientRunId, buildReadyMetadata(event));
+        },
+        onDelta: (event) => {
+          handleDelta(runtime, emit, event);
+        },
+        onSessionEvent: (event) => {
+          handleSession(runtime, emit, event);
+        }
+      });
+
+      void streamTask
+        .then((result) => {
+          closeDelta(runtime, emit);
+          emitFallbackReplyIfNeeded(runtime, emit, result.reply);
+          emitRunMetadata(emit, clientRunId, buildFinalMetadata(result, runtime.hasAssistantSessionEvent));
+          emit({
+            type: EventType.RUN_FINISHED,
+            runId: clientRunId
+          });
+          subscriber.complete();
+        })
+        .catch((error) => {
+          closeDelta(runtime, emit);
+          if (!isAbortLikeError(error)) {
+            emit({
+              type: EventType.RUN_ERROR,
+              runId: clientRunId,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+          subscriber.complete();
+        })
+        .finally(() => {
+          this.finalizeRunState(abortController, runState);
+        });
+
+      return () => {
+        disposed = true;
+        abortController.abort();
+        if (this.activeAbortController === abortController) {
+          this.activeAbortController = null;
+        }
+      };
+    });
+
+  abortRun = () => {
+    const activeRunState = this.activeRunState;
+    if (activeRunState?.backendStopSupported) {
+      void requestStopRun(activeRunState);
+    }
+    this.activeAbortController?.abort();
+    this.activeAbortController = null;
+    this.activeRunState = null;
+  };
+
+  run = (input: RunAgentInput): Subscribable<AgentEvent> => {
+    const metadata = readRunMetadata(input);
+    const clientRunId = typeof input.runId === 'string' && input.runId.trim() ? input.runId : `run-${Date.now()}`;
+    if (!metadata) {
+      return this.buildMissingMetadataObservable(clientRunId);
+    }
+
+    const normalizedMetadata = withEnsuredSendRunId(metadata);
+    this.abortRun();
+    const abortController = new AbortController();
+    this.activeAbortController = abortController;
+    const runState = buildInitialRunState(normalizedMetadata);
+    this.activeRunState = runState;
+    return this.createRunObservable({
+      metadata: normalizedMetadata,
+      clientRunId,
+      abortController,
+      runState
+    });
+  };
+}

package/src/components/chat/chat-stream/stream-event-adapter.ts

@@ -0,0 +1,98 @@
+import { EventType, type AgentEvent } from '@nextclaw/agent-chat';
+import type { SessionEventView } from '@/api/types';
+
+export function buildDeltaEvents(params: { messageId: string; delta: string; started: boolean }): AgentEvent[] {
+  if (!params.delta) {
+    return [];
+  }
+  if (params.started) {
+    return [{ type: EventType.TEXT_DELTA, messageId: params.messageId, delta: params.delta }];
+  }
+  return [
+    { type: EventType.TEXT_START, messageId: params.messageId },
+    { type: EventType.TEXT_DELTA, messageId: params.messageId, delta: params.delta }
+  ];
+}
+
+export function shouldCloseDeltaOnSessionEvent(event: SessionEventView): boolean {
+  void event;
+  return false;
+}
+
+export function isAssistantSessionEvent(event: SessionEventView): boolean {
+  const role = event.message?.role?.toLowerCase().trim();
+  return role === 'assistant';
+}
+
+export function buildSessionEventEvents(params: { event: SessionEventView; messageId: string }): AgentEvent[] {
+  const { event, messageId } = params;
+  const message = event.message;
+  if (!message) {
+    return [];
+  }
+  const role = message.role?.toLowerCase().trim();
+  if (!role) {
+    return [];
+  }
+
+  const events: AgentEvent[] = [];
+
+  if (typeof message.reasoning_content === 'string' && message.reasoning_content.trim()) {
+    events.push({ type: EventType.REASONING_START, messageId });
+    events.push({
+      type: EventType.REASONING_DELTA,
+      messageId,
+      delta: message.reasoning_content.trim()
+    });
+    events.push({ type: EventType.REASONING_END, messageId });
+  }
+
+  if (Array.isArray(message.tool_calls)) {
+    for (let index = 0; index < message.tool_calls.length; index += 1) {
+      const call = message.tool_calls[index];
+      if (!call || typeof call !== 'object') {
+        continue;
+      }
+      const callRecord = call as Record<string, unknown>;
+      const fnValue = callRecord.function;
+      const fn = typeof fnValue === 'object' && fnValue ? (fnValue as { name?: unknown; arguments?: unknown }) : null;
+      const seqPrefix = typeof event.seq === 'number' ? String(event.seq) : 'unknown';
+      const toolCallId = typeof callRecord.id === 'string' ? callRecord.id : `tool-${seqPrefix}-${index}`;
+      const toolName = typeof fn?.name === 'string' ? fn.name : typeof callRecord.name === 'string' ? callRecord.name : 'tool';
+      const rawArgs = fn?.arguments ?? callRecord.arguments ?? '';
+      const args = typeof rawArgs === 'string' ? rawArgs : JSON.stringify(rawArgs ?? {});
+      events.push({
+        type: EventType.TOOL_CALL_START,
+        messageId,
+        toolCallId,
+        toolName
+      });
+      events.push({
+        type: EventType.TOOL_CALL_ARGS,
+        toolCallId,
+        args
+      });
+      events.push({
+        type: EventType.TOOL_CALL_END,
+        toolCallId
+      });
+    }
+  }
+
+  if (role === 'tool' || role === 'tool_result' || role === 'toolresult' || role === 'function') {
+    const toolCallId = typeof message.tool_call_id === 'string' ? message.tool_call_id.trim() : '';
+    if (toolCallId) {
+      events.push({
+        type: EventType.TOOL_CALL_RESULT,
+        toolCallId,
+        content: message.content
+      });
+    }
+  }
+
+  return events;
+}
+
+export function buildDeltaMessageId(): string {
+  return `stream-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}

package/src/components/chat/chat-stream/transport.ts

@@ -0,0 +1,159 @@
+import { fetchChatRuns, sendChatTurnStream, stopChatTurn, streamChatRun } from '@/api/config';
+import type { ActiveRunState, SendMessageParams, StreamDeltaEvent, StreamReadyEvent, StreamSessionEvent } from './types';
+
+function buildSendTurnPayload(item: SendMessageParams, requestedSkills: string[]) {
+  const metadata: Record<string, unknown> = {};
+  if (item.sessionType) {
+    metadata.session_type = item.sessionType;
+  }
+  if (requestedSkills.length > 0) {
+    metadata.requested_skills = requestedSkills;
+  }
+  return {
+    message: item.message,
+    ...(item.runId ? { runId: item.runId } : {}),
+    sessionKey: item.sessionKey,
+    agentId: item.agentId,
+    ...(item.model ? { model: item.model } : {}),
+    ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
+    channel: 'ui',
+    chatId: 'web-ui'
+  };
+}
+
+export async function openSendTurnStream(params: {
+  item: SendMessageParams;
+  requestedSkills: string[];
+  signal: AbortSignal;
+  onReady: (event: StreamReadyEvent) => void;
+  onDelta: (event: StreamDeltaEvent) => void;
+  onSessionEvent: (event: StreamSessionEvent) => void;
+}) {
+  return sendChatTurnStream(buildSendTurnPayload(params.item, params.requestedSkills), {
+    signal: params.signal,
+    onReady: params.onReady,
+    onDelta: params.onDelta,
+    onSessionEvent: params.onSessionEvent
+  });
+}
+
+export async function openResumeRunStream(params: {
+  runId: string;
+  fromEventIndex?: number;
+  signal: AbortSignal;
+  onReady: (event: StreamReadyEvent) => void;
+  onDelta: (event: StreamDeltaEvent) => void;
+  onSessionEvent: (event: StreamSessionEvent) => void;
+}) {
+  return streamChatRun(
+    {
+      runId: params.runId,
+      ...(typeof params.fromEventIndex === 'number' ? { fromEventIndex: params.fromEventIndex } : {})
+    },
+    {
+      signal: params.signal,
+      onReady: params.onReady,
+      onDelta: params.onDelta,
+      onSessionEvent: params.onSessionEvent
+    }
+  );
+}
+
+export async function requestStopRun(activeRun: ActiveRunState): Promise<void> {
+  if (!activeRun.backendStopSupported) {
+    return;
+  }
+
+  try {
+    const attemptedRunIds = new Set<string>();
+    const knownRunId = activeRun.backendRunId?.trim();
+    if (knownRunId) {
+      attemptedRunIds.add(knownRunId);
+      const stopped = await stopRunById(knownRunId);
+      if (stopped) {
+        return;
+      }
+    }
+
+    const candidateRunIds = await resolveStopCandidateRunIds(activeRun);
+    for (const runId of candidateRunIds) {
+      if (attemptedRunIds.has(runId)) {
+        continue;
+      }
+      attemptedRunIds.add(runId);
+      const stopped = await stopRunById(runId);
+      if (stopped) {
+        return;
+      }
+    }
+    if (knownRunId) {
+      const stopped = await stopRunById(knownRunId);
+      if (stopped) {
+        return;
+      }
+    }
+  } catch {
+    // Keep local abort as fallback even if stop API fails.
+  }
+}
+
+async function stopRunById(runId: string): Promise<boolean> {
+  const normalizedRunId = runId.trim();
+  if (!normalizedRunId) {
+    return false;
+  }
+  try {
+    const result = await stopChatTurn({
+      runId: normalizedRunId
+    });
+    return result.stopped === true;
+  } catch {
+    return false;
+  }
+}
+
+async function resolveStopCandidateRunIds(activeRun: ActiveRunState): Promise<string[]> {
+  const sessionKey = activeRun.sessionKey?.trim();
+  if (!sessionKey) {
+    return [];
+  }
+  const attempts = 8;
+  const delayMs = 120;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    const runIds = await listActiveRunIdsBySession(activeRun, sessionKey);
+    if (runIds.length > 0) {
+      return runIds;
+    }
+    if (attempt < attempts - 1) {
+      await sleep(delayMs);
+    }
+  }
+  return [];
+}
+
+async function listActiveRunIdsBySession(activeRun: ActiveRunState, sessionKey: string): Promise<string[]> {
+  try {
+    const response = await fetchChatRuns({
+      sessionKey,
+      states: ['queued', 'running'],
+      limit: 50
+    });
+    const primary = response.runs
+      .filter((run) => run.runId?.trim() && run.sessionKey === sessionKey && run.agentId === activeRun.agentId)
+      .map((run) => run.runId.trim());
+    if (primary.length > 0) {
+      return primary;
+    }
+    return response.runs
+      .filter((run) => run.runId?.trim() && run.sessionKey === sessionKey)
+      .map((run) => run.runId.trim());
+  } catch {
+    return [];
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    window.setTimeout(resolve, ms);
+  });
+}