@opencxh/domain 1.154.0 → 1.158.0

package/dist/platform/ai-tools.d.ts

@@ -104,6 +104,26 @@ export interface AiToolResult {
      */
     sources?: ToolSource[];
 }
+/**
+ * Stabiele sleutel voor "dit heb ik al laten zien".
+ *
+ * De volgorde `id` → `url` → `title` is aflopend in betrouwbaarheid: een id is stabiel, een
+ * url meestal, een titel alleen bij gebrek aan beide. Dat laatste is bewust geen fout — een
+ * geheugen-item heeft geen pagina en soms geen id, en dan is de titel de enige identiteit die
+ * het heeft. Een sleutel is nooit leeg, want dan zou hetzelfde item elke ronde terugkomen.
+ */
+export declare function sourceKey(source: ToolSource): string;
+/**
+ * Wat hiervan nieuw is, met de sleutels erbij.
+ *
+ * Voor een oppervlak dat zichzelf ongevraagd bijwerkt (live meelezen) is dit het verschil
+ * tussen "drie kaarten" en "dezelfde drie kaarten, elke acht seconden opnieuw". Ontdubbelt
+ * ook binnen de lading zelf: twee banen kunnen hetzelfde artikel aandragen.
+ */
+export declare function freshSources(sources: readonly ToolSource[], alreadyShown?: readonly string[]): {
+    sources: ToolSource[];
+    keys: string[];
+};
 /**
  * Returned by an app's `GET /provider/ai-tools/describe`.
  *

package/dist/platform/audio-gate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/platform/context.d.ts

@@ -17,6 +17,22 @@ export interface HostContext {
     title?: string;
     /** Highest wins when multiple apps claim the same route. */
     priority?: number;
+    /**
+     * De interactie waar dit oppervlak over gaat, als er één is.
+     *
+     * Als **veld** en niet als losse `slices`-sleutel: een paneel dat hierop leunt hoort te
+     * kunnen vertrouwen dat het er is. `CallTranscriptTab` hing zijn "Opslaan als notitie" hier
+     * al aan terwijl niemand het vulde, dus die knop was permanent uitgeschakeld — een
+     * toevallige sleutel geeft geen typefout, een ontbrekend veld wel.
+     */
+    interactionId?: string;
+    /**
+     * De **live** gesprekssessie, alleen gevuld zolang er een verbinding staat.
+     *
+     * Dit is de sleutel waarmee een paneel zich op `transcripts.deltas$(sessionId)` abonneert.
+     * Zonder dit veld toonde de transcript-tab altijd de lege staat, ongeacht wat er gezegd werd.
+     */
+    sessionId?: string;
     /** Extra data providers attach (e.g. interaction, activities, transcripts). */
     slices?: Record<string, unknown>;
 }

package/dist/platform/presence.d.ts

