@komaa/standin-sdk 0.1.0

package/dist/minutes.d.ts

@@ -0,0 +1,398 @@
+import type { ToolSpec } from "./callTools.js";
+import type { PersonalChat } from "./chat.js";
+/**
+ * Turns kept. A long meeting must not grow without limit inside a process that
+ * is also carrying live audio.
+ */
+export declare const MAX_TRANSCRIPT_TURNS = 600;
+/** Things shown. Far fewer than turns, because a screen changes slowly. */
+export declare const MAX_TRANSCRIPT_VISUALS = 60;
+/**
+ * What the summarising model is given. The tail, not the head: the end of a
+ * meeting is what the minutes are mostly about.
+ */
+export declare const MAX_TRANSCRIPT_CHARS = 12000;
+/**
+ * How long one entry may grow before the next fragment starts a new one.
+ *
+ * Streaming transcripts arrive as fragments and {@link Transcript.add} joins
+ * them back up. Without this cap, one long same-speaker run - an hour of a
+ * group call heard as a single stream - becomes one ever-growing entry that the
+ * entry count can never trim.
+ */
+export declare const MAX_TRANSCRIPT_ENTRY_CHARS = 1000;
+/**
+ * Entries a recap is written from. {@link MAX_TRANSCRIPT_TURNS} is the hard
+ * bound on what is HELD; this is the window that reaches the model, and
+ * {@link Transcript.render} applies it.
+ */
+export declare const MAX_TRANSCRIPT_ENTRIES = 40;
+/**
+ * Entries below which a recap is not worth running: under four turns there is
+ * no meeting to summarise, only a greeting.
+ */
+export declare const RECAP_MIN_TURNS = 4;
+/** Which side of the call a turn came from. */
+export type TurnRole = "assistant" | "caller";
+/** One turn: who said it, what they said, and which side they are on. */
+export interface Turn {
+    readonly speaker: string;
+    readonly text: string;
+    /**
+     * Kept apart from {@link Turn.speaker} because the document labels the two
+     * sides differently, and because a fragment must never continue an entry from
+     * the other side. Absent on a turn built by hand, and absent means "caller".
+     */
+    readonly role?: TurnRole;
+}
+/** Options for {@link Transcript}. */
+export interface TranscriptOptions {
+    /**
+     * Entries HELD before the oldest is discarded. Defaults to the hard bound,
+     * {@link MAX_TRANSCRIPT_TURNS}. Lower it only to hold less of a long call in
+     * memory: what reaches the model is {@link Transcript.render}'s own window.
+     */
+    maxEntries?: number;
+}
+/**
+ * What was said, and what was shown, in the order it happened.
+ *
+ * The audio track records who SAID what. The visual track records who SHOWED
+ * what, and it is the half a transcript-first recap structurally cannot have:
+ * the agent was on the call and looked at the screen.
+ *
+ * Both are bounded. Feed it as the call runs:
+ *
+ * ```ts
+ * transcript.add(callerName, "we should push the launch to March");
+ * transcript.addVisual("Sara's shared screen: the Q3 revenue dashboard");
+ * ```
+ */
+export declare class Transcript {
+    #private;
+    constructor(options?: TranscriptOptions);
+    /** What was said, oldest first. */
+    get turns(): readonly Turn[];
+    /** What was shown, oldest first. */
+    get visuals(): readonly string[];
+    /**
+     * Record one turn. Empty text is ignored rather than recorded blank.
+     *
+     * A fragment continues the entry before it when the SAME speaker is still
+     * talking and the entry has room. Speech arrives in pieces, and a model fed
+     * half-sentences as separate turns writes minutes that read like a stutter.
+     *
+     * Merging across speakers is the case worth being careful about: every later
+     * person's words would be filed under the first speaker's name, which is
+     * worse than no attribution because it is confidently wrong. The role is
+     * checked with it, so the agent's own words never continue a caller's entry
+     * even on a call where both are recorded under one name.
+     */
+    add(speaker: string, text: string, role?: TurnRole): void;
+    /**
+     * Record something shown, for example a slide or a shared screen.
+     *
+     * Consecutive repeats are collapsed. The vision lane describes whatever is on
+     * screen each time it is asked, and a screen that has not changed would
+     * otherwise fill the record with the same line.
+     */
+    addVisual(what: string): void;
+    get empty(): boolean;
+    /**
+     * The transcript as the summarising model sees it.
+     *
+     * The last `maxEntries` entries, tailed again to `maxChars`. Both ends are
+     * deliberate: the recap window is small because a summary is mostly about how
+     * the meeting ENDED, and the character tail is what stops one long entry
+     * crowding out everything before it.
+     */
+    render(maxChars?: number, maxEntries?: number): string;
+}
+/**
+ * Whether somebody just asked for the meeting to be written up.
+ *
+ * Both halves are needed. "Summarise" alone is asked about a document, an email,
+ * or a page the agent is looking at; only paired with a word for the meeting
+ * itself does it mean minutes.
+ */
+export declare function isSummaryRequest(text: string): boolean;
+/**
+ * Ask a model for minutes, and only minutes.
+ *
+ * The instruction not to infer what was on screen is the load-bearing one. A
+ * model handed "Sara shared a dashboard" will happily invent the numbers on it,
+ * and minutes that invent numbers are worse than minutes with a gap.
+ */
+export declare function minutesPrompt(transcript: string): string;
+/**
+ * The tool a model calls to write the meeting up mid-call. Registered by a
+ * plugin that has somewhere to post it, which is why it is not a built-in: an
+ * agent on a one-to-one call has no chat to post minutes into.
+ */
+export declare const MINUTES_TOOL: ToolSpec;
+/**
+ * Where the minutes go. One value, decided once, before anything is written.
+ *
+ * Resolve it with {@link resolveMinutesTarget} at the start of a recap and pass
+ * this same object to every step after it: the summarising run, the document
+ * write and the send. No step downstream may work out a recipient of its own.
+ *
+ * That belt-and-braces reads as overkill until it happens: a message tool with
+ * no pinned target falls back to the operator's own chat when a reference is
+ * missing, and a customer's meeting minutes - the most sensitive thing this
+ * feature produces - are then delivered to the vendor. When the pinned target
+ * cannot be reached, not sending is the correct outcome. Sending somewhere else
+ * is not.
+ */
+export interface DeliveryTarget {
+    /** The meeting chat, or the caller's own 1:1 chat with this bot. */
+    readonly kind: "thread" | "caller-dm";
+    readonly conversationId: string;
+    readonly tenantId: string;
+}
+/** What {@link resolveMinutesTarget} needs to decide where minutes go. */
+export interface MinutesTargetOptions {
+    /** The call's thread id, as `session.start` gave it. */
+    threadId?: string;
+    /** Humans on the call, when a participants frame carried one. */
+    humanCount?: number;
+    /** The caller's AAD object id. A call that names nobody gets no target. */
+    callerAadId?: string;
+    /**
+     * The caller's remembered 1:1 chat, from `PersonalChats.forCaller()`, which
+     * is where the four narrowing rules live.
+     */
+    callerChat?: PersonalChat;
+    /** The tenant from `session.start`. The first choice, and normally the one. */
+    sessionTenantId?: string;
+    /** The tenant this worker is configured for. */
+    configTenantId?: string;
+}
+/**
+ * Decide where a recap should be posted, before a single token is generated.
+ *
+ * ```ts
+ * const target = resolveMinutesTarget({
+ *   threadId: session.threadId,
+ *   humanCount: session.humanCount,
+ *   callerAadId: session.caller.aadId,
+ *   callerChat: chats.forCaller({ callerAadId, tenantId }),
+ *   sessionTenantId: session.tenantId,
+ * });
+ * ```
+ *
+ * A group call is minuted into the meeting it summarises. Two signals say it is
+ * one, and either will do: a human count of two or more, and a meeting thread
+ * id. The count only arrives on topologies that send a participants frame - on
+ * a hosted worker it stays pinned at 1 - so a count-only test sent every
+ * MEETING recap to the caller's private chat instead, which is the minutes of a
+ * group call landing in one attendee's DM. The thread id is on `session.start`
+ * already and needs no roster.
+ *
+ * Anything else is a 1:1 call, and the target is the caller's own chat with
+ * this bot, which is admitted by `PersonalChats.forCaller()` and its four
+ * narrowing rules. The first of those is worth restating here: a chat counts as
+ * personal because its SCOPE says so, never because of how its conversation id
+ * is spelled. A bot's personal chat is addressed `a:1...`, while `19:...` is
+ * precisely the group and channel shape the rule exists to exclude, so an
+ * id-prefix test admits nothing at all.
+ *
+ * The tenant is taken from `session.start`, then from configuration, then from
+ * the remembered chat's sender. All three describe the tenant this worker is
+ * bound to. The caller's own tenant id is deliberately not one of them and is
+ * not even accepted here: it describes whoever is on the phone, and for a guest
+ * it is foreign or absent, so addressing a conversation with it reaches into an
+ * organisation this worker was never bound to. It is the one plausible-looking
+ * source that is actively wrong.
+ *
+ * Returns undefined when there is nowhere safe to post, which is a real answer:
+ * a call that identifies nobody and has no thread gets no minutes rather than
+ * minutes in a stranger's chat.
+ *
+ * One target comes back, the best one. When a caller keeps more than one
+ * admissible target - the thread first, the caller's chat behind it - the rule
+ * for walking to the next is: advance on an HTTP 404 and on nothing else. A
+ * gateway posts through a stored conversation reference and holds one only for
+ * conversations it has seen an activity from, so a meeting joined over the
+ * calling path answers 404 while the caller's own chat is perfectly reachable.
+ * A 401 is our signing and a 5xx is the gateway, and both would fail the same
+ * way at the next target; 404 is also the only status that proves nothing was
+ * delivered, so it is the only one where trying again cannot double-post.
+ */
+export declare function resolveMinutesTarget(options: MinutesTargetOptions): DeliveryTarget | undefined;
+/** What happened when the meeting was written up. */
+export interface RecapResult {
+    /** One sentence for the agent to say. Always present, including on failure. */
+    readonly spoken: string;
+    /** The minutes themselves, empty when none were produced. */
+    readonly minutes: string;
+    /** Where the Word document was written, when one was. */
+    readonly document?: string;
+    /** Whether the minutes actually reached the chat. */
+    readonly delivered: boolean;
+    /** Which target took them, when one did. */
+    readonly target?: DeliveryTarget;
+}
+/** Turn a transcript into minutes. Normally a {@link Consultant}. */
+export type Summariser = (prompt: string) => Promise<string>;
+/**
+ * What the gateway said about one attempted post.
+ *
+ * Branch on {@link PostOutcome.ok}, and never test the outcome itself for
+ * truth: an object is always truthy, so a recap the gateway rejected with a 404
+ * or a 401 reads as delivered, which is the very failure the log line exists to
+ * catch.
+ */
+export interface PostOutcome {
+    /** Whether the message actually landed. */
+    readonly ok: boolean;
+    /**
+     * The HTTP status behind it, when there was one. 404 is the only status that
+     * means this conversation cannot be reached, and the only one on which a
+     * second target is tried.
+     */
+    readonly status?: number;
+}
+/**
+ * Post the minutes into ONE named conversation.
+ *
+ * The target is handed over with the text rather than looked up again, because
+ * the recipient was settled before the summarising run and nothing downstream
+ * may choose another one. Return a {@link PostOutcome}, or a bare boolean where
+ * no status is available.
+ */
+export type Poster = (target: DeliveryTarget, text: string) => Promise<PostOutcome | boolean>;
+/**
+ * Said in the message when a document was written but could not ride along.
+ *
+ * A chat reply carries text and cards, not files. Somebody who was told the
+ * minutes were coming with a document, and gets text with no explanation,
+ * assumes the attachment was lost in transit and goes looking for it.
+ */
+export declare const DOCUMENT_NOT_ATTACHED: string;
+/** Options for {@link postMinutes}. */
+export interface PostMinutesOptions {
+    /** Where to keep the Word document. Omit and none is written. */
+    documentDir?: string;
+    /** The line under the document title, naming the call. */
+    subtitle?: string;
+    /** What the agent is called in the attributed transcript. */
+    assistantLabel?: string;
+    /** What an unnamed caller is called in the attributed transcript. */
+    callerLabel?: string;
+}
+/**
+ * Write the meeting up and post it. Never throws.
+ *
+ * This normally runs during teardown, where an exception takes the whole
+ * teardown with it, so every failure here comes back as a sentence instead.
+ *
+ * A call with nowhere to post is told apart from a call with nothing to say.
+ * Conflating them tells people their conversation did not count when it did.
+ *
+ * The target comes in already resolved, by {@link resolveMinutesTarget}, and is
+ * passed on to the delivery unchanged. A 1:1 call is no longer a refusal: it
+ * has a caller with their own chat, and that chat is a real target. Only an
+ * undefined target, which means nowhere safe was found, still says so out loud.
+ *
+ * Pass several targets, best first, when more than one conversation is
+ * admissible. The next is tried ONLY when the gateway answers 404.
+ */
+export declare function postMinutes(summarise: Summariser, transcript: Transcript, target: DeliveryTarget | readonly DeliveryTarget[] | undefined, deliver: Poster, options?: PostMinutesOptions): Promise<RecapResult>;
+/** One headed block of minutes: a heading, and the lines under it. */
+export interface MinutesSection {
+    readonly heading: string;
+    readonly items: readonly string[];
+}
+/**
+ * Read a model's markdown minutes into sections, for the document writer.
+ *
+ * Pure and total: every line of the input reaches the output, no line is
+ * dropped silently, and nothing here reads or writes anything.
+ *
+ * ```ts
+ * parseMinutesSections("### Decisions\n- the launch moves to March");
+ * // [{ heading: "Decisions", items: ["the launch moves to March"] }]
+ * ```
+ *
+ * Every form a summarising model actually emits is accepted. Asked for
+ * "### Key points" it returns "## Key points", "# Key points" or
+ * "**Key points:**" depending on the model and the day, and accepting one form
+ * only produced a single unheaded blob: the document still built, with every
+ * section break gone and nothing raised anywhere.
+ *
+ * The same goes for bullets. Models mix "- ", "* ", "• " and "1. " inside one
+ * answer, and often write a whole section as one prose paragraph with no bullet
+ * at all, so a line under a heading that carries no marker is kept as written
+ * rather than discarded.
+ *
+ * Content that arrives before any heading opens a section called "Summary",
+ * because a model that ignores the format instruction and answers in one
+ * paragraph would otherwise parse to nothing and produce a document with a
+ * title and no body.
+ *
+ * Sections with no items survive here on purpose. Omitting them is the
+ * DOCUMENT's job ({@link writeMinutesDocx}), which keeps this function
+ * round-trippable and leaves one place that decides what is worth printing.
+ */
+export declare function parseMinutesSections(text: string): MinutesSection[];
+/**
+ * Speaker attribution the text already carries: a name, a colon and a space.
+ *
+ * ```ts
+ * hasSpeakerPrefix("Sara: we should ship on Friday"); // true
+ * ```
+ *
+ * Only for the compatibility case where a caller hands in turns with the name
+ * baked into the text. A {@link Turn} carries its speaker in its own field,
+ * which is better, and needs no test.
+ *
+ * A leading colon and a leading space are both rejected, so ": ok" and
+ * " Sara: ok" are not mistaken for attribution.
+ */
+export declare function hasSpeakerPrefix(text: string): boolean;
+/** Options for {@link writeMinutesDocx}. All optional: old calls still hold. */
+export interface WriteMinutesDocxOptions {
+    /** One line under the title, naming the call. */
+    subtitle?: string;
+    /**
+     * Sections from {@link parseMinutesSections}. Given these, the `minutes`
+     * string is not read line by line: these are what gets written.
+     */
+    sections?: readonly MinutesSection[];
+    /**
+     * Turns to write up as an attributed transcript after the sections. A turn is
+     * named by its own speaker; one recorded as "assistant" takes
+     * `assistantLabel`, and one with no speaker at all takes `callerLabel`.
+     */
+    transcript?: Iterable<Turn>;
+    /** What the agent is called. Default "Assistant". */
+    assistantLabel?: string;
+    /** What an unnamed caller is called. Default "Caller". */
+    callerLabel?: string;
+}
+/**
+ * Write minutes to a Word-openable document, with no dependencies.
+ *
+ * ```ts
+ * writeMinutesDocx("Meeting minutes", minutes, path, {
+ *   subtitle: "Call with Dana - ~12 min, 3 human participants.",
+ *   sections: parseMinutesSections(minutes),
+ *   transcript: transcript.turns,
+ * });
+ * ```
+ *
+ * A .docx is a zip of four XML parts, and emitting them directly is a few dozen
+ * lines. A document format library would be a dependency every install pays for
+ * so that the small fraction who ask for minutes get a file, which is the wrong
+ * trade for an SDK.
+ *
+ * With no options it behaves as it always has: markdown emphasis around a whole
+ * line becomes a bold heading, because that is what a model reaches for.
+ *
+ * A section whose items are all blank is left out entirely, heading and all. A
+ * bare "Decisions" over white space reads as a section the agent failed to
+ * fill, rather than one that had nothing in it.
+ */
+export declare function writeMinutesDocx(title: string, minutes: string, path: string, options?: WriteMinutesDocxOptions): void;
+//# sourceMappingURL=minutes.d.ts.map

package/dist/minutes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minutes.d.ts","sourceRoot":"","sources":["../src/minutes.ts"],"names":[],"mappings":"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"}