@axhub/genie 0.2.9 → 0.2.10

package/server/external-agent/ws.js

@@ -15,7 +15,11 @@ import {
   seedSessionRuntimeSubscriptionSnapshot,
   subscribeToSessionRuntimeStateChanges
 } from '../session-core/runtimeState.js';
-import { SUPPORTED_PROVIDERS } from '../../shared/conversationEvents.js';
+import {
+  CONVERSATION_EVENT_KINDS,
+  stripAssistantProtocolTags,
+  SUPPORTED_PROVIDERS
+} from '../../shared/conversationEvents.js';
 import { materializeDataUrlImageToFile, sanitizeFileName } from '../utils/agentImages.js';
 
 const INTEGRATION_ROLE_FRONTEND_PAGE = 'frontend-page';
@@ -39,6 +43,9 @@ const pendingIntegrationRequests = new Map();
 const pendingIntegrationPings = new Map();
 const sessionStateSubscriptionsByWs = new Map();
 const sessionStateSubscribersByKey = new Map();
+const sessionActivitySubscriptionsByWs = new Map();
+const sessionActivitySubscribersByKey = new Map();
+const assistantActivityBuffersByRequestId = new Map();
 
 // Editing state cache for resilience across connection drops
 const recentEditingStates = new Map();
@@ -111,6 +118,296 @@ function normalizePositiveInteger(value) {
   return next;
 }
 