@@ -97,3 +97,62 @@ export interface AgeablePresence {
  * on a real transition.
  */
 export declare function agePresenceEntry<T extends AgeablePresence>(entry: T, now: number): T;
+/**
+ * Voor welk **team** iemand nu werkt.
+ *
+ * De rol van een medewerker is een eigenschap van de persoon en niet van het gesprek: een
+ * support-medewerker doet meestal één ding, en op een persoonlijk kanaal is er niets aan het
+ * gesprek af te lezen. Deze instelling staat naast presence om dezelfde reden dat presence
+ * bestaat — het is "hoe ben ik nu", niet "wie ben ik".
+ *
+ * Waarde is een `teamId` en geen profielverwijzing: team is de scope waar profielen, onderwerpen,
+ * workflows en inboxen al op gescoped zijn, en het is ook wat een gerouteerd gesprek oplevert
+ * (`assignedInboxId` → `Inbox.teamId`). Eén keuze lost ze allemaal consistent op.
+ */
+export interface WorkMode {
+    userId: string;
+    teamId: string;
+    /** `"manual"` of een bron die het namens de gebruiker zette (een rooster, later). */
+    source: string;
+}
+/**
+ * Voor welk team deze gebruiker nu werkt, en of hij daarvoor iets moet kiezen.
+ *
+ * Drie uitkomsten, en de derde is het hele punt:
+ *
+ * - **`teamId`** — óf expliciet gezet, óf impliciet omdat er maar één team is. Wie één ding doet
+ *   hoeft nooit iets in te stellen.
+ * - **`undefined` met `mustChoose: false`** — geen enkel team; er is niets te kiezen en niets te
+ *   doen.
+ * - **`undefined` met `mustChoose: true`** — meer dan één team en niets gekozen. Dan hoort een
+ *   oppervlak dat op de rol leunt te **zwijgen** in plaats van er één te raden: fout gokken is
+ *   erger dan niets tonen, en dat is dezelfde fail-closed regel als bij de account↔kanaal-binding.
+ *
+ * Pure functie, want dit is de enige echte beslissing in de werkmodus — de rest is opslag.
+ */
+export declare function resolveWorkMode(stored: {
+    teamId?: string;
+} | null | undefined, readableTeamIds: readonly string[]): {
+    teamId?: string;
+    mustChoose: boolean;
+};
+/**
+ * Mag de audio-pijplijn lopen — en dus: mag er meegelezen worden?
+ *
+ * Twee onafhankelijke voorwaarden, en dat is precies waarom dit een functie is en geen `&&` op
+ * de plek van gebruik:
+ *
+ * - **`providerAvailable`** — is er een STT-provider geregistreerd. Dat was tot nu toe de énige
+ *   voorwaarde, en daarmee was "de AI-app is geïnstalleerd" hetzelfde als "we luisteren mee bij
+ *   elk gesprek, org-breed". Een technische toevalligheid als beleid.
+ * - **`allowed`** — wil de organisatie dat. Een assistent die ongevraagd meeleest hoort niet te
+ *   bestaan zonder dat je hem kunt stoppen.
+ *
+ * De gate wordt elke twee seconden opnieuw geasserteerd (federated remotes kunnen hun handler
+ * later registreren dan deze app boot), dus een schakelaar die niet in deze functie zit racet
+ * tegen die tik en gaat vanzelf weer aan.
+ */
+export declare function shouldRunAudioPipeline(input: {
+    providerAvailable: boolean;
+    allowed: boolean;
+}): boolean;

package/dist/platform/resource.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Waar iets **over gaat**: een verwijzing naar een resource, los van welke app hem bezit.
+ *
+ * Dit type stond in `entities/read-state`, met als doc "so read-state (and, later, an audit log)
+ * can attach to any resource". Dat "later" is nu: een run heeft precies dezelfde verwijzing nodig.
+ * Hij is daarom naar `platform/` gehesen in plaats van er een tweede naast te zetten — read-state
+ * exporteert hem door, zodat geen enkele bestaande importeur verandert.
+ *
+ * De platformbrede sleutelvorm is `"<soort>:<id>"`: dat is wat `authorizeScope` aanneemt, wat
+ * `ScopeAuthorizeRequest.scopeKey` draagt, en waar de dossiersleutels uit bestaan. {@link refKey}
+ * is de brug daarheen.
+ *
+ * Let op de veldnaam: `type`, terwijl de rest van de codebase `kind` gebruikt voor een
+ * discriminant (`OwnerScope.kind`, `ActingIdentity.kind`, `Decider.kind`, `splitScopeKey().kind`).
+ * Dat is een inconsistentie van vóór dit type, en hem hier omdopen zou read-state en de
+ * resource-reminders meesleuren — een eigen opruiming, niet deze.
+ */
+export interface ResourceRef {
+    /** `"interaction"`, `"task"`, … — dezelfde soorten die een scope-provider declareert. */
+    type: string;
+    id: string;
+}
+/** De sleutelvorm die `authorizeScope` en de dossiersleutels gebruiken. */
+export declare function refKey(ref: ResourceRef): string;
+/**
+ * De soort die comms bezit, en de enige waar de engine iets extra's van weet: op een interactie
+ * kun je wachten op een antwoord en een regel in de tijdlijn zetten. Andere soorten kunnen dat
+ * niet, en dat is geen omissie maar het verschil tussen een gesprek en een taak.
+ */
+export declare const INTERACTION_KIND = "interaction";
+/**
+ * Het interactie-id, als dit onderwerp een gesprek is.
+ *
+ * Bestaat zodat de twee dingen die écht een gesprek nodig hebben (`wait-for-reply` en de
+ * lifecycle-marker) daarnaar kunnen vragen zonder overal `type === "interaction"` uit te
+ * schrijven — en zodat een run over een taak daar netjes `undefined` uit krijgt in plaats van
+ * stilzwijgend een id dat naar het verkeerde soort wijst.
+ */
+export declare function interactionIdOf(subject: ResourceRef | undefined): string | undefined;

package/dist/platform/sdk.d.ts

@@ -105,8 +105,14 @@ export interface InternalSDK<LocalServices extends ServiceMap = {}, TranslationK
             partials$(sessionId: string): Observable<TranscriptSegment>;
             persist(sessionId: string): Promise<void>;
             clear(sessionId: string): void;
+            /**
+             * `opts.from` is de index waar `segments` in het transcript begint: `0` is het hele
+             * transcript, hoger maakt het een delta op wat de ontvanger al heeft. Zonder dat stuurde
+             * elke flush (elke ~3s) de complete array opnieuw.
+             */
             setPersister(fn: (sessionId: string, segments: TranscriptSegment[], opts: {
                 finalize: boolean;
+                from: number;
             }) => Promise<void>): void;
         };
     };

