@genesislcap/ai-assistant 15.86.1 → 15.87.0

package/dist/esm/headless/headless.types.js

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

package/dist/esm/headless/index.js

@@ -0,0 +1,3 @@
+export { describeInteraction } from './describe-interaction';
+export { headlessCurrentDebugLog, headlessDiagnosticEntries, headlessMetaSnapshot, } from './headless-debug';
+export { HeadlessSession } from './headless-session';

package/dist/esm/headless-server/compact.js

@@ -0,0 +1,160 @@
+/** How much of an assistant message a reply carries: its first lines, and how long it was. */
+const MESSAGE_LINES = 3;
+const MESSAGE_CHARS = 300;
+/** A turn's final text is what a written question looks like, so it gets more room. */
+const TURN_TEXT_CHARS = 1500;
+/** The first `lines` lines of `text`, at most `chars` characters, and its full length when it was cut. */
+export function firstLines(text, lines, chars) {
+    const kept = text.split('\n').slice(0, lines).join('\n');
+    const cut = kept.length > chars ? `${kept.slice(0, chars)}…` : kept;
+    return cut === text ? { text } : { text: cut, chars: text.length };
+}
+/** The keys of `source` that are set, as a new object: a field with nothing to say is dropped. */
+export function present(source) {
+    const out = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (value === undefined || value === null || value === '' || value === false)
+            continue;
+        if (Array.isArray(value) && value.length === 0)
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+/**
+ * One session event, compact. `decision` and `working` are not reported as events: what the person is asked
+ * is the reply's `decision`, and what is working is its `working`. A message carries its first lines and
+ * its length; a probe event is the host's view of it (see `ServerOptions.probeEvent`).
+ */
+export function compactEvent(event, options = {}) {
+    switch (event.type) {
+        case 'decision':
+        case 'working':
+            return undefined;
+        case 'settled':
+            return Object.assign({ event: 'settled', component: event.component }, present({
+                answeredBy: event.answeredBy,
+                auto: event.auto,
+                raw: event.raw,
+                resolvedItself: event.resolvedItself,
+            }));
+        case 'message': {
+            const { text, chars } = firstLines(event.text, MESSAGE_LINES, MESSAGE_CHARS);
+            return Object.assign({ event: 'message', text }, present({ chars: chars !== null && chars !== void 0 ? chars : event.chars }));
+        }
+        case 'turn': {
+            const out = Object.assign({ event: 'turn', reason: event.reason }, present({ failureReason: event.failureReason }));
+            if (event.text) {
+                const { text, chars } = firstLines(event.text, Number.MAX_SAFE_INTEGER, TURN_TEXT_CHARS);
+                out.text = text;
+                if (chars !== null && chars !== void 0 ? chars : event.chars)
+                    out.chars = chars !== null && chars !== void 0 ? chars : event.chars;
+            }
+            return out;
+        }
+        case 'autopilot':
+            // An autopilot that is not available says nothing the reader can use.
+            if (event.mode === 'unavailable' && !event.needsUser)
+                return undefined;
+            return Object.assign({ event: 'autopilot', mode: event.mode, status: event.status }, present({ needsUser: event.needsUser, working: event.working, reason: event.reason }));
+        case 'error':
+            return { event: 'error', where: event.where, message: event.message };
+        case 'probe': {
+            const view = options.probeEvent;
+            if (!view) {
+                const changed = Object.fromEntries(event.changed.map((key) => [key, event.probe[key]]));
+                return Object.assign({ event: 'probe' }, changed);
+            }
+            if (!event.changed.some((key) => view.keys.includes(key)))
+                return undefined;
+            return Object.assign({ event: view.name }, Object.fromEntries(view.keys.map((key) => { var _a; return [key, (_a = event.probe[key]) !== null && _a !== void 0 ? _a : null]; })));
+        }
+        default:
+            return undefined;
+    }
+}
+/** How the platform's Views list marks the preview view (`renderViews`), at the end of its line. */
+const PREVIEW_MARK = ' (shown below as Now)';
+/** The line that carries the preview view as JSON (`renderDecision`). */
+const NOW_PREFIX = 'Now: ';
+/** What `capRead` appends, on a line of its own, to a read it cut. It belongs to the `Now:` line. */
+const CUT_PREFIX = '[Cut at ';
+/**
+ * A decision's text without its `Now: <the preview view as JSON>` line, and nothing else (`decisionText:
+ * "lean"`). `renderDecision` writes the preview as `Now: ${capRead(JSON.stringify(view))}`: `JSON.stringify`
+ * with no indent never breaks a line, so the JSON is the one line, and `capRead` adds a second, `[Cut at …]`,
+ * only when it cut it. Both go; in their place is a pointer to `read`. The line is found by position, not
+ * by prefix alone: it follows the Views list, whose entry for the preview ends `(shown below as Now)`, so a
+ * card that itself has a line starting `Now: ` is not mistaken for it.
+ *
+ * The text comes back as it was when there is no preview to find (a card with no preview view, or a short-form
+ * decision, which shows no `Now:`), or when `views` does not name the one the Views list marks.
+ */
+export function leanDecisionText(text, views) {
+    var _a;
+    const names = Object.keys(views !== null && views !== void 0 ? views : {});
+    if (!names.length)
+        return text;
+    const lines = text.split('\n');
+    const marked = lines.findIndex((line) => line.endsWith(PREVIEW_MARK));
+    if (marked < 0)
+        return text;
+    // The entry starts at or before the marked line (a description may run to several lines).
+    const startsEntry = (line, name) => line === `  ${name}${PREVIEW_MARK}` || line.startsWith(`  ${name} — `);
+    let entry = marked;
+    while (entry >= 0 && !names.some((n) => startsEntry(lines[entry], n)))
+        entry -= 1;
+    const view = entry < 0 ? undefined : names.find((n) => startsEntry(lines[entry], n));
+    if (view === undefined)
+        return text;
+    const now = lines.findIndex((line, i) => i > marked && line.startsWith(NOW_PREFIX));
+    if (now < 0)
+        return text;
+    const end = ((_a = lines[now + 1]) === null || _a === void 0 ? void 0 : _a.startsWith(CUT_PREFIX)) ? now + 2 : now + 1;
+    lines.splice(now, end - now, `(The "${view}" view is not repeated here: read it with read ${view}.)`);
+    return lines.join('\n');
+}
+/**
+ * A decision as the reply carries it: what to read and what to choose from, and nothing empty. With
+ * `decisionText: "lean"` its `text` leaves out the preview view's JSON ({@link leanDecisionText}); nothing
+ * else about it changes.
+ */
+export function compactDecision(description, decisionText = 'full') {
+    const actions = description.actions.map((a) => (Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (a.n !== undefined ? { n: a.n } : {})), { name: a.name }), present({ label: a.label !== a.name ? a.label : undefined })), { enabled: a.enabled }), present({
+        unavailable: a.unavailable,
+        args: a.args,
+        argsSchema: a.args === 'fields' ? a.argsSchema : undefined,
+    }))));
+    return Object.assign(Object.assign({ interactionId: description.interactionId, component: description.component, text: decisionText === 'lean'
+            ? leanDecisionText(description.text, description.views)
+            : description.text, actions }, (description.views && Object.keys(description.views).length
+        ? { views: Object.assign({}, description.views) }
+        : {})), (description.controller ? {} : { controller: false }));
+}
+/**
+ * A decision cut to what a caller who has already read the card needs: which interaction, and the actions as
+ * `n`, `name`, `enabled`. For the reply to an edit, and to a refused action, where the card has not changed
+ * enough to be worth sending again.
+ */
+export function shortDecision(interactionId, component, actions) {
+    return {
+        interactionId,
+        component,
+        actions: actions.map((a) => (Object.assign(Object.assign({}, (a.n !== undefined ? { n: a.n } : {})), { name: a.name, enabled: a.enabled }))),
+    };
+}
+/** The most an action's `output` may take in a reply, as JSON. */
+const OUTPUT_CHARS = 4000;
+/** What an editing action returned, as the reply carries it: whole when small, else its first characters. */
+export function capOutput(output) {
+    let json;
+    try {
+        json = JSON.stringify(output);
+    }
+    catch (_a) {
+        return String(output);
+    }
+    if (json === undefined || json.length <= OUTPUT_CHARS)
+        return output;
+    return { truncated: `${json.slice(0, OUTPUT_CHARS)}…`, chars: json.length };
+}

