flare-chat-core 0.2.1 → 0.2.2

package/src/adapters/session-message-api.http.js

@@ -0,0 +1,161 @@
+export function ensureFetchImpl(fetchImpl) {
+  const resolvedFetch = fetchImpl ?? globalThis.fetch;
+  if (typeof resolvedFetch !== 'function') {
+    throw new Error('fetch implementation is required');
+  }
+  return resolvedFetch;
+}
+
+export function joinUrl(baseUrl = '', path = '') {
+  if (!baseUrl) {
+    return path || '';
+  }
+  if (!path) {
+    return baseUrl;
+  }
+  return `${baseUrl.replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}`;
+}
+
+export function buildHeaders({ headers, token }) {
+  const resolvedHeaders = new Headers(headers || {});
+  if (token) {
+    resolvedHeaders.set('Authorization', `Bearer ${token}`);
+  }
+  return resolvedHeaders;
+}
+
+export async function parseJsonResponse(response) {
+  const text = await response.text();
+  if (!text) {
+    return {};
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return {};
+  }
+}
+
+export function createHttpError({ status, statusText, method, url, payload }) {
+  const payloadMessage = String(payload?.message || payload?.detail || '').trim();
+  const message = payloadMessage || String(statusText || 'request failed');
+  const error = new Error(`HTTP ${status}: ${message}`);
+  error.status = status;
+  error.method = method;
+  error.url = url;
+  error.payload = payload;
+  return error;
+}
+
+export async function requestFormWithUploadProgress({
+  url,
+  method = 'POST',
+  formData,
+  headers,
+  signal,
+  onProgress,
+}) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open(method, url, true);
+    headers.forEach((value, key) => {
+      if (String(key).toLowerCase() === 'content-type') {
+        return;
+      }
+      xhr.setRequestHeader(key, value);
+    });
+    if (typeof onProgress === 'function') {
+      xhr.upload.onprogress = (event) => {
+        if (!event.lengthComputable) {
+          return;
+        }
+        const percent = (event.loaded / event.total) * 100;
+        onProgress(percent);
+      };
+    }
+    xhr.onload = () => {
+      let payload = {};
+      const rawText = String(xhr.responseText || '').trim();
+      if (rawText) {
+        try {
+          payload = JSON.parse(rawText);
+        } catch {
+          payload = {};
+        }
+      }
+      if (xhr.status >= 200 && xhr.status < 300) {
+        resolve(payload);
+        return;
+      }
+      reject(createHttpError({
+        status: xhr.status,
+        statusText: xhr.statusText,
+        method,
+        url,
+        payload,
+      }));
+    };
+    xhr.onerror = () => {
+      reject(new Error('Network request failed'));
+    };
+    xhr.onabort = () => {
+      reject(new Error('Request aborted'));
+    };
+    if (signal) {
+      signal.addEventListener('abort', () => xhr.abort(), { once: true });
+    }
+    xhr.send(formData);
+  });
+}
+
+export async function requestJson(path, { method = 'GET', body, options }) {
+  const fetchImpl = ensureFetchImpl(options.fetchImpl);
+  const url = joinUrl(options.baseUrl, path);
+  const resolvedHeaders = buildHeaders(options);
+  resolvedHeaders.set('Content-Type', 'application/json');
+  const response = await fetchImpl(url, {
+    method,
+    headers: resolvedHeaders,
+    body: body ? JSON.stringify(body) : undefined,
+    signal: options.signal,
+  });
+  const payload = await parseJsonResponse(response);
+  if (!response.ok) {
+    throw createHttpError({
+      status: response.status,
+      statusText: response.statusText,
+      method,
+      url,
+      payload,
+    });
+  }
+  return payload;
+}
+
+export async function requestJsonWithRouteFallback({
+  buildPath,
+  method = 'GET',
+  body,
+  options,
+  routeMode,
+  setRouteMode,
+}) {
+  const primaryMode = routeMode === 'chat' ? 'chat' : 'root';
+  const fallbackMode = primaryMode === 'chat' ? 'root' : 'chat';
+  try {
+    return await requestJson(buildPath(primaryMode), { method, body, options });
+  } catch (error) {
+    const statusCode = Number(error?.status);
+    const errorMessage = String(error?.message || '').trim().toLowerCase();
+    const isRouteNotFound = statusCode === 404;
+    const isNetworkLikeFailure = !Number.isFinite(statusCode)
+      && (errorMessage.includes('failed to fetch') || errorMessage.includes('network request failed'));
+    if (!isRouteNotFound && !isNetworkLikeFailure) {
+      throw error;
+    }
+    const payloadPath = buildPath(fallbackMode);
+    const payload = await requestJson(payloadPath, { method, body, options });
+    setRouteMode(fallbackMode);
+    return payload;
+  }
+}