package/dist/platform/tool-sources.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/platform/transcript-cadence.d.ts

@@ -0,0 +1,93 @@
+import { TranscriptSegment } from './media';
+/**
+ * Wanneer is er genoeg nieuw gezegd om opnieuw te gaan kijken?
+ *
+ * Dit is de héle beslissing achter een live-meelezende assistent, en met opzet puur: geen
+ * model, geen klok, geen store. Comms bepaalt *wanneer* (hier), de ai-app bepaalt *wat*.
+ *
+ * De twee valkuilen die de drempels hieronder afdekken:
+ *
+ * - **Te vaak.** De transcribe-route wordt elke ~3 seconden per actief gesprek geraakt. Zonder
+ *   vloer is dat 20 zoekrondes per minuut per gesprek, waarvan de meeste hetzelfde antwoord
+ *   opleveren omdat er één woord bij is gekomen.
+ * - **Te gretig.** "Ja." en "Klopt." zijn nieuwe uitingen maar geen nieuw onderwerp. Daarom
+ *   telt niet alleen tijd, maar ook of de zoekvraag wérkelijk verschoven is.
+ *
+ * De vergelijking gebeurt tegen de vorige **uitgevoerde** zoekvraag, niet tegen het vorige
+ * venster: anders schuift het onderwerp mee met het venster en vuurt hij eeuwig door.
+ */
+/** Hoeveel gesprek er in de zoekvraag gaat. Ouder dan dit is niet meer waar het over gaat. */
+export declare const CADENCE_WINDOW_MS = 60000;
+/** Ondergrens tussen twee rondes, ongeacht hoeveel er gezegd is. */
+export declare const CADENCE_FLOOR_MS = 8000;
+/** Minder dan dit aantal nieuwe definitieve uitingen is nog geen nieuw onderwerp. */
+export declare const CADENCE_MIN_NEW_SEGMENTS = 2;
+/** Onder dit aandeel nieuwe woorden gaat het nog over hetzelfde. */
+export declare const CADENCE_MIN_NOVELTY = 0.4;
+/** De losse woorden waar een zoekvraag op rust: kleine letters, zonder ruis, zonder dubbelen. */
+export declare function extractTerms(text: string): string[];
+/**
+ * Welk deel van waar het nú over gaat, is nog niet opgezocht? 1 is volledig nieuw, 0 is
+ * precies dezelfde vraag.
+ *
+ * Bewust asymmetrisch, en niet Jaccard. Het venster groeit terwijl de vorige zoekvraag
+ * blijft staan, en Jaccard straft die groei af: hoe langer het gesprek over één onderwerp
+ * doorgaat, hoe lager de symmetrische overlap wordt, tot hij alsnog vuurt. Dat is exact de
+ * "vuurt eeuwig door"-fout die de vergelijking moest voorkomen. De vraag die telt is
+ * eenzijdig: staat er iets nieuws op tafel?
+ */
+export declare function novelty(current: readonly string[], previous: readonly string[]): number;
+/**
+ * De laatste ~60 seconden gesproken tekst, schoongemaakt.
+ *
+ * Het venster wordt gemeten vanaf de **laatste uiting**, niet vanaf de serverklok:
+ * `startedAt`/`endedAt` van een segment komen van de transcriptieprovider en hoeven niet
+ * dezelfde oorsprong te hebben als `Date.now()` hier. Onderling verschil is wél
+ * betrouwbaar, en dat is alles wat een venster nodig heeft.
+ *
+ * Partiële segmenten blijven eruit: die veranderen nog terwijl je ze leest.
+ */
+export declare function buildWindow(segments: readonly TranscriptSegment[], windowMs?: number): {
+    text: string;
+    segmentCount: number;
+};
+/**
+ * Hoeveel getoonde sleutels we bijhouden. Een gesprek van een half uur kan er honderden
+ * opleveren en de rij wordt bij elke flush in zijn geheel herschreven, dus dit is geen
+ * geheugen maar een venster: wat eruit valt mag opnieuw verschijnen.
+ */
+export declare const MAX_SHOWN_KEYS = 60;
+/**
+ * Wat dit gesprek al te zien heeft gekregen, plus wat er net bij kwam — zonder dubbelen en
+ * begrensd. De oudste sleutels vallen eruit, want de nieuwste zijn de kaarten die nu op het
+ * scherm staan.
+ */
+export declare function mergeShownKeys(existing: readonly string[], shown: readonly string[], max?: number): string[];
+/** Wat er van de vorige ronde bewaard is. Leeg betekent "nog nooit gekeken". */
+export interface CadenceState {
+    /** Serverklok van de vorige ronde — alleen voor de vloer. */
+    lastTriggerAt?: number;
+    /** Aantal definitieve uitingen op dat moment — alleen voor "hoeveel is er bij gekomen". */
+    lastSegmentCount?: number;
+    /** De vorige uitgevoerde zoekvraag, waar de onderwerpwissel tegen gemeten wordt. */
+    lastQueryTerms?: string[];
+}
+export type CadenceDecision = {
+    trigger: false;
+    reason: "no_speech" | "too_soon" | "too_few_new" | "same_topic";
+} | {
+    trigger: true;
+    text: string;
+    terms: string[];
+    segmentCount: number;
+};
+/**
+ * Vier poorten, van goedkoop naar duur — de eerste die dichtblijft, is het antwoord.
+ * `reason` is er zodat een gesprek dat níets oplevert te verklaren is zonder een debugger.
+ */
+export declare function decideCadence(input: {
+    segments: readonly TranscriptSegment[];
+    now: number;
+    state: CadenceState;
+    windowMs?: number;
+}): CadenceDecision;

package/dist/platform/transcript-cadence.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/platform/transcript-sanitize.d.ts

@@ -0,0 +1 @@
+export declare const sanitizeTranscript: (transcript: string) => string;

package/dist/platform/transcript-sanitize.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/platform/work-mode.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencxh/domain",
-  "version": "1.154.0",
+  "version": "1.158.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",