package/dist/esm/headless-server/index.js

@@ -0,0 +1,21 @@
+/**
+ * Node-only entry point for the headless assistant protocol server
+ * (`@genesislcap/ai-assistant/headless-server`).
+ *
+ * The server speaks a small HTTP/JSON protocol over a {@link HeadlessSession}: one JSON command in,
+ * one compact JSON reply out. A coding agent or a script can drive an assistant journey with no
+ * browser. It uses `node:http` and `node:fs`, so it has an entry of its own, built for Node
+ * (`dist/headless-server.{mjs,cjs}`), and is never reachable from the package root
+ * (`src/index.ts`): a browser bundle must not see a `node:` import.
+ *
+ * It knows only a session and Node built-ins. Its imports of `../headless` are type-only, so the
+ * bundle carries no second copy of `HeadlessSession`: the session it is given comes from
+ * `@genesislcap/ai-assistant` (or `/chat-driver`), whichever the host built it with.
+ * `headless-server-entry.test.ts` holds all of this.
+ *
+ * @packageDocumentation
+ * @beta
+ */
+export { capOutput, compactDecision, compactEvent, firstLines, leanDecisionText, shortDecision, } from './compact';
+export { createHeadlessServer } from './server';
+export { DECISION_TEXTS, DEFAULT_DECISION_TEXT } from './types';