package/src/adapters/session-message-api.js

@@ -0,0 +1,34 @@
+import { createSessionAPI } from './session-api.adapter.js';
+import { createMessageAPI } from './message-api.adapter.js';
+import { createSourceAPI } from './source-api.adapter.js';
+
+export function createSessionMessageAPI({
+  baseUrl = '',
+  token = '',
+  headers,
+  fetchImpl,
+  signal,
+} = {}) {
+  const requestOptions = {
+    baseUrl,
+    token: String(token || '').trim(),
+    headers,
+    fetchImpl,
+    signal,
+  };
+
+  const routeState = {
+    sourceRouteMode: 'root',
+    fileRouteMode: 'root',
+    sessionCollectionRouteMode: 'chat',
+    sessionDetailRouteMode: 'chat',
+    sessionMessageRouteMode: 'chat',
+    messageCollectionRouteMode: 'chat',
+  };
+
+  return {
+    sessionAPI: createSessionAPI(requestOptions, routeState),
+    messageAPI: createMessageAPI(requestOptions, routeState),
+    sourceAPI: createSourceAPI(requestOptions, routeState),
+  };
+}

package/src/adapters/session-message-api.normalize-source-record.test.mjs

@@ -0,0 +1,180 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createSessionMessageAPI } from './session-message-api.js';
+
+function buildJsonResponse(payload, status = 200) {
+  return new Response(JSON.stringify(payload), {
+    status,
+    headers: { 'Content-Type': 'application/json' },
+  });
+}
+
+function buildFetchWithSources(sources) {
+  return async () => buildJsonResponse({ sources });
+}
+
+function buildFetchWithMessages(messages) {
+  return async () => buildJsonResponse({ messages });
+}
+
+test('normalizeSourceRecord keeps source_id and error_code from server payload', async () => {
+  const api = createSessionMessageAPI({
+    fetchImpl: buildFetchWithSources([
+      {
+        id: 'row-1',
+        source_id: 'src-1',
+        status: 'failed',
+        error_code: 'ingest_failed',
+        error_message: 'parse failed',
+      },
+    ]),
+  });
+
+  const response = await api.sourceAPI.listProjectSources('project-1');
+  assert.equal(response.sources[0].id, 'row-1');
+  assert.equal(response.sources[0].source_id, 'src-1');
+  assert.equal(response.sources[0].status, 'failed');
+  assert.equal(response.sources[0].error_code, 'ingest_failed');
+  assert.equal(response.sources[0].error_message, 'parse failed');
+});
+
+test('normalizeSourceRecord falls back source_id to resolved id', async () => {
+  const api = createSessionMessageAPI({
+    fetchImpl: buildFetchWithSources([
+      {
+        id: 'row-2',
+      },
+    ]),
+  });
+
+  const response = await api.sourceAPI.listProjectSources('project-2');
+  assert.equal(response.sources[0].id, 'row-2');
+  assert.equal(response.sources[0].source_id, 'row-2');
+  assert.equal(response.sources[0].error_code, null);
+});
+
+test('normalizeSourceRecord keeps explicit server status and only defaults when missing', async () => {
+  const apiWithExplicitEmptyStatus = createSessionMessageAPI({
+    fetchImpl: buildFetchWithSources([
+      {
+        id: 'row-3',
+        status: '',
+      },
+    ]),
+  });
+  const explicitStatusResponse = await apiWithExplicitEmptyStatus.sourceAPI.listProjectSources('project-3');
+  assert.equal(explicitStatusResponse.sources[0].status, '');
+
+  const apiWithMissingStatus = createSessionMessageAPI({
+    fetchImpl: buildFetchWithSources([
+      {
+        id: 'row-4',
+      },
+    ]),
+  });
+  const missingStatusResponse = await apiWithMissingStatus.sourceAPI.listProjectSources('project-4');
+  assert.equal(missingStatusResponse.sources[0].status, 'ready');
+});
+
+test('normalizeSourceRecord keeps explicit null status from server payload', async () => {
+  const api = createSessionMessageAPI({
+    fetchImpl: buildFetchWithSources([
+      {
+        id: 'row-5',
+        status: null,
+      },
+    ]),
+  });
+
+  const response = await api.sourceAPI.listProjectSources('project-5');
+  assert.equal(response.sources[0].status, null);
+});
+
+test('listProjectSources appends session_id query when provided', async () => {
+  let requestedUrl = '';
+  const api = createSessionMessageAPI({
+    fetchImpl: async (url) => {
+      requestedUrl = String(url || '');
+      return buildJsonResponse({ sources: [] });
+    },
+  });
+
+  await api.sourceAPI.listProjectSources('project-6', 'sess-6');
+  assert.match(requestedUrl, /\/projects\/project-6\/sources\?session_id=sess-6$/);
+});
+
+test('normalizeMessageRecord keeps attachments and refs for session replay', async () => {
+  const api = createSessionMessageAPI({
+    fetchImpl: buildFetchWithMessages([
+      {
+        message_id: 'm-1',
+        session_id: 's-1',
+        role: 'user',
+        content: '总结附件',
+        attachments: [
+          {
+            source_id: 'src-1',
+            filename: '附件一.pdf',
+            mime_type: 'application/pdf',
+          },
+        ],
+        context_refs: [{ source_id: 'src-1' }],
+        knowledge_refs: ['src-2'],
+      },
+    ]),
+  });
+
+  const response = await api.messageAPI.list('s-1');
+  assert.equal(response.messages[0].attachments.length, 2);
+  assert.equal(response.messages[0].attachments[0].filename, '附件一.pdf');
+  assert.equal(response.messages[0].attachments[1].source_id, 'src-2');
+  assert.deepEqual(response.messages[0].context_refs, [{ source_id: 'src-1' }]);
+  assert.deepEqual(response.messages[0].knowledge_refs, [{ source_id: 'src-2' }]);
+});
+
+test('normalizeMessageRecord keeps sourcing_candidates for canvas sourcing panel projection', async () => {
+  const api = createSessionMessageAPI({
+    fetchImpl: buildFetchWithMessages([
+      {
+        message_id: 'm-sourcing-1',
+        session_id: 's-sourcing-1',
+        role: 'assistant',
+        content: '已完成寻源',
+        sourcing_candidates: {
+          run_id: 'run-1',
+          candidates: [
+            { id: 'c-1', title: '供应商A' },
+          ],
+        },
+      },
+    ]),
+  });
+
+  const response = await api.messageAPI.list('s-sourcing-1');
+  assert.equal(response.messages[0].sourcing_candidates.run_id, 'run-1');
+  assert.equal(response.messages[0].sourcing_candidates.candidates[0].id, 'c-1');
+});
+
+test('uploadSourceFile includes user_id in form data when provided', async () => {
+  let capturedUserId = '';
+  const api = createSessionMessageAPI({
+    fetchImpl: async (_url, init = {}) => {
+      const formData = init?.body;
+      capturedUserId = String(formData?.get?.('user_id') || '');
+      return buildJsonResponse({
+        data: {
+          source_id: 'src-user-test',
+          status: 'uploaded',
+        },
+      });
+    },
+  });
+
+  await api.sourceAPI.uploadSourceFile({
+    project_id: 'project-uid-test',
+    user_id: 'user_demo_001',
+    file: new File(['hello'], 'probe.txt', { type: 'text/plain' }),
+  });
+
+  assert.equal(capturedUserId, 'user_demo_001');
+});