+function buildSessionActivitySubscriptionKey({ requestId = null, provider = null, sessionId = null } = {}) {
+  if (requestId) {
+    return `request:${requestId}`;
+  }
+  if (provider && sessionId) {
+    return `session:${provider}:${sessionId}`;
+  }
+  return null;
+}
+
+function normalizeSessionActivityTarget(payload) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    throw Object.assign(new Error('payload must be an object'), { statusCode: 400 });
+  }
+
+  const requestId = normalizeNonEmptyString(payload.requestId);
+  const sessionId = normalizeNonEmptyString(payload.sessionId);
+  const provider = normalizeNonEmptyString(payload.provider)?.toLowerCase() || null;
+
+  if (provider && !SUPPORTED_PROVIDERS.includes(provider)) {
+    throw Object.assign(new Error(`provider must be one of: ${SUPPORTED_PROVIDERS.join(', ')}`), {
+      statusCode: 400
+    });
+  }
+
+  if (!requestId && !(sessionId && provider)) {
+    throw Object.assign(new Error('requestId or sessionId+provider is required'), {
+      statusCode: 400
+    });
+  }
+
+  return {
+    requestId,
+    sessionId,
+    provider
+  };
+}
+
+function addSessionActivitySubscription(ws, target) {
+  const key = buildSessionActivitySubscriptionKey(target);
+  if (!key) {
+    return;
+  }
+
+  if (!sessionActivitySubscriptionsByWs.has(ws)) {
+    sessionActivitySubscriptionsByWs.set(ws, new Map());
+  }
+  sessionActivitySubscriptionsByWs.get(ws).set(key, target);
+
+  if (!sessionActivitySubscribersByKey.has(key)) {
+    sessionActivitySubscribersByKey.set(key, new Set());
+  }
+  sessionActivitySubscribersByKey.get(key).add(ws);
+}
+
+function removeSessionActivitySubscription(ws, target) {
+  const key = buildSessionActivitySubscriptionKey(target);
+  if (!key) {
+    return;
+  }
+
+  const targets = sessionActivitySubscriptionsByWs.get(ws);
+  if (targets) {
+    targets.delete(key);
+    if (targets.size === 0) {
+      sessionActivitySubscriptionsByWs.delete(ws);
+    }
+  }
+
+  const subscribers = sessionActivitySubscribersByKey.get(key);
+  if (!subscribers) {
+    return;
+  }
+
+  subscribers.delete(ws);
+  if (subscribers.size === 0) {
+    sessionActivitySubscribersByKey.delete(key);
+  }
+}
+
+function removeSessionActivitySubscriptionsForWs(ws) {
+  const targets = sessionActivitySubscriptionsByWs.get(ws);
+  if (!targets) {
+    return;
+  }
+
+  for (const key of targets.keys()) {
+    const subscribers = sessionActivitySubscribersByKey.get(key);
+    if (!subscribers) {
+      continue;
+    }
+    subscribers.delete(ws);
+    if (subscribers.size === 0) {
+      sessionActivitySubscribersByKey.delete(key);
+    }
+  }
+
+  sessionActivitySubscriptionsByWs.delete(ws);
+}
+
+function clearAssistantActivityBuffers(requestId) {
+  if (!requestId) {
+    return;
+  }
+  assistantActivityBuffersByRequestId.delete(requestId);
+}
+
+function getAssistantActivityBuffer(requestId, messageId) {
+  if (!requestId || !messageId) {
+    return null;
+  }
+
+  if (!assistantActivityBuffersByRequestId.has(requestId)) {
+    assistantActivityBuffersByRequestId.set(requestId, new Map());
+  }
+
+  const buffers = assistantActivityBuffersByRequestId.get(requestId);
+  if (!buffers.has(messageId)) {
+    buffers.set(messageId, {
+      text: '',
+      updatedAt: Date.now()
+    });
+  }
+
+  return buffers.get(messageId);
+}
+
+function consumeAssistantActivityBuffer(requestId, messageId) {
+  if (!requestId || !messageId) {
+    return null;
+  }
+
+  const buffers = assistantActivityBuffersByRequestId.get(requestId);
+  if (!buffers) {
+    return null;
+  }
+
+  const buffer = buffers.get(messageId) || null;
+  buffers.delete(messageId);
+  if (buffers.size === 0) {
+    assistantActivityBuffersByRequestId.delete(requestId);
+  }
+  return buffer;
+}
+
+function summarizeSessionActivityText(text) {
+  const normalized = stripAssistantProtocolTags(String(text || ''))
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!normalized) {
+    return '';
+  }
+  if (normalized.length <= 160) {
+    return normalized;
+  }
+  return `${normalized.slice(0, 157).trimEnd()}...`;
+}
+
+function createSessionActivityItem({
+  id,
+  timestamp,
+  kind,
+  text,
+  requestId,
+  sessionId,
+  provider,
+  toolName
+}) {
+  const normalizedText = summarizeSessionActivityText(text);
+  if (!normalizedText) {
+    return null;
+  }
+
+  const parsedTimestamp = timestamp ? Date.parse(timestamp) : NaN;
+  return {
+    id: normalizeNonEmptyString(id) || createRuntimeId('session_activity'),
+    timestamp: Number.isFinite(parsedTimestamp) ? parsedTimestamp : Date.now(),
+    kind,
+    text: normalizedText,
+    requestId: requestId || null,
+    sessionId: sessionId || null,
+    provider: provider || null,
+    ...(toolName ? { toolName } : {})
+  };
+}
+
+function buildSessionActivityFromConversationEvent({
+  requestId,
+  provider,
+  sessionId,
+  event
+}) {
+  if (!event || typeof event !== 'object') {
+    return null;
+  }
+
+  const eventKind = normalizeNonEmptyString(event.kind);
+  const payload = isPlainObject(event.payload) ? event.payload : {};
+  const resolvedProvider = normalizeNonEmptyString(event.provider)?.toLowerCase() || provider || null;
+  const resolvedSessionId = normalizeNonEmptyString(event.sessionId) || sessionId || null;
+  const messageId =
+    normalizeNonEmptyString(payload.messageId)
+    || normalizeNonEmptyString(event.extensions?.messageId);
+
+  if (eventKind === CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_START) {
+    getAssistantActivityBuffer(requestId, messageId);
+    return null;
+  }
+
+  if (eventKind === CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_DELTA) {
+    const buffer = getAssistantActivityBuffer(requestId, messageId);
+    if (!buffer) {
+      return null;
+    }
+    buffer.text += String(payload.text || '');
+    buffer.updatedAt = Date.now();
+    return null;
+  }
+
+  if (eventKind === CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_END) {
+    const buffer = consumeAssistantActivityBuffer(requestId, messageId);
+    if (!buffer?.text) {
+      return null;
+    }
+    return createSessionActivityItem({
+      id: event.eventId,
+      timestamp: event.timestamp,
+      kind: 'assistant',
+      text: buffer.text,
+      requestId,
+      sessionId: resolvedSessionId,
+      provider: resolvedProvider
+    });
+  }
+
+  if (eventKind === CONVERSATION_EVENT_KINDS.TOOL_CALL_START) {
+    const toolName = normalizeNonEmptyString(payload.toolName) || 'unknown';
+    return createSessionActivityItem({
+      id: event.eventId,
+      timestamp: event.timestamp,
+      kind: 'tool',
+      text: `调用工具：${toolName}`,
+      requestId,
+      sessionId: resolvedSessionId,
+      provider: resolvedProvider,
+      toolName
+    });
+  }
+
+  return null;
+}
+
+function publishSessionActivity(item) {
+  if (!item || typeof item !== 'object') {
+    return;
+  }
+
+  const keys = new Set();
+  const requestKey = buildSessionActivitySubscriptionKey({ requestId: item.requestId });
+  const sessionKey = buildSessionActivitySubscriptionKey({
+    provider: item.provider,
+    sessionId: item.sessionId
+  });
+  if (requestKey) {
+    keys.add(requestKey);
+  }
+  if (sessionKey) {
+    keys.add(sessionKey);
+  }
+  if (keys.size === 0) {
+    return;
+  }
+
+  const recipients = new Set();
+  for (const key of keys) {
+    const subscribers = sessionActivitySubscribersByKey.get(key);
+    if (!subscribers) {
+      continue;
+    }
+    subscribers.forEach((ws) => recipients.add(ws));
+  }
+
+  recipients.forEach((ws) => {
+    sendJson(ws, {
+      type: 'session.activity.event',
+      payload: item
+    });
+  });
+}
+
 function isEditorResultMessageType(type) {
   return typeof type === 'string'
     && type.startsWith(INTEGRATION_EDITOR_TYPE_PREFIX)
@@ -303,6 +600,56 @@ async function handleAgentStateSubscribe(ws, data) {
   });
 }
 
