@spark-strategic/helix-core 0.2.4 → 0.2.5

package/dist/chat/chat-store-context.js

@@ -0,0 +1,94 @@
+"use strict";
+// ============================================================================
+// GENERATED — DO NOT EDIT.
+// Vendored from @spark-strategic/helix-chat (auxiliary/helix-chat/src/chat-store-context.ts) by
+// helix-core/scripts/vendor-helix-chat.js at build time. Edit the canonical file
+// in @spark-strategic/helix-chat and rebuild; changes made directly here will be overwritten.
+// ============================================================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureChatStore = configureChatStore;
+exports.getChatStoreContext = getChatStoreContext;
+/**
+ * The dependency-injection seam for the durable chat store (`chat-store.ts`) and its
+ * §5.1 reconciler (`chat-reconcile.ts`).
+ *
+ * The store itself is pure Node (fs/path/crypto) and must stay that way so the SAME
+ * source can be vendored byte-for-byte into both consumers that ship standalone with
+ * plain `tsc`:
+ *
+ *   - helix-os   — the heavy node runtime. dataDir = `getConfig().dataDir`,
+ *                  logger  = its winston `getLogger()`.
+ *   - helix-core — the minimal personal-agent connector. dataDir = `~/.helix`,
+ *                  logger  = the connector's console logger.
+ *
+ * Those are the ONLY two things the store ever needed from its host (the `getConfig().dataDir`
+ * read in `storeDir()` and the `getLogger()` call in the fail-soft `warn`/`markAcked`/reconcile
+ * paths). Rather than import a host module, the host calls {@link configureChatStore} once at
+ * boot to inject them. Both are resolved LAZILY (`resolveDataDir()` is called per operation,
+ * the logger methods delegate at call time), so configuration order never matters and a host
+ * whose config/logger is set up after this module is imported still works — the exact lazy
+ * behavior the original `getConfig()`/`getLogger()` calls had.
+ *
+ * Fail-soft to the last: if a host forgets to configure, the store does NOT throw (it is pure
+ * instrumentation and must never break a turn). It falls back to `~/.helix` and a console
+ * logger — a safe default that keeps a lone import runnable.
+ */
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/** The safe fallback used until (or if) a host configures: `~/.helix` + console. Keeps
+ *  the store runnable on a bare import without ever throwing. */
+const DEFAULT_CONTEXT = {
+    resolveDataDir: () => path.join(os.homedir(), '.helix'),
+    logger: {
+        debug: () => { },
+        info: () => { },
+        warn: (m, x) => console.warn(`[helix-chat] ${m}`, x ?? ''),
+        error: (m, x) => console.error(`[helix-chat] ${m}`, x ?? ''),
+    },
+};
+let _ctx = null;
+/**
+ * Inject the host's data dir resolver + logger. Call once at boot. Idempotent — a later
+ * call simply replaces the context (useful for tests). Never throws.
+ */
+function configureChatStore(ctx) {
+    _ctx = ctx;
+}
+/** The active context, or the safe default if the host never configured. Never throws. */
+function getChatStoreContext() {
+    return _ctx ?? DEFAULT_CONTEXT;
+}
+//# sourceMappingURL=chat-store-context.js.map

package/dist/chat/chat-store-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-store-context.js","sourceRoot":"","sources":["../../src/chat/chat-store-context.ts"],"names":[],"mappings":";AAAA,+EAA+E;AAC/E,2BAA2B;AAC3B,gGAAgG;AAChG,iFAAiF;AACjF,8FAA8F;AAC9F,+EAA+E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoE/E,gDAEC;AAGD,kDAEC;AAzED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,uCAAyB;AACzB,2CAA6B;AAqB7B;iEACiE;AACjE,MAAM,eAAe,GAAqB;IACxC,cAAc,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,QAAQ,CAAC;IACvD,MAAM,EAAE;QACN,KAAK,EAAE,GAAG,EAAE,GAAE,CAAC;QACf,IAAI,EAAE,GAAG,EAAE,GAAE,CAAC;QACd,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC;QAC1D,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,gBAAgB,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC;KAC7D;CACF,CAAC;AAEF,IAAI,IAAI,GAA4B,IAAI,CAAC;AAEzC;;;GAGG;AACH,SAAgB,kBAAkB,CAAC,GAAqB;IACtD,IAAI,GAAG,GAAG,CAAC;AACb,CAAC;AAED,0FAA0F;AAC1F,SAAgB,mBAAmB;IACjC,OAAO,IAAI,IAAI,eAAe,CAAC;AACjC,CAAC"}