package/src/adapters/session-message-api.normalizers.js

@@ -0,0 +1,153 @@
+export function normalizeSessionRecord(record = {}) {
+  return {
+    sessionId: String(record.session_id || record.sessionId || '').trim(),
+    project_id: record.project_id ?? null,
+    title: String(record.title || '').trim(),
+    preview: String(record.preview || '').trim(),
+    title_source: String(record.title_source || '').trim(),
+    status: String(record.status || 'active').trim(),
+    user_id: record.user_id ?? null,
+    function_type: record.function_type ?? null,
+    createdAt: record.created_at || record.createdAt || '',
+    updatedAt: record.updated_at || record.updatedAt || '',
+  };
+}
+
+export function normalizeMessageRefList(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const refs = [];
+  const seen = new Set();
+  value.forEach((item) => {
+    const sourceId = String(
+      typeof item === 'string'
+        ? item
+        : item?.source_id || item?.id || ''
+    ).trim();
+    if (!sourceId || seen.has(sourceId)) {
+      return;
+    }
+    seen.add(sourceId);
+    refs.push({ source_id: sourceId });
+  });
+  return refs;
+}
+
+export function normalizeMessageAttachmentList(value, contextRefs = [], knowledgeRefs = []) {
+  const base = Array.isArray(value) ? value : [];
+  const attachments = [];
+  const seen = new Set();
+  base.forEach((item) => {
+    const sourceId = String(item?.source_id || item?.id || '').trim();
+    const filename = String(item?.filename || item?.name || '').trim();
+    const mimeType = String(item?.mime_type || item?.type || '').trim();
+    if (!sourceId && !filename) {
+      return;
+    }
+    if (sourceId && seen.has(sourceId)) {
+      return;
+    }
+    if (sourceId) {
+      seen.add(sourceId);
+    }
+    attachments.push({
+      source_id: sourceId || '',
+      filename: filename || (sourceId ? sourceId : '未命名附件'),
+      mime_type: mimeType || '',
+      status: String(item?.status || 'ready').trim() || 'ready',
+      scope: String(item?.scope || 'session').trim() || 'session',
+    });
+  });
+  [...contextRefs, ...knowledgeRefs].forEach((item) => {
+    const sourceId = String(item?.source_id || '').trim();
+    if (!sourceId || seen.has(sourceId)) {
+      return;
+    }
+    seen.add(sourceId);
+    attachments.push({
+      source_id: sourceId,
+      filename: sourceId,
+      mime_type: '',
+      status: 'ready',
+      scope: 'session',
+    });
+  });
+  return attachments;
+}
+
+export function normalizeMessageRecord(record = {}) {
+  const contextRefs = normalizeMessageRefList(record.context_refs);
+  const knowledgeRefs = normalizeMessageRefList(record.knowledge_refs);
+  const agentStatus = (
+    record.agent_status
+    && typeof record.agent_status === 'object'
+    && !Array.isArray(record.agent_status)
+  ) ? { ...record.agent_status } : null;
+  const executionTrace = (
+    record.execution_trace
+    && typeof record.execution_trace === 'object'
+    && !Array.isArray(record.execution_trace)
+  ) ? { ...record.execution_trace } : null;
+  const knowledgeSearch = (
+    record.knowledge_search
+    && typeof record.knowledge_search === 'object'
+    && !Array.isArray(record.knowledge_search)
+  ) ? { ...record.knowledge_search } : null;
+  const knowledgeCitation = (
+    record.knowledge_citation
+    && typeof record.knowledge_citation === 'object'
+    && !Array.isArray(record.knowledge_citation)
+  ) ? { ...record.knowledge_citation } : null;
+  const sourcingCandidates = (
+    record.sourcing_candidates
+    && typeof record.sourcing_candidates === 'object'
+    && !Array.isArray(record.sourcing_candidates)
+  ) ? { ...record.sourcing_candidates } : null;
+  const contextUsage = (
+    record.context_usage
+    && typeof record.context_usage === 'object'
+    && !Array.isArray(record.context_usage)
+  ) ? { ...record.context_usage } : null;
+  return {
+    message_id: String(record.message_id || '').trim(),
+    session_id: String(record.session_id || '').trim(),
+    role: String(record.role || '').trim(),
+    content: String(record.content || ''),
+    attachments: normalizeMessageAttachmentList(record.attachments, contextRefs, knowledgeRefs),
+    context_refs: contextRefs,
+    knowledge_refs: knowledgeRefs,
+    agent_status: agentStatus,
+    thinking_trace: String(record.thinking_trace || ''),
+    execution_trace: executionTrace,
+    knowledge_search: knowledgeSearch,
+    sourcing_candidates: sourcingCandidates,
+    knowledge_citation: knowledgeCitation,
+    context_usage: contextUsage,
+    created_at: record.created_at || '',
+  };
+}
+
+export function normalizeSourceRecord(record = {}) {
+  const resolvedId = String(record.id || record.source_id || record.uid || '').trim();
+  const hasStatus = Object.prototype.hasOwnProperty.call(record, 'status');
+  const resolvedStatus = hasStatus ? record.status : 'ready';
+  return {
+    id: resolvedId,
+    source_id: String(record.source_id || resolvedId).trim(),
+    project_id: record.project_id ?? null,
+    message_id: record.message_id ?? null,
+    scope: String(record.scope || 'project').trim() || 'project',
+    source: String(record.source || 'local_upload').trim() || 'local_upload',
+    filename: String(record.filename || record.file_name || record.name || '').trim(),
+    mime_type: String(record.mime_type || record.type || '').trim(),
+    size: Number.isFinite(record.size) ? record.size : null,
+    created_at: record.created_at || '',
+    status: resolvedStatus,
+    error_code: record.error_code === undefined || record.error_code === null
+      ? null
+      : String(record.error_code).trim(),
+    error_message: String(record.error_message || '').trim(),
+    persisted_to_project: record.persisted_to_project === true,
+  };
+}