+function handleSessionActivitySubscribe(ws, data) {
+  const requestId = getRequestId(data);
+
+  let normalized = null;
+  try {
+    normalized = normalizeSessionActivityTarget(data?.payload);
+  } catch (error) {
+    sendRequestError(ws, {
+      requestId,
+      provider: data?.payload?.provider || null,
+      sessionId: data?.payload?.sessionId || null,
+      error: error.message,
+      statusCode: error.statusCode || 400
+    });
+    return;
+  }
+
+  addSessionActivitySubscription(ws, normalized);
+  sendJson(ws, {
+    type: 'session.activity.subscribed',
+    requestId,
+    payload: normalized
+  });
+}
+
+function handleSessionActivityUnsubscribe(ws, data) {
+  const requestId = getRequestId(data);
+
+  let normalized = null;
+  try {
+    normalized = normalizeSessionActivityTarget(data?.payload);
+  } catch (error) {
+    sendRequestError(ws, {
+      requestId,
+      provider: data?.payload?.provider || null,
+      sessionId: data?.payload?.sessionId || null,
+      error: error.message,
+      statusCode: error.statusCode || 400
+    });
+    return;
+  }
+
+  removeSessionActivitySubscription(ws, normalized);
+  sendJson(ws, {
+    type: 'session.activity.unsubscribed',
+    requestId,
+    payload: normalized
+  });
+}
+
 function cleanupExpiredPendingIntegrationRequests() {
   const now = Date.now();
   for (const [requestId, entry] of pendingIntegrationRequests.entries()) {
@@ -850,6 +1197,69 @@ function getTargetFrontendConnections(channel, targetClientId) {
   });
 }
 