package/dist/chat/chat-store.d.ts

@@ -0,0 +1,313 @@
+/** Schema version stamped on every record so the inspect command can reject drift. */
+declare const SCHEMA: 1;
+export type ToolState = 'started' | 'executed' | 'indeterminate';
+export type TerminalReason = 'done' | 'error' | 'interrupted';
+/**
+ * §5.1 crash-reconcile disposition — the policy outcome the resume-path reconciler
+ * assigns to a ledger gap (`started && !executed`) by the tool's declared effect class:
+ *   - `resolved-safe`       pure/read/idempotent-keyed — a re-run is free or collapses
+ *                           by key, so nothing is stranded; no human/agent attention.
+ *   - `needs-verify`        verifiable — the agent should query reality by the key on
+ *                           its next turn and re-run only if the effect didn't land.
+ *   - `needs-agent-review`  irreversible-unverifiable (the fail-closed default) — never
+ *                           auto-replayed; surfaces as an agent-facing reconcile task.
+ */
+export type ReconcileDisposition = 'resolved-safe' | 'needs-verify' | 'needs-agent-review';
+export interface ToolLedgerEntry {
+    /** Stable per-turn display ordinal (for the §5.3 inspect command). */
+    ordinal: number;
+    /** §5.1 per-invocation key: the provider's `tool_use` id. The ledger dedupes on
+     *  it (replay = same id = no second entry). Absent only on the full-assistant-
+     *  message fallback path, which carries no streamed block id — those fall back to
+     *  the name/oldest-started heuristic for result resolution. */
+    toolCallId?: string;
+    /** Display name of the tool. */
+    name: string;
+    /** §5.1 effect class, resolved from the tool at call time (fail-closed default
+     *  `irreversible-unverifiable` for anything undeclared/undeterminable). */
+    effectClass: string;
+    startedAt: string;
+    executedAt?: string;
+    ok?: boolean;
+    state: ToolState;
+    /** §5.1 crash-reconcile verdict, written by the resume-path reconciler when it
+     *  visits this entry's gap. Absent until a reconcile pass runs; an `executed`
+     *  entry never gets one (no gap to reconcile). */
+    reconcile?: {
+        disposition: ReconcileDisposition;
+        /** The effect class the reconciler applied policy to (the recorded class today;
+         *  a refined class once record-time resolution is broadened). */
+        effectClass: string;
+        at: string;
+    };
+}
+/**
+ * Sender classification for the §5.3 inspector — the firewall verdict (agents-api,
+ * resolved server-side) reduced to the one label that answers "who is this message
+ * from, and how do I trust them?":
+ *   - `internal`           a recognized Helix colleague (mapped to a real User, `known`).
+ *   - `external-verified`  an EXTERNAL visitor the embedding site cryptographically
+ *                          vouched for (widget HMAC) — not a colleague, but identified
+ *                          and trusted to act on their own behalf.
+ *   - `anonymous`          an unidentified public-widget visitor.
+ *   - `unknown`            no identity resolved / an unrecognized sender the agent must
+ *                          not assume an identity for (and the absent-user fallback).
+ */
+export type IdentityClass = 'internal' | 'external-verified' | 'anonymous' | 'unknown';
+/** The firewall-resolved sender flags this store records (mirrors `AgentChatTurn.user`). */
+interface IdentityFlags {
+    id?: string;
+    email?: string;
+    name?: string;
+    known?: boolean;
+    anonymous?: boolean;
+    verified?: boolean;
+}
+/**
+ * Reduce the firewall's sender flags to one class. Precedence matches the firewall's
+ * own semantics: a recognized colleague (`known`) wins; else an HMAC-vouched external
+ * visitor (`verified`); else an anonymous public visitor; else unknown (the fail-closed
+ * default an undecidable/absent sender collapses to — the agent assumes no identity).
+ */
+export declare function classifyIdentity(user?: IdentityFlags): IdentityClass;
+/**
+ * Sender attribution recorded on the turn (§5.3). Answers who the message is from, their
+ * email, whether they're internal/external, and — for an external sender — whether the
+ * embedding site cryptographically verified them (HMAC). Derived once at turn open from
+ * the firewall-resolved `AgentChatTurn.user`/`org`; the raw flags are kept alongside the
+ * reduced `class` so the inspector can show both the verdict and what drove it.
+ */
+export interface TurnIdentity {
+    /** The reduced sender classification (`classifyIdentity`). */
+    class: IdentityClass;
+    userId?: string;
+    email?: string;
+    name?: string;
+    /** The org the agent serves this turn (customer org display name), for context. */
+    org?: string;
+    /** Raw firewall flags (what drove `class`). */
+    known?: boolean;
+    anonymous?: boolean;
+    verified?: boolean;
+}
+export interface ChatTurnRecord {
+    schema: typeof SCHEMA;
+    turnId: string;
+    sessionId: string;
+    agentId?: string;
+    /** §1.1 origination attribute (no bearing on lifecycle; recorded for context). */
+    createdBy: 'human' | 'agent';
+    /** §5.3 sender attribution — who this message is from and how they're trusted,
+     *  from the firewall verdict. Absent only on turns opened without a resolved user
+     *  (older records / non-attributed paths); the inspector reads it as `unknown`. */
+    identity?: TurnIdentity;
+    model?: string;
+    openedAt: string;
+    /** Renews on every committed stream frame — the §3.1 backstop's "last progress". */
+    lastProgressAt: string;
+    closedAt?: string;
+    terminalReason?: TerminalReason;
+    /** §5.1 reconcile-pass marker: set once the resume-path reconciler has visited this
+     *  turn and applied policy to its ledger gaps. Keeps the pass idempotent — a turn is
+     *  reconciled exactly once (`listTurnsNeedingReconcile` excludes anything stamped). */
+    reconciledAt?: string;
+    /** §5.1 residual-surfacing marker: set once this turn's unresolved residual
+     *  (`needs-verify`/`needs-agent-review` gaps) has been handed to the agent as a
+     *  reconcile task on a later turn (`takeReconcileResidualForSession`). Keeps the
+     *  hand-off single-shot — the residual surfaces to the agent exactly once, then the
+     *  agent owns it (verify / ask the user / let it drop); it never re-nags turn after
+     *  turn. The durable disposition on each entry stays readable in the inspector
+     *  regardless. Absent until a turn with residual is surfaced. */
+    reconcileSurfacedAt?: string;
+    /** Provider continuation handle, if the turn emitted one (resume anchor). */
+    providerRef?: string;
+    /** Stream buffer coordinates (§5.3). */
+    stream: {
+        lastStreamSeq: number;
+        byteCount: number;
+        complete: boolean;
+    };
+    /** Tool-call ledger (§5.3). */
+    tools: ToolLedgerEntry[];
+    /** Final-write state (§5.3). `acked` flips when agents-api confirms the final
+     *  message is durably in the DB transcript (§3.2 ack); `evicted` flips with it
+     *  (the node-local durable copy is then redundant and its content is dropped). */
+    final: {
+        written: boolean;
+        acked: boolean;
+        evicted: boolean;
+        /** When the server ack landed (the final write was confirmed durable). */
+        ackedAt?: string;
+    };
+    /** Settled attribution from the terminal `done` frame. */
+    usage?: unknown;
+    costUsd?: number | null;
+    durationMs?: number;
+    errorMessage?: string;
+    /** The accumulated agent content — the literal answer to "did it have everything?" */
+    content: string;
+}
+/**
+ * A live handle wrapping one turn's record. `streamChatTurn` drives it through the
+ * turn; every method is fail-soft so instrumentation can never break the turn.
+ */
+export declare class TurnRecordHandle {
+    private rec;
+    private timer;
+    private dirty;
+    private closed;
+    constructor(seed: {
+        sessionId: string;
+        agentId?: string;
+        createdBy?: 'human' | 'agent';
+        model?: string;
+        user?: IdentityFlags;
+        org?: string;
+    });
+    get turnId(): string;
+    /** A committed stream frame (a `chat_delta` leaving the node). Renews progress,
+     *  advances `streamSeq`, accumulates content. Disk flush is debounced. */
+    commitFrame(text: string): void;
+    /** Provider continuation handle learned mid-turn (resume anchor). */
+    markRef(providerRef: string): void;
+    /** Ledger: a tool call STARTED (written before the result — side-effect ordering,
+     *  §5.1). Flushed immediately so the `started && !executed` gap survives a crash.
+     *  Keyed by `toolCallId` (the provider `tool_use` id): a replay of the SAME
+     *  invocation (same id) dedupes and does NOT open a second entry, while two
+     *  distinct ids both record. `effectClass` is what the tool declared, resolved
+     *  fail-closed by the caller. */
+    toolStarted(name: string, opts?: {
+        toolCallId?: string;
+        effectClass?: string;
+    }): void;
+    /** Ledger: a tool call returned. Resolves the entry by `toolCallId` when the
+     *  result carries one (§5.1 — the exact invocation its call opened); otherwise
+     *  falls back to the oldest unresolved same-named call, then the oldest unresolved
+     *  call (the full-assistant-message path that carries no block id). */
+    toolExecuted(name: string, ok: boolean, opts?: {
+        toolCallId?: string;
+    }): void;
+    /** Terminal success: the final full-message write landed (§3.2). `complete` flips
+     *  true; `acked`/`evicted` await the §3.2 browser ack path (not wired here). */
+    markDone(settle: {
+        usage?: unknown;
+        costUsd?: number | null;
+        durationMs?: number;
+        providerRef?: string;
+    }): void;
+    /** Terminal failure frame. */
+    markError(message: string): void;
+    /** Seal a turn that reached no terminal frame (abort/transport drop/crash of the
+     *  stream loop). Any still-`started` tool call becomes `indeterminate` — the §5.1
+     *  fail-closed residual. No-op if the turn already closed via done/error. */
+    seal(): void;
+    private close;
+    private scheduleFlush;
+    private flushNow;
+    private warn;
+}
+/**
+ * Open a record for a new turn. Sweeps expired records first (cheap, bounded) so
+ * disk stays capped until the §3.2 ack-eviction path lands. Fail-soft: on any
+ * error returns a no-op-ish handle that still drives the turn without persisting.
+ */
+export declare function openTurnRecord(seed: {
+    sessionId: string;
+    agentId?: string;
+    createdBy?: 'human' | 'agent';
+    model?: string;
+    /** Firewall-resolved sender identity (§5.3 attribution), classified at open. */
+    user?: IdentityFlags;
+    /** Org the agent serves this turn (customer org display name). */
+    org?: string;
+}): TurnRecordHandle;
+/** Read every persisted record (newest first). Read-only — for the §5.3 command. */
+export declare function listTurnRecords(): ChatTurnRecord[];
+/** Read one record by turnId. */
+export declare function readTurnRecord(turnId: string): ChatTurnRecord | null;
+/**
+ * §3.2 final-write ack. Called when agents-api confirms — via a `chat_ack` frame —
+ * that this turn's final message is DURABLY in the DB transcript. That ack is the
+ * authoritative close: it is the one signal that proves the node's local copy is now
+ * redundant, so we evict the content (the durability purpose of the store is served)
+ * while keeping a tombstone so the §5.3 inspect command can still confirm "acked +
+ * evicted". Reads off disk (the live `TurnRecordHandle` is long gone by the time the
+ * ack returns) and rewrites tmp+rename. Fail-soft and IDEMPOTENT: a duplicate ack (or
+ * one for an unknown/already-evicted turn) is a no-op. Returns true iff it flipped a
+ * record. Never throws — a store error must never break the node.
+ */
+export declare function markAcked(turnId: string): boolean;
+/** Every record for a session, newest first. */
+export declare function recordsForSession(sessionId: string): ChatTurnRecord[];
+/** A ledger entry is a §5.1 reconcile GAP when it started but never resolved to a
+ *  result — `started` (a hard crash before `seal` ran) or `indeterminate` (sealed).
+ *  An `executed` entry has no gap. */
+export declare function isReconcileGap(entry: ToolLedgerEntry): boolean;
+/** Turns the resume-path reconciler still owes a pass: at least one ledger gap and
+ *  not yet stamped `reconciledAt`. Read-only. The reconciler runs at boot, when every
+ *  on-disk record predates this process, so a gap here is a prior life's interrupted
+ *  turn — never a turn live in THIS process. Newest-first (inherits listTurnRecords). */
+export declare function listTurnsNeedingReconcile(): ChatTurnRecord[];
+/** One per-entry reconcile verdict the reconciler hands back to be written durably. */
+export interface ToolReconcileOutcome {
+    /** Identifies the entry: by `toolCallId` when present, else by stable `ordinal`. */
+    ordinal: number;
+    toolCallId?: string;
+    disposition: ReconcileDisposition;
+    effectClass: string;
+}
+/**
+ * §5.1 reconcile write-back. The resume-path reconciler applies the policy table to a
+ * turn's ledger gaps (`chat-reconcile.ts`) and calls this to record the verdict durably:
+ * each outcome stamps its entry's `reconcile`, and the turn is stamped `reconciledAt` so
+ * the pass is IDEMPOTENT — a turn is reconciled exactly once (a second call, or one for
+ * an already-reconciled/unknown turn, is a no-op returning false). Reads off disk and
+ * rewrites tmp+rename (the live handle is long gone by boot). Fail-soft: a store error
+ * never throws — an unwritten verdict just leaves the turn for the next boot's pass.
+ * Returns true iff it stamped the record.
+ */
+export declare function reconcileTurnRecord(turnId: string, outcomes: ToolReconcileOutcome[]): boolean;
+/** One unresolved residual gap handed to the agent as a reconcile task (§5.1 residual
+ *  handling). Carries the human-readable coordinates the agent needs to resolve it
+ *  itself (verify by key) or to ask the user in its own natural language — never a raw
+ *  `rerun tool_abc123?`. `disposition` is always a non-`resolved-safe` verdict (a safe
+ *  re-run strands nothing, so it is never surfaced). */
+export interface ReconcileResidualItem {
+    /** The interrupted turn this gap belongs to (the §5.1 `(turnId, toolCallId)` key). */
+    turnId: string;
+    /** Display name of the tool whose outcome is unknown. */
+    tool: string;
+    /** `needs-verify` (verifiable — check reality by key, re-run only if absent) or
+     *  `needs-agent-review` (irreversible/undeclared — never auto-replay; ask the user). */
+    disposition: ReconcileDisposition;
+    effectClass: string;
+    /** The per-invocation key — binds any eventual re-run to the SAME original call so it
+     *  re-enters the normal consent gate rather than a privileged rerun fast-path. */
+    toolCallId?: string;
+    /** When the owning turn was sealed (so the agent can phrase "earlier" / "a moment ago"). */
+    interruptedAt?: string;
+}
+/**
+ * §5.1 residual hand-off. Take this session's unresolved reconcile residual — the
+ * `needs-verify` / `needs-agent-review` gaps a prior interrupted turn left and the
+ * boot reconciler has already classified — so the NEXT turn can surface them to the
+ * agent as a reconcile task (spec §5.1: "surfaces first as an agent-facing reconcile
+ * task," the agent then resolves it itself or asks the user in natural language).
+ *
+ * SINGLE-SHOT by design: each contributing turn is stamped `reconcileSurfacedAt` as it
+ * is taken, so the residual is handed to the agent exactly once and never re-nags every
+ * subsequent turn. The durable per-entry disposition is untouched — the §5.3 inspector
+ * still reads it regardless of whether it was surfaced. Fail-soft: any read/write error
+ * yields the empty set (a missed hand-off leaves the residual visible in the inspector
+ * and node log — never silently re-run, the safe direction).
+ *
+ * Only `resolved-safe` gaps are filtered out (a free/keyed re-run strands nothing);
+ * everything else is the agent's to resolve. Returns newest-turn-first.
+ */
+export declare function takeReconcileResidualForSession(sessionId: string): ReconcileResidualItem[];
+/** Prune CLOSED records older than RETENTION_MS, and any closed overflow past
+ *  MAX_RECORDS (oldest first). Live/unclosed records are never pruned — a stall
+ *  must stay inspectable. */
+export declare function sweepExpired(now?: number): number;
+export {};
+//# sourceMappingURL=chat-store.d.ts.map

package/dist/chat/chat-store.d.ts.map

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