flare-chat-core 0.2.0 → 0.2.2

package/src/chat-core/pipelines/entity-extraction.js

@@ -0,0 +1,159 @@
+const ENTITY_TYPES = {
+  VENDOR: 'vendor',
+  PRODUCT: 'product',
+  ORG: 'org',
+};
+
+const PRODUCT_TOKENS = [
+  'ERP',
+  'CRM',
+  'SCM',
+  'MES',
+  'PLM',
+  'SRM',
+  'WMS',
+  'HRM',
+];
+
+const KNOWN_ENTITY_DEFS = [
+  { type: ENTITY_TYPES.VENDOR, text: '用友', aliases: ['用友', '用友网络', 'yonyou'] },
+  { type: ENTITY_TYPES.VENDOR, text: '金蝶', aliases: ['金蝶', 'kingdee'] },
+  { type: ENTITY_TYPES.VENDOR, text: 'SAP', aliases: ['sap', 'sap erp', '思爱普'] },
+  { type: ENTITY_TYPES.VENDOR, text: 'Oracle', aliases: ['oracle', 'oracle erp', '甲骨文'] },
+  { type: ENTITY_TYPES.VENDOR, text: '鼎捷', aliases: ['鼎捷', 'digiwin'] },
+  { type: ENTITY_TYPES.VENDOR, text: 'Microsoft Dynamics', aliases: ['microsoft dynamics', 'dynamics 365'] },
+  { type: ENTITY_TYPES.VENDOR, text: 'Infor', aliases: ['infor'] },
+  { type: ENTITY_TYPES.VENDOR, text: 'Workday', aliases: ['workday'] },
+  { type: ENTITY_TYPES.VENDOR, text: 'Sage', aliases: ['sage'] },
+  { type: ENTITY_TYPES.VENDOR, text: 'Odoo', aliases: ['odoo'] },
+  { type: ENTITY_TYPES.VENDOR, text: 'Epicor', aliases: ['epicor'] },
+  { type: ENTITY_TYPES.VENDOR, text: 'IFS', aliases: ['ifs'] },
+  ...PRODUCT_TOKENS.map((token) => ({ type: ENTITY_TYPES.PRODUCT, text: token, aliases: [token] })),
+];
+
+function normalizeEntityKey(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[\u3000\s]+/g, ' ')
+    .replace(/^[,.;:!?()[\]{}"'`~]+|[,.;:!?()[\]{}"'`~]+$/g, '');
+}
+
+function escapeRegExp(value) {
+  return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function hasCjk(value) {
+  return /[\u3400-\u9fff]/.test(String(value || ''));
+}
+
+function includesAlias(text, alias) {
+  const sourceText = String(text || '');
+  const sourceAlias = String(alias || '').trim();
+  if (!sourceText || !sourceAlias) {
+    return false;
+  }
+  if (hasCjk(sourceAlias)) {
+    return sourceText.includes(sourceAlias);
+  }
+  const pattern = new RegExp(`\\b${escapeRegExp(sourceAlias)}\\b`, 'i');
+  return pattern.test(sourceText);
+}
+
+function inferEntityType(text, fallbackType = ENTITY_TYPES.ORG) {
+  const normalized = normalizeEntityKey(text);
+  if (PRODUCT_TOKENS.some((token) => normalizeEntityKey(token) === normalized)) {
+    return ENTITY_TYPES.PRODUCT;
+  }
+  return fallbackType;
+}
+
+function normalizeEntityItem(item) {
+  if (typeof item === 'string') {
+    const normalized = normalizeEntityKey(item);
+    if (!normalized) return null;
+    return {
+      text: String(item).trim(),
+      normalized,
+      type: inferEntityType(item),
+    };
+  }
+  if (!item || typeof item !== 'object' || Array.isArray(item)) {
+    return null;
+  }
+  const text = String(item.text || item.name || item.value || '').trim();
+  const normalized = normalizeEntityKey(item.normalized || text);
+  if (!text && !normalized) {
+    return null;
+  }
+  return {
+    text: text || normalized,
+    normalized,
+    type: String(item.type || inferEntityType(text || normalized)).trim().toLowerCase() || ENTITY_TYPES.ORG,
+  };
+}
+
+function dedupeEntities(list = []) {
+  const seen = new Set();
+  const normalized = [];
+  list.forEach((item) => {
+    const normalizedItem = normalizeEntityItem(item);
+    if (!normalizedItem || !normalizedItem.normalized) {
+      return;
+    }
+    const key = `${normalizedItem.type}:${normalizedItem.normalized}`;
+    if (seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    normalized.push(normalizedItem);
+  });
+  return normalized;
+}
+
+function extractKnownEntities(text = '') {
+  const sourceText = String(text || '');
+  if (!sourceText.trim()) {
+    return [];
+  }
+  return KNOWN_ENTITY_DEFS
+    .filter((entity) => entity.aliases.some((alias) => includesAlias(sourceText, alias)))
+    .map((entity) => ({
+      text: entity.text,
+      normalized: normalizeEntityKey(entity.text),
+      type: entity.type,
+    }));
+}
+
+function extractOrgLikeEntities(text = '') {
+  const sourceText = String(text || '');
+  if (!sourceText.trim()) {
+    return [];
+  }
+  const matches = [];
+  const cnPattern = /([\u4e00-\u9fa5]{2,24}(?:公司|集团|科技|信息|股份|研究院))/g;
+  const enPattern = /\b([A-Z][A-Za-z0-9&.-]{1,}(?:\s+[A-Z][A-Za-z0-9&.-]{1,}){0,3}\s+(?:Inc|Corp|Corporation|Ltd|LLC|Group|Systems|Technologies|Technology))\b/g;
+  for (const match of sourceText.matchAll(cnPattern)) {
+    matches.push({ text: match[1], type: ENTITY_TYPES.ORG });
+  }
+  for (const match of sourceText.matchAll(enPattern)) {
+    matches.push({ text: match[1], type: ENTITY_TYPES.ORG });
+  }
+  return matches;
+}
+
+export function extractEntitiesFromText(text = '') {
+  return dedupeEntities([
+    ...extractKnownEntities(text),
+    ...extractOrgLikeEntities(text),
+  ]);
+}
+
+export function resolveEntities({ text = '', entities = [] } = {}) {
+  return dedupeEntities([
+    ...(Array.isArray(entities) ? entities : []),
+    ...extractEntitiesFromText(text),
+  ]);
+}
+
+export { ENTITY_TYPES };

package/src/chat-core/pipelines/preprocess-message.js

@@ -0,0 +1,16 @@
+import { extractEntitiesFromText } from './entity-extraction.js';
+
+export function normalizeIntentText(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+export function detectSourcingIntent(text) {
+  const normalized = normalizeIntentText(text);
+  if (!normalized) return false;
+  const signals = ['寻源', '供应商', '比价', '采购', '招标', 'source', 'vendor', 'supplier', 'sourcing'];
+  return signals.some((token) => normalized.includes(token));
+}
+
+export function extractMessageEntities(text) {
+  return extractEntitiesFromText(text);
+}

package/src/chat-core/pipelines/stream-persist-utils.js

@@ -0,0 +1,32 @@
+export function resolvePersistExchangeResult(result, fallbackSessionId = '') {
+  const fallback = String(fallbackSessionId || '').trim();
+  if (result && typeof result === 'object' && !Array.isArray(result)) {
+    return {
+      sessionId: String(result.sessionId || result.session_id || fallback).trim(),
+      title: String(result.title || '').trim(),
+    };
+  }
+  return {
+    sessionId: String(result || fallback).trim(),
+    title: '',
+  };
+}
+
+export function collectSourceIdsFromRefs(refs = []) {
+  if (!Array.isArray(refs)) {
+    return [];
+  }
+  const ids = [];
+  const seen = new Set();
+  refs.forEach((item) => {
+    const sourceId = typeof item === 'string'
+      ? String(item).trim()
+      : String(item?.source_id || item?.id || '').trim();
+    if (!sourceId || seen.has(sourceId)) {
+      return;
+    }
+    seen.add(sourceId);
+    ids.push(sourceId);
+  });
+  return ids;
+}

package/src/chat-core/pipelines/transport/send-mock-stream.js

@@ -0,0 +1,86 @@
+import { resolvePersistExchangeResult } from '../stream-persist-utils.js';
+
+function chunkText(content, chunkSize = 16) {
+  if (!content) {
+    return [];
+  }
+
+  const result = [];
+  for (let index = 0; index < content.length; index += chunkSize) {
+    result.push(content.slice(index, index + chunkSize));
+  }
+
+  return result;
+}
+
+export async function sendMockStreamMessage({
+  runtime,
+  content,
+  handlers = {},
+  options = {},
+  scope = {},
+  persistExchange,
+  schedule,
+}) {
+  const sessionId = String(options.sessionIdOverride || '').trim();
+  const enabledCapabilities = Array.isArray(options.enabledCapabilities)
+    ? options.enabledCapabilities
+    : [];
+  const finalReply = runtime.buildAssistantReply(content, enabledCapabilities);
+  const chunks = chunkText(finalReply);
+  const resolvedProjectId = String(scope?.projectId || '').trim();
+  const resolvedUserId = String(scope?.userId || '').trim();
+
+  await new Promise((resolve) => {
+    let delay = 120;
+    chunks.forEach((chunk) => {
+      schedule(delay, () => {
+        handlers.onContent?.(chunk);
+      });
+      delay += 70;
+    });
+
+    schedule(delay + 40, () => {
+      const persistedResult = (typeof persistExchange === 'function'
+        ? persistExchange(sessionId, content, finalReply, {
+          functionType: options.modeKey || 'chat_component_debug',
+          projectId: resolvedProjectId || null,
+          userId: resolvedUserId || null,
+        })
+        : String(sessionId || '').trim()
+      );
+      const persistedSession = resolvePersistExchangeResult(persistedResult, sessionId);
+      const resolvedSessionId = persistedSession.sessionId;
+      handlers.onPatchEvent?.({
+        session: {
+          session_id: resolvedSessionId,
+          turn_id: '',
+        },
+        payload: persistedSession.title
+          ? {
+              session: {
+                title: persistedSession.title,
+              },
+            }
+          : {},
+        patch_scope: ['session'],
+        event_type: 'ack',
+        final: false,
+        invalid: false,
+      });
+      handlers.onComplete?.(finalReply, {
+        sessionId: resolvedSessionId,
+        ...(persistedSession.title
+          ? {
+              payload: {
+                session: {
+                  title: persistedSession.title,
+                },
+              },
+            }
+          : {}),
+      });
+      resolve();
+    });
+  });
+}

package/src/chat-core/pipelines/transport/send-real-stream.js

@@ -0,0 +1,330 @@
+import {
+  parseAgentStatus,
+  parseExecutionTrace,
+  parseKnowledgeSearch,
+  parseThinkingTrace,
+  parseSourcingCandidates,
+  parseKnowledgeCitation,
+} from '../../../contracts/sse-events.js';
+import { debugCoreLog, getCoreRuntimeMode } from '../../runtime/runtimeMode.js';
+import { buildRealStreamRequestBody, resolvePayloadExtra } from '../build-stream-request.js';
+import { buildRealActionRequestBody } from '../build-action-request.js';
+import { collectSourceIdsFromRefs, resolvePersistExchangeResult } from '../stream-persist-utils.js';
+import { requestSourcingSearch } from './send-sourcing-search.js';
+
+function joinUrl(baseUrl = '', path = '') {
+  if (!baseUrl) {
+    return path || '';
+  }
+  if (!path) {
+    return baseUrl;
+  }
+  return `${baseUrl.replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}`;
+}
+
+export function shouldUseSourcingSearchPath(options = {}, content = '') {
+  void content;
+  const modeKey = String(options?.modeKey || options?.manualModeKey || '').trim();
+  if (modeKey !== 'intelligent_sourcing') {
+    return false;
+  }
+  const payloadExtra = resolvePayloadExtra(options);
+  if (payloadExtra.append_mode === true) {
+    return true;
+  }
+  if (payloadExtra.force_sourcing_search === true) {
+    return true;
+  }
+  return false;
+}
+
+export async function sendRealStreamMessage({
+  apiBaseUrl,
+  content,
+  handlers = {},
+  options = {},
+  scope = {},
+  persistExchange,
+  signal,
+}) {
+  const resolvedProjectId = String(scope?.projectId || '').trim();
+  const resolvedUserId = String(scope?.userId || '').trim();
+  const sessionId = String(options.sessionIdOverride || '').trim();
+  const requestBody = buildRealStreamRequestBody({
+    content,
+    options,
+    scope: {
+      projectId: resolvedProjectId,
+      userId: resolvedUserId,
+    },
+  });
+
+  const runtimeMode = getCoreRuntimeMode();
+  // Dev-only debug: show request-side mode and key stream switches.
+  debugCoreLog('stream.send.start', {
+    mode: runtimeMode.mode,
+    sessionId,
+    modeKey: String(options?.modeKey || ''),
+    manualModeKey: String(options?.manualModeKey || ''),
+    knowledgeRefsCount: Array.isArray(requestBody?.knowledge_refs) ? requestBody.knowledge_refs.length : 0,
+  });
+  const requestSourceIds = collectSourceIdsFromRefs([
+    ...(Array.isArray(requestBody?.context_refs) ? requestBody.context_refs : []),
+    ...(Array.isArray(requestBody?.knowledge_refs) ? requestBody.knowledge_refs : []),
+  ]);
+  const resolvedModeKey = String(options?.modeKey || options?.manualModeKey || '').trim() || 'auto';
+  handlers.onExecutionTrace?.({
+    session_id: sessionId || '',
+    step_id: 'context_binding',
+    agent: 'context_router',
+    stage: 'orchestration',
+    label: '上下文绑定',
+    detail: requestSourceIds.length > 0
+      ? `mode=${resolvedModeKey}; 绑定 ${requestSourceIds.length} 个来源: ${requestSourceIds.join(', ')}`
+      : `mode=${resolvedModeKey}; 未绑定来源，按常规上下文流程处理`,
+    reason: '',
+    status: 'running',
+    mode_key: resolvedModeKey,
+    sources: requestSourceIds.map((sourceId) => ({ source_id: sourceId })),
+    timestamp: Date.now(),
+  });
+
+  let finalContent = '';
+  let resolvedSessionId = sessionId;
+  let latestContextUsage = null;
+
+  if (shouldUseSourcingSearchPath(options, content)) {
+    await requestSourcingSearch({
+      apiBaseUrl,
+      content,
+      options,
+      scope: { projectId: resolvedProjectId, userId: resolvedUserId },
+      handlers,
+      persistExchange,
+      resolvedSessionId,
+    });
+    return;
+  }
+
+  const response = await fetch(joinUrl(apiBaseUrl, '/chat/stream'), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(requestBody),
+    signal,
+  });
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+
+  if (!response.body) {
+    throw new Error('stream response body is empty');
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let currentEvent = '';
+  let dataLines = [];
+
+  const emitEvent = () => {
+    if (!currentEvent || dataLines.length === 0) {
+      currentEvent = '';
+      dataLines = [];
+      return;
+    }
+
+    const rawData = dataLines.join('\n');
+    let payload = {};
+    try {
+      payload = JSON.parse(rawData);
+    } catch {
+      payload = {};
+    }
+    // Dev-only debug: trace the incoming SSE event types and payload outline.
+    debugCoreLog('stream.event', {
+      type: currentEvent,
+      keys: Object.keys(payload || {}),
+    });
+
+    if (currentEvent === 'content') {
+      const chunk = String(payload?.content || '');
+      finalContent += chunk;
+      handlers.onContent?.(chunk);
+    } else if (currentEvent === 'agent_status') {
+      handlers.onAgentStatus?.(parseAgentStatus(payload));
+    } else if (currentEvent === 'thinking_trace') {
+      handlers.onThinkingTrace?.(parseThinkingTrace(payload)?.trace || '');
+    } else if (currentEvent === 'execution_trace') {
+      handlers.onExecutionTrace?.(parseExecutionTrace(payload));
+    } else if (currentEvent === 'context_usage') {
+      latestContextUsage = (
+        payload
+        && typeof payload === 'object'
+        && !Array.isArray(payload)
+      ) ? { ...payload } : null;
+      const modeKey = String(payload?.mode_key || '').trim();
+      const modeState = String(payload?.mode_state || '').trim();
+      const profile = String(payload?.profile || '').trim();
+      const totalTokens = Number(payload?.token_estimate?.total_prompt_tokens_estimate || 0);
+      handlers.onExecutionTrace?.({
+        session_id: String(payload?.session_id || '').trim(),
+        step_id: 'context_usage',
+        agent: 'context_router',
+        stage: 'orchestration',
+        label: '上下文预算评估',
+        detail: `mode=${modeKey || 'default'}/${modeState || 'default'}; profile=${profile || 'default'}; tokens≈${totalTokens}`,
+        reason: '',
+        status: 'completed',
+        timestamp: Number.isFinite(Number(payload?.ts)) ? Number(payload.ts) : Date.now(),
+      });
+    } else if (currentEvent === 'knowledge_search') {
+      handlers.onKnowledgeSearch?.(parseKnowledgeSearch(payload));
+    } else if (currentEvent === 'sourcing_candidates') {
+      handlers.onSourcingCandidates?.(parseSourcingCandidates(payload));
+    } else if (currentEvent === 'knowledge_citation') {
+      handlers.onKnowledgeCitation?.(parseKnowledgeCitation(payload));
+    } else if (currentEvent === 'patch_event') {
+      const patchSessionId = String(payload?.session?.session_id || '').trim();
+      if (patchSessionId) {
+        resolvedSessionId = patchSessionId;
+      }
+      handlers.onPatchEvent?.(payload);
+    } else if (currentEvent === 'complete') {
+      let resolvedSessionTitle = '';
+      if (typeof persistExchange === 'function') {
+        const persistedResult = persistExchange(resolvedSessionId, content, finalContent, {
+          functionType: 'chat_component_debug',
+          projectId: resolvedProjectId || null,
+          userId: resolvedUserId || null,
+        });
+        const persistedSession = resolvePersistExchangeResult(persistedResult, resolvedSessionId);
+        resolvedSessionId = persistedSession.sessionId;
+        resolvedSessionTitle = persistedSession.title;
+      }
+      handlers.onPatchEvent?.({
+        session: {
+          session_id: resolvedSessionId,
+          turn_id: '',
+        },
+        payload: resolvedSessionTitle
+          ? {
+              session: {
+                title: resolvedSessionTitle,
+              },
+            }
+          : {},
+        patch_scope: ['session'],
+        event_type: 'final',
+        final: true,
+        invalid: false,
+      });
+      handlers.onComplete?.(finalContent, {
+        sessionId: resolvedSessionId,
+        ...(latestContextUsage
+          ? {
+              context_usage: latestContextUsage,
+            }
+          : {}),
+        ...(resolvedSessionTitle
+          ? {
+              payload: {
+                session: {
+                  title: resolvedSessionTitle,
+                },
+              },
+            }
+          : {}),
+      });
+      debugCoreLog('stream.send.complete', {
+        sessionId: resolvedSessionId,
+        finalContentLength: finalContent.length,
+      });
+    }
+
+    currentEvent = '';
+    dataLines = [];
+  };
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      const normalized = line.replace(/\r$/, '');
+      if (!normalized) {
+        emitEvent();
+        continue;
+      }
+      if (normalized.startsWith('event:')) {
+        currentEvent = normalized.slice(6).trim();
+        continue;
+      }
+      if (normalized.startsWith('data:')) {
+        dataLines.push(normalized.slice(5).trim());
+      }
+    }
+  }
+
+  emitEvent();
+  handlers.onExecutionTrace?.({
+    session_id: resolvedSessionId || '',
+    step_id: 'context_binding',
+    agent: 'context_router',
+    stage: 'orchestration',
+    label: '上下文绑定',
+    detail: requestSourceIds.length > 0
+      ? `已完成来源绑定（${requestSourceIds.length}）`
+      : '已完成常规上下文绑定',
+    reason: '',
+    status: 'completed',
+    sources: requestSourceIds.map((sourceId) => ({ source_id: sourceId })),
+    timestamp: Date.now(),
+  });
+}
+
+export async function sendRealStreamAction({
+  apiBaseUrl,
+  action,
+  handlers = {},
+  options = {},
+  scope = {},
+  signal,
+}) {
+  const requestBody = buildRealActionRequestBody({
+    action,
+    options,
+    scope,
+  });
+
+  const response = await fetch(joinUrl(apiBaseUrl, '/chat/action'), {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(requestBody),
+    signal,
+  });
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+  }
+
+  const payload = await response.json();
+  const result = (
+    payload?.result
+    && typeof payload.result === 'object'
+    && !Array.isArray(payload.result)
+  ) ? payload.result : {};
+  const content = String(result.message || payload?.message || '').trim();
+
+  if (content) {
+    handlers.onContent?.(content);
+  }
+  handlers.onComplete?.(content);
+  return payload;
+}

package/src/chat-core/pipelines/transport/send-real-stream.test.mjs

@@ -0,0 +1,27 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { shouldUseSourcingSearchPath } from './send-real-stream.js';
+
+test('shouldUseSourcingSearchPath keeps sourcing mode on stream path by default', () => {
+  const shouldUse = shouldUseSourcingSearchPath({
+    modeKey: 'intelligent_sourcing',
+    payloadExtra: {},
+  }, '来源1');
+  assert.equal(shouldUse, false);
+});
+
+test('shouldUseSourcingSearchPath uses direct path in append rounds', () => {
+  const shouldUse = shouldUseSourcingSearchPath({
+    modeKey: 'intelligent_sourcing',
+    payloadExtra: { append_mode: true },
+  }, '能不能换一批');
+  assert.equal(shouldUse, true);
+});
+
+test('shouldUseSourcingSearchPath uses direct path only with explicit force flag', () => {
+  const shouldUse = shouldUseSourcingSearchPath({
+    modeKey: 'intelligent_sourcing',
+    payloadExtra: { force_sourcing_search: true },
+  }, '任意输入');
+  assert.equal(shouldUse, true);
+});