+function resolveForwardTargets(originWs, { channel, targetClientId }) {
+  const explicitTargetId = normalizeNonEmptyString(targetClientId);
+  if (explicitTargetId) {
+    return {
+      targets: getTargetFrontendConnections(channel, explicitTargetId),
+      resolvedTargetClientId: explicitTargetId,
+      error: null
+    };
+  }
+
+  const channelTargets = getTargetFrontendConnections(channel, null);
+  if (channelTargets.length === 0) {
+    return {
+      targets: [],
+      resolvedTargetClientId: null,
+      error: {
+        code: 'FRONTEND_NOT_ONLINE',
+        message: 'Target frontend page is not connected'
+      }
+    };
+  }
+
+  if (channelTargets.length === 1) {
+    return {
+      targets: channelTargets,
+      resolvedTargetClientId: channelTargets[0].clientId,
+      error: null
+    };
+  }
+
+  const originMeta = integrationConnections.get(originWs) || null;
+  const sessionMatchedTargets = originMeta?.sessionId
+    ? channelTargets.filter((target) => target.sessionId && target.sessionId === originMeta.sessionId)
+    : [];
+  if (sessionMatchedTargets.length === 1) {
+    return {
+      targets: sessionMatchedTargets,
+      resolvedTargetClientId: sessionMatchedTargets[0].clientId,
+      error: null
+    };
+  }
+
+  const pageMatchedTargets = originMeta?.pageUrl
+    ? channelTargets.filter((target) => target.pageUrl && target.pageUrl === originMeta.pageUrl)
+    : [];
+  if (pageMatchedTargets.length === 1) {
+    return {
+      targets: pageMatchedTargets,
+      resolvedTargetClientId: pageMatchedTargets[0].clientId,
+      error: null
+    };
+  }
+
+  return {
+    targets: [],
+    resolvedTargetClientId: null,
+    error: {
+      code: 'AMBIGUOUS_TARGET',
+      message: 'Multiple frontend pages are online for this channel; specify targetClientId or close extra pages'
+    }
+  };
+}
+
 function validateEditorClientsListPayload(payload) {
   if (payload === undefined || payload === null) {
     return {
@@ -884,16 +1294,11 @@ function validateEditorTargetPayload(payload, extras = {}) {
     return { ok: false, code: 'INVALID_PAYLOAD', message: 'channel is required' };
   }
 
-  const targetClientId = normalizeNonEmptyString(payload.targetClientId);
-  if (!targetClientId) {
-    return { ok: false, code: 'INVALID_TARGET', message: 'targetClientId is required' };
-  }
-
   return {
     ok: true,
     payload: {
       channel,
-      targetClientId,
+      targetClientId: normalizeNonEmptyString(payload.targetClientId),
       ...extras
     }
   };
@@ -1036,11 +1441,6 @@ function validateIntegrationContextUpdatePayload(payload) {
     return { ok: false, code: 'INVALID_PAYLOAD', message: 'channel is required' };
   }
 
-  const targetClientId = normalizeNonEmptyString(payload.targetClientId);
-  if (!targetClientId) {
-    return { ok: false, code: 'INVALID_TARGET', message: 'targetClientId is required' };
-  }
-
   const mode = normalizeNonEmptyString(payload.mode) || 'replace';
   if (mode !== 'replace' && mode !== 'append') {
     return { ok: false, code: 'INVALID_PAYLOAD', message: 'mode must be replace or append' };
@@ -1054,7 +1454,7 @@ function validateIntegrationContextUpdatePayload(payload) {
     ok: true,
     payload: {
       channel,
-      targetClientId,
+      targetClientId: normalizeNonEmptyString(payload.targetClientId),
       mode,
       context: payload.context
     }
@@ -1071,11 +1471,6 @@ function validateIntegrationPromptUpdatePayload(payload) {
     return { ok: false, code: 'INVALID_PAYLOAD', message: 'channel is required' };
   }
 
-  const targetClientId = normalizeNonEmptyString(payload.targetClientId);
-  if (!targetClientId) {
-    return { ok: false, code: 'INVALID_TARGET', message: 'targetClientId is required' };
-  }
-
   if (typeof payload.prompt !== 'string') {
     return { ok: false, code: 'INVALID_PAYLOAD', message: 'prompt must be a string' };
   }
@@ -1084,7 +1479,7 @@ function validateIntegrationPromptUpdatePayload(payload) {
     ok: true,
     payload: {
       channel,
-      targetClientId,
+      targetClientId: normalizeNonEmptyString(payload.targetClientId),
       prompt: payload.prompt,
       autoSend: payload.autoSend === true
     }
@@ -1104,8 +1499,18 @@ function forwardIntegrationMessage(ws, data, { validator, type, awaitResult = fa
   }
 
   const { channel, targetClientId } = validation.payload;
-  const targets = getTargetFrontendConnections(channel, targetClientId);
-  if (targets.length === 0) {
+  const resolution = resolveForwardTargets(ws, { channel, targetClientId });
+  if (resolution.error) {
+    sendIntegrationError(ws, {
+      requestId,
+      code: resolution.error.code,
+      message: resolution.error.message
+    });
+    return;
+  }
+
+  const { targets, resolvedTargetClientId } = resolution;
+  if (targets.length === 0 || !resolvedTargetClientId) {
     sendIntegrationError(ws, {
       requestId,
       code: 'FRONTEND_NOT_ONLINE',
@@ -1127,17 +1532,22 @@ function forwardIntegrationMessage(ws, data, { validator, type, awaitResult = fa
     }
   }
 
+  const resolvedPayload = {
+    ...validation.payload,
+    targetClientId: resolvedTargetClientId
+  };
+
   storePendingIntegrationRequest(requestId, ws, {
     awaitResult,
     requestType: type,
     timeoutMs: data?.payload?.timeoutMs,
-    requestPayload: validation.payload
+    requestPayload: resolvedPayload
   });
 
   const outgoingPayload = {
     type,
     requestId,
-    payload: validation.payload
+    payload: resolvedPayload
   };
 
   for (const target of targets) {
@@ -1243,14 +1653,25 @@ class ExternalAgentWebSocketWriter {
       if (sessionId) {
         this.sessionId = sessionId;
       }
+      const resolvedProvider = payload.provider || payload.event?.provider || this.provider;
 
       sendJson(this.ws, {
         type: 'agent.event',
         requestId: this.requestId,
-        provider: payload.provider || payload.event?.provider || this.provider,
+        provider: resolvedProvider,
         sessionId,
         event: payload.event
       });
+
+      const activity = buildSessionActivityFromConversationEvent({
+        requestId: this.requestId,
+        provider: resolvedProvider,
+        sessionId,
+        event: payload.event
+      });
+      if (activity) {
+        publishSessionActivity(activity);
+      }
     }
   }
 
@@ -1353,6 +1774,8 @@ async function handleAgentRun(ws, request, data) {
       error: error.message,
       statusCode: error.statusCode || 500
     });
+  } finally {
+    clearAssistantActivityBuffers(requestId);
   }
 }
 
@@ -1557,6 +1980,16 @@ export function handleExternalAgentWebSocketConnection(ws, request) {
       return;
     }
 
+    if (data?.type === 'session.activity.subscribe') {
+      handleSessionActivitySubscribe(ws, data);
+      return;
+    }
+
+    if (data?.type === 'session.activity.unsubscribe') {
+      handleSessionActivityUnsubscribe(ws, data);
+      return;
+    }
+
     if (data?.type === 'agent.abort') {
       void handleAgentAbort(ws, data);
       return;
@@ -1581,6 +2014,26 @@ export function handleExternalAgentWebSocketConnection(ws, request) {
   });
 
   ws.on('close', () => {
+    removeSessionActivitySubscriptionsForWs(ws);
     unregisterIntegrationConnection(ws);
   });
 }
+
+export function __buildSessionActivityFromConversationEventForTest(input) {
+  return buildSessionActivityFromConversationEvent(input);
+}
+
+export function __publishSessionActivityForTest(item) {
+  publishSessionActivity(item);
+}
+
+export function __resetExternalAgentWsTestState() {
+  integrationConnections.clear();
+  pendingIntegrationRequests.clear();
+  pendingIntegrationPings.clear();
+  sessionStateSubscriptionsByWs.clear();
+  sessionStateSubscribersByKey.clear();
+  sessionActivitySubscriptionsByWs.clear();
+  sessionActivitySubscribersByKey.clear();
+  assistantActivityBuffersByRequestId.clear();
+}