package/src/adapters/source-api.adapter.js

@@ -0,0 +1,135 @@
+import { normalizeSourceRecord } from './session-message-api.normalizers.js';
+import {
+  buildHeaders,
+  createHttpError,
+  ensureFetchImpl,
+  joinUrl,
+  parseJsonResponse,
+  requestFormWithUploadProgress,
+  requestJsonWithRouteFallback,
+} from './session-message-api.http.js';
+
+export function createSourceAPI(requestOptions, routeState) {
+  return {
+    async listProjectSources(projectId, sessionId = '') {
+      const resolvedProjectId = String(projectId || '').trim();
+      if (!resolvedProjectId) {
+        throw new Error('projectId is required');
+      }
+      const encodedProjectId = encodeURIComponent(resolvedProjectId);
+      const resolvedSessionId = String(sessionId || '').trim();
+      const query = resolvedSessionId
+        ? `?session_id=${encodeURIComponent(resolvedSessionId)}`
+        : '';
+      const response = await requestJsonWithRouteFallback({
+        buildPath: (mode) => (mode === 'chat'
+          ? `/chat/projects/${encodedProjectId}/sources${query}`
+          : `/projects/${encodedProjectId}/sources${query}`),
+        method: 'GET',
+        options: requestOptions,
+        routeMode: routeState.sourceRouteMode,
+        setRouteMode: (nextMode) => {
+          routeState.sourceRouteMode = nextMode;
+        },
+      });
+      const source = Array.isArray(response?.sources)
+        ? response.sources
+        : Array.isArray(response?.data?.sources)
+          ? response.data.sources
+          : [];
+      return {
+        sources: source.map(normalizeSourceRecord),
+      };
+    },
+
+    async uploadSourceFile(payload = {}) {
+      const resolvedProjectId = String(payload.project_id || '').trim();
+      if (!resolvedProjectId) {
+        throw new Error('project_id is required');
+      }
+      if (!(payload.file instanceof File)) {
+        throw new Error('file is required');
+      }
+      const formData = new FormData();
+      formData.append('project_id', resolvedProjectId);
+      const resolvedUserId = String(payload.user_id || '').trim();
+      if (resolvedUserId) {
+        formData.append('user_id', resolvedUserId);
+      }
+      if (payload.session_id !== undefined && payload.session_id !== null) {
+        formData.append('session_id', String(payload.session_id));
+      }
+      formData.append('file', payload.file, payload.filename || payload.file.name || 'upload.bin');
+
+      const fetchImpl = ensureFetchImpl(requestOptions.fetchImpl);
+      const onProgress = typeof payload.onProgress === 'function' ? payload.onProgress : null;
+      const executeUpload = async (mode) => {
+        const path = mode === 'chat' ? '/chat/files/upload' : '/files/upload';
+        const url = joinUrl(requestOptions.baseUrl, path);
+        if (onProgress) {
+          return requestFormWithUploadProgress({
+            url,
+            method: 'POST',
+            formData,
+            headers: buildHeaders(requestOptions),
+            signal: requestOptions.signal,
+            onProgress,
+          });
+        }
+        const response = await fetchImpl(url, {
+          method: 'POST',
+          headers: buildHeaders(requestOptions),
+          body: formData,
+          signal: requestOptions.signal,
+        });
+        const responsePayload = await parseJsonResponse(response);
+        if (!response.ok) {
+          throw createHttpError({
+            status: response.status,
+            statusText: response.statusText,
+            method: 'POST',
+            url,
+            payload: responsePayload,
+          });
+        }
+        return responsePayload;
+      };
+      let responsePayload;
+      try {
+        responsePayload = await executeUpload(routeState.fileRouteMode);
+      } catch (error) {
+        if (Number(error?.status) !== 404) {
+          throw error;
+        }
+        const fallbackMode = routeState.fileRouteMode === 'chat' ? 'root' : 'chat';
+        responsePayload = await executeUpload(fallbackMode);
+        routeState.fileRouteMode = fallbackMode;
+      }
+      return normalizeSourceRecord(responsePayload?.data || responsePayload);
+    },
+
+    async deleteProjectSource(projectId, sourceId) {
+      const resolvedProjectId = String(projectId || '').trim();
+      const resolvedSourceId = String(sourceId || '').trim();
+      if (!resolvedProjectId) {
+        throw new Error('projectId is required');
+      }
+      if (!resolvedSourceId) {
+        throw new Error('sourceId is required');
+      }
+      const encodedProjectId = encodeURIComponent(resolvedProjectId);
+      const encodedSourceId = encodeURIComponent(resolvedSourceId);
+      return requestJsonWithRouteFallback({
+        buildPath: (mode) => (mode === 'chat'
+          ? `/chat/projects/${encodedProjectId}/sources/${encodedSourceId}`
+          : `/projects/${encodedProjectId}/sources/${encodedSourceId}`),
+        method: 'DELETE',
+        options: requestOptions,
+        routeMode: routeState.sourceRouteMode,
+        setRouteMode: (nextMode) => {
+          routeState.sourceRouteMode = nextMode;
+        },
+      });
+    },
+  };
+}