@startsimpli/integrations 0.1.5 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/integrations",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Provider-agnostic types, API clients, hooks, and UI primitives for email + calendar integrations across StartSimpli apps.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/__tests__/corpus-copy.test.tsx

@@ -0,0 +1,196 @@
+/**
+ * What the corpus surfaces SAY, as opposed to what they fetch.
+ *
+ * Three defects the pre-demo rehearsal (bd startsim-768w.38.10) put on a
+ * screenshot, all of them the kind that survives a green test suite because no
+ * assertion ever read the sentence:
+ *
+ *   • Markdown rendered literally — `## Decisions` and `**$4,800**` as text
+ *     (bd startsim-768w.38.10, MINOR);
+ *   • `Answered by a none stub ((provider default))` — not English, and
+ *     `(provider default)` where the model's name belongs
+ *     (bd startsim-768w.38.21);
+ *   • `1 more record were searched`.
+ */
+import { describe, expect, it } from 'vitest';
+import { render, screen, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+
+import { Markdown, stripMarkdown } from '../components/Markdown';
+import { AskPage } from '../components/pages/AskPage';
+import { LibraryPage } from '../components/pages/LibraryPage';
+import { configuredModel } from '../corpus/llm';
+import { createFixtureCorpusApi, FIXTURE_DOCUMENTS, FIXTURE_ORG } from '../corpus/fixtures';
+import type { AskResult, CorpusAskApi, SourceDocument } from '../corpus/types';
+
+const SCOPE = { orgId: FIXTURE_ORG };
+
+const MARKDOWN_BODY = [
+  '## Decisions',
+  '- Globex pricing agreed at **$4,800 per month**, 20 seats included.',
+  '- Additional seats are `$95` each per month.',
+  '',
+  'See the [rate card](https://docs.example/rate-card) for the rest.',
+].join('\n');
+
+function resultWith(overrides: Partial<AskResult>): AskResult {
+  const document = FIXTURE_DOCUMENTS[0];
+  return {
+    status: 'answered',
+    answer: MARKDOWN_BODY,
+    citations: [{ documentId: document.id, document, quote: '**SAML SSO has not shipped**' }],
+    considered: [{ document, score: 1, matchedTerms: ['globex'], snippet: '' }],
+    unresolvedCitations: [],
+    droppedOutOfScope: 0,
+    provider: { provider: 'openai', model: 'gpt-4o-mini', live: true },
+    ...overrides,
+  };
+}
+
+function askApi(result: AskResult): CorpusAskApi {
+  return { ask: async () => result };
+}
+
+async function ask(result: AskResult) {
+  const user = userEvent.setup();
+  render(<AskPage api={askApi(result)} scope={SCOPE} />);
+  await user.type(screen.getByRole('textbox'), 'What did we agree?');
+  await user.click(screen.getByRole('button', { name: 'Ask' }));
+  return screen.findByRole('region', { name: 'Answer' });
+}
+
+// ---------------------------------------------------------------------------
+
+describe('Markdown is rendered, not printed', () => {
+  it('turns a heading into a heading rather than two hashes', () => {
+    render(<Markdown text={MARKDOWN_BODY} />);
+    expect(screen.getByText('Decisions')).toBeInTheDocument();
+    expect(screen.queryByText(/##/)).not.toBeInTheDocument();
+  });
+
+  it('emphasises an amount instead of wrapping it in asterisks', () => {
+    render(<Markdown text={MARKDOWN_BODY} />);
+    const strong = screen.getByText('$4,800 per month');
+    expect(strong.tagName).toBe('STRONG');
+    expect(screen.queryByText(/\*\*/)).not.toBeInTheDocument();
+  });
+
+  it('makes a list a list, and a link a link', () => {
+    render(<Markdown text={MARKDOWN_BODY} />);
+    expect(screen.getAllByRole('listitem')).toHaveLength(2);
+    expect(screen.getByRole('link', { name: 'rate card' })).toHaveAttribute(
+      'href',
+      'https://docs.example/rate-card',
+    );
+  });
+
+  it('keeps the label but drops the link for a scheme it does not trust', () => {
+    render(<Markdown text={'[click me](javascript:doSomething)'} />);
+    expect(screen.getByText('click me')).toBeInTheDocument();
+    expect(screen.queryByRole('link')).not.toBeInTheDocument();
+  });
+
+  it('leaves prose containing a lone asterisk exactly as written', () => {
+    // A false positive here silently edits somebody's contract.
+    render(<Markdown text={'Fees are 2.5% * the invoice total.'} />);
+    expect(screen.getByText('Fees are 2.5% * the invoice total.')).toBeInTheDocument();
+  });
+
+  it('flattens to plain text when a string is what is needed', () => {
+    expect(stripMarkdown('## Blocker\n- **SAML SSO** has not shipped')).toBe(
+      'Blocker\nSAML SSO has not shipped',
+    );
+  });
+});
+
+describe('LibraryPage renders a document’s own Markdown', () => {
+  it('shows the summary as prose, not as source', async () => {
+    const user = userEvent.setup();
+    const document: SourceDocument = { ...FIXTURE_DOCUMENTS[0], body: MARKDOWN_BODY };
+    const api = createFixtureCorpusApi({ scope: SCOPE, documents: [document], moneyEvents: [] });
+    render(<LibraryPage api={api} scope={SCOPE} />);
+
+    await user.click(await screen.findByText(document.title));
+    const detail = await screen.findByRole('region', { name: 'Record detail' });
+    expect(within(detail).getByText('Decisions')).toBeInTheDocument();
+    expect(within(detail).getByText('$4,800 per month').tagName).toBe('STRONG');
+  });
+});
+
+describe('AskPage says who answered, in English', () => {
+  it('names the model when one answered', async () => {
+    const panel = await ask(resultWith({}));
+    expect(within(panel).getByText('Answered by openai · gpt-4o-mini')).toBeInTheDocument();
+  });
+
+  it('says no model is configured rather than "a none stub ((provider default))"', async () => {
+    const panel = await ask(
+      resultWith({ provider: { provider: 'none', model: '', live: false } }),
+    );
+    expect(within(panel).getByText(/No model is configured for this workspace/)).toBeInTheDocument();
+    // The honesty is kept: it still says nothing live ran.
+    expect(within(panel).getByText(/no live model was called/)).toBeInTheDocument();
+    expect(within(panel).queryByText(/\(\(/)).not.toBeInTheDocument();
+    expect(within(panel).queryByText(/none stub/)).not.toBeInTheDocument();
+  });
+
+  it('still calls a stub a stub', async () => {
+    const panel = await ask(
+      resultWith({ provider: { provider: 'fixture', model: 'fixture-echo', live: false } }),
+    );
+    expect(
+      within(panel).getByText('Answered by a fixture stub (fixture-echo) — no live model was called'),
+    ).toBeInTheDocument();
+  });
+
+  it('renders the answer’s Markdown and flattens the citation quote', async () => {
+    const panel = await ask(resultWith({}));
+    expect(within(panel).getByText('Decisions')).toBeInTheDocument();
+    expect(within(panel).getByText('“SAML SSO has not shipped”')).toBeInTheDocument();
+  });
+
+  it('agrees in number about how many records went uncited', async () => {
+    const document = FIXTURE_DOCUMENTS[1];
+    const panel = await ask(
+      resultWith({
+        considered: [
+          { document: FIXTURE_DOCUMENTS[0], score: 1, matchedTerms: [], snippet: '' },
+          { document, score: 0.5, matchedTerms: [], snippet: '' },
+        ],
+      }),
+    );
+    expect(within(panel).getByText('1 more record was searched but not cited')).toBeInTheDocument();
+  });
+
+  it('uses the plural when more than one was passed over', async () => {
+    const panel = await ask(
+      resultWith({
+        considered: [
+          { document: FIXTURE_DOCUMENTS[0], score: 1, matchedTerms: [], snippet: '' },
+          { document: FIXTURE_DOCUMENTS[1], score: 0.5, matchedTerms: [], snippet: '' },
+          { document: FIXTURE_DOCUMENTS[2], score: 0.4, matchedTerms: [], snippet: '' },
+        ],
+      }),
+    );
+    expect(within(panel).getByText('2 more records were searched but not cited')).toBeInTheDocument();
+  });
+});
+
+describe('the model named before the first call is the CONFIGURED one', () => {
+  it('reads the provider’s own variable', () => {
+    expect(configuredModel('openai', { OPENAI_MODEL: 'gpt-4o-mini' })).toBe('gpt-4o-mini');
+    expect(configuredModel('anthropic', { ANTHROPIC_MODEL: 'claude-x' })).toBe('claude-x');
+  });
+
+  it('prefers the specific variable over the generic one', () => {
+    expect(configuredModel('openai', { OPENAI_MODEL: 'gpt-4o-mini', LLM_MODEL: 'other' })).toBe(
+      'gpt-4o-mini',
+    );
+  });
+
+  it('falls back to LLM_MODEL, and to nothing at all', () => {
+    expect(configuredModel('openai', { LLM_MODEL: 'gpt-5' })).toBe('gpt-5');
+    expect(configuredModel('openai', {})).toBe('');
+    expect(configuredModel('none', { OPENAI_MODEL: 'gpt-4o-mini' })).toBe('');
+  });
+});

package/src/__tests__/corpus-storage.test.ts

@@ -0,0 +1,301 @@
+/**
+ * THE SEAM: tenant storage -> `SourceDocument` (bd startsim-768w.38.22).
+ *
+ * WHY THIS FILE EXISTS. Every other suite in this package starts from a domain
+ * object. That is correct for a composer — it should be handed a contract — but
+ * it meant nothing in the package had ever run against the shape the pipeline
+ * really writes. The corpus delivery lands people as typed EDGES and puts only a
+ * `participant_count` on the document; the mapper read an inline
+ * `data.participants` array that `declare_canonical()` never emits. Both halves
+ * were individually correct, both were tested, and the Library shipped with an
+ * empty Parties block on every document the pipeline had ever delivered.
+ *
+ * So the assertions below start at the WIRE — raw `Entity` rows and raw
+ * `Relationship` rows, through `createCorpusApi`, out as documents — and they
+ * are the ones that go red if the two halves ever disagree again.
+ */
+import { describe, expect, it } from 'vitest';
+
+import { createCorpusApi } from '../corpus/client';
+import {
+  indexParticipants,
+  toMoneyEvent,
+  toParty,
+  toSourceDocument,
+} from '../corpus/entities';
+import type { TenantEntity, TenantRelationship } from '../corpus/entities';
+import {
+  createFixtureCorpusHttp,
+  FIXTURE_ORG,
+  FIXTURE_SOURCE_LABELS,
+  FIXTURE_TENANT_DOCUMENTS,
+  FIXTURE_TENANT_MONEY_EVENTS,
+  FIXTURE_TENANT_PARTIES,
+  FIXTURE_TENANT_RELATIONSHIPS,
+} from '../corpus/fixtures';
+import { rankDocuments } from '../corpus/retrieval';
+
+const SCOPE = { orgId: FIXTURE_ORG };
+
+function apiOver(overrides: Parameters<typeof createFixtureCorpusHttp>[0] = {}) {
+  const { http, requests } = createFixtureCorpusHttp(overrides);
+  const api = createCorpusApi({ http, scope: SCOPE, sourceLabels: FIXTURE_SOURCE_LABELS });
+  return { api, requests };
+}
+
+/** The exact row the corpus delivery writes, as read back on live tandem. */
+const DELIVERED_DOCUMENT: TenantEntity = {
+  id: '6c2f1e40-0000-4000-8000-000000000001',
+  entity_type: 'source_document',
+  external_id: 'granola:not_RHRSLnote00003',
+  name: 'Initech — security review',
+  data: {
+    url: 'https://notes.granola.ai/d/initech',
+    title: 'Initech — security review',
+    source: 'granola',
+    _origin: 'central-connector',
+    subtype: 'meeting',
+    summary: '## Blocker\n- **SAML SSO has not shipped**, and Initech will not sign without it.',
+    source_ref: 'not_RHRSLnote00003',
+    occurred_at: '2026-07-20T16:00:00Z',
+    participant_count: 2,
+  },
+  created_at: '2026-08-09T23:35:00Z',
+};
+
+const DELIVERED_PARTIES: TenantEntity[] = [
+  {
+    id: '6c2f1e40-0000-4000-8000-0000000000a1',
+    entity_type: 'party',
+    external_id: 'granola:priya@example.com',
+    name: 'Priya Nakamura',
+    data: {
+      source: 'granola', _origin: 'central-connector', subtype: 'person',
+      display_name: 'Priya Nakamura', email: 'priya@example.com', domain: 'example.com',
+      source_ref: 'priya@example.com',
+    },
+  },
+  {
+    id: '6c2f1e40-0000-4000-8000-0000000000a2',
+    entity_type: 'party',
+    external_id: 'granola:lena@example.com',
+    name: 'Lena Fischer',
+    data: {
+      source: 'granola', _origin: 'central-connector', subtype: 'person',
+      display_name: 'Lena Fischer', email: 'lena@example.com', domain: 'example.com',
+      source_ref: 'lena@example.com',
+    },
+  },
+];
+
+const DELIVERED_EDGES: TenantRelationship[] = [
+  { id: 'e1', rel_type: 'authored_by', source: DELIVERED_DOCUMENT.id, target: DELIVERED_PARTIES[0].id },
+  { id: 'e2', rel_type: 'involves', source: DELIVERED_DOCUMENT.id, target: DELIVERED_PARTIES[1].id },
+];
+
+// ---------------------------------------------------------------------------
+
+describe('the row the pipeline actually delivers', () => {
+  it('has NO inline participants — only a count', () => {
+    // If this ever stops being true the bug class has changed, and the rest of
+    // this file is testing the wrong thing.
+    const data = DELIVERED_DOCUMENT.data as Record<string, unknown>;
+    expect(data.participants).toBeUndefined();
+    expect(data.participant_count).toBe(2);
+  });
+
+  it('renders its people from the EDGES', async () => {
+    const { api } = apiOver({
+      entities: [DELIVERED_DOCUMENT, ...DELIVERED_PARTIES],
+      relationships: DELIVERED_EDGES,
+    });
+
+    const page = await api.listDocuments({ page: 1 });
+    const document = page.results[0];
+
+    expect(document.title).toBe('Initech — security review');
+    expect(document.participants.map((party) => party.name)).toEqual([
+      'Priya Nakamura',
+      'Lena Fischer',
+    ]);
+    // The AUTHOR leads, whatever order the edges paged in.
+    expect(document.participants[0].email).toBe('priya@example.com');
+  });
+
+  it('resolves people on the DETAIL fetch too, not only in the list', async () => {
+    const { api } = apiOver({
+      entities: [DELIVERED_DOCUMENT, ...DELIVERED_PARTIES],
+      relationships: DELIVERED_EDGES,
+    });
+    const document = await api.getDocument(String(DELIVERED_DOCUMENT.id));
+    expect(document.participants.map((party) => party.name)).toContain('Lena Fischer');
+  });
+
+  it('keeps a canonical party readable — `display_name`, not `name`', () => {
+    const party = toParty(DELIVERED_PARTIES[0], SCOPE);
+    expect(party.name).toBe('Priya Nakamura');
+    expect(party.kind).toBe('person');
+    expect(party.source).toBe('granola');
+  });
+});
+
+describe('both storage shapes, because both are real', () => {
+  it('still reads an inline participants array', () => {
+    const inline: TenantEntity = {
+      id: 'doc_inline',
+      entity_type: 'source_document',
+      data: {
+        source: 'upload', title: 'Hand-entered note',
+        participants: [{ id: 'p1', name: 'Ada Byron', email: 'ada@example.com' }],
+      },
+    };
+    expect(toSourceDocument(inline, SCOPE).participants.map((p) => p.name)).toEqual(['Ada Byron']);
+  });
+
+  it('unions the two without listing anyone twice', () => {
+    const both: TenantEntity = {
+      id: 'doc_both',
+      entity_type: 'source_document',
+      data: { source: 'upload', participants: [{ id: 'party_dana', name: 'Dana Reed' }] },
+    };
+    const merged = toSourceDocument(both, SCOPE, {}, [
+      { id: 'party_dana', name: 'Dana Reed', kind: 'person' },
+      { id: 'party_sam', name: 'Sam Ortiz', kind: 'person' },
+    ]);
+    expect(merged.participants.map((party) => party.name)).toEqual(['Dana Reed', 'Sam Ortiz']);
+  });
+
+  it('never puts a DOCUMENT in the parties list — `derived_from` is not a person', () => {
+    const byRecord = indexParticipants(FIXTURE_TENANT_RELATIONSHIPS, [
+      { id: 'party_dana', name: 'Dana Reed' },
+    ]);
+    // `not_7Kq2ZbVnRt4aXm` is the TARGET of a derived_from edge from doc one.
+    expect(byRecord.get('not_1d3tmYTlCICgjy')?.map((p) => p.id)).toEqual(['party_dana']);
+  });
+
+  it('drops an edge whose far end is not a party it can name', () => {
+    const byRecord = indexParticipants(
+      [{ rel_type: 'involves', source: 'doc_1', target: 'party_nobody' }],
+      [{ id: 'party_dana', name: 'Dana Reed' }],
+    );
+    expect(byRecord.size).toBe(0);
+  });
+
+  it('reads a money event’s party from its `billed_to` edge', async () => {
+    const { api } = apiOver();
+    const page = await api.listMoneyEvents!({ page: 1 });
+    const subscription = page.results.find((event) => event.id === 'sub_RedSuite01Acme')!;
+    expect(subscription.party?.name).toBe('Acme Robotics');
+    // …and the amount is still MINOR units off the canonical attribute.
+    expect(subscription.amount).toBe(400000);
+  });
+});
+
+describe('the graph read is bounded, cached and fails soft', () => {
+  it('costs ONE graph read across a list, a detail and a second page', async () => {
+    const { api, requests } = apiOver();
+    await api.listDocuments({ page: 1 });
+    await api.listDocuments({ page: 1 });
+    await api.getDocument('dbx_9812f0');
+
+    const relationshipReads = requests.filter((request) => request.path.includes('relationships'));
+    expect(relationshipReads).toHaveLength(1);
+  });
+
+  it('does not read the graph at all for an EMPTY corpus', async () => {
+    const { api, requests } = apiOver({ entities: [], relationships: [] });
+    const page = await api.listDocuments({ page: 1 });
+
+    expect(page.results).toEqual([]);
+    expect(requests.filter((request) => request.path.includes('relationships'))).toHaveLength(0);
+  });
+
+  it('still renders the corpus when the relationships endpoint is missing', async () => {
+    // A tenant one deploy behind must degrade to what it showed before this
+    // existed — not to an error where a Library used to be.
+    const { api } = apiOver({ missing: ['relationships'] });
+    const page = await api.listDocuments({ page: 1 });
+
+    expect(page.results.length).toBeGreaterThan(0);
+    expect(page.results.every((document) => document.participants.length === 0)).toBe(true);
+  });
+
+  it('walks every page of the graph, since the tenant ignores page_size', async () => {
+    // Two rows a page: the edges for the last document are only reachable by
+    // paging, which is exactly what the real PAGE_SIZE=50 does at scale.
+    const { api, requests } = apiOver({ pageSize: 2 });
+    // `pageSize: 100` is ignored by the server, exactly as the tenant ignores
+    // it — so the Dropbox row is on page THREE however wide the caller asked.
+    const page = await api.listDocuments({ page: 3, pageSize: 100 });
+    const dropbox = page.results.find((document) => document.id === 'dbx_9812f0');
+
+    expect(dropbox?.participants.map((party) => party.name)).toEqual(['Acme Robotics', 'Dana Reed']);
+    expect(requests.filter((request) => request.path.includes('relationships')).length).toBeGreaterThan(1);
+  });
+});
+
+describe('retrieval scores the people, not an empty string', () => {
+  it('finds a meeting by an attendee’s name that appears nowhere in its text', () => {
+    // `FIELD_WEIGHTS.participants` is 2 — second only to title. Before the edge
+    // join it scored an empty string on every row the pipeline delivered, so a
+    // question naming a person only landed if the prose happened to repeat it.
+    const documents = [
+      toSourceDocument(
+        DELIVERED_DOCUMENT,
+        SCOPE,
+        FIXTURE_SOURCE_LABELS,
+        indexParticipants(DELIVERED_EDGES, DELIVERED_PARTIES.map((row) => toParty(row, SCOPE))).get(
+          String(DELIVERED_DOCUMENT.id),
+        ) ?? [],
+      ),
+      toSourceDocument(FIXTURE_TENANT_DOCUMENTS[1], SCOPE, FIXTURE_SOURCE_LABELS),
+    ];
+    expect(documents[0].body).not.toContain('Lena');
+
+    const ranked = rankDocuments(documents, 'What did Lena Fischer raise?', { limit: 2 });
+    expect(ranked[0]?.document.id).toBe(String(DELIVERED_DOCUMENT.id));
+    expect(ranked[0]?.matchedTerms).toContain('lena');
+  });
+});
+
+describe('the fixtures are the pipeline’s shape, not a friendlier one', () => {
+  it('holds no inline participants anywhere in the raw rows', () => {
+    for (const entity of [...FIXTURE_TENANT_DOCUMENTS, ...FIXTURE_TENANT_MONEY_EVENTS]) {
+      const data = (entity.data ?? {}) as Record<string, unknown>;
+      expect(data.participants).toBeUndefined();
+      expect(data.attendees).toBeUndefined();
+      expect(data.party).toBeUndefined();
+    }
+  });
+
+  it('namespaces every external_id as `<connector_key>:<vendor id>`', () => {
+    for (const entity of [...FIXTURE_TENANT_DOCUMENTS, ...FIXTURE_TENANT_PARTIES]) {
+      const data = (entity.data ?? {}) as Record<string, unknown>;
+      expect(entity.external_id).toBe(`${String(data.source)}:${String(data.source_ref)}`);
+      expect(data._origin).toBe('central-connector');
+    }
+  });
+
+  it('serves them through the adapter with people on every meeting', async () => {
+    const { api } = apiOver();
+    const page = await api.listDocuments({ page: 1 });
+    const weekly = page.results.find((document) => document.sourceRef === 'not_1d3tmYTlCICgjy')!;
+
+    expect(weekly.participants.map((party) => party.name)).toEqual([
+      'Dana Reed', 'Sam Ortiz', 'Kim Li', 'Acme Robotics',
+    ]);
+    expect(weekly.sourceLabel).toBe('Granola');
+  });
+});
+
+describe('the tenant’s filters are still not honoured, and are still not faked', () => {
+  it('reports search as unapplied because the entities endpoint ignores it', async () => {
+    const { api, requests } = apiOver();
+    const page = await api.listDocuments({ search: 'SAML', page: 1 });
+
+    // The parameter IS sent — the day the API learns it, nothing here changes.
+    expect(requests[0].params.search).toBe('SAML');
+    expect(page.appliedFilters).toEqual([]);
+    expect(page.count).toBe(FIXTURE_TENANT_DOCUMENTS.length);
+  });
+});