@aleph-alpha/chat-kit 3.2.0 → 3.3.0

package/src/composables/fileUpload/useFileUploadWrapper.ts

@@ -13,7 +13,6 @@ import type {
   UploadEvent,
 } from './types';
 import { useFileUpload } from './useFileUpload';
-import { defaultEndpoints } from './types';
 
 function buildHttpClient(
   baseUrl: string,
@@ -177,34 +176,14 @@ export function createDocumentUploadProvider(
   };
 
   const httpClient = buildHttpClient(baseUrl, defaultHeaders);
-  const endpoints = defaultEndpoints;
 
-  // ---- Search store resolution (one per user) ----
+  // ---- Search store resolution (one per conversation) ----
 
-  let resolvedStoreId: string | null = null;
-  let resolvePromise: Promise<string> | null = null;
-  const resolvedWorkflowIdByStore = new Map<string, string>();
+  const storeIdByConversation = new Map<string, string>();
+  const resolvePromises = new Map<string, Promise<string>>();
 
-  async function createWorkflowForStore(storeId: string): Promise<string> {
-    const workflowRes = await httpClient.post<{ id: string }>(
-      endpoints.createWorkflow(storeId),
-      workflowConfig,
-    );
-    return workflowRes.id;
-  }
-
-  async function createSearchStoreWithWorkflow(): Promise<string> {
-    const name = `store-${new Date().toISOString().replace(/[:.]/g, '-')}`;
-    const storeRes = await httpClient.post<{ id: string }>('search-stores', {
-      name,
-      ...searchStoreConfig,
-    });
-    const newStoreId = storeRes.id;
-
-    const workflowApiId = await createWorkflowForStore(newStoreId);
-    resolvedWorkflowIdByStore.set(newStoreId, workflowApiId);
-
-    return newStoreId;
+  function searchStoreNameForConversation(conversationId: string): string {
+    return conversationId;
   }
 
   interface SearchStoreListResponse {
@@ -217,63 +196,109 @@ export function createDocumentUploadProvider(
   }
 
   interface WorkflowListResponse {
-    items: Array<{
-      id: string;
-      name: string;
-      created_at: string;
-    }>;
-    total: number;
+    items: Array<{ id: string; name?: string }>;
   }
 
-  async function fetchOrCreateWorkflow(storeId: string): Promise<string> {
-    const cached = resolvedWorkflowIdByStore.get(storeId);
-    if (cached) return cached;
+  function findConfiguredWorkflow(
+    items: WorkflowListResponse['items'],
+  ): { id: string } | undefined {
+    const configuredWorkflowName =
+      typeof workflowConfig.name === 'string' ? workflowConfig.name : undefined;
+
+    return items?.find(
+      (workflow) =>
+        workflow.id === workflowId ||
+        workflow.name === workflowId ||
+        (configuredWorkflowName != null &&
+          workflow.name === configuredWorkflowName),
+    );
+  }
 
+  async function resolveWorkflowId(storeId: string): Promise<string> {
     const response = await httpClient.get<WorkflowListResponse>(
-      endpoints.workflows(storeId),
+      `search-stores/${storeId}/workflows`,
     );
+    const existing = findConfiguredWorkflow(response.items);
 
-    if (response.items.length > 0) {
-      const match = response.items.find((item) => item.name === workflowId);
-      const selected = match ?? response.items[0]!;
-      resolvedWorkflowIdByStore.set(storeId, selected.id);
-      return selected.id;
+    if (existing) {
+      return existing.id;
     }
 
-    const workflowApiId = await createWorkflowForStore(storeId);
-    resolvedWorkflowIdByStore.set(storeId, workflowApiId);
-    return workflowApiId;
+    const created = await httpClient.post<{ id: string }>(
+      `search-stores/${storeId}/workflows`,
+      workflowConfig,
+    );
+    return created.id;
   }
 
-  async function fetchOrCreateStore(): Promise<string> {
-    try {
-      const response =
-        await httpClient.get<SearchStoreListResponse>('search-stores');
+  async function createSearchStore(conversationId: string): Promise<string> {
+    const storeRes = await httpClient.post<{ id: string }>('search-stores', {
+      name: searchStoreNameForConversation(conversationId),
+      ...searchStoreConfig,
+    });
 
-      const expectedModel = searchStoreConfig.models[0]?.embedding_model;
-      const match = response.items.find((store) =>
-        store.models.some((m) => m.embedding_model === expectedModel),
-      );
+    await httpClient.post(
+      `search-stores/${storeRes.id}/workflows`,
+      workflowConfig,
+    );
 
-      if (match) {
-        resolvedStoreId = match.id;
-        return resolvedStoreId;
-      }
+    return storeRes.id;
+  }
 
-      resolvedStoreId = await createSearchStoreWithWorkflow();
-      return resolvedStoreId;
-    } catch (err) {
-      resolvePromise = null;
-      throw err;
+  function findStoreForConversation(
+    items: SearchStoreListResponse['items'],
+    conversationId: string,
+  ) {
+    const expectedName = searchStoreNameForConversation(conversationId);
+    const expectedModel = searchStoreConfig.models[0]?.embedding_model;
+
+    return items.find(
+      (store) =>
+        store.name === expectedName &&
+        (!expectedModel ||
+          store.models.some((m) => m.embedding_model === expectedModel)),
+    );
+  }
+
+  async function fetchOrCreateStore(conversationId: string): Promise<string> {
+    const response =
+      await httpClient.get<SearchStoreListResponse>('search-stores');
+
+    const existing = findStoreForConversation(response.items, conversationId);
+
+    if (existing) {
+      await resolveWorkflowId(existing.id);
+      storeIdByConversation.set(conversationId, existing.id);
+      return existing.id;
     }
+
+    const newStoreId = await createSearchStore(conversationId);
+    storeIdByConversation.set(conversationId, newStoreId);
+    return newStoreId;
   }
 
-  async function resolveSearchStore(): Promise<string> {
-    if (resolvedStoreId) return resolvedStoreId;
-    if (resolvePromise) return resolvePromise;
+  async function resolveSearchStore(conversationId: string): Promise<string> {
+    if (!conversationId) {
+      throw new Error('conversationId is required to resolve a search store.');
+    }
+
+    const cached = storeIdByConversation.get(conversationId);
+    if (cached) return cached;
+
+    const pending = resolvePromises.get(conversationId);
+    if (pending) return pending;
+
+    const promise = fetchOrCreateStore(conversationId).catch((err) => {
+      storeIdByConversation.delete(conversationId);
+      throw err;
+    });
+    resolvePromises.set(conversationId, promise);
 
-    resolvePromise = fetchOrCreateStore();
-    return resolvePromise;
+    try {
+      return await promise;
+    } finally {
+      resolvePromises.delete(conversationId);
+    }
   }
 
   // ---- Upload SDK singleton ----
@@ -319,7 +344,9 @@ export function createDocumentUploadProvider(
     const fileInput = ref<HTMLInputElement | null>(null);
     const upload = getUploadInstance();
     const resolvedMaxFiles = upload.getSupportedFileTypes().maxFilesPerUpload;
-    const storeId = ref<string>(resolvedStoreId ?? '');
+    const storeId = ref<string>(
+      storeIdByConversation.get(toValue(conversationIdRef)) ?? '',
+    );
 
     const currentScope = shallowRef<ScopedFileView | null>(
       upload.scopeBy('conversationId', toValue(conversationIdRef)),
@@ -327,15 +354,20 @@ export function createDocumentUploadProvider(
 
     watch(
       () => toValue(conversationIdRef),
-      (newId: string, oldId: string) => {
-        if (oldId && oldId !== newId) {
-          const oldScope = upload.scopeBy('conversationId', oldId);
-          for (const entry of oldScope.files.value) {
-            upload.updateFileMetadata(entry.id, { conversationId: newId });
-          }
-        }
+      async (newId: string) => {
         currentScope.value = upload.scopeBy('conversationId', newId);
+        if (!newId) {
+          storeId.value = '';
+          return;
+        }
+
+        try {
+          storeId.value = await resolveSearchStore(newId);
+        } catch {
+          storeId.value = '';
+        }
       },
+      { immediate: true },
     );
 
     function scopedFiles(): FileEntry[] {
@@ -345,13 +377,15 @@ export function createDocumentUploadProvider(
     async function uploadFiles(files: File[]) {
       if (!files.length) return;
 
-      const userStoreId = await resolveSearchStore();
-      const workflowApiId = await fetchOrCreateWorkflow(userStoreId);
+      const conversationId = toValue(conversationIdRef);
+      if (!conversationId) return;
+
+      const userStoreId = await resolveSearchStore(conversationId);
+      const workflowApiId = await resolveWorkflowId(userStoreId);
       upload.setStoreId(userStoreId);
       upload.setWorkflowId(workflowApiId);
       storeId.value = userStoreId;
 
-      const conversationId = toValue(conversationIdRef);
       const result = await upload.upload({
         id: `${conversationId}::${Date.now()}`,
         files,
@@ -425,13 +459,12 @@ export function createDocumentUploadProvider(
     ) {
       const input = event.target as HTMLInputElement;
       let fileList = Array.from(input.files ?? []);
-      const availableSlots = resolvedMaxFiles - unassignedFiles.value.length;
 
-      if (fileList.length > availableSlots) {
-        const kept = Math.max(0, availableSlots);
+      if (fileList.length > resolvedMaxFiles) {
+        const kept = Math.max(0, resolvedMaxFiles);
         options?.onFilesExceeded?.({
           selected: fileList.length,
-          allowed: availableSlots,
+          allowed: resolvedMaxFiles,
           kept,
         });
         fileList = fileList.slice(0, kept);

package/src/handlers/index.ts

@@ -4,6 +4,8 @@ export {
   remarkNormalizeMath,
   normalizeMathDelimiters,
 } from '../helpers/unified/remarkNormalizeMath';
+export { remarkCitations } from '../helpers/unified/remarkCitations';
+export type { RemarkCitationsOptions } from '../helpers/unified/remarkCitations';
 export {
   provideChatKitLabels,
   useChatKitLabels,

package/src/handlers/useChatKitLabels.ts

@@ -81,6 +81,17 @@ export type ChatKitLabels = {
    * can scroll wide tables). Falls back to `defaultChatKitLabels` when omitted.
    */
   markdownTableLabel?: string;
+  /**
+   * Accessible label for the external-link action in a citation card
+   * (`CkCitation` / `CkCitationCard`). Falls back to `defaultChatKitLabels`.
+   */
+  citationOpenSource?: string;
+  /**
+   * Prefix for a citation marker's accessible name in `CkCitation`, composed
+   * as `"{citationSourceLabel} {index}"` (e.g. "Source 1"). Falls back to
+   * `defaultChatKitLabels`.
+   */
+  citationSourceLabel?: string;
   /** Fallback title used by `CkHistory` when a conversation has no `title`. */
   historyItemUntitled: string;
   /** Accessible name for the trailing kebab trigger on each `CkHistory` row. */
@@ -123,6 +134,8 @@ export const defaultChatKitLabels: ChatKitLabels = {
   modelSelectorListAriaLabel: 'Models',
   modelSelectorPlaceholder: 'Select model',
   markdownTableLabel: 'Table',
+  citationOpenSource: 'Open source',
+  citationSourceLabel: 'Source',
   historyItemUntitled: 'Untitled conversation',
   historyItemActionAriaLabel: 'Conversation options',
   historyItemEditAction: 'Edit',

package/src/handlers/useMarkdownParser.ts

@@ -83,8 +83,11 @@ function buildProcessor(plugins: PluggableList): SyncProcessor {
     .use(remarkNormalizeMath)
     .use(remarkGfm)
     .use(remarkMath);
-  for (const plugin of plugins) {
-    proc = proc.use(plugin as any);
+  // Apply the whole list at once. unified resolves `[plugin, options]` tuples
+  // when they're entries of a list; calling `.use(tuple)` per entry instead
+  // misreads the options object as a preset and throws.
+  if (plugins.length > 0) {
+    proc = proc.use(plugins);
   }
   return proc.use(remarkRehype).use(rehypeKatex).use(rehypeStringify);
 }

package/src/helpers/unified/remarkCitations.spec.ts

@@ -0,0 +1,112 @@
+import { remarkCitations } from './remarkCitations';
+
+// The plugin is a pure mdast transformer, so we can exercise it directly on a
+// hand-built tree without spinning up the full unified/remark parser.
+interface MdNode {
+  type: string;
+  value?: string;
+  children?: MdNode[];
+  data?: Record<string, unknown>;
+}
+
+function rootWithText(text: string): MdNode {
+  return { type: 'root', children: [{ type: 'text', value: text }] };
+}
+
+// `remarkCitations` is typed as a unified `Plugin` (it expects a `Processor`
+// `this`). In these unit tests we call it as a plain factory, so cast away the
+// `this` context to invoke it directly on a hand-built tree.
+const makeTransformer = remarkCitations as unknown as (options: {
+  indices?: ReadonlySet<number>;
+}) => (tree: MdNode) => void;
+
+function run(text: string, indices?: ReadonlySet<number>): MdNode[] {
+  const tree = rootWithText(text);
+  makeTransformer({ indices })(tree);
+  return tree.children!;
+}
+
+describe('remarkCitations', () => {
+  it('replaces a known [n] marker with a citation placeholder node', () => {
+    const out = run('see this [1] here', new Set([1]));
+    expect(out.map((n) => n.type)).toEqual([
+      'text',
+      'citationReference',
+      'text',
+    ]);
+    expect(out[0]).toEqual({ type: 'text', value: 'see this ' });
+    expect(out[2]).toEqual({ type: 'text', value: ' here' });
+  });
+
+  it('emits a span placeholder with the index as a data attribute', () => {
+    const [citation] = run('[1]', new Set([1]));
+    expect(citation.data).toEqual({
+      hName: 'span',
+      hProperties: { 'data-citation-index': 1 },
+      hChildren: [{ type: 'text', value: '1' }],
+    });
+  });
+
+  it('handles adjacent markers', () => {
+    const out = run('claim [1][2] end', new Set([1, 2]));
+    expect(out.map((n) => n.type)).toEqual([
+      'text',
+      'citationReference',
+      'citationReference',
+      'text',
+    ]);
+    expect(
+      (out[1].data!.hProperties as Record<string, number>)[
+        'data-citation-index'
+      ],
+    ).toBe(1);
+    expect(
+      (out[2].data!.hProperties as Record<string, number>)[
+        'data-citation-index'
+      ],
+    ).toBe(2);
+  });
+
+  it('leaves unsupported markers (no matching source) as literal text', () => {
+    const out = run('real [1] but [9] is not', new Set([1]));
+    expect(out.map((n) => n.type)).toEqual([
+      'text',
+      'citationReference',
+      'text',
+    ]);
+    // The [9] survives verbatim in the trailing text node.
+    expect(out[2].value).toBe(' but [9] is not');
+  });
+
+  it('treats every [n] as a citation when no index set is given', () => {
+    const out = run('a [1] b [2]');
+    expect(out.filter((n) => n.type === 'citationReference')).toHaveLength(2);
+  });
+
+  it('never converts [0] — citations are 1-based', () => {
+    const out = run('the value arr[0] here'); // no allow-list: every [n] except 0
+    expect(out.some((n) => n.type === 'citationReference')).toBe(false);
+    expect(out.map((n) => n.value ?? '').join('')).toContain('[0]');
+  });
+
+  it('leaves text without markers untouched', () => {
+    const out = run('no citations here', new Set([1]));
+    expect(out).toEqual([{ type: 'text', value: 'no citations here' }]);
+  });
+
+  it('does not descend into code/inlineCode value nodes', () => {
+    const tree: MdNode = {
+      type: 'root',
+      children: [
+        { type: 'inlineCode', value: 'arr[1]' },
+        { type: 'text', value: ' and [1]' },
+      ],
+    };
+    makeTransformer({ indices: new Set([1]) })(tree);
+    // inlineCode is untouched; only the text node's [1] becomes a citation.
+    expect(tree.children![0]).toEqual({ type: 'inlineCode', value: 'arr[1]' });
+    expect(tree.children!.some((n) => n.type === 'citationReference')).toBe(
+      true,
+    );
+  });
+});

package/src/helpers/unified/remarkCitations.ts

@@ -0,0 +1,55 @@
+import type { Plugin } from 'unified';
+import type { PhrasingContent } from 'mdast';
+import { findAndReplace } from 'mdast-util-find-and-replace';
+
+export interface RemarkCitationsOptions {
+  /**
+   * When provided, only `[n]` markers whose number is in this set are turned
+   * into citation placeholders; any other `[n]` is left as literal text
+   * (an "unsupported" marker with no backing source). When omitted, every
+   * `[n]` is treated as a citation.
+   */
+  indices?: ReadonlySet<number>;
+}
+
+// Matches a bare `[n]` reference, e.g. `[1]`. Because this runs on the parsed
+// mdast tree (via `findAndReplace`, which only visits `text` nodes), `[n]`
+// inside code spans/blocks and bracketed links never reaches it — only a
+// literal `[n]` typed in prose does.
+const CITATION_RE = /\[(\d+)\]/g;
+
+/**
+ * Replaces inline `[n]` citation references in the parsed markdown with a
+ * placeholder element (`<span data-citation-index="n">n</span>`) that survives
+ * stringify + sanitisation (`data-*` attributes are allowed by default).
+ */
+// The tree type is left as unified's default (a unist `Node`) so the public
+// type signature — and therefore the published `.d.ts` — doesn't depend on
+// `mdast` types; the cast below keeps the internal `findAndReplace` call typed.
+export const remarkCitations: Plugin<[RemarkCitationsOptions?]> = (
+  options = {},
+) => {
+  const { indices } = options;
+
+  return (tree) => {
+    findAndReplace(tree as Parameters<typeof findAndReplace>[0], [
+      CITATION_RE,
+      (_match: string, digits: string) => {
+        const index = Number(digits);
+        if (index < 1) return false; // citations are 1-based
+        // Leave unsupported markers (no backing source) as literal text.
+        if (indices && !indices.has(index)) return false;
+        return {
+          type: 'citationReference',
+          data: {
+            hName: 'span',
+            // Use the literal attribute name so the placeholder contract matches
+            // the renderer's `getAttribute('data-citation-index')` lookup exactly.
+            hProperties: { 'data-citation-index': index },
+            hChildren: [{ type: 'text', value: String(index) }],
+          },
+        } as unknown as PhrasingContent;
+      },
+    ]);
+  };
+};

package/src/index.ts

@@ -63,6 +63,8 @@ export type {
 // Components
 export {
   CkAgentMessage,
+  CkCitation,
+  CkCitationCard,
   CkConversation,
   CkConversationLayout,
   CkCopyMessageActionButton,
@@ -87,6 +89,11 @@ export {
   CkUserMessage,
 } from './components';
 export type {
+  CkCitationProps,
+  CkCitationEmits,
+  CkCitationSource,
+  CkCitationCardProps,
+  CkCitationCardEmits,
   CkConversationLayoutProps,
   CkConversationProps,
   CkDropZoneOverlayProps,
@@ -110,6 +117,7 @@ export type {
   CkHistoryWrapperProps,
   CkMarkdownElementClasses,
   CkMarkdownRendererProps,
+  CkMarkdownRendererEmits,
   CkModelOption,
   CkModelSelectorProps,
   CkModelSelectorEmits,