@aleph-alpha/chat-kit 3.1.3 → 3.3.0

package/src/composables/fileUpload/useFileUploadWrapper.ts

@@ -177,25 +177,13 @@ export function createDocumentUploadProvider(
 
   const httpClient = buildHttpClient(baseUrl, defaultHeaders);
 
-  // ---- Search store resolution (one per user) ----
+  // ---- Search store resolution (one per conversation) ----
 
-  let resolvedStoreId: string | null = null;
-  let resolvePromise: Promise<string> | null = null;
+  const storeIdByConversation = new Map<string, string>();
+  const resolvePromises = new Map<string, Promise<string>>();
 
-  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;
-
-    await httpClient.post(
-      `search-stores/${newStoreId}/workflows`,
-      workflowConfig,
-    );
-
-    return newStoreId;
+  function searchStoreNameForConversation(conversationId: string): string {
+    return conversationId;
   }
 
   interface SearchStoreListResponse {
@@ -207,35 +195,110 @@ export function createDocumentUploadProvider(
     total: number;
   }
 
-  async function fetchOrCreateStore(): Promise<string> {
-    try {
-      const response =
-        await httpClient.get<SearchStoreListResponse>('search-stores');
+  interface WorkflowListResponse {
+    items: Array<{ id: string; name?: string }>;
+  }
 
-      const expectedModel = searchStoreConfig.models[0]?.embedding_model;
-      const match = response.items.find((store) =>
-        store.models.some((m) => m.embedding_model === expectedModel),
-      );
+  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),
+    );
+  }
 
-      if (match) {
-        resolvedStoreId = match.id;
-        return resolvedStoreId;
-      }
+  async function resolveWorkflowId(storeId: string): Promise<string> {
+    const response = await httpClient.get<WorkflowListResponse>(
+      `search-stores/${storeId}/workflows`,
+    );
+    const existing = findConfiguredWorkflow(response.items);
 
-      resolvedStoreId = await createSearchStoreWithWorkflow();
-      return resolvedStoreId;
-    } catch (err) {
-      resolvePromise = null;
-      throw err;
+    if (existing) {
+      return existing.id;
     }
+
+    const created = await httpClient.post<{ id: string }>(
+      `search-stores/${storeId}/workflows`,
+      workflowConfig,
+    );
+    return created.id;
   }
 
-  async function resolveSearchStore(): Promise<string> {
-    if (resolvedStoreId) return resolvedStoreId;
-    if (resolvePromise) return resolvePromise;
+  async function createSearchStore(conversationId: string): Promise<string> {
+    const storeRes = await httpClient.post<{ id: string }>('search-stores', {
+      name: searchStoreNameForConversation(conversationId),
+      ...searchStoreConfig,
+    });
 
-    resolvePromise = fetchOrCreateStore();
-    return resolvePromise;
+    await httpClient.post(
+      `search-stores/${storeRes.id}/workflows`,
+      workflowConfig,
+    );
+
+    return storeRes.id;
+  }
+
+  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(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);
+
+    try {
+      return await promise;
+    } finally {
+      resolvePromises.delete(conversationId);
+    }
   }
 
   // ---- Upload SDK singleton ----
@@ -281,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)),
@@ -289,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[] {
@@ -307,11 +377,15 @@ export function createDocumentUploadProvider(
     async function uploadFiles(files: File[]) {
       if (!files.length) return;
 
-      const userStoreId = await resolveSearchStore();
+      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,
@@ -385,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

@@ -1,5 +1,11 @@
 export { useMessageHandler } from './useMessageHandler';
 export { useMarkdownParser } from './useMarkdownParser';
+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.spec.ts

@@ -140,4 +140,38 @@ describe('useMarkdownParser', () => {
     expect(html.value).not.toContain('class="katex"');
     expect(html.value).toContain('$5');
   });
+
+  it('promotes inline `$$...$$` to block math via the normalizer plugin', () => {
+    const source = ref('Inline before $$E=mc^2$$ inline after');
+    const { html } = useMarkdownParser(source, ref(undefined));
+
+    expect(html.value).toContain('class="katex-display"');
+    expect(html.value).toContain('E=mc^2');
+    expect(html.value).toContain('Inline before');
+    expect(html.value).toContain('inline after');
+  });
+
+  it('renders LaTeX-style `\\(...\\)` as inline math', () => {
+    const source = ref('The expression \\(a+b\\) is small.');
+    const { html } = useMarkdownParser(source, ref(undefined));
+
+    expect(html.value).toContain('class="katex"');
+    expect(html.value).not.toContain('class="katex-display"');
+  });
+
+  it('renders LaTeX-style `\\[...\\]` as block math', () => {
+    const source = ref('See \\[a+b\\] above.');
+    const { html } = useMarkdownParser(source, ref(undefined));
+
+    expect(html.value).toContain('class="katex-display"');
+  });
+
+  it('does not render `$$...$$` inside a fenced code block as math', () => {
+    const source = ref('```\n$$x$$\n```');
+    const { html } = useMarkdownParser(source, ref(undefined));
+
+    expect(html.value).not.toContain('class="katex"');
+    expect(html.value).toContain('<code>');
+    expect(html.value).toContain('$$x$$');
+  });
 });

package/src/handlers/useMarkdownParser.ts

@@ -8,6 +8,7 @@ import rehypeKatex from 'rehype-katex';
 import rehypeStringify from 'rehype-stringify';
 import DOMPurify, { type Config } from 'dompurify';
 import 'katex/dist/katex.min.css';
+import { remarkNormalizeMath } from '../helpers/unified/remarkNormalizeMath';
 
 type SyncProcessor = { processSync: (value: string) => { toString(): string } };
 
@@ -73,9 +74,20 @@ const SANITIZE_CONFIG: Config = {
 };
 
 function buildProcessor(plugins: PluggableList): SyncProcessor {
-  let proc = unified().use(remarkParse).use(remarkGfm).use(remarkMath);
-  for (const plugin of plugins) {
-    proc = proc.use(plugin as any);
+  // `remarkNormalizeMath` wraps `this.parser`, so it must be registered after
+  // `remark-parse`. The wrap rewrites the markdown source before `remark-math`
+  // sees it, promoting single-line `$$…$$` and LaTeX `\(…\)` / `\[…\]` into
+  // delimiters that `remark-math` recognizes.
+  let proc = unified()
+    .use(remarkParse)
+    .use(remarkNormalizeMath)
+    .use(remarkGfm)
+    .use(remarkMath);
+  // 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/helpers/unified/remarkNormalizeMath.spec.ts

@@ -0,0 +1,84 @@
+import { normalizeMathDelimiters } from '../../helpers/unified/remarkNormalizeMath';
+
+describe('normalizeMathDelimiters', () => {
+  it('returns an empty string for empty input', () => {
+    expect(normalizeMathDelimiters('')).toBe('');
+  });
+
+  it('leaves text without math untouched', () => {
+    const input = 'Hello world, nothing to see here.';
+    expect(normalizeMathDelimiters(input)).toBe(input);
+  });
+
+  it('promotes inline `$$...$$` to a block math fence', () => {
+    const out = normalizeMathDelimiters('before $$E=mc^2$$ after');
+    expect(out).toBe('before \n\n$$\nE=mc^2\n$$\n\n after');
+  });
+
+  it('promotes multiple inline `$$...$$` occurrences on the same line', () => {
+    const out = normalizeMathDelimiters('$$a$$ and $$b$$');
+    expect(out).toBe('\n\n$$\na\n$$\n\n and \n\n$$\nb\n$$\n\n');
+  });
+
+  it('leaves a properly fenced multi-line block math expression unchanged', () => {
+    const input = '$$\n\\int_0^1 x^2 dx\n$$';
+    expect(normalizeMathDelimiters(input)).toBe(input);
+  });
+
+  it('converts LaTeX-style `\\(...\\)` to inline math', () => {
+    const out = normalizeMathDelimiters('The expression \\(a+b\\) is small.');
+    expect(out).toBe('The expression $a+b$ is small.');
+  });
+
+  it('converts LaTeX-style `\\[...\\]` to a block math fence', () => {
+    const out = normalizeMathDelimiters('See \\[a+b\\] above.');
+    expect(out).toBe('See \n\n$$\na+b\n$$\n\n above.');
+  });
+
+  it('handles multi-line `\\[...\\]` bodies', () => {
+    const out = normalizeMathDelimiters('\\[\n a+b \n\\]');
+    expect(out).toBe('\n\n$$\na+b\n$$\n\n');
+  });
+
+  it('does not transform `$$...$$` inside a fenced code block', () => {
+    const input = '```\n$$x$$\n```';
+    expect(normalizeMathDelimiters(input)).toBe(input);
+  });
+
+  it('does not transform `$$...$$` inside a tilde-fenced code block', () => {
+    const input = '~~~\n$$x$$\n~~~';
+    expect(normalizeMathDelimiters(input)).toBe(input);
+  });
+
+  it('does not transform `$$...$$` inside an inline code span', () => {
+    const input = 'see `$$x$$` here';
+    expect(normalizeMathDelimiters(input)).toBe(input);
+  });
+
+  it('does not transform LaTeX delimiters inside a fenced code block', () => {
+    const input = '```\nuse \\(x\\) and \\[y\\] verbatim\n```';
+    expect(normalizeMathDelimiters(input)).toBe(input);
+  });
+
+  it('still transforms math outside the code block when both coexist', () => {
+    const input = '```\n$$inside$$\n```\noutside $$x$$ after';
+    const out = normalizeMathDelimiters(input);
+    expect(out).toContain('```\n$$inside$$\n```');
+    expect(out).toContain('\n\n$$\nx\n$$\n\n');
+  });
+
+  it('leaves a lone dollar sign alone', () => {
+    const input = 'The price is $5.';
+    expect(normalizeMathDelimiters(input)).toBe(input);
+  });
+
+  it('leaves two unrelated dollar amounts alone', () => {
+    const input = 'It costs $5 and $10 in total.';
+    expect(normalizeMathDelimiters(input)).toBe(input);
+  });
+
+  it('trims internal whitespace inside transformed `$$...$$`', () => {
+    const out = normalizeMathDelimiters('$$  x + y  $$');
+    expect(out).toBe('\n\n$$\nx + y\n$$\n\n');
+  });
+});